Implement approximate_circular_arc_by_line_segments

Author: fontanf

include/packingsolver/irregular/shape.hpp

@@ -50,12 +50,6 @@ struct Point
      */
 
     std::string to_string() const;
-
-    /*
-     * Others
-     */
-
-    bool operator==(const Point& point) const { return x == point.x && y == point.y; }
 };
 
 Point operator+(
@@ -153,6 +147,19 @@ struct ShapeElement
     std::string to_string() const;
 };
 
+/**
+ * Convert a shape element of type CircularArc into multiple shape elements
+ * of type LineSegment.
+ */
+std::vector<ShapeElement> approximate_circular_arc_by_line_segments(
+        const ShapeElement& circular_arc,
+        ElementPos number_of_line_segments,
+        bool outer);
+
+////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////// Shape /////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
 enum class ShapeType
 {
     Circle,
@@ -260,7 +267,9 @@ struct BuildShapeElement
  * Build a right triangle where the hypotenuse is a drilled circular arc
  * build_shape({{0, 0}, {1, 0}, {0, 0, -1}, {1, 1}})
  */
-Shape build_shape(const std::vector<BuildShapeElement>& points);
+Shape build_shape(
+        const std::vector<BuildShapeElement>& points,
+        bool path = false);
 
 double compute_svg_factor(double width);
 
@@ -287,13 +296,35 @@ std::pair<bool, Shape> equalize_close_y(
 Shape clean_shape(
         const Shape& shape);
 
+inline bool operator==(
+        const Point& point_1,
+        const Point& point_2)
+{
+    return (point_1.x == point_2.x) && (point_1.y == point_2.y);
+}
+
+inline bool near(
+        const Point& point_1,
+        const Point& point_2)
+{
+    return equal(point_1.x, point_2.x) && equal(point_1.y, point_2.y);
+}
+
 bool operator==(
         const ShapeElement& element_1,
         const ShapeElement& element_2);
 
+bool near(
+        const ShapeElement& element_1,
+        const ShapeElement& element_2);
+
 bool operator==(
         const Shape& shape_1,
         const Shape& shape_2);
 
+bool near(
+        const Shape& shape_1,
+        const Shape& shape_2);
+
 }
 }

src/irregular/shape.cpp

@@ -249,6 +249,95 @@ char irregular::element2char(ShapeElementType type)
     return ' ';
 }
 
