update according to feedback

- Implemented new inflate function in shape.cpp to support shapes with holes
- Removed inflate method from trapezoid.hpp
- Added GeneralizedTrapezoid::to_shape method for converting trapezoids to shapes
- Modified all calls to trapezoid.inflate in branching_scheme.cpp
- Added unit tests in shape_test.cpp to verify functionality of new inflate function

Author: DusKing1

src/irregular/branching_scheme.cpp

@@ -165,9 +165,14 @@ BranchingScheme::BranchingScheme(
                 if (cleaned_shape.elements.size() > 2) {
                     auto trapezoids = trapezoidation(cleaned_shape);
                     for (const GeneralizedTrapezoid& trapezoid: trapezoids) {
+                        // Convert trapezoid to shape, then use Shape's inflate function
+                        Shape trapezoid_shape = trapezoid.to_shape();
+                        Shape inflated_shape = inflate(trapezoid_shape, instance().parameters().item_bin_minimum_spacing);
+                        // Then convert the inflated shape back to trapezoid
+                        GeneralizedTrapezoid inflated_trapezoid = trapezoidation(inflated_shape)[0];
                         UncoveredTrapezoid defect(
                                 -1,
-                                trapezoid.clean().inflate(instance().parameters().item_bin_minimum_spacing));
+                                inflated_trapezoid);
                         bb_bin_type_x.defects.push_back(defect);
                     }
                 }
@@ -178,9 +183,14 @@ BranchingScheme::BranchingScheme(
                 if (cleaned_shape.elements.size() > 2) {
                     auto trapezoids = trapezoidation(cleaned_shape);
                     for (const GeneralizedTrapezoid& trapezoid: trapezoids) {
+                        // Convert trapezoid to shape, then use Shape's inflate function
+                        Shape trapezoid_shape = trapezoid.to_shape();
+                        Shape inflated_shape = inflate(trapezoid_shape, instance().parameters().item_bin_minimum_spacing);
+                        // Then convert the inflated shape back to trapezoid
+                        GeneralizedTrapezoid inflated_trapezoid = trapezoidation(inflated_shape)[0];
                         UncoveredTrapezoid defect(
                                 -1,
-                                trapezoid.clean().inflate(instance().parameters().item_bin_minimum_spacing));
+                                inflated_trapezoid);
                         bb_bin_type_y.defects.push_back(defect);
                     }
                 }
@@ -204,9 +214,14 @@ BranchingScheme::BranchingScheme(
                             cleaned_shape,
                             cleaned_holes);
                     for (const GeneralizedTrapezoid& trapezoid: trapezoids) {
+                        // Convert trapezoid to shape, then use Shape's inflate function
+                        Shape trapezoid_shape = trapezoid.to_shape();
+                        Shape inflated_shape = inflate(trapezoid_shape, instance().parameters().item_bin_minimum_spacing);
+                        // Then convert the inflated shape back to trapezoid
+                        GeneralizedTrapezoid inflated_trapezoid = trapezoidation(inflated_shape)[0];
                         UncoveredTrapezoid defect(
                                 defect_id,
-                                trapezoid.clean().inflate(instance().parameters().item_bin_minimum_spacing));
+                                inflated_trapezoid);
                         bb_bin_type_x.defects.push_back(defect);
                     }
                 }
@@ -227,9 +242,14 @@ BranchingScheme::BranchingScheme(
                         cleaned_shape,
                         cleaned_holes);
                 for (const GeneralizedTrapezoid& trapezoid: trapezoids) {
+                    // Convert trapezoid to shape, then use Shape's inflate function
+                    Shape trapezoid_shape = trapezoid.to_shape();
+                    Shape inflated_shape = inflate(trapezoid_shape, instance().parameters().item_bin_minimum_spacing);
+                    // Then convert the inflated shape back to trapezoid
+                    GeneralizedTrapezoid inflated_trapezoid = trapezoidation(inflated_shape)[0];
                     UncoveredTrapezoid defect(
                             defect_id,
-                            trapezoid.clean().inflate(instance().parameters().item_bin_minimum_spacing));
+                            inflated_trapezoid);
                     bb_bin_type_y.defects.push_back(defect);
                 }
             }

src/irregular/shape.cpp

