Fix add_ironing_range (put ironing in wrong islands)

Author: supermerill

src/libslic3r/Fill/Fill.cpp

@@ -672,11 +672,29 @@ static LayerIsland *get_fill_island(Layer &layer,
         // Sort the extrusion range into its LayerIsland.
         // Traverse the slices in an increasing order of bounding box size, so that the islands inside another islands are tested first,
         // so we can just test a point inside ExPolygon::contour and we may skip testing the holes.
+        // That is because layer.lslices() is topologically sorted. 
         auto point_inside_surface = [&layer](const size_t lslice_idx, const Point &point) {
             const BoundingBox &bbox = layer.lslices_ex[lslice_idx].bbox;
             return point.x() >= bbox.min.x() && point.x() < bbox.max.x() && point.y() >= bbox.min.y() && point.y() < bbox.max.y() &&
                    layer.lslices()[lslice_idx].contour.contains(point);
         };
+#ifdef _DEBUG
+        // check topological sort
+        if (layer.lslices().size() > 1) {
+            std::vector<BoundingBox> bboxes;
+            bboxes.emplace_back(layer.lslices()[0].contour.points);
+            for (size_t check_idx = 1; check_idx < layer.lslices().size(); ++check_idx) {
+                assert(bboxes.size() == check_idx);
+                bboxes.emplace_back(layer.lslices()[check_idx].contour.points);
+                for (size_t bigger_idx = 0; bigger_idx < check_idx; ++bigger_idx) {
+                    // higher idx can be inside holes, but not the opposite!
+                    if (bboxes[check_idx].contains(bboxes[bigger_idx])) {
+                        assert(!layer.lslices()[check_idx].contour.contains(layer.lslices()[bigger_idx].contour.first_point()));
+                    }
+                }
+            }
+        }
+#endif
         int   lslice_idx = int(layer.lslices_ex.size()) - 1;
         for (; lslice_idx >= 0; --lslice_idx)
             if (point_inside_surface(lslice_idx, point))
@@ -759,6 +777,7 @@ static void insert_ironings_into_islands(Layer &layer, uint32_t layer_region_id,
     	// Sort the extrusion range into its LayerIsland.
 	    // Traverse the slices in an increasing order of bounding box size, so that the islands inside another islands are tested first,
 	    // so we can just test a point inside ExPolygon::contour and we may skip testing the holes.
+        // That is because layer.lslices() is topologically sorted. 
 	    auto point_inside_surface = [&layer](const size_t lslice_idx, const Point &point) {
 	        const BoundingBox &bbox = layer.lslices_ex[lslice_idx].bbox;
 	        return point.x() >= bbox.min.x() && point.x() < bbox.max.x() &&

src/libslic3r/GCode.cpp

@@ -5870,8 +5870,10 @@ void GCodeGenerator::extrude_ironing(const ExtrudeArgs &print_args, const LayerI
         }
         if (!temp_fill_extrusions.empty()) {
             set_region_for_extrude(print, nullptr, &layerm, gcode);
-            for (const ExtrusionEntityReference &fill : chain_extrusion_references(temp_fill_extrusions, last_pos_defined() ? &last_pos() : nullptr))
+            for (const ExtrusionEntityReference &fill :
+                 chain_extrusion_references(temp_fill_extrusions, last_pos_defined() ? &last_pos() : nullptr)) {
                 gcode += this->extrude_entity(fill, "ironing"sv);
+            }
         }
         it = it_end;
         m_region = nullptr;

src/libslic3r/Layer.cpp

@@ -68,6 +68,22 @@ void Layer::make_slices()
         ensure_valid(slices, std::max(scale_t(this->object()->print()->config().resolution), SCALED_EPSILON));
         for (ExPolygon &poly : slices) poly.assert_valid();
         // lslices are sorted by topological order from outside to inside from the clipper union used above
+#ifdef _DEBUG
+        if (slices.size() > 1) {
+            std::vector<BoundingBox> bboxes;
+            bboxes.emplace_back(slices[0].contour.points);
+            for (size_t check_idx = 1; check_idx < slices.size(); ++check_idx) {
+                assert(bboxes.size() == check_idx);
+                bboxes.emplace_back(slices[check_idx].contour.points);
+                for (size_t bigger_idx = 0; bigger_idx < check_idx; ++bigger_idx) {
+                    // higher idx can be inside holes, but not the opposite!
+                    if (bboxes[check_idx].contains(bboxes[bigger_idx])) {
+                        assert(!slices[check_idx].contour.contains(slices[bigger_idx].contour.first_point()));
+                    }
+                }
+            }
+        }
+#endif
         this->set_lslices() = slices;
     }
 

src/libslic3r/Layer.hpp

@@ -312,9 +312,9 @@ struct LayerIsland
     }
     void                  add_ironing_range(const LayerExtrusionRange &new_ironing_range) {
         // Compress ranges.
-        if (!this->ironings.empty() && this->fills.back().region() == new_ironing_range.region() &&
-            *this->fills.back().end() == *new_ironing_range.begin())
-            this->ironings.back() = {new_ironing_range.region(), {*this->fills.back().begin(), *new_ironing_range.end()}};
+        if (!this->ironings.empty() && this->ironings.back().region() == new_ironing_range.region() &&
+            *this->ironings.back().end() == *new_ironing_range.begin())
+            this->ironings.back() = {new_ironing_range.region(), {*this->ironings.back().begin(), *new_ironing_range.end()}};
         else
             this->ironings.push_back(new_ironing_range);
     }

src/libslic3r/PrintObjectSlice.cpp

@@ -895,6 +895,23 @@ void PrintObject::_max_overhang_threshold() {
         ExPolygons new_lslices = intersection_ex(my_layer->lslices(), all_region_modified, ApplySafetyOffset::Yes);
         ensure_valid(new_lslices, resolution);
         assert_valid(new_lslices);
+        // lslices are sorted by topological order from outside to inside from the clipper intersection_ex used above
+#ifdef _DEBUG
+        if (new_lslices.size() > 1) {
+            std::vector<BoundingBox> bboxes;
+            bboxes.emplace_back(new_lslices[0].contour.points);
+            for (size_t check_idx = 1; check_idx < new_lslices.size(); ++check_idx) {
+                assert(bboxes.size() == check_idx);
+                bboxes.emplace_back(new_lslices[check_idx].contour.points);
+                for (size_t bigger_idx = 0; bigger_idx < check_idx; ++bigger_idx) {
+                    // higher idx can be inside holes, but not the opposite!
+                    if (bboxes[check_idx].contains(bboxes[bigger_idx])) {
+                        assert(!new_lslices[check_idx].contour.contains(new_lslices[bigger_idx].contour.first_point()));
+                    }
+                }
+            }
+        }
+#endif
         my_layer->set_lslices() = std::move(new_lslices);
         my_layer->lslice_indices_sorted_by_print_order = chain_expolygons(my_layer->lslices());
         assert(my_layer->lslices().size() == my_layer->lslice_indices_sorted_by_print_order.size());