Improve shape cleaning robustness

Author: fontanf

data/irregular/users/2024-08-08_solution.json

@@ -14,7 +14,7 @@ FetchContent_MakeAvailable(optimizationtools)
 FetchContent_Declare(
     shape
     GIT_REPOSITORY https://github.com/fontanf/shape.git
-    GIT_TAG 3eb30c9538fd0ca8d9cb0c6e251169dc1ce4ba54
+    GIT_TAG cb7899d6a1596a36b142c83a0483941bbf624b7d
     #SOURCE_DIR "${PROJECT_SOURCE_DIR}/../shape/"
     EXCLUDE_FROM_ALL)
 FetchContent_MakeAvailable(shape)

data/irregular/users/2024-08-08_sub_2_solution.json

@@ -155,8 +155,7 @@ BranchingScheme::BranchingScheme(
                     border_pos < (DefectId)simplified_bin_type.borders.size();
                     ++border_pos) {
                 const Shape& simplified_inflated_shape = simplified_bin_type.borders[border_pos].shape_inflated;
-                Shape shape_inflated = convert_shape(simplified_inflated_shape, direction);
-                shape_inflated = clean_shape(shape_inflated, true);
+                const Shape& shape_inflated = convert_shape(simplified_inflated_shape, direction);
 
                 // Supports.
                 shape::ShapeSupports supports = shape::compute_shape_supports(shape_inflated, false);
@@ -186,8 +185,7 @@ BranchingScheme::BranchingScheme(
                     ++defect_id) {
                 //std::cout << "defect_id " << defect_id << std::endl;
                 const Shape& simplified_inflated_shape = simplified_bin_type.defects[defect_id].shape_inflated;
-                Shape shape_inflated = convert_shape(simplified_inflated_shape, direction);
-                shape_inflated = clean_shape(shape_inflated, true);
+                const Shape& shape_inflated = convert_shape(simplified_inflated_shape, direction);
 
                 // Supports.
                 shape::ShapeSupports supports = shape::compute_shape_supports(shape_inflated, false);
@@ -206,8 +204,7 @@ BranchingScheme::BranchingScheme(
                         hole_pos < (ShapePos)simplified_bin_type.defects[defect_id].holes_deflated.size();
                         ++hole_pos) {
                     const Shape& simplified_deflated_shape = simplified_bin_type.defects[defect_id].holes_deflated[hole_pos];
-                    Shape shape_deflated = convert_shape(simplified_deflated_shape, direction);
-                    shape_deflated = clean_shape(shape_deflated, false);
+                    const Shape& shape_deflated = convert_shape(simplified_deflated_shape, direction);
 
                     // Update trapezoidation input.
                     holes_deflated.push_back(shape_deflated);
@@ -271,6 +268,12 @@ BranchingScheme::BranchingScheme(
                         const ItemShape& item_shape = item_type.shapes[item_shape_pos];
                         const Shape& simplified_shape = simplified_item_type.shapes[item_shape_pos].shape;
                         const Shape& simplified_inflated_shape = simplified_item_type.shapes[item_shape_pos].shape_inflated;
+                        //std::cout << "item_type_id " << item_type_id
+                        //    << " item_shape_pos " << item_shape_pos
+                        //    << " angle " << angle_range.first
+                        //    << " mirror " << mirror
+                        //    << " simplified_shape " << simplified_shape.to_string(2)
+                        //    << std::endl;
 
                         if (write_shapes) {
                             simplified_shape.write_svg(
@@ -283,10 +286,8 @@ BranchingScheme::BranchingScheme(
                                     + "_inflated_simplified.svg");
                         }
 
-                        Shape shape = convert_shape(simplified_shape, angle_range.first, mirror, direction);
-                        Shape shape_inflated = convert_shape(simplified_inflated_shape, angle_range.first, mirror, direction);
-                        shape = clean_shape(shape, true);
-                        shape_inflated = clean_shape(shape_inflated, true);
+                        const Shape& shape = convert_shape(simplified_shape, angle_range.first, mirror, direction);
+                        const Shape& shape_inflated = convert_shape(simplified_inflated_shape, angle_range.first, mirror, direction);
 
                         if (write_shapes) {
                             simplified_inflated_shape.write_svg(
@@ -331,8 +332,7 @@ BranchingScheme::BranchingScheme(
                                 ++hole_pos) {
                             const Shape& simplified_shape = simplified_item_type.shapes[item_shape_pos].holes[hole_pos];
 
-                            Shape shape = convert_shape(simplified_shape, angle_range.first, mirror, direction);
-                            shape = clean_shape(shape, true);
+                            const Shape& shape = convert_shape(simplified_shape, angle_range.first, mirror, direction);
 
                             // Update trapezoidation input.
                             holes.push_back(shape);
@@ -358,8 +358,7 @@ BranchingScheme::BranchingScheme(
                                 ++hole_pos) {
                             const Shape& simplified_deflated_shape = simplified_item_type.shapes[item_shape_pos].holes_deflated[hole_pos];
 
-                            Shape shape_deflated = convert_shape(simplified_deflated_shape, angle_range.first, mirror, direction);
-                            shape_deflated = clean_shape(shape_deflated, true);
+                            const Shape& shape_deflated = convert_shape(simplified_deflated_shape, angle_range.first, mirror, direction);
 
                             // Update trapezoidation input.
                             holes_deflated.push_back(shape_deflated);

extern/CMakeLists.txt

@@ -2,6 +2,7 @@
 
 #include "shape/offset.hpp"
 #include "shape/extract_borders.hpp"
+#include "shape/self_intersections_removal.hpp"
 
 #include <sstream>
 
@@ -432,6 +433,49 @@ void InstanceBuilder::read(
 //////////////////////////////////// Build /////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
+namespace
+{
+
+std::pair<Shape, std::vector<Shape>> process_shape_outer(
+        const Shape& shape)
+{
+    bool outer = true;
+    Shape shape_tmp = shape::approximate_by_line_segments(shape, 1, outer);
+    for (int i;; ++i) {
+        if (i == 100) {
+            throw std::runtime_error(
+                    "packingsolver::irregular::process_shape_outer: "
+                    "too many iterations.");
+        }
+        auto res = shape::clean_extreme_slopes(shape_tmp, outer);
+        if (!res.first)
+            break;
+        shape_tmp = res.second;
+    }
+    return shape::remove_self_intersections(shape_tmp);
+}
+
+std::vector<Shape> process_shape_inner(
+        const Shape& shape)
+{
+    bool outer = false;
+    Shape shape_tmp = shape::approximate_by_line_segments(shape, 1, outer);
+    for (int i = 0;; ++i) {
+        if (i == 100) {
+            throw std::runtime_error(
+                    "packingsolver::irregular::process_shape_inner: "
+                    "too many iterations.");
+        }
+        auto res = shape::clean_extreme_slopes(shape_tmp, outer);
+        if (!res.first)
+            break;
+        shape_tmp = res.second;
+    }
+    return shape::extract_all_holes_from_self_intersecting_hole(shape_tmp);
+}
+
+}
+
 Instance InstanceBuilder::build()
 {
     // Compute scale value.
@@ -466,9 +510,17 @@ Instance InstanceBuilder::build()
             ItemShape& item_shape = item_type.shapes[shape_pos];
             if (!item_shape.shape_scaled.elements.empty())
                 continue;
-            item_shape.shape_scaled = instance_.parameters().scale_value * item_shape.shape_orig;
-            for (const Shape& hole: item_shape.holes_orig)
-                item_shape.holes_scaled.push_back(instance_.parameters().scale_value * hole);
+
+            auto res = process_shape_outer(instance_.parameters().scale_value * item_shape.shape_orig);
+            item_shape.shape_scaled = res.first;
+            for (const Shape& hole: res.second)
+                item_shape.holes_scaled.push_back(hole);
+
+            for (const Shape& hole: item_shape.holes_orig) {
+                auto res = process_shape_inner(instance_.parameters().scale_value * hole);
+                for (const Shape& hole: res)
+                    item_shape.holes_scaled.push_back(hole);
+            }
         }
 
         // Compute inflated shapes.
@@ -478,18 +530,22 @@ Instance InstanceBuilder::build()
             ItemShape& item_shape = item_type.shapes[shape_pos];
             if (!item_shape.shape_inflated.elements.empty())
                 continue;
-            auto inflated_item_shape = inflate(
+            auto shape_tmp_0 = inflate(
                     item_shape.shape_scaled,
-                    instance_.parameters().scale_value * instance_.parameters().item_item_minimum_spacing);
-            item_shape.shape_inflated = inflated_item_shape.first;
-            for (const Shape& hole: inflated_item_shape.second)
+                    instance_.parameters().scale_value * instance_.parameters().item_item_minimum_spacing,
+                    false);
+            auto res = process_shape_outer(shape_tmp_0.first);
+            item_shape.shape_inflated = res.first;
+            for (const Shape& hole: res.second)
                 item_shape.holes_deflated.push_back(hole);
 
             for (const Shape& hole: item_shape.holes_scaled) {
-                auto deflated_hole = deflate(
+                auto shape_tmp_0 = deflate(
                         hole,
-                        instance_.parameters().scale_value * instance_.parameters().item_item_minimum_spacing);
-                for (const Shape& hole: deflated_hole)
+                        instance_.parameters().scale_value * instance_.parameters().item_item_minimum_spacing,
+                        false);
+                auto res = process_shape_inner(shape_tmp_0.front());
+                for (const Shape& hole: res)
                     item_shape.holes_deflated.push_back(hole);
             }
         }
@@ -545,9 +601,16 @@ Instance InstanceBuilder::build()
         if (bin_type.shape_scaled.elements.empty()) {
             bin_type.shape_scaled = instance_.parameters().scale_value * bin_type.shape_orig;
             for (Defect& defect: bin_type.defects) {
-                defect.shape_scaled = instance_.parameters().scale_value * defect.shape_orig;
-                for (const Shape& hole: defect.holes_orig)
-                    defect.holes_scaled.push_back(instance_.parameters().scale_value * hole);
+                auto res = process_shape_outer(instance_.parameters().scale_value * defect.shape_orig);
+                defect.shape_scaled = res.first;
+                for (const Shape& hole: res.second)
+                    defect.holes_scaled.push_back(hole);
+
+                for (const Shape& hole: defect.holes_orig) {
+                    auto res = process_shape_inner(instance_.parameters().scale_value * hole);
+                    for (const Shape& hole: res)
+                        defect.holes_scaled.push_back(hole);
+                }
             }
         }
 
@@ -556,34 +619,42 @@ Instance InstanceBuilder::build()
             if (!defect.shape_inflated.elements.empty())
                 continue;
 
-            auto inflated_defect_shape = inflate(
+            auto shape_tmp_0 = inflate(
                     defect.shape_scaled,
-                    instance_.parameters().scale_value * instance_.parameters().item_bin_minimum_spacing);
-            defect.shape_inflated = inflated_defect_shape.first;
-            for (const Shape& hole: inflated_defect_shape.second)
+                    instance_.parameters().scale_value * instance_.parameters().item_bin_minimum_spacing,
+                    false);
+            auto res = process_shape_outer(shape_tmp_0.first);
+            defect.shape_inflated = res.first;
+            for (const Shape& hole: res.second)
                 defect.holes_deflated.push_back(hole);
 
             for (const Shape& hole: defect.holes_scaled) {
-                auto deflated_hole = deflate(
+                auto shape_tmp_0 = deflate(
                         hole,
-                        instance_.parameters().scale_value * instance_.parameters().item_bin_minimum_spacing);
-                for (const Shape& hole: deflated_hole)
+                        instance_.parameters().scale_value * instance_.parameters().item_bin_minimum_spacing,
+                        false);
+                auto res = process_shape_inner(shape_tmp_0.front());
+                for (const Shape& hole: res)
                     defect.holes_deflated.push_back(hole);
             }
         }
 
         // Compute inflated borders.
         if (bin_type.borders.empty()) {
             for (const Shape& shape_border: extract_borders(bin_type.shape_scaled)) {
-                auto inflated_shape_border = inflate(
-                        shape_border,
-                        instance_.parameters().scale_value * instance_.parameters().item_bin_minimum_spacing);
                 Defect border;
                 border.type = -2;
                 border.shape_scaled = shape_border;
-                border.shape_inflated = inflated_shape_border.first;
-                for (const Shape& hole: inflated_shape_border.second)
+
+                auto shape_tmp_0 = inflate(
+                        shape_border,
+                        instance_.parameters().scale_value * instance_.parameters().item_bin_minimum_spacing,
+                        false);
+                auto res = process_shape_outer(shape_tmp_0.first);
+                border.shape_inflated = res.first;
+                for (const Shape& hole: res.second)
                     border.holes_deflated.push_back(hole);
+
                 bin_type.borders.push_back(border);
             }
         }

src/irregular/branching_scheme.cpp

@@ -86,10 +86,8 @@ SimplifiedInstance irregular::shape_simplification(
             total_bin_area -= bin_type.copies * border.shape_scaled.compute_area();
 
             bool outer = true;
-            Shape shape = shape::approximate_by_line_segments(border.shape_inflated, 1, outer);
-            shape = shape::clean_shape(shape, outer);
             SimplifyInputShape simplify_input_shape;
-            simplify_input_shape.shape = shape;
+            simplify_input_shape.shape = border.shape_inflated;
             simplify_input_shape.copies = bin_type.copies;
             simplify_input_shape.outer = outer;
             simplify_inflated_bin_types_input.push_back(simplify_input_shape);
@@ -109,10 +107,8 @@ SimplifiedInstance irregular::shape_simplification(
             total_bin_area -= bin_type.copies * defect.shape_scaled.compute_area();
 
             bool outer = true;
-            Shape shape = shape::approximate_by_line_segments(defect.shape_inflated, 1, outer);
-            shape = shape::clean_shape(shape, outer);
             SimplifyInputShape simplify_input_shape;
-            simplify_input_shape.shape = shape;
+            simplify_input_shape.shape = defect.shape_inflated;
             simplify_input_shape.copies = bin_type.copies;
             simplify_input_shape.outer = outer;
             simplify_inflated_bin_types_input.push_back(simplify_input_shape);
@@ -142,10 +138,8 @@ SimplifiedInstance irregular::shape_simplification(
                     continue;
 
                 bool outer = false;
-                Shape shape = shape::approximate_by_line_segments(hole_deflated, 1, outer);
-                shape = shape::clean_shape(shape, outer);
                 SimplifyInputShape simplify_input_shape;
-                simplify_input_shape.shape = shape;
+                simplify_input_shape.shape = hole_deflated;
                 simplify_input_shape.copies = bin_type.copies;
                 simplify_input_shape.outer = outer;
                 simplify_inflated_bin_types_input.push_back(simplify_input_shape);
@@ -176,9 +170,8 @@ SimplifiedInstance irregular::shape_simplification(
 
             {
                 bool outer = true;
-                Shape shape = shape::clean_shape(item_shape.shape_scaled, outer);
                 SimplifyInputShape simplify_input_shape;
-                simplify_input_shape.shape = shape;
+                simplify_input_shape.shape = item_shape.shape_scaled;
                 simplify_input_shape.copies = item_type.copies;
                 simplify_input_shape.outer = outer;
                 simplify_item_types_input.push_back(simplify_input_shape);
@@ -191,18 +184,8 @@ SimplifiedInstance irregular::shape_simplification(
             }
             {
                 bool outer = true;
-                Shape shape = shape::approximate_by_line_segments(item_shape.shape_inflated, 1, outer);
-                //shape.write_svg(
-                //        "item_type_" + std::to_string(item_type_id)
-                //        + "_shape_pos_" + std::to_string(item_shape_pos)
-                //        + "_inflated_approximated.svg");
-                shape = shape::clean_shape(shape, outer);
-                //shape.write_svg(
-                //        "item_type_" + std::to_string(item_type_id)
-                //        + "_shape_pos_" + std::to_string(item_shape_pos)
-                //        + "_inflated_approximated_cleaned.svg");
                 SimplifyInputShape simplify_input_shape;
-                simplify_input_shape.shape = shape;
+                simplify_input_shape.shape = item_shape.shape_inflated;
                 simplify_input_shape.copies = item_type.copies;
                 simplify_input_shape.outer = outer;
                 simplify_inflated_item_types_input.push_back(simplify_input_shape);
@@ -225,9 +208,8 @@ SimplifiedInstance irregular::shape_simplification(
                 total_item_area -= item_type.copies * hole.compute_area();
 
                 bool outer = false;
-                Shape shape = shape::clean_shape(hole, outer);
                 SimplifyInputShape simplify_input_shape;
-                simplify_input_shape.shape = shape;
+                simplify_input_shape.shape = hole;
                 simplify_input_shape.copies = item_type.copies;
                 simplify_input_shape.outer = outer;
                 simplify_item_types_input.push_back(simplify_input_shape);
@@ -249,10 +231,8 @@ SimplifiedInstance irregular::shape_simplification(
                     continue;
 
                 bool outer = false;
-                Shape shape = shape::approximate_by_line_segments(hole_deflated, 1, outer);
-                shape = shape::clean_shape(shape, outer);
                 SimplifyInputShape simplify_input_shape;
-                simplify_input_shape.shape = shape;
+                simplify_input_shape.shape = hole_deflated;
                 simplify_input_shape.copies = item_type.copies;
                 simplify_input_shape.outer = outer;
                 simplify_inflated_item_types_input.push_back(simplify_input_shape);