SPE-1963: Improve ordering of perimeters with Arachne perimeter generator

Especially in cases when the object is composed only of 2 external perimeters and 1 or 2 internal perimeters, the order of perimeters wasn't optimal and differed from the Classic perimeter generator. That caused unnecessary long travels before the external contour was printed.

The ordering of perimeters is slightly inspired by the latest changes in CuraEngine.

Cherry-picked from prusa3d/PrusaSlicer@10875082de

Co-authored-by: Lukáš Hejl <hejl.lukas@gmail.com>

src/libslic3r/Arachne/PerimeterOrder.cpp

@@ -0,0 +1,276 @@
+#include "PerimeterOrder.hpp"
+
+namespace Slic3r::Arachne::PerimeterOrder {
+
+using namespace Arachne;
+
+static size_t get_extrusion_lines_count(const Perimeters &perimeters) {
+    size_t extrusion_lines_count = 0;
+    for (const Perimeter &perimeter : perimeters)
+        extrusion_lines_count += perimeter.size();
+
+    return extrusion_lines_count;
+}
+
+static PerimeterExtrusions get_sorted_perimeter_extrusions_by_area(const Perimeters &perimeters) {
+    PerimeterExtrusions sorted_perimeter_extrusions;
+    sorted_perimeter_extrusions.reserve(get_extrusion_lines_count(perimeters));
+
+    for (const Perimeter &perimeter : perimeters) {
+        for (const ExtrusionLine &extrusion_line : perimeter) {
+            if (extrusion_line.empty())
+                continue; // This shouldn't ever happen.
+
+            const BoundingBox bbox    = get_extents(extrusion_line);
+            // Be aware that Arachne produces contours with clockwise orientation and holes with counterclockwise orientation.
+            const double      area    = std::abs(extrusion_line.area());
+            const Polygon     polygon = extrusion_line.is_closed ? to_polygon(extrusion_line) : Polygon{};
+
+            sorted_perimeter_extrusions.emplace_back(extrusion_line, area, polygon, bbox);
+        }
+    }
+
+    // Open extrusions have an area equal to zero, so sorting based on the area ensures that open extrusions will always be before closed ones.
+    std::sort(sorted_perimeter_extrusions.begin(), sorted_perimeter_extrusions.end(),
+              [](const PerimeterExtrusion &l, const PerimeterExtrusion &r) { return l.area < r.area; });
+
+    return sorted_perimeter_extrusions;
+}
+
+// Functions fill adjacent_perimeter_extrusions field for every PerimeterExtrusion by pointers to PerimeterExtrusions that contain or are inside this PerimeterExtrusion.
+static void construct_perimeter_extrusions_adjacency_graph(PerimeterExtrusions &sorted_perimeter_extrusions) {
+    // Construct a graph (defined using adjacent_perimeter_extrusions field) where two PerimeterExtrusion are adjacent when one is inside the other.
+    std::vector<bool> root_candidates(sorted_perimeter_extrusions.size(), false);
+    for (PerimeterExtrusion &perimeter_extrusion : sorted_perimeter_extrusions) {
+        const size_t perimeter_extrusion_idx = &perimeter_extrusion - sorted_perimeter_extrusions.data();
+
+        if (!perimeter_extrusion.is_closed()) {
+            root_candidates[perimeter_extrusion_idx] = true;
+            continue;
+        }
+
+        for (PerimeterExtrusion &root_candidate : sorted_perimeter_extrusions) {
+            const size_t root_candidate_idx = &root_candidate - sorted_perimeter_extrusions.data();
+
+            if (!root_candidates[root_candidate_idx])
+                continue;
+
+            if (perimeter_extrusion.bbox.contains(root_candidate.bbox) && perimeter_extrusion.polygon.contains(root_candidate.extrusion.junctions.front().p)) {
+                perimeter_extrusion.adjacent_perimeter_extrusions.emplace_back(&root_candidate);
+                root_candidate.adjacent_perimeter_extrusions.emplace_back(&perimeter_extrusion);
+                root_candidates[root_candidate_idx] = false;
+            }
+        }
+
+        root_candidates[perimeter_extrusion_idx] = true;
+    }
+}
+
+// Perform the depth-first search to assign the nearest external perimeter for every PerimeterExtrusion.
+// When some PerimeterExtrusion is achievable from more than one external perimeter, then we choose the
+// one that comes from a contour.
+static void assign_nearest_external_perimeter(PerimeterExtrusions &sorted_perimeter_extrusions) {
+    std::stack<PerimeterExtrusion *> stack;
+    for (PerimeterExtrusion &perimeter_extrusion : sorted_perimeter_extrusions) {
+        if (perimeter_extrusion.is_external_perimeter()) {
+            perimeter_extrusion.depth                      = 0;
+            perimeter_extrusion.nearest_external_perimeter = &perimeter_extrusion;
+            stack.push(&perimeter_extrusion);
+        }
+    }
+
+    while (!stack.empty()) {
+        PerimeterExtrusion *current_extrusion = stack.top();
+        stack.pop();
+
+        for (PerimeterExtrusion *adjacent_extrusion : current_extrusion->adjacent_perimeter_extrusions) {
+            const size_t adjacent_extrusion_depth = current_extrusion->depth + 1;
+            // Update depth when the new depth is smaller or when we can achieve the same depth from a contour.
+            // This will ensure that the internal perimeter will be extruded before the outer external perimeter
+            // when there are two external perimeters and one internal.
+            if (adjacent_extrusion_depth < adjacent_extrusion->depth) {
+                adjacent_extrusion->nearest_external_perimeter = current_extrusion->nearest_external_perimeter;
+                adjacent_extrusion->depth                      = adjacent_extrusion_depth;
+                stack.push(adjacent_extrusion);
+            } else if (adjacent_extrusion_depth == adjacent_extrusion->depth && !adjacent_extrusion->nearest_external_perimeter->is_contour() && current_extrusion->is_contour()) {
+                adjacent_extrusion->nearest_external_perimeter = current_extrusion->nearest_external_perimeter;
+                stack.push(adjacent_extrusion);
+            }
+        }
+    }
+}
+
+inline Point get_end_position(const ExtrusionLine &extrusion) {
+    if (extrusion.is_closed)
+        return extrusion.junctions[0].p; // We ended where we started.
+    else
+        return extrusion.junctions.back().p; // Pick the other end from where we started.
+}
+
+// Returns ordered extrusions.
+static std::vector<const PerimeterExtrusion *> ordered_perimeter_extrusions_to_minimize_distances(Point current_position, std::vector<const PerimeterExtrusion *> extrusions) {
+    // Ensure that open extrusions will be placed before the closed one.
+    std::sort(extrusions.begin(), extrusions.end(),
+              [](const PerimeterExtrusion *l, const PerimeterExtrusion *r) -> bool { return l->is_closed() < r->is_closed(); });
+
+    std::vector<const PerimeterExtrusion *> ordered_extrusions;
+    std::vector<bool> already_selected(extrusions.size(), false);
+    while (ordered_extrusions.size() < extrusions.size()) {
+        double nearest_distance_sqr  = std::numeric_limits<double>::max();
+        size_t nearest_extrusion_idx = 0;
+        bool   is_nearest_closed     = false;
+
+        for (size_t extrusion_idx = 0; extrusion_idx < extrusions.size(); ++extrusion_idx) {
+            if (already_selected[extrusion_idx])
+                continue;
+
+            const ExtrusionLine &extrusion_line           = extrusions[extrusion_idx]->extrusion;
+            const Point         &extrusion_start_position = extrusion_line.junctions.front().p;
+            const double         distance_sqr             = (current_position - extrusion_start_position).cast<double>().squaredNorm();
+            if (distance_sqr < nearest_distance_sqr) {
+                if (extrusion_line.is_closed || (!extrusion_line.is_closed && nearest_distance_sqr != std::numeric_limits<double>::max()) || (!extrusion_line.is_closed && !is_nearest_closed)) {
+                    nearest_extrusion_idx = extrusion_idx;
+                    nearest_distance_sqr  = distance_sqr;
+                    is_nearest_closed     = extrusion_line.is_closed;
+                }
+            }
+        }
+
+        already_selected[nearest_extrusion_idx]     = true;
+        const PerimeterExtrusion *nearest_extrusion = extrusions[nearest_extrusion_idx];
+        current_position                            = get_end_position(nearest_extrusion->extrusion);
+        ordered_extrusions.emplace_back(nearest_extrusion);
+    }
+
+    return ordered_extrusions;
+}
+
+struct GroupedPerimeterExtrusions
+{
+    GroupedPerimeterExtrusions() = delete;
+    explicit GroupedPerimeterExtrusions(const PerimeterExtrusion *external_perimeter_extrusion)
+        : external_perimeter_extrusion(external_perimeter_extrusion) {}
+
+    std::vector<const PerimeterExtrusion *> extrusions;
+    const PerimeterExtrusion               *external_perimeter_extrusion  = nullptr;
+};
+
+// Returns vector of indexes that represent the order of grouped extrusions in grouped_extrusions.
+static std::vector<size_t> order_of_grouped_perimeter_extrusions_to_minimize_distances(Point current_position, std::vector<GroupedPerimeterExtrusions> grouped_extrusions) {
+    // Ensure that holes will be placed before contour and open extrusions before the closed one.
+    std::sort(grouped_extrusions.begin(), grouped_extrusions.end(), [](const GroupedPerimeterExtrusions &l, const GroupedPerimeterExtrusions &r) -> bool {
+        return (l.external_perimeter_extrusion->is_contour() <  r.external_perimeter_extrusion->is_contour()) ||
+               (l.external_perimeter_extrusion->is_contour() == r.external_perimeter_extrusion->is_contour()  && l.external_perimeter_extrusion->is_closed() < r.external_perimeter_extrusion->is_closed());
+    });
+
+    const size_t holes_cnt = std::count_if(grouped_extrusions.begin(), grouped_extrusions.end(), [](const GroupedPerimeterExtrusions &grouped_extrusions) {
+        return !grouped_extrusions.external_perimeter_extrusion->is_contour();
+    });
+
+    std::vector<size_t> grouped_extrusions_order;
+    std::vector<bool>   already_selected(grouped_extrusions.size(), false);
+    while (grouped_extrusions_order.size() < grouped_extrusions.size()) {
+        double nearest_distance_sqr           = std::numeric_limits<double>::max();
+        size_t nearest_grouped_extrusions_idx = 0;
+        bool   is_nearest_closed              = false;
+
+        // First we order all holes and then we start ordering contours.
+        const size_t grouped_extrusion_end = grouped_extrusions_order.size() < holes_cnt ? holes_cnt: grouped_extrusions.size();
+        for (size_t grouped_extrusion_idx = 0; grouped_extrusion_idx < grouped_extrusion_end; ++grouped_extrusion_idx) {
+            if (already_selected[grouped_extrusion_idx])
+                continue;
+
+            const ExtrusionLine &external_perimeter_extrusion_line = grouped_extrusions[grouped_extrusion_idx].external_perimeter_extrusion->extrusion;
+            const Point         &extrusion_start_position          = external_perimeter_extrusion_line.junctions.front().p;
+            const double         distance_sqr                      = (current_position - extrusion_start_position).cast<double>().squaredNorm();
+            if (distance_sqr < nearest_distance_sqr) {
+                if (external_perimeter_extrusion_line.is_closed || (!external_perimeter_extrusion_line.is_closed && nearest_distance_sqr != std::numeric_limits<double>::max()) || (!external_perimeter_extrusion_line.is_closed && !is_nearest_closed)) {
+                    nearest_grouped_extrusions_idx = grouped_extrusion_idx;
+                    nearest_distance_sqr           = distance_sqr;
+                    is_nearest_closed              = external_perimeter_extrusion_line.is_closed;
+                }
+            }
+        }
+
+        grouped_extrusions_order.emplace_back(nearest_grouped_extrusions_idx);
+        already_selected[nearest_grouped_extrusions_idx]             = true;
+        const GroupedPerimeterExtrusions &nearest_grouped_extrusions = grouped_extrusions[nearest_grouped_extrusions_idx];
+        const ExtrusionLine              &last_extrusion_line        = nearest_grouped_extrusions.extrusions.back()->extrusion;
+        current_position                                             = get_end_position(last_extrusion_line);
+    }
+
+    return grouped_extrusions_order;
+}
+
+static PerimeterExtrusions extract_ordered_perimeter_extrusions(const PerimeterExtrusions &sorted_perimeter_extrusions, const bool external_perimeters_first) {
+    // Extrusions are ordered inside each group.
+    std::vector<GroupedPerimeterExtrusions> grouped_extrusions;
+
+    std::stack<const PerimeterExtrusion *> stack;
+    std::vector<bool>                      visited(sorted_perimeter_extrusions.size(), false);
+    for (const PerimeterExtrusion &perimeter_extrusion : sorted_perimeter_extrusions) {
+        if (!perimeter_extrusion.is_external_perimeter())
+            continue;
+
+        stack.push(&perimeter_extrusion);
+        visited.assign(sorted_perimeter_extrusions.size(), false);
+
+        grouped_extrusions.emplace_back(&perimeter_extrusion);
+        while (!stack.empty()) {
+            const PerimeterExtrusion *current_extrusion     = stack.top();
+            const size_t              current_extrusion_idx = current_extrusion - sorted_perimeter_extrusions.data();
+            stack.pop();
+
+            if (visited[current_extrusion_idx])
+                continue;
+
+            if (current_extrusion->nearest_external_perimeter == &perimeter_extrusion)
+                grouped_extrusions.back().extrusions.emplace_back(current_extrusion);
+
+            if (current_extrusion->adjacent_perimeter_extrusions.size() == 1) {
+                const PerimeterExtrusion *adjacent_extrusion = current_extrusion->adjacent_perimeter_extrusions.front();
+                stack.push(adjacent_extrusion);
+            } else if (current_extrusion->adjacent_perimeter_extrusions.size() > 1) {
+                // When there is more than one available candidate, then order candidates to minimize distances between
+                // candidates and also to minimize the distance from the current_position.
+                std::vector<const PerimeterExtrusion *> available_candidates;
+                for (const PerimeterExtrusion *adjacent_extrusion : current_extrusion->adjacent_perimeter_extrusions) {
+                    if (const size_t adjacent_extrusion_idx = adjacent_extrusion - sorted_perimeter_extrusions.data(); !visited[adjacent_extrusion_idx])
+                        available_candidates.emplace_back(adjacent_extrusion);
+                }
+
+                std::vector<const PerimeterExtrusion *> adjacent_extrusions = ordered_perimeter_extrusions_to_minimize_distances(Point::Zero(), available_candidates);
+                std::reverse(adjacent_extrusions.begin(), adjacent_extrusions.end());
+                for (const PerimeterExtrusion *adjacent_extrusion : adjacent_extrusions)
+                    stack.push(adjacent_extrusion);
+            }
+
+            visited[current_extrusion_idx] = true;
+        }
+
+        if (!external_perimeters_first)
+            std::reverse(grouped_extrusions.back().extrusions.begin(), grouped_extrusions.back().extrusions.end());
+    }
+
+    const std::vector<size_t> grouped_extrusion_order = order_of_grouped_perimeter_extrusions_to_minimize_distances(Point::Zero(), grouped_extrusions);
+    assert(grouped_extrusion_order.size() == grouped_ordered_extrusions.size());
+
+    PerimeterExtrusions ordered_extrusions;
+    for (size_t order_idx : grouped_extrusion_order) {
+        for (const PerimeterExtrusion *perimeter_extrusion : grouped_extrusions[order_idx].extrusions)
+            ordered_extrusions.emplace_back(*perimeter_extrusion);
+    }
+
+    return ordered_extrusions;
+}
+
+// FIXME: From the point of better patch planning, it should be better to do ordering when we have generated all extrusions (for now, when G-Code is exported).
+// FIXME: It would be better to extract the adjacency graph of extrusions from the SkeletalTrapezoidation graph.
+PerimeterExtrusions ordered_perimeter_extrusions(const Perimeters &perimeters, const bool external_perimeters_first) {
+    PerimeterExtrusions sorted_perimeter_extrusions = get_sorted_perimeter_extrusions_by_area(perimeters);
+    construct_perimeter_extrusions_adjacency_graph(sorted_perimeter_extrusions);
+    assign_nearest_external_perimeter(sorted_perimeter_extrusions);
+    return extract_ordered_perimeter_extrusions(sorted_perimeter_extrusions, external_perimeters_first);
+}
+
+} // namespace Slic3r::Arachne::PerimeterOrder

