Merge branch 'master-remote' into SoftFever

# Conflicts:
#	resources/profiles/Creality.json
#	resources/profiles/Voron.json
#	version.inc

src/libslic3r/AppConfig.cpp

@@ -533,8 +533,10 @@ void AppConfig::save()
     {
         // Returns "undefined" if the thread naming functionality is not supported by the operating system.
         std::optional<std::string> current_thread_name = get_current_thread_name();
-        if (current_thread_name && *current_thread_name != "bambustu_main")
-            throw CriticalException("Calling AppConfig::save() from a worker thread!");
+        if (current_thread_name && *current_thread_name != "bambustu_main") {
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<<", current_thread_name is " << *current_thread_name;
+            throw CriticalException("Calling AppConfig::save() from a worker thread, thread name: " + *current_thread_name);
+        }
     }
 
     // The config is first written to a file with a PID suffix and then moved

src/libslic3r/Arrange.cpp

@@ -404,8 +404,8 @@ protected:
                 hasLidHeightConflict |= (p.height > clearance_height_to_lid);
             }
 
-            double lambda3 = LARGE_COST_TO_REJECT;
-            double lambda4 = LARGE_COST_TO_REJECT;
+            double lambda3 = LARGE_COST_TO_REJECT*1.1;
+            double lambda4 = LARGE_COST_TO_REJECT*1.2;
             for (int i = 0; i < m_items.size(); i++) {
                 Item& p = m_items[i];
                 if (p.is_virt_object) continue;
@@ -556,12 +556,11 @@ public:
                     }
                 });
 
-        //if (progressind) {
-        //    m_pck.unfitIndicator([this, progressind](std::string name) {
-        //        progressind(100, name+" not fit!");
-        //        BOOST_LOG_TRIVIAL(debug) << "arrange not fit: " + name;
-        //        });
-        //}
+        if (progressind) {
+            m_pck.unfitIndicator([this, progressind](std::string name) {
+                BOOST_LOG_TRIVIAL(debug) << "arrange not fit: " + name;
+                });
+        }
 
         if (stopcond) m_pck.stopCondition(stopcond);
 

src/libslic3r/Arrange.hpp

