Another step towards C++ presets.

xs/src/libslic3r/BoundingBox.cpp

@@ -7,7 +7,8 @@ namespace Slic3r {
 template <class PointClass>
 BoundingBoxBase<PointClass>::BoundingBoxBase(const std::vector<PointClass> &points)
 {
-    if (points.empty()) CONFESS("Empty point set supplied to BoundingBoxBase constructor");
+    if (points.empty()) 
+        CONFESS("Empty point set supplied to BoundingBoxBase constructor");
     typename std::vector<PointClass>::const_iterator it = points.begin();
     this->min.x = this->max.x = it->x;
     this->min.y = this->max.y = it->y;
@@ -26,7 +27,8 @@ template <class PointClass>
 BoundingBox3Base<PointClass>::BoundingBox3Base(const std::vector<PointClass> &points)
     : BoundingBoxBase<PointClass>(points)
 {
-    if (points.empty()) CONFESS("Empty point set supplied to BoundingBox3Base constructor");
+    if (points.empty())
+        CONFESS("Empty point set supplied to BoundingBox3Base constructor");
     typename std::vector<PointClass>::const_iterator it = points.begin();
     this->min.z = this->max.z = it->z;
     for (++it; it != points.end(); ++it) {
@@ -39,9 +41,10 @@ template BoundingBox3Base<Pointf3>::BoundingBox3Base(const std::vector<Pointf3>
 BoundingBox::BoundingBox(const Lines &lines)
 {
     Points points;
-    for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) {
-        points.push_back(line->a);
-        points.push_back(line->b);
+    points.reserve(lines.size());
+    for (const Line &line : lines) {
+        points.emplace_back(line.a);
+        points.emplace_back(line.b);
     }
     *this = BoundingBox(points);
 }
@@ -190,9 +193,9 @@ BoundingBox3Base<PointClass>::size() const
 }
 template Pointf3 BoundingBox3Base<Pointf3>::size() const;
 
-template <class PointClass> double
-BoundingBoxBase<PointClass>::radius() const
+template <class PointClass> double BoundingBoxBase<PointClass>::radius() const
 {
+    assert(this->defined);
     double x = this->max.x - this->min.x;
     double y = this->max.y - this->min.y;
     return 0.5 * sqrt(x*x+y*y);
@@ -200,8 +203,7 @@ BoundingBoxBase<PointClass>::radius() const
 template double BoundingBoxBase<Point>::radius() const;
 template double BoundingBoxBase<Pointf>::radius() const;
 
-template <class PointClass> double
-BoundingBox3Base<PointClass>::radius() const
+template <class PointClass> double BoundingBox3Base<PointClass>::radius() const
 {
     double x = this->max.x - this->min.x;
     double y = this->max.y - this->min.y;

xs/src/libslic3r/Config.hpp

@@ -27,35 +27,36 @@ extern bool         unescape_strings_cstyle(const std::string &str, std::vector<
 
 // Type of a configuration value.
 enum ConfigOptionType {
-    coNone,
+    coVectorType    = 0x4000,
+    coNone          = 0,
     // single float
-    coFloat,
+    coFloat         = 1,
     // vector of floats
-    coFloats,
+    coFloats        = coFloat + coVectorType,
     // single int
-    coInt,
+    coInt           = 2,
     // vector of ints
-    coInts,
+    coInts          = coInt + coVectorType,
     // single string
-    coString,
+    coString        = 3,
     // vector of strings
-    coStrings,
+    coStrings       = coString + coVectorType,
     // percent value. Currently only used for infill.
-    coPercent,
+    coPercent       = 4,
     // percents value. Currently used for retract before wipe only.
-    coPercents,
+    coPercents      = coPercent + coVectorType,
     // a fraction or an absolute value
-    coFloatOrPercent,
+    coFloatOrPercent = 5,
     // single 2d point. Currently not used.
-    coPoint,
+    coPoint         = 6,
     // vector of 2d points. Currently used for the definition of the print bed and for the extruder offsets.
-    coPoints,
+    coPoints        = coPoint + coVectorType,
     // single boolean value
-    coBool,
+    coBool          = 7,
     // vector of boolean values
-    coBools,
+    coBools         = coBool + coVectorType,
     // a generic enum
-    coEnum,
+    coEnum          = 8,
 };
 
 // A generic value of a configuration option.
@@ -75,6 +76,8 @@ public:
     virtual void                setInt(int /* val */) { throw std::runtime_error("Calling ConfigOption::setInt on a non-int ConfigOption"); }
     virtual bool                operator==(const ConfigOption &rhs) const = 0;
     bool                        operator!=(const ConfigOption &rhs) const { return ! (*this == rhs); }
+    bool                        is_scalar()     const { return (int(this->type()) & int(coVectorType)) == 0; }
+    bool                        is_vector()     const { return ! this->is_scalar(); }
 };
 
 // Value of a single valued option (bool, int, float, string, point, enum)
@@ -110,6 +113,18 @@ class ConfigOptionVectorBase : public ConfigOption {
 public:
     // Currently used only to initialize the PlaceholderParser.
     virtual std::vector<std::string> vserialize() const = 0;
+    // Set from a vector of ConfigOptions. 
+    // If the rhs ConfigOption is scalar, then its value is used,
+    // otherwise for each of rhs, the first value of a vector is used.
+    // This function is useful to collect values for multiple extrder / filament settings.
+    virtual void set(const std::vector<const ConfigOption*> &rhs) = 0;
+    // Set a single vector item from either a scalar option or the first value of a vector option.vector of ConfigOptions. 
+    // This function is useful to split values from multiple extrder / filament settings into separate configurations.
+    virtual void set_at(const ConfigOption *rhs, size_t i, size_t j) = 0;
+
+protected:
+    // Used to verify type compatibility when assigning to / from a scalar ConfigOption.
+    ConfigOptionType scalar_type() const { return static_cast<ConfigOptionType>(this->type() - coVectorType); }
 };
 
 // Value of a vector valued option (bools, ints, floats, strings, points), template
@@ -125,13 +140,57 @@ public:
             throw std::runtime_error("ConfigOptionVector: Assigning an incompatible type");
         assert(dynamic_cast<const ConfigOptionVector<T>*>(rhs));
         this->values = static_cast<const ConfigOptionVector<T>*>(rhs)->values;
-    };
+    }
+
+    // Set from a vector of ConfigOptions. 
+    // If the rhs ConfigOption is scalar, then its value is used,
+    // otherwise for each of rhs, the first value of a vector is used.
+    // This function is useful to collect values for multiple extrder / filament settings.
+    void set(const std::vector<const ConfigOption*> &rhs) override
+    {
+        this->values.clear();
+        this->values.reserve(rhs.size());
+        for (const ConfigOption *opt : rhs) {
+            if (opt->type() == this->type()) {
+                auto other = static_cast<const ConfigOptionVector<T>*>(opt);
+                if (other->values.empty())
+                    throw std::runtime_error("ConfigOptionVector::set(): Assigning from an empty vector");
+                this->values.emplace_back(other->values.front());
+            } else if (opt->type() == this->scalar_type())
+                this->values.emplace_back(static_cast<const ConfigOptionSingle<T>*>(opt)->value);
+            else
+                throw std::runtime_error("ConfigOptionVector::set():: Assigning an incompatible type");
+        }
+    }
+
+    // Set a single vector item from either a scalar option or the first value of a vector option.vector of ConfigOptions. 
+    // This function is useful to split values from multiple extrder / filament settings into separate configurations.
+    void set_at(const ConfigOption *rhs, size_t i, size_t j) override
+    {
+        // It is expected that the vector value has at least one value, which is the default, if not overwritten.
+        assert(! this->values.empty());
+        if (this->values.size() <= i) {
+            // Resize this vector, fill in the new vector fields with the copy of the first field.
+            T v = this->values.front();
+            this->values.resize(i + 1, v);
+        }
+        if (rhs->type() == this->type()) {
+            // Assign the first value of the rhs vector.
+            auto other = static_cast<const ConfigOptionVector<T>*>(rhs);
+            if (other->values.empty())
+                throw std::runtime_error("ConfigOptionVector::set_at(): Assigning from an empty vector");
+            this->values[i] = other->get_at(j);
+        } else if (rhs->type() == this->scalar_type())
+            this->values[i] = static_cast<const ConfigOptionSingle<T>*>(rhs)->value;
+        else
+            throw std::runtime_error("ConfigOptionVector::set_at(): Assigning an incompatible type");
+    }
 
     T& get_at(size_t i)
     {
         assert(! this->values.empty());
         return (i < this->values.size()) ? this->values[i] : this->values.front();
-    };
+    }
 
     const T& get_at(size_t i) const { return const_cast<ConfigOptionVector<T>*>(this)->get_at(i); }
 

xs/src/libslic3r/TriangleMesh.cpp

@@ -1208,6 +1208,8 @@ void TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slic
 
     // perform a safety offset to merge very close facets (TODO: find test case for this)
     double safety_offset = scale_(0.0499);
+//FIXME see https://github.com/prusa3d/Slic3r/issues/520
+//    double safety_offset = scale_(0.0001);
     ExPolygons ex_slices = offset2_ex(p_slices, +safety_offset, -safety_offset);
     
     #ifdef SLIC3R_TRIANGLEMESH_DEBUG

xs/src/libslic3r/Utils.hpp

@@ -8,11 +8,21 @@ extern void trace(unsigned int level, const char *message);
 
 // Set a path with GUI resource files.
 void set_var_dir(const std::string &path);
-// Return a path to the GUI resource files.
+// Return a full path to the GUI resource files.
 const std::string& var_dir();
-// Return a resource path for a file_name.
+// Return a full resource path for a file_name.
 std::string var(const std::string &file_name);
 
+// Set a path with preset files.
+void set_data_dir(const std::string &path);
+// Return a full path to the GUI resource files.
+const std::string& data_dir();
+// Return a full path to a configuration file given its file name..
+std::string config_path(const std::string &file_name);
+// Return a full path to a configuration file given the section and name.
+// The suffix ".ini" will be added if it is missing in the name.
+std::string config_path(const std::string &section, const std::string &name);
+
 extern std::string encode_path(const char *src);
 extern std::string decode_path(const char *src);
 extern std::string normalize_utf8_nfc(const char *src);

xs/src/libslic3r/utils.cpp

@@ -6,8 +6,8 @@
 
 #include <boost/locale.hpp>
 
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem.hpp>
-
 #include <boost/nowide/integration/filesystem.hpp>
 #include <boost/nowide/convert.hpp>
 
@@ -87,6 +87,31 @@ std::string var(const std::string &file_name)
     return file.string();
 }
 
+static std::string g_data_dir;
+
+void set_data_dir(const std::string &dir)
+{
+    g_data_dir = dir;
+}
+
+const std::string& data_dir()
+{
+    return g_data_dir;
+}
+
+std::string config_path(const std::string &file_name)
+{
+    auto file = boost::filesystem::canonical(boost::filesystem::path(g_data_dir) / file_name).make_preferred();
+    return file.string();
+}
+
+std::string config_path(const std::string &section, const std::string &name)
+{
+    auto file_name = boost::algorithm::iends_with(name, ".ini") ? name : name + ".ini";
+    auto file = boost::filesystem::canonical(boost::filesystem::path(g_data_dir) / file_name).make_preferred();
+    return file.string();
+}
+
 } // namespace Slic3r
 
 #ifdef SLIC3R_HAS_BROKEN_CROAK