src/libslic3r/Arachne/PerimeterOrder.hpp

@@ -0,0 +1,44 @@
+#ifndef slic3r_GCode_PerimeterOrder_hpp_
+#define slic3r_GCode_PerimeterOrder_hpp_
+
+#include <Arachne/utils/ExtrusionLine.hpp>
+
+namespace Slic3r::Arachne::PerimeterOrder {
+
+// Data structure stores ExtrusionLine (closed and open) together with additional data.
+struct PerimeterExtrusion
+{
+    explicit PerimeterExtrusion(const Arachne::ExtrusionLine &extrusion, const double area, const Polygon &polygon, const BoundingBox &bbox)
+        : extrusion(extrusion), area(area), polygon(polygon), bbox(bbox) {}
+
+    Arachne::ExtrusionLine             extrusion;
+    // Absolute value of the area of the polygon. The value is always non-negative, even for holes.
+    double                             area = 0;
+
+    // Polygon is non-empty only for closed extrusions.
+    Polygon                            polygon;
+    BoundingBox                        bbox;
+
+    std::vector<PerimeterExtrusion *>  adjacent_perimeter_extrusions;
+
+    // How far is this perimeter from the nearest external perimeter. Contour is always preferred over holes.
+    size_t                             depth                      = std::numeric_limits<size_t>::max();
+    PerimeterExtrusion                *nearest_external_perimeter = nullptr;
+
+    // Returns if ExtrusionLine is a contour or a hole.
+    bool is_contour() const { return extrusion.is_contour(); }
+
+    // Returns if ExtrusionLine is closed or opened.
+    bool is_closed() const { return extrusion.is_closed; }
+
+    // Returns if ExtrusionLine is an external or an internal perimeter.
+    bool is_external_perimeter() const { return extrusion.is_external_perimeter(); }
+};
+
+using PerimeterExtrusions = std::vector<PerimeterExtrusion>;
+
+PerimeterExtrusions ordered_perimeter_extrusions(const Perimeters &perimeters, bool external_perimeters_first);
+
+} // namespace Slic3r::Arachne::PerimeterOrder
+
+#endif // slic3r_GCode_Travels_hpp_