@@ -52,6 +52,7 @@ struct ArrangePolygon {
     //BBS: add locked_plate to indicate whether it is in the locked plate
     int       locked_plate{ -1 };
     bool      is_virt_object{ false };
+    bool      is_extrusion_cali_object{ false };
     bool      is_wipe_tower{false};
     //BBS: add row/col for sudoku-style layout
     int       row{0};

src/libslic3r/Fill/Fill.cpp

@@ -469,7 +469,7 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
 		LayerRegion* layerm = this->m_regions[surface_fill.region_id];
 		params.config = &layerm->region().config();
 		for (ExPolygon& expoly : surface_fill.expolygons) {
-			f->no_overlap_expolygons = intersection_ex(layerm->fill_no_overlap_expolygons, ExPolygons() = { expoly });
+			f->no_overlap_expolygons = intersection_ex(surface_fill.no_overlap_expolygons, ExPolygons() = {expoly});
 			// Spacing is modified by the filler to indicate adjustments. Reset it for each expolygon.
 			f->spacing = surface_fill.params.spacing;
 			surface_fill.surface.expolygon = std::move(expoly);

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -4058,18 +4058,21 @@ void GCodeProcessor::update_slice_warnings()
 
     auto used_extruders = get_used_extruders();
     assert(!used_extruders.empty());
+    GCodeProcessorResult::SliceWarning warning;
+    warning.level = 1;
     if (m_highest_bed_temp != 0) {
         for (size_t i = 0; i < used_extruders.size(); i++) {
             int temperature = get_filament_vitrification_temperature(used_extruders[i]);
-            if (temperature != 0 && m_highest_bed_temp > temperature) {
-                GCodeProcessorResult::SliceWarning warning;
-                warning.level = 1;
-                warning.msg = BED_TEMP_TOO_HIGH_THAN_FILAMENT;
-                m_result.warnings.emplace_back(std::move(warning));
-            }
+            if (temperature != 0 && m_highest_bed_temp > temperature)
+                warning.params.push_back(std::to_string(used_extruders[i]));
         }
     }
 
+    if (!warning.params.empty()) {
+        warning.msg   = BED_TEMP_TOO_HIGH_THAN_FILAMENT;
+        m_result.warnings.push_back(warning);
+    }
+
     m_result.warnings.shrink_to_fit();
 }
 

src/libslic3r/ModelArrange.cpp

@@ -127,11 +127,11 @@ ArrangePolygon get_instance_arrange_poly(ModelInstance* instance, const Slic3r::
 
         const ConfigOptionInts* bed_opt = config.option<ConfigOptionInts>(get_bed_temp_key(curr_bed_type));
         if (bed_opt != nullptr)
-            ap.bed_temp = bed_opt->get_at(ap.extrude_ids.back());
+            ap.bed_temp = bed_opt->get_at(ap.extrude_ids.back()-1);
 
         const ConfigOptionInts* bed_opt_1st_layer = config.option<ConfigOptionInts>(get_bed_temp_1st_layer_key(curr_bed_type));
         if (bed_opt_1st_layer != nullptr)
-            ap.first_bed_temp = bed_opt_1st_layer->get_at(ap.extrude_ids.back());
+            ap.first_bed_temp = bed_opt_1st_layer->get_at(ap.extrude_ids.back()-1);
     }
 
     if (config.has("nozzle_temperature")) //get the print temperature

src/libslic3r/Preset.cpp

@@ -764,7 +764,7 @@ static std::vector<std::string> s_Preset_printer_options {
     "printer_technology",
     "printable_area", "bed_exclude_area", "gcode_flavor","z_lift_type",
     "single_extruder_multi_material", "machine_start_gcode", "machine_end_gcode", "before_layer_change_gcode", "layer_change_gcode", "change_filament_gcode",
-    "printer_model", "printer_variant", "printable_height", "extruder_clearance_radius", "extruder_clearance_height_to_lid", "extruder_clearance_height_to_rod",
+    "printer_model", "printer_variant", "printable_height", "extruder_clearance_radius",  "extruder_clearance_max_radius","extruder_clearance_height_to_lid", "extruder_clearance_height_to_rod",
     "default_print_profile", "inherits",
     "silent_mode",
     // BBS

src/libslic3r/Print.cpp

@@ -82,6 +82,7 @@ bool Print::invalidate_state_by_config_options(const ConfigOptionResolver & /* n
         "extruder_clearance_height_to_rod",
         "extruder_clearance_height_to_lid",
         "extruder_clearance_radius",
+        "extruder_clearance_max_radius",
         "extruder_colour",
         "extruder_offset",
         "filament_flow_ratio",
@@ -398,6 +399,9 @@ StringObjectException Print::sequential_print_clearance_valid(const Print &print
         const PrintInstance *print_instance;
         BoundingBox    bounding_box;
         Polygon        hull_polygon;
+        int                  index;
+        double         arrange_score;
+        double               height;
     };
     std::vector<struct print_instance_info> print_instance_with_bounding_box;
     {
@@ -475,6 +479,7 @@ StringObjectException Print::sequential_print_clearance_valid(const Print &print
                     }
                 }
                 struct print_instance_info print_info {&instance, convex_hull.bounding_box(), convex_hull};
+                print_info.height = instance.print_object->height();
                 print_instance_with_bounding_box.push_back(std::move(print_info));
                 convex_hulls_other.emplace_back(std::move(convex_hull));
             }
@@ -489,22 +494,104 @@ StringObjectException Print::sequential_print_clearance_valid(const Print &print
         }
     }
 
-    //sort the print instance
+    // calc sort order
+    double hc1              = scale_(print.config().extruder_clearance_height_to_lid); // height to lid
+    double hc2              = scale_(print.config().extruder_clearance_height_to_rod); // height to rod
+    double printable_height = scale_(print.config().printable_height);
+
+    auto bed_points = get_bed_shape(print_config);
+    float bed_width = bed_points[1].x() - bed_points[0].x();
+    // 如果扩大以后的多边形的距离小于这个值，就需要严格保证从左到右的打印顺序，否则会撞工具头右侧
+    float unsafe_dist = scale_(print_config.extruder_clearance_max_radius.value - print_config.extruder_clearance_radius.value);
+    struct VecHash
+    {
+        size_t operator()(const Vec2i &n1) const
+        {
+            return std::hash<coord_t>()(int(n1(0) * 100 + 100)) + std::hash<coord_t>()(int(n1(1) * 100 + 100)) * 101;
+        }
+    };
+    std::unordered_set<Vec2i, VecHash> left_right_pair; // pairs in this vector must strictly obey the left-right order
+    for (size_t i = 0; i < print_instance_with_bounding_box.size();i++) { 
+        auto &inst         = print_instance_with_bounding_box[i];
+        inst.index         = i;
+        Point pt           = inst.bounding_box.center();
+        inst.arrange_score = pt.x() / 2 + pt.y(); // we prefer print row-by-row, so cost on x-direction is smaller
+    }
+    for (size_t i = 0; i < print_instance_with_bounding_box.size(); i++) {
+        auto &inst         = print_instance_with_bounding_box[i];        
+        auto &l            = print_instance_with_bounding_box[i];
+        for (size_t j = 0; j < print_instance_with_bounding_box.size(); j++) {
+            if (j != i) { 
+                auto &r        = print_instance_with_bounding_box[j];
+                auto ly1       = l.bounding_box.min.y();
+                auto ly2       = l.bounding_box.max.y();
+                auto ry1       = r.bounding_box.min.y();
+                auto ry2       = r.bounding_box.max.y();
+                auto lx1       = l.bounding_box.min.x();
+                auto rx1       = r.bounding_box.min.x();
+                auto lx2       = l.bounding_box.max.x();
+                auto rx2       = r.bounding_box.max.x();
+                auto inter_min = std::max(ly1, ry1);
+                auto inter_max = std::min(ly2, ry2);
+                auto inter_y   = inter_max - inter_min;
+                inter_min      = std::max(lx1, rx1);
+                inter_max      = std::min(lx2, rx2);
+                auto inter_x   = inter_max - inter_min;
+
+                // 如果y方向的重合超过轮廓的膨胀量，说明两个物体在一行，应该先打左边的物体，即先比较二者的x坐标。
+                if (inter_y > scale_(1)) {
+                    if (std::max(rx1 - lx2, lx1 - rx2) < unsafe_dist) {
+                        if (lx1 > rx1) {
+                            left_right_pair.insert({j, i});
+                            BOOST_LOG_TRIVIAL(debug) << "in-a-row, print_instance " << r.print_instance->model_instance->get_object()->name << "(" << r.arrange_score << ")"
+                                                     << " -> " << l.print_instance->model_instance->get_object()->name << "(" << l.arrange_score << ")";
+                        } else {
+                            left_right_pair.insert({i, j});
+                            BOOST_LOG_TRIVIAL(debug) << "in-a-row, print_instance " << l.print_instance->model_instance->get_object()->name << "(" << l.arrange_score << ")"
+                                                     << " -> " << r.print_instance->model_instance->get_object()->name << "(" << r.arrange_score << ")";
+                        }
+                    }
+                } 
+                if (l.height > hc1 && r.height < hc1) {
+                    // 当前物体超过了顶盖高度，必须后打
+                    left_right_pair.insert({j, i});
+                    BOOST_LOG_TRIVIAL(debug) << "height>hc1, print_instance " << r.print_instance->model_instance->get_object()->name << "(" << r.arrange_score << ")"
+                                             << " -> " << l.print_instance->model_instance->get_object()->name << "(" << l.arrange_score << ")";
+                }
+                else if (l.height > hc2 && l.height > r.height && l.arrange_score<r.arrange_score) {
+                    // 如果当前物体的高度超过滑杆，且比r高，就给它加一点代价，尽量让高的物体后打（只有物体高度超过滑杆时才有必要按高度来）
+                    l.arrange_score = std::max(l.arrange_score, r.arrange_score + bed_width/2);
+                    BOOST_LOG_TRIVIAL(debug) << "height>hc2, print_instance " << inst.print_instance->model_instance->get_object()->name
+                                             << ", right=" << r.print_instance->model_instance->get_object()->name << ", l.score: " << l.arrange_score
+                                             << ", r.score: " << r.arrange_score;
+                }
+            }
+        }
+    }
+    BOOST_LOG_TRIVIAL(debug) << "bed width: " << bed_width << ", unsafe_dist:" << unsafe_dist;
+    // 多做几次代价传播，因为前一次有些值没有更新。
+    // TODO 更好的办法是建立一颗树，一步到位。不过我暂时没精力搞，先就这样吧
+    for (int k=0;k<5;k++)
+    for (auto p : left_right_pair) {
+        auto &l = print_instance_with_bounding_box[p(0)];
+        auto &r = print_instance_with_bounding_box[p(1)];
+        if(r.arrange_score<l.arrange_score)
+            r.arrange_score = l.arrange_score + bed_width/2;
+    }
+    
+    for (auto p : left_right_pair) {
+        auto &l         = print_instance_with_bounding_box[p(0)];
+        auto &r         = print_instance_with_bounding_box[p(1)];
+        BOOST_LOG_TRIVIAL(debug) << "print_instance " << l.print_instance->model_instance->get_object()->name << "(" << l.arrange_score << ")"
+                                 << " -> " << r.print_instance->model_instance->get_object()->name << "(" << r.arrange_score << ")";
+    }
+    // sort the print instance
     std::sort(print_instance_with_bounding_box.begin(), print_instance_with_bounding_box.end(),
-        [](auto &l, auto &r) {
-            auto ly1       = l.bounding_box.min.y();
-            auto ly2       = l.bounding_box.max.y();
-            auto ry1       = r.bounding_box.min.y();
-            auto ry2       = r.bounding_box.max.y();
-            auto inter_min = std::max(ly1, ry1);
-            auto inter_max = std::min(ly2, ry2);
-            auto lx        = l.bounding_box.min.x();
-            auto rx        = r.bounding_box.min.x();
-            if (inter_max - inter_min > 0)
-                return (lx < rx) || ((lx == rx) && (ly1 < ry1));
-            else
-                return (ly1 < ry1);
-        });
+        [](print_instance_info& l, print_instance_info& r) {return l.arrange_score < r.arrange_score;});
+
+    for (auto &inst : print_instance_with_bounding_box)
+        BOOST_LOG_TRIVIAL(debug) << "after sorting print_instance " << inst.print_instance->model_instance->get_object()->name << ", score: " << inst.arrange_score
+                                 << ", height:"<< inst.height;
 
     // sequential_print_vertical_clearance_valid
     {
@@ -535,9 +622,6 @@ StringObjectException Print::sequential_print_clearance_valid(const Print &print
                 break;
         }*/
 
-        double hc1 = scale_(print.config().extruder_clearance_height_to_lid);
-        double hc2 = scale_(print.config().extruder_clearance_height_to_rod);
-        double printable_height = scale_(print.config().printable_height);
 
         // if objects are not overlapped on y-axis, they will not collide even if they are taller than extruder_clearance_height_to_rod
         int print_instance_count = print_instance_with_bounding_box.size();
@@ -545,7 +629,8 @@ StringObjectException Print::sequential_print_clearance_valid(const Print &print
         for (int k = 0; k < print_instance_count; k++)
         {
             auto inst = print_instance_with_bounding_box[k].print_instance;
-            auto bbox = print_instance_with_bounding_box[k].bounding_box;
+            // 只需要考虑喷嘴到滑杆的偏移量，这个比整个工具头的碰撞半径要小得多
+            auto bbox = print_instance_with_bounding_box[k].bounding_box.inflated(-scale_(0.5 * print.config().extruder_clearance_radius.value));
             auto iy1 = bbox.min.y();
             auto iy2 = bbox.max.y();
             (const_cast<ModelInstance*>(inst->model_instance))->arrange_order = k+1;

src/libslic3r/PrintConfig.cpp

@@ -1025,7 +1025,7 @@ void PrintConfigDef::init_fff_params()
     def = this->add("extruder_clearance_height_to_rod", coFloat);
     def->label = L("Height to rod");
     def->tooltip = L("Distance of the nozzle tip to the lower rod. "
-        "Used as input of auto-arranging to avoid collision when printing by object");
+        "Used for collision avoidance in by-object printing.");
     def->sidetext = L("mm");
     def->min = 0;
     def->mode = comAdvanced;
@@ -1035,7 +1035,7 @@ void PrintConfigDef::init_fff_params()
     def = this->add("extruder_clearance_height_to_lid", coFloat);
     def->label = L("Height to lid");
     def->tooltip = L("Distance of the nozzle tip to the lid. "
-        "Used as input of auto-arranging to avoid collision when printing by object");
+        "Used for collision avoidance in by-object printing.");
     def->sidetext = L("mm");
     def->min = 0;
     def->mode = comAdvanced;
@@ -1043,12 +1043,20 @@ void PrintConfigDef::init_fff_params()
 
     def = this->add("extruder_clearance_radius", coFloat);
     def->label = L("Radius");
-    def->tooltip = L("Clearance radius around extruder. Used as input of auto-arranging to avoid collision when printing by object");
+    def->tooltip = L("Clearance radius around extruder. Used for collision avoidance in by-object printing.");
     def->sidetext = L("mm");
     def->min = 0;
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionFloat(40));
 
+    def           = this->add("extruder_clearance_max_radius", coFloat);
+    def->label    = L("Max Radius");
+    def->tooltip  = L("Max clearance radius around extruder. Used for collision avoidance in by-object printing.");
+    def->sidetext = L("mm");
+    def->min      = 0;
+    def->mode     = comAdvanced;
+    def->set_default_value(new ConfigOptionFloat(68));
+
     def = this->add("extruder_colour", coStrings);
     def->label = L("Extruder Color");
     def->tooltip = L("Only used as a visual help on UI");

src/libslic3r/PrintConfig.hpp

@@ -841,6 +841,7 @@ PRINT_CONFIG_CLASS_DERIVED_DEFINE(
     ((ConfigOptionFloat,              extruder_clearance_height_to_rod))//BBs
     ((ConfigOptionFloat,              extruder_clearance_height_to_lid))//BBS
     ((ConfigOptionFloat,              extruder_clearance_radius))
+    ((ConfigOptionFloat,              extruder_clearance_max_radius))
     ((ConfigOptionStrings,            extruder_colour))
     ((ConfigOptionPoints,             extruder_offset))
     ((ConfigOptionBools,              reduce_fan_stop_start_freq))