ENH: CLI: support multi-extruder slicing

1. add slicing errors for gcode in unprintable area, also for filament mapping
2. use common area for auto arrange
3. support filament_map/filament_map_mode related params
4. add logic to check the filament maps before slicing
5. uptodate support multi-extruder
6. switch new machine/filament support multi-extruder
7. process config params support transfer between mult-extruder and
   single-extruder
8. improve machine-limit logic support multi-extruder
9. flush-volume support multi-extruder
10. add default params to support auto mapping slicing

jira: no-jira
Change-Id: Ice39a365841322ddb586d39c56ff923626822528
(cherry picked from commit f518d6804a9de69deef81c20cd22005a4bbd0cd4)

src/libslic3r/BuildVolume.cpp

@@ -148,6 +148,8 @@ BuildVolume::BuildVolume(const std::vector<Vec2d> &printable_area, const double
                     extruder_volume.bboxf = m_bboxf;
                     extruder_volume.circle = m_circle;
                 }
+                //always ignore z
+                extruder_volume.bboxf.min.z() = -std::numeric_limits<double>::max();
                 m_extruder_volumes.push_back(std::move(extruder_volume));
             }
 

src/libslic3r/PrintConfig.cpp

@@ -4492,7 +4492,6 @@ void PrintConfigDef::init_fff_params()
     def->label = "Extruder ams count";
     def->tooltip = "Ams counts of per extruder";
     def->set_default_value(new ConfigOptionStrings { });
-    def->cli = ConfigOptionDef::nocli;
 
     def = this->add("printer_extruder_id", coInts);
     def->label = "Printer extruder id";