src/libslic3r/Arachne/WallToolPaths.cpp

@@ -782,98 +782,4 @@ bool WallToolPaths::removeEmptyToolPaths(std::vector<VariableWidthLines> &toolpa
     return toolpaths.empty();
 }
 
-/*!
-     * Get the order constraints of the insets when printing walls per region / hole.
-     * Each returned pair consists of adjacent wall lines where the left has an inset_idx one lower than the right.
-     *
-     * Odd walls should always go after their enclosing wall polygons.
-     *
-     * \param outer_to_inner Whether the wall polygons with a lower inset_idx should go before those with a higher one.
- */
-WallToolPaths::ExtrusionLineSet WallToolPaths::getRegionOrder(const std::vector<ExtrusionLine *> &input, const bool outer_to_inner)
-{
-    ExtrusionLineSet order_requirements;
-    // We build a grid where we map toolpath vertex locations to toolpaths,
-    // so that we can easily find which two toolpaths are next to each other,
-    // which is the requirement for there to be an order constraint.
-    //
-    // We use a PointGrid rather than a LineGrid to save on computation time.
-    // In very rare cases two insets might lie next to each other without having neighboring vertices, e.g.
-    //  \            .
-    //   |  /        .
-    //   | /         .
-    //   ||          .
-    //   | \         .
-    //   |  \        .
-    //  /            .
-    // However, because of how Arachne works this will likely never be the case for two consecutive insets.
-    // On the other hand one could imagine that two consecutive insets of a very large circle
-    // could be simplify()ed such that the remaining vertices of the two insets don't align.
-    // In those cases the order requirement is not captured,
-    // which means that the PathOrderOptimizer *might* result in a violation of the user set path order.
-    // This problem is expected to be not so severe and happen very sparsely.
-
-    coord_t max_line_w = 0u;
-    for (const ExtrusionLine *line : input) // compute max_line_w
-        for (const ExtrusionJunction &junction : *line)
-            max_line_w = std::max(max_line_w, junction.w);
-    if (max_line_w == 0u)
-        return order_requirements;
-
-    struct LineLoc
-    {
-        ExtrusionJunction    j;
-        const ExtrusionLine *line;
-    };
-    struct Locator
-    {
-        Point operator()(const LineLoc &elem) { return elem.j.p; }
-    };
-
-    // How much farther two verts may be apart due to corners.
-    // This distance must be smaller than 2, because otherwise
-    // we could create an order requirement between e.g.
-    // wall 2 of one region and wall 3 of another region,
-    // while another wall 3 of the first region would lie in between those two walls.
-    // However, higher values are better against the limitations of using a PointGrid rather than a LineGrid.
-    constexpr float diagonal_extension = 1.9f;
-    const auto      searching_radius   = coord_t(max_line_w * diagonal_extension);
-    using GridT                        = SparsePointGrid<LineLoc, Locator>;
-    GridT grid(searching_radius);
-
-    for (const ExtrusionLine *line : input)
-        for (const ExtrusionJunction &junction : *line) grid.insert(LineLoc{junction, line});
-    for (const std::pair<const SquareGrid::GridPoint, LineLoc> &pair : grid) {
-        const LineLoc       &lineloc_here = pair.second;
-        const ExtrusionLine *here         = lineloc_here.line;
-        Point                loc_here     = pair.second.j.p;
-        std::vector<LineLoc> nearby_verts = grid.getNearby(loc_here, searching_radius);
-        for (const LineLoc &lineloc_nearby : nearby_verts) {
-            const ExtrusionLine *nearby = lineloc_nearby.line;
-            if (nearby == here)
-                continue;
-            if (nearby->inset_idx == here->inset_idx)
-                continue;
-            if (nearby->inset_idx > here->inset_idx + 1)
-                continue; // not directly adjacent
-            if (here->inset_idx > nearby->inset_idx + 1)
-                continue; // not directly adjacent
-            if (!shorter_then(loc_here - lineloc_nearby.j.p, (lineloc_here.j.w + lineloc_nearby.j.w) / 2 * diagonal_extension))
-                continue; // points are too far away from each other
-            if (here->is_odd || nearby->is_odd) {
-                if (here->is_odd && !nearby->is_odd && nearby->inset_idx < here->inset_idx)
-                    order_requirements.emplace(std::make_pair(nearby, here));
-                if (nearby->is_odd && !here->is_odd && here->inset_idx < nearby->inset_idx)
-                    order_requirements.emplace(std::make_pair(here, nearby));
-            } else if ((nearby->inset_idx < here->inset_idx) == outer_to_inner) {
-                order_requirements.emplace(std::make_pair(nearby, here));
-            } else {
-                assert((nearby->inset_idx > here->inset_idx) == outer_to_inner);
-                order_requirements.emplace(std::make_pair(here, nearby));
-            }
-        }
-    }
-    return order_requirements;
-}
-
 } // namespace Slic3r::Arachne