+std::vector<ShapeElement> irregular::approximate_circular_arc_by_line_segments(
+        const ShapeElement& circular_arc,
+        ElementPos number_of_line_segments,
+        bool outer)
+{
+    if (circular_arc.type != ShapeElementType::CircularArc) {
+        throw std::runtime_error(
+                "packingsolver::irregular::circular_arc_to_line_segments: "
+                "input element must be of type CircularArc; "
+                "circular_arc.type: " + element2str(circular_arc.type) + ".");
+    }
+    if (!outer && number_of_line_segments < 1) {
+        throw std::runtime_error(
+                "packingsolver::irregular::circular_arc_to_line_segments: "
+                "at least 1 line segment is needed to inner approximate a circular arc; "
+                "outer: " + std::to_string(outer) + "; "
+                "number_of_line_segments: " + std::to_string(number_of_line_segments) + ".");
+    }
+
+    Angle angle = angle_radian(
+            circular_arc.start - circular_arc.center,
+            circular_arc.end - circular_arc.center);
+    if (outer) {
+        if (angle < M_PI && number_of_line_segments < 2) {
+            throw std::runtime_error(
+                    "packingsolver::irregular::circular_arc_to_line_segments: "
+                    "at least 2 line segments are needed to outer approximate a circular arc with an angle <= PI; "
+                    "outer: " + std::to_string(outer) + "; "
+                    "angle: " + std::to_string(angle) + "; "
+                    "number_of_line_segments: " + std::to_string(number_of_line_segments) + ".");
+        } else if (angle >= M_PI && number_of_line_segments < 3) {
+            throw std::runtime_error(
+                    "packingsolver::irregular::circular_arc_to_line_segments: "
+                    "at least 3 line segments are needed to outer approximate a circular arc with an angle >= PI; "
+                    "outer: " + std::to_string(outer) + "; "
+                    "angle: " + std::to_string(angle) + "; "
+                    "number_of_line_segments: " + std::to_string(number_of_line_segments) + ".");
+        }
+    }
+
+    std::vector<ShapeElement> line_segments;
+    Length radius = distance(circular_arc.center, circular_arc.start);
+    Point point_prev = circular_arc.start;
+    Point point_circle_prev = circular_arc.start;
+    for (ElementPos line_segment_id = 0;
+            line_segment_id < number_of_line_segments - 1;
+            ++line_segment_id) {
+        Angle angle_cur = (angle * (line_segment_id + 1)) / (number_of_line_segments - 1);
+        Point point_circle;
+        point_circle.x = circular_arc.center.x + radius * std::cos(angle_cur);
+        point_circle.y = circular_arc.center.y + radius * std::sin(angle_cur);
+        Point point_cur;
+        if (!outer) {
+            point_cur = point_circle;
+        } else {
+            // https://en.wikipedia.org/wiki/Tangent_lines_to_circles#Cartesian_equation
+            // https://en.wikipedia.org/wiki/Intersection_(geometry)#Two_lines
+            // The tangent line of the circle at (x1, y1) has Cartesian equation
+            // (x - x1)(x1 - xc) + (y - y1)(y1 - yc) = 0
+            // (x1 - xc) * x + (y1 - yc) * y - x1 * (x1 - xc) - y1 * (y1 - yc) = 0
+            // At (x2, y2)
+            // (x2 - xc) * x + (y2 - yc) * y - x2 * (x2 - xc) - y2 * (y1 - yc) = 0
+            LengthDbl a1 = (point_circle_prev.x - circular_arc.center.x);
+            LengthDbl b1 = (point_circle_prev.y - circular_arc.center.y);
+            LengthDbl c1 = point_circle_prev.x * (point_circle_prev.x - circular_arc.center.x)
+                + point_circle_prev.y * (point_circle_prev.y - circular_arc.center.y);
+            LengthDbl a2 = (point_circle.x - circular_arc.center.x);
+            LengthDbl b2 = (point_circle.y - circular_arc.center.y);
+            LengthDbl c2 = point_circle.x * (point_circle.x - circular_arc.center.x)
+                + point_circle.y * (point_circle.y - circular_arc.center.y);
+            point_cur.x = (c1 * b2 - c2 * b1) / (a1 * b2 - a2 * b1);
+            point_cur.y = (a1 * c2 - a2 * c1) / (a1 * b2 - a2 * b1);
+        }
+        ShapeElement line_segment;
+        line_segment.start = point_prev;
+        line_segment.end = point_cur;
+        line_segment.type = ShapeElementType::LineSegment;
+        line_segments.push_back(line_segment);
+        point_prev = point_cur;
+        point_circle_prev = point_circle;
+    }
+    ShapeElement line_segment;
+    line_segment.start = point_prev;
+    line_segment.end = circular_arc.end;
+    line_segment.type = ShapeElementType::LineSegment;
+    line_segments.push_back(line_segment);
+    return line_segments;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////// Shape /////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -592,24 +681,29 @@ void Shape::write_svg(
 }
 
 Shape packingsolver::irregular::build_shape(
-        const std::vector<BuildShapeElement>& points)
+        const std::vector<BuildShapeElement>& points,
+        bool path)
 {
     Shape shape;
     Point point_prev = {points.back().x, points.back().y};
+    ShapeElementType type = ShapeElementType::LineSegment;
     bool anticlockwise = false;
     Point center = {0, 0};
     for (ElementPos pos = 0; pos < (ElementPos)points.size(); ++pos) {
-        const BuildShapeElement point = points[pos];
+        const BuildShapeElement& point = points[pos];
         if (point.type == 0) {
             ShapeElement element;
-            element.type = ShapeElementType::LineSegment;
+            element.type = type;
             element.start = point_prev;
             element.end = {points[pos].x, points[pos].y};
-            shape.elements.push_back(element);
+            if (!path || pos > 0)
+                shape.elements.push_back(element);
             point_prev = element.end;
+            type = ShapeElementType::LineSegment;
         } else {
             anticlockwise = (point.type == 1);
             center = {points[pos].x, points[pos].y};
+            type = ShapeElementType::CircularArc;
         }
     }
     return shape;
@@ -834,6 +928,25 @@ bool irregular::operator==(
     return true;
 }
 
+bool irregular::near(
+        const ShapeElement& element_1,
+        const ShapeElement& element_2)
+{
+    if (element_1.type != element_2.type)
+        return false;
+    if (!near(element_1.start, element_2.start))
+        return false;
+    if (!near(element_1.end, element_2.end))
+        return false;
+    if (element_1.type == ShapeElementType::CircularArc) {
+        if (!near(element_1.center, element_2.center))
+            return false;
+        if (element_1.anticlockwise != element_2.anticlockwise)
+            return false;
+    }
+    return true;
+}
+
 bool irregular::operator==(
         const Shape& shape_1,
         const Shape& shape_2)
@@ -865,3 +978,35 @@ bool irregular::operator==(
 
     return true;
 }
+
+bool irregular::near(
+        const Shape& shape_1,
+        const Shape& shape_2)
+{
+    // First, check if both shapes have the same number of elements.
+    if (shape_1.elements.size() != shape_2.elements.size())
+        return false;
+
+    ElementPos offset = -1;
+    for (ElementPos element_pos = 0;
+            element_pos < (ElementPos)shape_2.elements.size();
+            ++element_pos) {
+        if (near(shape_2.elements[element_pos], shape_1.elements[0])) {
+            offset = element_pos;
+            break;
+        }
+    }
+    if (offset == -1)
+        return false;
+
+    for (ElementPos element_pos = 0;
+            element_pos < (ElementPos)shape_2.elements.size();
+            ++element_pos) {
+        ElementPos element_pos_2 = (element_pos + offset) % shape_2.elements.size();
+        if (!near(shape_1.elements[element_pos], shape_2.elements[element_pos_2])) {
+            return false;
+        }
+    }
+
+    return true;
+}

test/irregular/shape_test.cpp

@@ -35,3 +35,58 @@ INSTANTIATE_TEST_SUITE_P(
                 build_shape({{0, 0}, {100, 0}, {100, 100}, {50, 50}}),
                 build_shape({{0, 0}, {100, 0}, {100, 100}})
             }}));