@@ -7213,12 +7212,12 @@ std::set<std::string> print_options_with_variant = {
     "initial_layer_infill_speed",
     "outer_wall_speed",
     "inner_wall_speed",
-    "small_perimeter_speed",
+    "small_perimeter_speed",  //coFloatsOrPercents
     "small_perimeter_threshold",
     "sparse_infill_speed",
     "internal_solid_infill_speed",
     "top_surface_speed",
-    "enable_overhang_speed",
+    "enable_overhang_speed", //coBools
     "overhang_1_4_speed",
     "overhang_2_4_speed",
     "overhang_3_4_speed",
@@ -7233,10 +7232,10 @@ std::set<std::string> print_options_with_variant = {
     "initial_layer_acceleration",
     "outer_wall_acceleration",
     "inner_wall_acceleration",
-    "sparse_infill_acceleration",
+    "sparse_infill_acceleration", //coFloatsOrPercents
     "top_surface_acceleration",
-    "print_extruder_id",
-    "print_extruder_variant"
+    "print_extruder_id", //coInts
+    "print_extruder_variant" //coStrings
 };
 
 std::set<std::string> filament_options_with_variant = {
@@ -7784,6 +7783,210 @@ int DynamicPrintConfig::get_index_for_extruder(int extruder_or_filament_id, std:
     return ret;
 }
 
+//only used for cli
+//update values in single extruder process config to values in multi-extruder process
+//limit the new values
+int DynamicPrintConfig::update_values_from_single_to_multi(DynamicPrintConfig& multi_config, std::set<std::string>& key_set, std::string id_name, std::string variant_name)
+{
+    auto print_variant_opt = dynamic_cast<const ConfigOptionStrings*>(multi_config.option(variant_name));
+    if (!print_variant_opt) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("%1%:%2%, can not get %3% from config")%__FUNCTION__ %__LINE__ % variant_name;
+        return -1;
+    }
+    int variant_count = print_variant_opt->size();
+
+    const ConfigDef  *config_def     = this->def();
+    if (!config_def) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define")%__LINE__;
+        return -1;
+    }
+    for (auto& key: key_set)
+    {
+        const ConfigOptionDef *optdef  = config_def->get(key);
+        if (!optdef) {
+            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%")%__LINE__%key;
+            continue;
+        }
+        switch (optdef->type) {
+            case coStrings:
+            {
+                ConfigOptionStrings * opt = this->option<ConfigOptionStrings>(key);
+                ConfigOptionStrings * src_opt = multi_config.option<ConfigOptionStrings>(key);
+
+                opt->values = src_opt->values;
+                break;
+            }
+            case coInts:
+            {
+                ConfigOptionInts * opt = this->option<ConfigOptionInts>(key);
+                ConfigOptionInts * src_opt = multi_config.option<ConfigOptionInts>(key);
+
+                opt->values = src_opt->values;
+                break;
+            }
+            case coFloats:
+            {
+                ConfigOptionFloats * opt = this->option<ConfigOptionFloats>(key);
+                ConfigOptionFloats * src_opt = multi_config.option<ConfigOptionFloats>(key);
+
+                assert(variant_count == src_opt->size());
+                opt->resize(variant_count, opt);
+
+                for (int index = 0; index < variant_count; index++)
+                {
+                    if (opt->values[index] > src_opt->values[index])
+                        opt->values[index] = src_opt->values[index];
+                }
+                break;
+            }
+            case coFloatsOrPercents:
+            {
+                ConfigOptionFloatsOrPercents * opt = this->option<ConfigOptionFloatsOrPercents>(key);
+                ConfigOptionFloatsOrPercents * src_opt = multi_config.option<ConfigOptionFloatsOrPercents>(key);
+
+                assert(variant_count == src_opt->size());
+                opt->resize(variant_count, opt);
+
+                for (int index = 0; index < variant_count; index++)
+                {
+                    if (opt->values[index].value > src_opt->values[index].value)
+                        opt->values[index] = src_opt->values[index];
+                }
+                break;
+            }
+            case coBools:
+            {
+                ConfigOptionBools * opt = this->option<ConfigOptionBools>(key);
+                ConfigOptionBools * src_opt = multi_config.option<ConfigOptionBools>(key);
+
+                assert(variant_count == src_opt->size());
+                opt->resize(variant_count, opt);
+
+                break;
+            }
+            default:
+                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%")%__LINE__%key;
+                break;
+        }
+    }
+
+    return 0;
+}
+
+int DynamicPrintConfig::update_values_from_multi_to_single(DynamicPrintConfig& single_config, std::set<std::string>& key_set, std::string id_name, std::string variant_name, std::vector<std::string>& extruder_variants)
+{
+    int extruder_count = extruder_variants.size();
+    std::vector<int> extruder_index(extruder_count, -1);
+
+    auto print_variant_opt = dynamic_cast<const ConfigOptionStrings*>(this->option(variant_name));
+    if (!print_variant_opt) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("%1%:%2%, can not get %3% from config")%__FUNCTION__ %__LINE__ % variant_name;
+        return -1;
+    }
+    int variant_count = print_variant_opt->size();
+
+    auto print_id_opt = dynamic_cast<const ConfigOptionInts*>(this->option(id_name));
+    if (!print_id_opt) {
+        BOOST_LOG_TRIVIAL(error) << boost::format("%1%:%2%, can not get %3% from config")%__FUNCTION__ %__LINE__ % id_name;
+        return -1;
+    }
+
+    for (int i = 0; i < extruder_count; i++)
+    {
+        for (int j = 0; j < variant_count; j++)
+        {
+            if ((i+1 == print_id_opt->values[j]) && (extruder_variants[i] == print_variant_opt->values[j])) {
+                extruder_index[i] = j;
+                break;
+            }
+        }
+    }
+
+    const ConfigDef* config_def = this->def();
+    if (!config_def) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define") % __LINE__;
+        return -1;
+    }
+    for (auto& key : key_set)
+    {
+        const ConfigOptionDef* optdef = config_def->get(key);
+        if (!optdef) {
+            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%") % __LINE__ % key;
+            continue;
+        }
+        switch (optdef->type) {
+        case coStrings:
+        {
+            ConfigOptionStrings* opt = this->option<ConfigOptionStrings>(key);
+            ConfigOptionStrings* src_opt = single_config.option<ConfigOptionStrings>(key);
+
+            assert(variant_count == opt->size());
+            opt->values = src_opt->values;
+            break;
+        }
+        case coInts:
+        {
+            ConfigOptionInts* opt = this->option<ConfigOptionInts>(key);
+            ConfigOptionInts* src_opt = single_config.option<ConfigOptionInts>(key);
+
+            assert(variant_count == opt->size());
+            opt->values = src_opt->values;
+            break;
+        }
+        case coFloats:
+        {
+            ConfigOptionFloats* opt = this->option<ConfigOptionFloats>(key);
+            ConfigOptionFloats* src_opt = single_config.option<ConfigOptionFloats>(key);
+            std::vector<double> old_values = opt->values;
+
+            assert(variant_count == opt->size());
+            opt->values = src_opt->values;
+
+            for (int i = 0; i < extruder_count; i++)
+            {
+                assert(extruder_index[i] != -1);
+                if (old_values[extruder_index[i]] < opt->values[0])
+                    opt->values[0] = old_values[extruder_index[i]];
+            }
+            break;
+        }
+        case coFloatsOrPercents:
+        {
+            ConfigOptionFloatsOrPercents* opt = this->option<ConfigOptionFloatsOrPercents>(key);
+            ConfigOptionFloatsOrPercents* src_opt = single_config.option<ConfigOptionFloatsOrPercents>(key);
+
+            std::vector<FloatOrPercent> old_values = opt->values;
+
+            assert(variant_count == opt->size());
+            opt->values = src_opt->values;
+
+            for (int i = 0; i < extruder_count; i++)
+            {
+                assert(extruder_index[i] != -1);
+                if (old_values[extruder_index[i]].value < opt->values[0].value)
+                    opt->values[0] = old_values[extruder_index[i]];
+            }
+            break;
+        }
+        case coBools:
+        {
+            ConfigOptionBools* opt = this->option<ConfigOptionBools>(key);
+            ConfigOptionBools* src_opt = single_config.option<ConfigOptionBools>(key);
+
+            assert(variant_count == opt->size());
+            opt->values = src_opt->values;
+
+            break;
+        }
+        default:
+            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%") % __LINE__ % key;
+            break;
+        }
+    }
+
+    return 0;
+}
+
 void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig& printer_config, std::set<std::string>& key_set, std::string id_name, std::string variant_name, unsigned int stride, unsigned int extruder_id)
 {
     int extruder_count;
@@ -7853,7 +8056,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
                     new_values.resize(extruder_count * stride);
                     for (int e_index = 0; e_index < extruder_count; e_index++)
                     {
-                        for (int i = 0; i < stride; i++)
+                        for (unsigned int i = 0; i < stride; i++)
                             new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                     }
                     opt->values = new_values;
@@ -7867,7 +8070,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
                     new_values.resize(extruder_count * stride);
                     for (int e_index = 0; e_index < extruder_count; e_index++)
                     {
-                        for (int i = 0; i < stride; i++)
+                        for (unsigned int i = 0; i < stride; i++)
                             new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                     }
                     opt->values = new_values;
@@ -7881,7 +8084,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
                     new_values.resize(extruder_count * stride);
                     for (int e_index = 0; e_index < extruder_count; e_index++)
                     {
-                        for (int i = 0; i < stride; i++)
+                        for (unsigned int i = 0; i < stride; i++)
                             new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                     }
                     opt->values = new_values;
@@ -7895,7 +8098,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
                     new_values.resize(extruder_count * stride);
                     for (int e_index = 0; e_index < extruder_count; e_index++)
                     {
-                        for (int i = 0; i < stride; i++)
+                        for (unsigned int i = 0; i < stride; i++)
                             new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                     }
                     opt->values = new_values;
@@ -7909,7 +8112,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
                     new_values.resize(extruder_count * stride);
                     for (int e_index = 0; e_index < extruder_count; e_index++)
                     {
-                        for (int i = 0; i < stride; i++)
+                        for (unsigned int i = 0; i < stride; i++)
                             new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                     }
                     opt->values = new_values;
@@ -7923,7 +8126,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
                     new_values.resize(extruder_count * stride);
                     for (int e_index = 0; e_index < extruder_count; e_index++)
                     {
-                        for (int i = 0; i < stride; i++)
+                        for (unsigned int i = 0; i < stride; i++)
                             new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                     }
                     opt->values = new_values;
@@ -7937,7 +8140,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
                     new_values.resize(extruder_count * stride);
                     for (int e_index = 0; e_index < extruder_count; e_index++)
                     {
-                        for (int i = 0; i < stride; i++)
+                        for (unsigned int i = 0; i < stride; i++)
                             new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                     }
                     opt->values = new_values;
@@ -7953,7 +8156,7 @@ void DynamicPrintConfig::update_values_to_printer_extruders(DynamicPrintConfig&
 
 void DynamicPrintConfig::update_values_to_printer_extruders_for_multiple_filaments(DynamicPrintConfig& printer_config, std::set<std::string>& key_set, std::string id_name, std::string variant_name)
 {
-    int extruder_count, filament_count;
+    int extruder_count;
     bool different_extruder = printer_config.support_different_extruders(extruder_count);
     if ((extruder_count > 1) || different_extruder)
     {
@@ -9291,9 +9494,26 @@ static Points to_points(const std::vector<Vec2d> &dpts)
     return pts;
 }
 
-Points get_bed_shape(const DynamicPrintConfig &config)
+static Polygon get_shared_poly(const std::vector<Pointfs>& extruder_polys)
 {
-    const auto *bed_shape_opt = config.opt<ConfigOptionPoints>("printable_area");
+    Polygon result;
+    for (int index = 0; index < extruder_polys.size(); index++)
+    {
+        const Pointfs& extruder_area = extruder_polys[index];
+        if (index == 0)
+            result.points = to_points(extruder_area);
+        else {
+            Polygon extruer_poly;
+            extruer_poly.points = to_points(extruder_area);
+            Polygons result_polygon = intersection(extruer_poly, result);
+            result = result_polygon[0];
+        }
+    }
+    return result;
+}
+Points get_bed_shape(const DynamicPrintConfig &config, bool use_share)
+{
+    const ConfigOptionPoints *bed_shape_opt = config.opt<ConfigOptionPoints>("printable_area");
     if (!bed_shape_opt) {
 
         // Here, it is certain that the bed shape is missing, so an infinite one
@@ -9304,12 +9524,37 @@ Points get_bed_shape(const DynamicPrintConfig &config)
         return {};
     }
 
-    return to_points(make_counter_clockwise(bed_shape_opt->values));
+    Polygon bed_poly;
+    if (use_share) {
+        const ConfigOptionPointsGroups *extruder_area_opt = config.opt<ConfigOptionPointsGroups>("extruder_printable_area");
+        if (extruder_area_opt && (extruder_area_opt->size() > 0)) {
+            const std::vector<Pointfs>& extruder_areas = extruder_area_opt->values;
+            bed_poly = get_shared_poly(extruder_areas);
+        }
+        else
+            bed_poly.points = to_points(make_counter_clockwise(bed_shape_opt->values));
+    }
+    else
+        bed_poly.points = to_points(make_counter_clockwise(bed_shape_opt->values));
+
+    return bed_poly.points;
 }
 
-Points get_bed_shape(const PrintConfig &cfg)
+Points get_bed_shape(const PrintConfig &cfg, bool use_share)
 {
-    return to_points(make_counter_clockwise(cfg.printable_area.values));
+    Polygon bed_poly;
+    if (use_share) {
+        const std::vector<Pointfs>& extruder_areas = cfg.extruder_printable_area.values;
+        if (extruder_areas.size() > 0) {
+            bed_poly = get_shared_poly(extruder_areas);
+        }
+        else
+            bed_poly.points = to_points(make_counter_clockwise(cfg.printable_area.values));
+    }
+    else
+        bed_poly.points = to_points(make_counter_clockwise(cfg.printable_area.values));
+
+    return bed_poly.points;
 }
 
 Points get_bed_shape(const SLAPrinterConfig &cfg) { return to_points(make_counter_clockwise(cfg.printable_area.values)); }
@@ -9329,10 +9574,11 @@ Polygons get_bed_excluded_area(const PrintConfig& cfg)
     return {exclude_poly};
 }
 
-Polygon get_bed_shape_with_excluded_area(const PrintConfig& cfg)
+Polygon get_bed_shape_with_excluded_area(const PrintConfig& cfg, bool use_share)
 {
     Polygon bed_poly;
-    bed_poly.points = get_bed_shape(cfg);
+    bed_poly.points = get_bed_shape(cfg, use_share);
+
 
     Polygons exclude_polys = get_bed_excluded_area(cfg);
     auto tmp = diff({ bed_poly }, exclude_polys);

src/libslic3r/PrintConfig.hpp

@@ -615,6 +615,9 @@ public:
     void update_non_diff_values_to_base_config(DynamicPrintConfig& new_config, const t_config_option_keys& keys, const std::set<std::string>& different_keys, std::string extruder_id_name, std::string extruder_variant_name,
         std::set<std::string>& key_set1, std::set<std::string>& key_set2 = std::set<std::string>());
 
+    int update_values_from_single_to_multi(DynamicPrintConfig& multi_config, std::set<std::string>& key_set, std::string id_name, std::string variant_name);
+    int update_values_from_multi_to_single(DynamicPrintConfig& single_config, std::set<std::string>& key_set, std::string id_name, std::string variant_name, std::vector<std::string>& extruder_variants);
+
 };
 extern std::set<std::string> printer_extruder_options;
 extern std::set<std::string> print_options_with_variant;
@@ -979,7 +982,7 @@ PRINT_CONFIG_CLASS_DEFINE(
     ((ConfigOptionFloat,              travel_jerk))
     ((ConfigOptionBool,               precise_z_height))
     ((ConfigOptionFloat,              default_junction_deviation))
-        
+
     ((ConfigOptionBool, interlocking_beam))
     ((ConfigOptionFloat,interlocking_beam_width))
     ((ConfigOptionFloat,interlocking_orientation))
@@ -1849,11 +1852,11 @@ private:
 bool is_XL_printer(const DynamicPrintConfig &cfg);
 bool is_XL_printer(const PrintConfig &cfg);
 
-Points get_bed_shape(const DynamicPrintConfig &cfg);
-Points get_bed_shape(const PrintConfig &cfg);
+Points get_bed_shape(const DynamicPrintConfig &cfg, bool use_share = true);
+Points get_bed_shape(const PrintConfig &cfg, bool use_share = false);
 Points get_bed_shape(const SLAPrinterConfig &cfg);
 Slic3r::Polygons get_bed_excluded_area(const PrintConfig& cfg);
-Slic3r::Polygon get_bed_shape_with_excluded_area(const PrintConfig& cfg);
+Slic3r::Polygon get_bed_shape_with_excluded_area(const PrintConfig& cfg, bool use_share = false);
 bool has_skirt(const DynamicPrintConfig& cfg);
 float get_real_skirt_dist(const DynamicPrintConfig& cfg);
 

src/libslic3r/Utils.hpp

@@ -65,9 +65,11 @@
 #define CLI_OBJECT_COLLISION_IN_SEQ_PRINT   -63
 #define CLI_OBJECT_COLLISION_IN_LAYER_PRINT -64
 #define CLI_SPIRAL_MODE_INVALID_PARAMS      -65
+#define CLI_FILAMENT_CAN_NOT_MAP      -66
 
 #define CLI_SLICING_ERROR                  -100
 #define CLI_GCODE_PATH_CONFLICTS           -101
+#define CLI_GCODE_PATH_IN_UNPRINTABLE_AREA -102
 
 
 namespace boost { namespace filesystem { class directory_entry; }}