src/libslic3r/Arachne/WallToolPaths.hpp

@@ -90,16 +90,6 @@ public:
 
     using ExtrusionLineSet = ankerl::unordered_dense::set<std::pair<const ExtrusionLine *, const ExtrusionLine *>, boost::hash<std::pair<const ExtrusionLine *, const ExtrusionLine *>>>;
 
-    /*!
-     * Get the order constraints of the insets when printing walls per region / hole.
-     * Each returned pair consists of adjacent wall lines where the left has an inset_idx one lower than the right.
-     *
-     * Odd walls should always go after their enclosing wall polygons.
-     *
-     * \param outer_to_inner Whether the wall polygons with a lower inset_idx should go before those with a higher one.
-     */
-    static ExtrusionLineSet getRegionOrder(const std::vector<ExtrusionLine *> &input, bool outer_to_inner);
-
 protected:
     /*!
      * Stitch the polylines together and form closed polygons.

src/libslic3r/Arachne/utils/ExtrusionLine.cpp

@@ -253,9 +253,10 @@ bool ExtrusionLine::is_contour() const
     return poly.is_clockwise();
 }
 
-double ExtrusionLine::area() const
-{
-    assert(this->is_closed);
+double ExtrusionLine::area() const {
+    if (!this->is_closed)
+        return 0.;
+
     double a = 0.;
     if (this->junctions.size() >= 3) {
         Vec2d p1 = this->junctions.back().p.cast<double>();
@@ -265,9 +266,25 @@ double ExtrusionLine::area() const
             p1 = p2;
         }
     }
+
     return 0.5 * a;
 }
 
+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;
+}
+
+BoundingBox get_extents(const ExtrusionLine &extrusion_line) {
+    BoundingBox bbox;
+    for (const ExtrusionJunction &junction : extrusion_line.junctions)
+        bbox.merge(junction.p);
+    return bbox;
+}
+
 } // namespace Slic3r::Arachne
 
 namespace Slic3r {

src/libslic3r/Arachne/utils/ExtrusionLine.hpp

@@ -187,6 +187,8 @@ struct ExtrusionLine
     bool is_contour() const;
 
     double area() const;
+
+    bool is_external_perimeter() const { return this->inset_idx == 0; }
 };
 
 template<class PathType>
@@ -213,6 +215,7 @@ static inline Slic3r::ThickPolyline to_thick_polyline(const PathType &path)
 static inline Polygon to_polygon(const ExtrusionLine &line)
 {
     Polygon out;
+    assert(line.is_closed);
     assert(line.junctions.size() >= 3);
     assert(line.junctions.front().p == line.junctions.back().p);
     out.points.reserve(line.junctions.size() - 1);
@@ -221,24 +224,11 @@ 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;
-}
+Points to_points(const ExtrusionLine &extrusion_line);
+
+BoundingBox get_extents(const ExtrusionLine &extrusion_line);
 
 #if 0
-static BoundingBox get_extents(const ExtrusionLine &extrusion_line)
-{
-    BoundingBox bbox;
-    for (const ExtrusionJunction &junction : extrusion_line.junctions)
-        bbox.merge(junction.p);
-    return bbox;
-}
-
 static BoundingBox get_extents(const std::vector<ExtrusionLine> &extrusion_lines)
 {
     BoundingBox bbox;
@@ -269,6 +259,8 @@ static std::vector<Points> to_points(const std::vector<const ExtrusionLine *> &e
 #endif
 
 using VariableWidthLines = std::vector<ExtrusionLine>; //<! The ExtrusionLines generated by libArachne
+using Perimeter = VariableWidthLines;
+using Perimeters = std::vector<Perimeter>;
 
 } // namespace Slic3r::Arachne
 

src/libslic3r/CMakeLists.txt

@@ -434,6 +434,8 @@ set(lisbslic3r_sources
     Arachne/utils/PolygonsSegmentIndex.hpp
     Arachne/utils/PolylineStitcher.hpp
     Arachne/utils/PolylineStitcher.cpp
+    Arachne/PerimeterOrder.hpp
+    Arachne/PerimeterOrder.cpp
     Arachne/SkeletalTrapezoidation.hpp
     Arachne/SkeletalTrapezoidation.cpp
     Arachne/SkeletalTrapezoidationEdge.hpp