+
+
+struct ApproximateCircularArcByLineSegmentsTestParams
+{
+    ShapeElement circular_arc;
+    ElementPos number_of_line_segments;
+    bool outer;
+    std::vector<ShapeElement> expected_line_segments;
+};
+
+class IrregularApproximateCircularArcByLineSegmentsTest: public testing::TestWithParam<ApproximateCircularArcByLineSegmentsTestParams> { };
+
+TEST_P(IrregularApproximateCircularArcByLineSegmentsTest, ApproximateCircularArcByLineSegments)
+{
+    ApproximateCircularArcByLineSegmentsTestParams test_params = GetParam();
+    std::cout << "circular_arc" << std::endl;
+    std::cout << test_params.circular_arc.to_string() << std::endl;
+    std::cout << "expected_line_segments" << std::endl;
+    for (const ShapeElement& line_segment: test_params.expected_line_segments)
+        std::cout << line_segment.to_string() << std::endl;
+    std::vector<ShapeElement> line_segments = approximate_circular_arc_by_line_segments(
+            test_params.circular_arc,
+            test_params.number_of_line_segments,
+            test_params.outer);
+    std::cout << "line_segments" << std::endl;
+    for (const ShapeElement& line_segment: line_segments)
+        std::cout << line_segment.to_string() << std::endl;
+
+    ASSERT_EQ(line_segments.size(), test_params.number_of_line_segments);
+    for (ElementPos pos = 0; pos < test_params.number_of_line_segments; ++pos) {
+        //std::cout << std::setprecision (15) << line_segments[pos].start.x << std::endl;
+        EXPECT_TRUE(near(line_segments[pos], test_params.expected_line_segments[pos]));
+    }
+}
+
+INSTANTIATE_TEST_SUITE_P(
+        Irregular,
+        IrregularApproximateCircularArcByLineSegmentsTest,
+        testing::ValuesIn(std::vector<ApproximateCircularArcByLineSegmentsTestParams>{
+            {
+                build_shape({{1, 0}, {0, 0, 1}, {0, 1}}, true).elements.front(),
+                1,
+                false,
+                build_shape({{1, 0}, {0, 1}}, true).elements
+            }, {
+                build_shape({{1, 0}, {0, 0, 1}, {0, 1}}, true).elements.front(),
+                2,
+                true,
+                build_shape({{1, 0}, {1, 1}, {0, 1}}, true).elements
+            }, {
+                build_shape({{1, 0}, {0, 0, 1}, {0, 1}}, true).elements.front(),
+                3,
+                true,
+                build_shape({{1, 0}, {1, 0.414213562373095}, {0.414213562373095, 1}, {0, 1}}, true).elements
+            }}));