@@ -371,98 +371,134 @@ std::vector<Shape> packingsolver::irregular::borders(
 
 Shape irregular::inflate(
         const Shape& shape,
+        const std::vector<Shape>& holes,
         LengthDbl value)
 {
-    Shape inflated_shape;
-    inflated_shape.elements.reserve(shape.elements.size());
+    // 1. Inflate the outer contour
+    Shape inflated_shape = inflate(shape, value);
+    
+    // 2. Shrink the holes (using opposite inflation value for holes)
+    std::vector<Shape> inflated_holes;
+    for (const Shape& hole : holes) {
+        // Note that holes need to use opposite value, as holes expand inward
+        Shape inflated_hole = inflate(hole, -value);
+        inflated_holes.push_back(inflated_hole);
+    }
+    
+    // 3. Set the holes for the inflated shape
+    inflated_shape.holes = inflated_holes;
+    
+    return inflated_shape;
+}
 
+Shape irregular::inflate(
+        const Shape& shape,
+        LengthDbl value)
+{
+    // If inflation value is zero, return the original shape
+    if (equal(value, 0)) {
+        return shape;
+    }
+    
+    Shape inflated_shape;
+    inflated_shape.elements.reserve(shape.elements.size() * 2); // Pre-allocate space, considering possible arc additions
+    
+    // 1. Calculate normal vectors for each edge and inflate the edges
     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
+        
+        // Get the adjacent next element
+        ElementPos next_pos = (element_pos + 1) % shape.elements.size();
+        const ShapeElement& next_element = shape.elements[next_pos];
+        
+        // Only process line segment elements (currently supporting line segments, can be extended to support arcs)
+        if (element.type == ShapeElementType::LineSegment) {
+            // 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);
+            
+            // Ensure length is not zero to avoid division by zero
+            if (length < 1e-10) {
+                continue;
+            }
+            
+            // Calculate unit normal vector (perpendicular to edge direction)
+            LengthDbl nx = dy / length;
+            LengthDbl ny = -dx / length;
+            
+            // Create inflated edge
+            ShapeElement new_element;
+            new_element.type = element.type; // Keep element type unchanged
+            
+            // Extend vertices along normal vector direction
+            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
             };
-            arc_element.end = new_element.start;
-            inflated_shape.elements.push_back(arc_element);
+            
+            // Handle connections between adjacent edges
+            if (next_element.type == ShapeElementType::LineSegment) {
+                // Calculate normal vector of the next edge
+                LengthDbl dx_next = next_element.end.x - next_element.start.x;
+                LengthDbl dy_next = next_element.end.y - next_element.start.y;
+                LengthDbl length_next = std::sqrt(dx_next * dx_next + dy_next * dy_next);
+                
+                if (length_next >= 1e-10) {
+                    LengthDbl nx_next = dy_next / length_next;
+                    LengthDbl ny_next = -dx_next / length_next;
+                    
+                    // Calculate average of two normal vectors for connecting corner
+                    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);
+                    
+                    // Avoid division by zero
+                    if (length_avg >= 1e-10) {
+                        nx_avg /= length_avg;
+                        ny_avg /= length_avg;
+                        
+                        // Create a more precise inflated vertex at the corner
+                        new_element.end = Point{
+                            element.end.x + nx_avg * value / (nx * nx_avg + ny * ny_avg),
+                            element.end.y + ny_avg * value / (nx * nx_avg + ny * ny_avg)
+                        };
+                    }
+                }
+            }
+            
+            // Add inflated edge to new shape
+            inflated_shape.elements.push_back(new_element);
+            
+            // If inflation value is positive and not the last element, we can add connecting arcs
+            if (value > 0 && element_pos < shape.elements.size() - 1) {
+                // TODO: Arc elements can be added here for more precise inflation, especially at corners
+                // Simplified implementation for now, using only line segments
+            }
+        } else if (element.type == ShapeElementType::Arc) {
+            // TODO: Support for inflating arc elements
+            // Simplified implementation for now, preserving the basic shape of arcs, only adjusting radius
+            
+            ShapeElement new_element = element;
+            // For arcs, need to adjust radius and center position
+            // This is a simplified implementation, more precise calculations may be needed in practice
+            
+            // Add inflated arc to new shape
+            inflated_shape.elements.push_back(new_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);
+    
+    // Ensure shape is closed
+    if (!inflated_shape.elements.empty()) {
+        inflated_shape.elements.back().end = inflated_shape.elements.front().start;
     }
-
+    
     return inflated_shape;
 }

src/irregular/shape.hpp

@@ -30,6 +30,26 @@ bool operator==(
         const Shape& shape_1,
         const Shape& shape_2);
 
+/**
+ * Inflate a shape, creating a new shape based on the given distance value from the original shape's outline.
+ * 
+ * @param shape The original shape to be inflated
+ * @param holes List of hole shapes within the main shape
+ * @param value Inflation distance, positive value for outward inflation, negative value for inward shrinking
+ * @return The inflated shape
+ */
+Shape inflate(
+        const Shape& shape,
+        const std::vector<Shape>& holes,
+        LengthDbl value);
+
+/**
+ * Inflate a shape, creating a new shape based on the given distance value from the original shape's outline.
+ * 
+ * @param shape The original shape to be inflated
+ * @param value Inflation distance, positive value for outward inflation, negative value for inward shrinking
+ * @return The inflated shape
+ */
 Shape inflate(
         const Shape& shape,
         LengthDbl value);

src/irregular/trapezoid.cpp

@@ -0,0 +1,46 @@
+#include "irregular/trapezoid.hpp"
+
+#include <iomanip>
+
+using namespace packingsolver;
+using namespace packingsolver::irregular;
+
+std::string GeneralizedTrapezoid::to_string() const
+{
+    std::stringstream ss;
+    std::streamsize precision = std::cout.precision();
+    ss << std::setprecision(std::numeric_limits<double>::digits10 + 1)
+        << "y_bottom " << y_bottom()
+        << " y_top " << y_top()
+        << " x_bottom_left " << x_bottom_left()
+        << " x_bottom_right " << x_bottom_right()
+        << " x_top_left " << x_top_left()
+        << " x_top_right " << x_top_right()
+        << std::setprecision(precision);
+    return ss.str();
+}
+
+std::string GeneralizedTrapezoid::to_svg(
+        const std::string& color,
+        double factor) const
+{
+    return std::string("<path d=\"")
+        + "M" + std::to_string(x_bottom_left() * factor) + "," + std::to_string(-y_bottom() * factor)
+        + "L" + std::to_string(x_bottom_right() * factor) + "," + std::to_string(-y_bottom() * factor)
+        + "L" + std::to_string(x_top_right() * factor) + "," + std::to_string(-y_top() * factor)
+        + "L" + std::to_string(x_top_left() * factor) + "," + std::to_string(-y_top() * factor)
+        + "Z\""
+        + " stroke=\"black\""
+        + " stroke-width=\"1\""
+        + " fill=\"" + color + "\""
+        + " fill-opacity=\"0.2\""
+        + "/>\n";
+}
+
+std::ostream& packingsolver::irregular::operator<<(
+        std::ostream &os,
+        const GeneralizedTrapezoid& trapezoid)
+{
+    os << trapezoid.to_string();
+    return os;
+}