add shape level inflate method

DusKing1 · DusKing1 · commit 87e77e429092 · 2025-03-19T23:52:42.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -7,6 +7,7 @@ checker/*
 OLD
 instances/*
 output/*
+build/*
 data/rectangle/imahori2010
 data/rectangle_raw/imahori2010
 data/irregular/cgshop2024
diff --git a/src/irregular/branching_scheme.cpp b/src/irregular/branching_scheme.cpp
@@ -757,6 +757,9 @@ BranchingScheme::BranchingScheme(
 
 void BranchingScheme::compute_inflated_trapezoid_sets()
 {
+    // initialize the inflated trapezoid sets
+    trapezoid_sets_inflated_.clear();
+    
     for (Direction direction: {
             Direction::LeftToRightThenBottomToTop,
             Direction::LeftToRightThenTopToBottom,
@@ -774,20 +777,53 @@ void BranchingScheme::compute_inflated_trapezoid_sets()
             const TrapezoidSet& trapezoid_set = trapezoid_sets_[(int)direction][trapezoid_set_id];
             trapezoid_sets_inflated_.back().push_back({});
 
-            // Loop through rectangles of the rectangle set.
+            // get the original item type
+            ItemTypeId item_type_id = trapezoid_set.item_type_id;
+            const ItemType& item_type = instance().item_type(item_type_id);
+
+            // process the item shape
             for (ItemShapePos item_shape_pos = 0;
                     item_shape_pos < (ItemShapePos)trapezoid_set.shapes.size();
                     ++item_shape_pos) {
-                const auto& item_shape_trapezoids = trapezoid_set.shapes[item_shape_pos];
                 trapezoid_sets_inflated_.back().back().push_back({});
-
-                for (TrapezoidPos item_shape_trapezoid_pos = 0;
-                        item_shape_trapezoid_pos < (TrapezoidPos)item_shape_trapezoids.size();
-                        ++item_shape_trapezoid_pos) {
-                    const auto& item_shape_trapezoid = item_shape_trapezoids[item_shape_trapezoid_pos];
-                    trapezoid_sets_inflated_.back().back().back().push_back(
-                            item_shape_trapezoid.inflate(instance().parameters().item_item_minimum_spacing));
+                
+                // get the original shape
+                const ItemShape& item_shape = item_type.shapes[item_shape_pos];
+                
+                // adjust the shape according to the direction
+                Shape adjusted_shape = item_shape.shape;
+                if (direction == Direction::LeftToRightThenTopToBottom) {
+                    adjusted_shape = adjusted_shape.axial_symmetry_x_axis();
+                } else if (direction == Direction::RightToLeftThenBottomToTop) {
+                    adjusted_shape = adjusted_shape.axial_symmetry_y_axis();
+                } else if (direction == Direction::RightToLeftThenTopToBottom) {
+                    adjusted_shape = adjusted_shape.axial_symmetry_x_axis();
+                    adjusted_shape = adjusted_shape.axial_symmetry_y_axis();
+                } else if (direction == Direction::BottomToTopThenLeftToRight) {
+                    adjusted_shape = adjusted_shape.axial_symmetry_identity_line();
+                } else if (direction == Direction::BottomToTopThenRightToLeft) {
+                    adjusted_shape = adjusted_shape.axial_symmetry_identity_line();
+                    adjusted_shape = adjusted_shape.axial_symmetry_x_axis();
+                } else if (direction == Direction::TopToBottomThenLeftToRight) {
+                    adjusted_shape = adjusted_shape.axial_symmetry_identity_line();
+                    adjusted_shape = adjusted_shape.axial_symmetry_y_axis();
+                } else if (direction == Direction::TopToBottomThenRightToLeft) {
+                    adjusted_shape = adjusted_shape.axial_symmetry_identity_line();
+                    adjusted_shape = adjusted_shape.axial_symmetry_y_axis();
+                    adjusted_shape = adjusted_shape.axial_symmetry_x_axis();
                 }
+                
+                // clean the shape
+                Shape cleaned_shape = clean_shape(adjusted_shape);
+                
+                // inflate the shape
+                Shape inflated_shape = inflate(cleaned_shape, instance().parameters().item_item_minimum_spacing);
+                
+                // then perform the trapezoidation on the inflated shape
+                std::vector<GeneralizedTrapezoid> inflated_trapezoids = trapezoidation(inflated_shape);
+                
+                // store the trapezoidation result
+                trapezoid_sets_inflated_.back().back().back() = inflated_trapezoids;
             }
         }
     }
diff --git a/src/irregular/shape.cpp b/src/irregular/shape.cpp
@@ -368,3 +368,101 @@ std::vector<Shape> packingsolver::irregular::borders(
 
     return res;
 }
+
+Shape irregular::inflate(
+        const Shape& shape,
+        LengthDbl value)
+{
+    Shape inflated_shape;
+    inflated_shape.elements.reserve(shape.elements.size());
+
+    for (ElementPos element_pos = 0;
+            element_pos < (ElementPos)shape.elements.size();
+            ++element_pos) {
+        const ShapeElement& element = shape.elements[element_pos];
+        ElementPos element_next_pos = (element_pos + 1) % shape.elements.size();
+        const ShapeElement& element_next = shape.elements[element_next_pos];
+
+        // calculate the normal vector of the current edge
+        LengthDbl dx = element.end.x - element.start.x;
+        LengthDbl dy = element.end.y - element.start.y;
+        LengthDbl length = std::sqrt(dx * dx + dy * dy);
+        LengthDbl nx = dy / length;
+        LengthDbl ny = -dx / length;
+
+        // calculate the normal vector of the next edge
+        LengthDbl dx_next = element_next.end.x - element_next.start.x;
+        LengthDbl dy_next = element_next.end.y - element_next.start.y;
+        LengthDbl length_next = std::sqrt(dx_next * dx_next + dy_next * dy_next);
+        LengthDbl nx_next = dy_next / length_next;
+        LengthDbl ny_next = -dx_next / length_next;
+
+        // calculate the average normal vector of the vertex
+        LengthDbl nx_avg = (nx + nx_next) / 2;
+        LengthDbl ny_avg = (ny + ny_next) / 2;
+        LengthDbl length_avg = std::sqrt(nx_avg * nx_avg + ny_avg * ny_avg);
+        nx_avg /= length_avg;
+        ny_avg /= length_avg;
+
+        // create a new edge
+        ShapeElement new_element;
+        new_element.type = element.type;
+        new_element.start = Point{
+            element.start.x + nx * value,
+            element.start.y + ny * value
+        };
+        new_element.end = Point{
+            element.end.x + nx * value,
+            element.end.y + ny * value
+        };
+
+        // add the arc at the vertex
+        if (element_pos > 0) {
+            ShapeElement arc_element;
+            arc_element.type = ShapeElementType::CircularArc;
+            arc_element.start = Point{
+                element.start.x + nx_avg * value,
+                element.start.y + ny_avg * value
+            };
+            arc_element.end = new_element.start;
+            inflated_shape.elements.push_back(arc_element);
+        }
+
+        inflated_shape.elements.push_back(new_element);
+    }
+
+    // add the arc at the last vertex
+    if (!shape.elements.empty()) {
+        const ShapeElement& first_element = shape.elements.front();
+        const ShapeElement& last_element = shape.elements.back();
+        
+        LengthDbl dx_first = first_element.end.x - first_element.start.x;
+        LengthDbl dy_first = first_element.end.y - first_element.start.y;
+        LengthDbl length_first = std::sqrt(dx_first * dx_first + dy_first * dy_first);
+        LengthDbl nx_first = dy_first / length_first;
+        LengthDbl ny_first = -dx_first / length_first;
+
+        LengthDbl dx_last = last_element.end.x - last_element.start.x;
+        LengthDbl dy_last = last_element.end.y - last_element.start.y;
+        LengthDbl length_last = std::sqrt(dx_last * dx_last + dy_last * dy_last);
+        LengthDbl nx_last = dy_last / length_last;
+        LengthDbl ny_last = -dx_last / length_last;
+
+        LengthDbl nx_avg = (nx_first + nx_last) / 2;
+        LengthDbl ny_avg = (ny_first + ny_last) / 2;
+        LengthDbl length_avg = std::sqrt(nx_avg * nx_avg + ny_avg * ny_avg);
+        nx_avg /= length_avg;
+        ny_avg /= length_avg;
+
+        ShapeElement arc_element;
+        arc_element.type = ShapeElementType::CircularArc;
+        arc_element.start = Point{
+            first_element.start.x + nx_avg * value,
+            first_element.start.y + ny_avg * value
+        };
+        arc_element.end = inflated_shape.elements.front().start;
+        inflated_shape.elements.push_back(arc_element);
+    }
+
+    return inflated_shape;
+}
diff --git a/src/irregular/shape.hpp b/src/irregular/shape.hpp
@@ -30,5 +30,9 @@ bool operator==(
         const Shape& shape_1,
         const Shape& shape_2);
 
+Shape inflate(
+        const Shape& shape,
+        LengthDbl value);
+
 }
 }
diff --git a/src/irregular/trapezoid.hpp b/src/irregular/trapezoid.hpp
@@ -513,30 +513,67 @@ class GeneralizedTrapezoid
     GeneralizedTrapezoid inflate(
             LengthDbl value) const
     {
+        // calculate the normal vector
         LengthDbl l_left = std::sqrt(
                 (x_top_left() - x_bottom_left()) * (x_top_left() - x_bottom_left())
                 + height() * height());
-        LengthDbl xbl = x_left(y_bottom() - value) - value * l_left / height();
-        LengthDbl xtl = x_left(y_top() + value) - value * l_left / height();
-        //std::cout << "l_left " << l_left << std::endl;
-        //std::cout << "cos_left " << cos_left << std::endl;
-        //std::cout << "xbl_ " << xbl_ << " -> " << xbl << std::endl;
         LengthDbl l_right = std::sqrt(
                 (x_top_right() - x_bottom_right()) * (x_top_right() - x_bottom_right())
                 + height() * height());
-        LengthDbl xbr = x_right(y_bottom() - value) + value * l_right / height();
-        LengthDbl xtr = x_right(y_top() + value) + value * l_right / height();
+
+        // calculate the unit normal vector (reference the implementation of Clipper2)
+        LengthDbl dx_left = x_top_left() - x_bottom_left();
+        LengthDbl dy_left = height();
+        LengthDbl inverse_hypot_left = 1.0 / l_left;
+        LengthDbl nx_left = dy_left * inverse_hypot_left;
+        LengthDbl ny_left = -dx_left * inverse_hypot_left;
+
+        LengthDbl dx_right = x_top_right() - x_bottom_right();
+        LengthDbl dy_right = height();
+        LengthDbl inverse_hypot_right = 1.0 / l_right;
+        LengthDbl nx_right = -dy_right * inverse_hypot_right;
+        LengthDbl ny_right = dx_right * inverse_hypot_right;
+
+        // calculate the new vertex positions
+        LengthDbl xbl = x_bottom_left() + value * nx_left;
+        LengthDbl ybl = y_bottom() + value * ny_left;
+        LengthDbl xtl = x_top_left() + value * nx_left;
+        LengthDbl ytl = y_top() + value * ny_left;
+        LengthDbl xbr = x_bottom_right() + value * nx_right;
+        LengthDbl ybr = y_bottom() + value * ny_right;
+        LengthDbl xtr = x_top_right() + value * nx_right;
+        LengthDbl ytr = y_top() + value * ny_right;
+
+        // calculate the new trapezoid parameters
+        LengthDbl yb = std::min(ybl, ybr);
+        LengthDbl yt = std::max(ytl, ytr);
+        
+        // calculate the new slopes
+        double a_left_new = (xtl - xbl) / (ytl - ybl);
+        double a_right_new = (xtr - xbr) / (ytr - ybr);
+
+        // calculate the new x coordinates
+        LengthDbl xbl_new = xbl + (yb - ybl) * a_left_new;
+        LengthDbl xbr_new = xbr + (yb - ybr) * a_right_new;
+        LengthDbl xtl_new = xtl + (yt - ytl) * a_left_new;
+        LengthDbl xtr_new = xtr + (yt - ytr) * a_right_new;
+
+        // keep the original output
+        //std::cout << "l_left " << l_left << std::endl;
+        //std::cout << "cos_left " << cos_left << std::endl;
+        //std::cout << "xbl_ " << xbl_ << " -> " << xbl << std::endl;
         //std::cout << "a_right " << a_right() << std::endl;
         //std::cout << "l_right " << l_right << std::endl;
         //std::cout << "cos_right " << cos_right << std::endl;
         //std::cout << " xbr " << xbr_ << " -> " << xbr << std::endl;
+
         return GeneralizedTrapezoid(
-                y_bottom() - value,
-                y_top() + value,
-                xbl,
-                xbr,
-                xtl,
-                xtr);
+                yb,
+                yt,
+                xbl_new,
+                xbr_new,
+                xtl_new,
+                xtr_new);
     }
 
     GeneralizedTrapezoid axial_symmetry_x_axis() const

Original file line number	Diff line number	Diff line change
`@@ -30,5 +30,9 @@ bool operator==(`
`30`	`30`	`const Shape& shape_1,`
`31`	`31`	`const Shape& shape_2);`
`32`	`32`
	`33`	`+Shape inflate(`
	`34`	`+ const Shape& shape,`
	`35`	`+ LengthDbl value);`
	`36`	`+`
`33`	`37`	`}`
`34`	`38`	`}`