Improvements in Inner Outer Inner wall ordering logic (#6138)

* Improvements in Inner Outer Inner wall ordering logic

* Updated to BFS algorithm, made ordering more robust and corrected edge cases

* Doc updates

* Refinements in perimeter sorting

* Removal of touch threshold and code debugging to improve sequencing

* Code cleanup

* Code refinements on perimeter distance thresholds

* Extend perimeter re-ordering to more than inset index 2, to reduce travel moves when printing neighbouring features

* Refinements to IOI perimeter re-ordering algorithm to improve travel scenarios where multiple external perimeters are contained in the same island.

* Documentation updates

* Removed unnecessary code

* Removed bespoke to_points function and replaced with ExtrusionLine member already present. Removed squaredDistance and replaced with Eigen library call.

* Refactor code to move distancing functions to the multipoint class. Renamed for more clarity on their purpose.

src/libslic3r/Arachne/utils/ExtrusionLine.hpp

@@ -245,6 +245,15 @@ static inline Polygon to_polygon(const ExtrusionLine &line)
     return out;
 }
 
+static Points to_points(const ExtrusionLine &extrusion_line)
+{
+    Points points;
+    points.reserve(extrusion_line.junctions.size());
+    for (const ExtrusionJunction &junction : extrusion_line.junctions)
+        points.emplace_back(junction.p);
+    return points;
+}
+
 #if 0
 static BoundingBox get_extents(const ExtrusionLine &extrusion_line)
 {
@@ -272,15 +281,6 @@ static BoundingBox get_extents(const std::vector<const ExtrusionLine *> &extrusi
     return bbox;
 }
 
-static Points to_points(const ExtrusionLine &extrusion_line)
-{
-    Points points;
-    points.reserve(extrusion_line.junctions.size());
-    for (const ExtrusionJunction &junction : extrusion_line.junctions)
-        points.emplace_back(junction.p);
-    return points;
-}
-
 static std::vector<Points> to_points(const std::vector<const ExtrusionLine *> &extrusion_lines)
 {
     std::vector<Points> points;

src/libslic3r/MultiPoint.cpp

@@ -370,6 +370,59 @@ Points MultiPoint::concave_hull_2d(const Points& pts, const double tolerence)
 }
 
 
+//Orca: Distancing function used by IOI wall ordering algorithm for arachne
+/**
+ * @brief Calculates the squared distance between a point and a line segment defined by two points.
+ *
+ * @param p The point.
+ * @param v The starting point of the line segment.
+ * @param w The ending point of the line segment.
+ * @return double The squared distance between the point and the line segment.
+ */
+ double MultiPoint::squaredDistanceToLineSegment(const Point& p, const Point& v, const Point& w) {
+    // Calculate the squared length of the line segment
+    double l2 = (v - w).squaredNorm();
+    // If the segment is a single point, return the squared distance to that point
+    if (l2 == 0.0) return (p - v).squaredNorm();
+    // Project point p onto the line defined by v and w, and clamp the projection to the segment
+    double t = std::max(0.0, std::min(1.0, ((p - v).dot(w - v)) / l2));
+    // Compute the projection point
+    Point projection{v.x() + t * (w.x() - v.x()), v.y() + t * (w.y() - v.y())};
+    // Return the squared distance between the point and the projection
+    return (p - projection).squaredNorm();
+}
+
+//Orca: Distancing function used by IOI wall ordering algorithm for arachne
+/**
+ * @brief Calculates the minimum distance between two lines defined by sets of points.
+ *
+ * @param A The first set of points defining a polyline.
+ * @param B The second set of points defining a polyline.
+ * @return double The minimum distance between the two polylines.
+ */
+ double MultiPoint::minimumDistanceBetweenLinesDefinedByPoints(const Points& A, const Points& B) {
+    double min_distance = std::numeric_limits<double>::infinity();
+
+    // Calculate the minimum distance between segments in A and points in B
+    for (size_t i = 0; i < A.size() - 1; ++i) {
+        for (const auto& b : B) {
+            double distance = squaredDistanceToLineSegment(b, A[i], A[i + 1]);
+            min_distance = std::min(min_distance, std::sqrt(distance));
+        }
+    }
+
+    // Calculate the minimum distance between segments in B and points in A
+    for (size_t i = 0; i < B.size() - 1; ++i) {
+        for (const auto& a : A) {
+            double distance = squaredDistanceToLineSegment(a, B[i], B[i + 1]);
+            min_distance = std::min(min_distance, std::sqrt(distance));
+        }
+    }
+
+    return min_distance;
+}
+
+
 void MultiPoint3::translate(double x, double y)
 {
     for (Vec3crd &p : points) {

src/libslic3r/MultiPoint.hpp

@@ -98,13 +98,20 @@ class MultiPoint
     static Points _douglas_peucker(const Points &points, const double tolerance);
     static Points visivalingam(const Points& pts, const double tolerance);
     static Points concave_hull_2d(const Points& pts, const double tolerence);
+
+    //Orca: Distancing function used by IOI wall ordering algorithm for arachne
+    static double minimumDistanceBetweenLinesDefinedByPoints(const Points& A, const Points& B);
 
     inline auto begin()        { return points.begin(); }
     inline auto begin()  const { return points.begin(); }
     inline auto end()          { return points.end();   }
     inline auto end()    const { return points.end();   }
     inline auto cbegin() const { return points.begin(); }
     inline auto cend()   const { return points.end();   }
+
+private:
+    //Orca: Distancing function used by IOI wall ordering algorithm for arachne
+    static double squaredDistanceToLineSegment(const Point& p, const Point& v, const Point& w);
 };
 
 class MultiPoint3