Apply fix includes.

Cherry-picked from prusa3d/PrusaSlicer@919740fb3e

Co-authored-by: Martin Šach <martin.sachin@gmail.com>

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp

@@ -1,10 +1,8 @@
 //Copyright (c) 2022 Ultimaker B.V.
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
-#include <cassert>
-
 #include "BeadingStrategy.hpp"
-#include "Point.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp

@@ -4,9 +4,13 @@
 #ifndef BEADING_STRATEGY_H
 #define BEADING_STRATEGY_H
 
+#include <math.h>
 #include <memory>
+#include <string>
+#include <vector>
+#include <cmath>
 
-#include "../../libslic3r.h"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp

@@ -3,51 +3,50 @@
 
 #include "BeadingStrategyFactory.hpp"
 
+#include <boost/log/trivial.hpp>
+#include <memory>
+#include <utility>
+
 #include "LimitedBeadingStrategy.hpp"
 #include "WideningBeadingStrategy.hpp"
 #include "DistributedBeadingStrategy.hpp"
 #include "RedistributeBeadingStrategy.hpp"
 #include "OuterWallInsetBeadingStrategy.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
-#include <limits>
+namespace Slic3r::Arachne {
-#include <boost/log/trivial.hpp>
 
-namespace Slic3r::Arachne
+BeadingStrategyPtr BeadingStrategyFactory::makeStrategy(const coord_t preferred_bead_width_outer,
-{
+                                                        const coord_t preferred_bead_width_inner,
-
+                                                        const coord_t preferred_transition_length,
-BeadingStrategyPtr BeadingStrategyFactory::makeStrategy(
+                                                        const float   transitioning_angle,
-    const coord_t preferred_bead_width_outer,
+                                                        const bool    print_thin_walls,
-    const coord_t preferred_bead_width_inner,
+                                                        const coord_t min_bead_width,
-    const coord_t preferred_transition_length,
+                                                        const coord_t min_feature_size,
-    const float transitioning_angle,
+                                                        const double  wall_split_middle_threshold,
-    const bool print_thin_walls,
+                                                        const double  wall_add_middle_threshold,
-    const coord_t min_bead_width,
+                                                        const coord_t max_bead_count,
-    const coord_t min_feature_size,
+                                                        const coord_t outer_wall_offset,
-    const double wall_split_middle_threshold,
+                                                        const int     inward_distributed_center_wall_count,
-    const double wall_add_middle_threshold,
+                                                        const double  minimum_variable_line_ratio)
-    const coord_t max_bead_count,
-    const coord_t outer_wall_offset,
-    const int inward_distributed_center_wall_count,
-    const double minimum_variable_line_ratio
-)
 {
     BeadingStrategyPtr ret = std::make_unique<DistributedBeadingStrategy>(preferred_bead_width_inner, preferred_transition_length, transitioning_angle, wall_split_middle_threshold, wall_add_middle_threshold, inward_distributed_center_wall_count);
-    BOOST_LOG_TRIVIAL(debug) << "Applying the Redistribute meta-strategy with outer-wall width = " << preferred_bead_width_outer << ", inner-wall width = " << preferred_bead_width_inner << ".";
+
+    BOOST_LOG_TRIVIAL(trace) << "Applying the Redistribute meta-strategy with outer-wall width = " << preferred_bead_width_outer << ", inner-wall width = " << preferred_bead_width_inner << ".";
     ret = std::make_unique<RedistributeBeadingStrategy>(preferred_bead_width_outer, minimum_variable_line_ratio, std::move(ret));
 
     if (print_thin_walls) {
-        BOOST_LOG_TRIVIAL(debug) << "Applying the Widening Beading meta-strategy with minimum input width " << min_feature_size << " and minimum output width " << min_bead_width << ".";
+        BOOST_LOG_TRIVIAL(trace) << "Applying the Widening Beading meta-strategy with minimum input width " << min_feature_size << " and minimum output width " << min_bead_width << ".";
         ret = std::make_unique<WideningBeadingStrategy>(std::move(ret), min_feature_size, min_bead_width);
     }
     // Orca: we allow negative outer_wall_offset here
-    if (outer_wall_offset != 0) 
+    if (outer_wall_offset != 0) {
-    {
+        BOOST_LOG_TRIVIAL(trace) << "Applying the OuterWallOffset meta-strategy with offset = " << outer_wall_offset << ".";
-        BOOST_LOG_TRIVIAL(debug) << "Applying the OuterWallOffset meta-strategy with offset = " << outer_wall_offset << ".";
         ret = std::make_unique<OuterWallInsetBeadingStrategy>(outer_wall_offset, std::move(ret));
     }
 
-    //Apply the LimitedBeadingStrategy last, since that adds a 0-width marker wall which other beading strategies shouldn't touch.
+    // Apply the LimitedBeadingStrategy last, since that adds a 0-width marker wall which other beading strategies shouldn't touch.
-    BOOST_LOG_TRIVIAL(debug) << "Applying the Limited Beading meta-strategy with maximum bead count = " << max_bead_count << ".";
+    BOOST_LOG_TRIVIAL(trace) << "Applying the Limited Beading meta-strategy with maximum bead count = " << max_bead_count << ".";
     ret = std::make_unique<LimitedBeadingStrategy>(max_bead_count, std::move(ret));
     return ret;
 }

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp

@@ -4,8 +4,12 @@
 #ifndef BEADING_STRATEGY_FACTORY_H
 #define BEADING_STRATEGY_FACTORY_H
 
+#include <math.h>
+#include <cmath>
+
 #include "BeadingStrategy.hpp"
 #include "../../Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.cpp

@@ -1,7 +1,12 @@
 // Copyright (c) 2022 Ultimaker B.V.
 // CuraEngine is released under the terms of the AGPLv3 or higher.
 #include <numeric>
+#include <algorithm>
+#include <vector>
+#include <cassert>
+
 #include "DistributedBeadingStrategy.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.hpp

@@ -5,6 +5,7 @@
 #define DISTRIBUTED_BEADING_STRATEGY_H
 
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp

@@ -1,11 +1,14 @@
 //Copyright (c) 2022 Ultimaker B.V.
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
-#include <cassert>
 #include <boost/log/trivial.hpp>
+#include <cassert>
+#include <utility>
+#include <cstddef>
 
 #include "LimitedBeadingStrategy.hpp"
-#include "Point.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.hpp

@@ -4,7 +4,10 @@
 #ifndef LIMITED_BEADING_STRATEGY_H
 #define LIMITED_BEADING_STRATEGY_H
 
+#include <string>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp

@@ -4,6 +4,9 @@
 #include "OuterWallInsetBeadingStrategy.hpp"
 
 #include <algorithm>
+#include <utility>
+
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.hpp

@@ -4,7 +4,10 @@
 #ifndef OUTER_WALL_INSET_BEADING_STRATEGY_H
 #define OUTER_WALL_INSET_BEADING_STRATEGY_H
 
+#include <string>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.cpp

@@ -5,6 +5,9 @@
 
 #include <algorithm>
 #include <numeric>
+#include <utility>
+
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.hpp

@@ -4,7 +4,10 @@
 #ifndef REDISTRIBUTE_DISTRIBUTED_BEADING_STRATEGY_H
 #define REDISTRIBUTE_DISTRIBUTED_BEADING_STRATEGY_H
 
+#include <string>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.cpp

@@ -3,6 +3,11 @@
 
 #include "WideningBeadingStrategy.hpp"
 
+#include <algorithm>
+#include <utility>
+
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
+
 namespace Slic3r::Arachne
 {
 
@@ -24,17 +29,16 @@ WideningBeadingStrategy::Beading WideningBeadingStrategy::compute(coord_t thickn
     if (thickness < optimal_width) {
         Beading ret;
         ret.total_thickness = thickness;
-        if (thickness >= min_input_width)
+        if (thickness >= min_input_width) {
-        {
             ret.bead_widths.emplace_back(std::max(thickness, min_output_width));
             ret.toolpath_locations.emplace_back(thickness / 2);
-        } else {
+            ret.left_over = 0;
+        } else
             ret.left_over = thickness;
-        }
+
         return ret;
-    } else {
+    } else
         return parent->compute(thickness, bead_count);
-    }
 }
 
 coord_t WideningBeadingStrategy::getOptimalThickness(coord_t bead_count) const

src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.hpp

@@ -4,7 +4,11 @@
 #ifndef WIDENING_BEADING_STRATEGY_H
 #define WIDENING_BEADING_STRATEGY_H
 
+#include <string>
+#include <vector>
+
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/SkeletalTrapezoidation.cpp

@@ -3,20 +3,27 @@
 
 #include "SkeletalTrapezoidation.hpp"
 
-#include <stack>
-#include <functional>
-#include <sstream>
-#include <queue>
 #include <boost/log/trivial.hpp>
+#include <boost/polygon/polygon.hpp>
+#include <queue>
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <utility>
+#include <cassert>
+#include <cstdlib>
 
-#include "utils/linearAlg2D.hpp"
+#include "libslic3r/Geometry/VoronoiUtils.hpp"
-#include "Utils.hpp"
+#include "ankerl/unordered_dense.h"
-#include "SVG.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
-#include "Geometry/VoronoiVisualUtils.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
-#include "Geometry/VoronoiUtilsCgal.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
-#include "../EdgeGrid.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
 
-#include "Geometry/VoronoiUtils.hpp"
+#ifndef NDEBUG
+    #include "libslic3r/EdgeGrid.hpp"
+#endif
 
 #define SKELETAL_TRAPEZOIDATION_BEAD_SEARCH_MAX 1000 //A limit to how long it'll keep searching for adjacent beads. Increasing will re-use beadings more often (saving performance), but search longer for beading (costing performance).
 
@@ -449,6 +456,8 @@ void SkeletalTrapezoidation::constructFromPolygons(const Polygons& polys)
             edge.from->incident_edge = &edge;
 }
 
+using NodeSet = SkeletalTrapezoidation::NodeSet;
+
 void SkeletalTrapezoidation::separatePointyQuadEndNodes()
 {
     NodeSet visited_nodes;
@@ -1924,6 +1933,8 @@ void SkeletalTrapezoidation::addToolpathSegment(const ExtrusionJunction& from, c
 
 void SkeletalTrapezoidation::connectJunctions(ptr_vector_t<LineJunctions>& edge_junctions)
 {
+    using EdgeSet = ankerl::unordered_dense::set<edge_t*>;
+
     EdgeSet unprocessed_quad_starts(graph.edges.size() * 5 / 2);
     for (edge_t& edge : graph.edges)
     {

src/libslic3r/Arachne/SkeletalTrapezoidation.hpp

@@ -5,11 +5,11 @@
 #define SKELETAL_TRAPEZOIDATION_H
 
 #include <boost/polygon/voronoi.hpp>
-
+#include <ankerl/unordered_dense.h>
 #include <memory> // smart pointers
 #include <utility> // pair
-
+#include <list>
-#include <ankerl/unordered_dense.h>
+#include <vector>
 
 #include "utils/HalfEdgeGraph.hpp"
 #include "utils/PolygonsSegmentIndex.hpp"
@@ -20,6 +20,10 @@
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 #include "SkeletalTrapezoidationGraph.hpp"
 #include "../Geometry/Voronoi.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 //#define ARACHNE_DEBUG
 //#define ARACHNE_DEBUG_VORONOI
@@ -82,10 +86,7 @@ class SkeletalTrapezoidation
 
 public:
     using Segment  = PolygonsSegmentIndex;
-    using NodeSet = ankerl::unordered_dense::set<node_t *>;
+    using NodeSet  = ankerl::unordered_dense::set<node_t*>;
-    using EdgeSet = ankerl::unordered_dense::set<edge_t *>;
-    using EdgeMap = ankerl::unordered_dense::map<const VD::edge_type *, edge_t *>;
-    using NodeMap = ankerl::unordered_dense::map<const VD::vertex_type *, node_t *>;
 
     /*!
      * Construct a new trapezoidation problem to solve.
@@ -169,8 +170,8 @@ protected:
      * mapping each voronoi VD edge to the corresponding halfedge HE edge
      * In case the result segment is discretized, we map the VD edge to the *last* HE edge
      */
-    EdgeMap vd_edge_to_he_edge;
+    ankerl::unordered_dense::map<const VD::edge_type *, edge_t *> vd_edge_to_he_edge;
-    NodeMap vd_node_to_he_node;
+    ankerl::unordered_dense::map<const VD::vertex_type *, node_t *> vd_node_to_he_node;
     node_t &makeNode(const VD::vertex_type &vd_node, Point p); //!< Get the node which the VD node maps to, or create a new mapping if there wasn't any yet.
 
     /*!

src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp

@@ -2,14 +2,18 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "SkeletalTrapezoidationGraph.hpp"
-#include "../Line.hpp"
+
 #include <ankerl/unordered_dense.h>
-
-
 #include <boost/log/trivial.hpp>
+#include <algorithm>
+#include <iostream>
+#include <cassert>
+#include <cinttypes>
 
-#include "utils/linearAlg2D.hpp"
 #include "../Line.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Arachne
 {
@@ -182,8 +186,8 @@ bool STHalfEdgeNode::isLocalMaximum(bool strict) const
 
 void SkeletalTrapezoidationGraph::collapseSmallEdges(coord_t snap_dist)
 {
-    ankerl::unordered_dense::map<edge_t*, std::list<edge_t>::iterator> edge_locator;
+    ankerl::unordered_dense::map<edge_t*, Edges::iterator> edge_locator;
-    ankerl::unordered_dense::map<node_t*, std::list<node_t>::iterator> node_locator;
+    ankerl::unordered_dense::map<node_t*, Nodes::iterator> node_locator;
     
     for (auto edge_it = edges.begin(); edge_it != edges.end(); ++edge_it)
     {
@@ -195,7 +199,7 @@ void SkeletalTrapezoidationGraph::collapseSmallEdges(coord_t snap_dist)
         node_locator.emplace(&*node_it, node_it);
     }
     
-    auto safelyRemoveEdge = [this, &edge_locator](edge_t* to_be_removed, std::list<edge_t>::iterator& current_edge_it, bool& edge_it_is_updated)
+    auto safelyRemoveEdge = [this, &edge_locator](edge_t* to_be_removed, Edges::iterator& current_edge_it, bool& edge_it_is_updated)
     {
         if (current_edge_it != edges.end()
             && to_be_removed == &*current_edge_it)

src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp

@@ -5,10 +5,20 @@
 #define SKELETAL_TRAPEZOIDATION_GRAPH_H
 
 #include <optional>
+#include <utility>
 
 #include "utils/HalfEdgeGraph.hpp"
 #include "SkeletalTrapezoidationEdge.hpp"
 #include "SkeletalTrapezoidationJoint.hpp"
+#include "libslic3r/Arachne/utils/HalfEdge.hpp"
+#include "libslic3r/Arachne/utils/HalfEdgeNode.hpp"
+#include "libslic3r/libslic3r.h"
+
+namespace Slic3r
+{
+class Line;
+class Point;
+};
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/ExtrusionLine.cpp

@@ -2,10 +2,21 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include <algorithm>
+#include <cmath>
+#include <cstdlib>
 
 #include "ExtrusionLine.hpp"
-#include "linearAlg2D.hpp"
 #include "../../VariableWidth.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+
+namespace Slic3r {
+class Flow;
+}  // namespace Slic3r
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/ExtrusionLine.hpp

@@ -5,16 +5,28 @@
 #ifndef UTILS_EXTRUSION_LINE_H
 #define UTILS_EXTRUSION_LINE_H
 
+#include <clipper/clipper_z.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <utility>
+#include <vector>
+#include <cassert>
+#include <cinttypes>
+#include <cstddef>
+
 #include "ExtrusionJunction.hpp"
 #include "../../Polyline.hpp"
 #include "../../Polygon.hpp"
 #include "../../BoundingBox.hpp"
 #include "../../ExtrusionEntity.hpp"
 #include "../../Flow.hpp"
-#include "../../../clipper/clipper_z.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 class ThickPolyline;
+class Flow;
 }
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/utils/HalfEdgeGraph.hpp

@@ -21,8 +21,10 @@ class HalfEdgeGraph
 public:
     using edge_t = derived_edge_t;
     using node_t = derived_node_t;
-    std::list<edge_t> edges;
+    using Edges = std::list<edge_t>;
-    std::list<node_t> nodes;
+    using Nodes = std::list<node_t>;
+    Edges edges;
+    Nodes nodes;
 };
 
 } // namespace Slic3r::Arachne

src/libslic3r/Arachne/utils/PolygonsPointIndex.hpp

@@ -156,8 +156,6 @@ struct PathsPointIndexLocator
     }
 };
 
-using PolygonsPointIndexLocator = PathsPointIndexLocator<Polygons>;
-
 }//namespace Slic3r::Arachne
 
 namespace std

src/libslic3r/Arachne/utils/PolylineStitcher.cpp

@@ -2,7 +2,16 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "PolylineStitcher.hpp"
+
 #include "ExtrusionLine.hpp"
+#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
+#include "libslic3r/Polygon.hpp"
+
+namespace Slic3r {
+namespace Arachne {
+struct ExtrusionJunction;
+}  // namespace Arachne
+}  // namespace Slic3r
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/utils/PolylineStitcher.hpp

@@ -4,11 +4,20 @@
 #ifndef UTILS_POLYLINE_STITCHER_H
 #define UTILS_POLYLINE_STITCHER_H
 
+#include <stddef.h>
+#include <stdint.h>
+#include <cassert>
+#include <functional>
+#include <limits>
+#include <vector>
+#include <cinttypes>
+#include <cstddef>
+
 #include "SparsePointGrid.hpp"
 #include "PolygonsPointIndex.hpp"
 #include "../../Polygon.hpp"
-#include <unordered_set>
+#include "libslic3r/Point.hpp"
-#include <cassert>
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/SparseGrid.hpp

@@ -6,7 +6,6 @@
 #define UTILS_SPARSE_GRID_H
 
 #include <cassert>
-#include <unordered_map>
 #include <vector>
 #include <functional>
 

src/libslic3r/Arachne/utils/SparseLineGrid.hpp

@@ -6,7 +6,6 @@
 #define UTILS_SPARSE_LINE_GRID_H
 
 #include <cassert>
-#include <unordered_map>
 #include <vector>
 #include <functional>
 

src/libslic3r/Arachne/utils/SquareGrid.hpp

@@ -4,12 +4,15 @@
 #ifndef UTILS_SQUARE_GRID_H
 #define UTILS_SQUARE_GRID_H
 
-#include "../../Point.hpp"
+#include <stdint.h>
-
 #include <cassert>
-#include <unordered_map>
 #include <vector>
 #include <functional>
+#include <utility>
+#include <cinttypes>
+
+#include "../../Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Geometry/MedialAxis.cpp

@@ -1,9 +1,16 @@
 #include <boost/log/trivial.hpp>
 #include "MedialAxis.hpp"
 
-#include "clipper.hpp"
+#include <boost/log/trivial.hpp>
+#include <boost/polygon/polygon.hpp>
+#include <cassert>
+#include <cmath>
+
 #include "VoronoiOffset.hpp"
-#include "../ClipperUtils.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 #ifdef SLIC3R_DEBUG
 namespace boost { namespace polygon {

src/libslic3r/Geometry/MedialAxis.hpp

@@ -1,8 +1,15 @@
 #ifndef slic3r_Geometry_MedialAxis_hpp_
 #define slic3r_Geometry_MedialAxis_hpp_
 
+#include <stddef.h>
+#include <utility>
+#include <vector>
+#include <cstddef>
+
 #include "Voronoi.hpp"
 #include "../ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r::Geometry {
 

src/libslic3r/Geometry/Voronoi.cpp

@@ -1,11 +1,13 @@
 #include "Voronoi.hpp"
 
+#include <boost/log/trivial.hpp>
+#include <cassert>
+
 #include "libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp"
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
 #include "libslic3r/Geometry/VoronoiUtilsCgal.hpp"
 #include "libslic3r/MultiMaterialSegmentation.hpp"
-
+#include "libslic3r/Line.hpp"
-#include <boost/log/trivial.hpp>
 
 namespace Slic3r::Geometry {
 

src/libslic3r/Geometry/Voronoi.hpp

@@ -1,8 +1,15 @@
 #ifndef slic3r_Geometry_Voronoi_hpp_
 #define slic3r_Geometry_Voronoi_hpp_
 
+#include <boost/polygon/polygon.hpp>
+#include <cstddef>
+#include <iterator>
+#include <vector>
+
 #include "../Line.hpp"
 #include "../Polyline.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 #ifdef _MSC_VER
 // Suppress warning C4146 in OpenVDB: unary minus operator applied to unsigned type, result still unsigned
@@ -10,6 +17,12 @@
 #pragma warning(disable : 4146)
 #endif // _MSC_VER
 #include "boost/polygon/voronoi.hpp"
+
+namespace boost {
+namespace polygon {
+template <typename Segment> struct segment_traits;
+}  // namespace polygon
+}  // namespace boost
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif // _MSC_VER

src/libslic3r/Geometry/VoronoiOffset.cpp

@@ -1,15 +1,21 @@
 // Polygon offsetting using Voronoi diagram prodiced by boost::polygon.
 
-#include "Geometry.hpp"
-#include "VoronoiOffset.hpp"
-#include "libslic3r.h"
-
 #include <cmath>
+#include <algorithm>
+#include <array>
+#include <limits>
+#include <tuple>
+#include <utility>
+#include <cassert>
+#include <cstdlib>
+
+#include "libslic3r/Geometry.hpp"
+#include "VoronoiOffset.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Geometry/Voronoi.hpp"
 
 // #define VORONOI_DEBUG_OUT
 
-#include <boost/polygon/detail/voronoi_ctypes.hpp>
-
 #ifdef VORONOI_DEBUG_OUT
 #include <libslic3r/VoronoiVisualUtils.hpp>
 #endif

src/libslic3r/Geometry/VoronoiOffset.hpp

@@ -3,9 +3,15 @@
 #ifndef slic3r_VoronoiOffset_hpp_
 #define slic3r_VoronoiOffset_hpp_
 
-#include "../libslic3r.h"
+#include <boost/polygon/polygon.hpp>
+#include <cmath>
+#include <vector>
 
+#include "libslic3r/libslic3r.h"
 #include "Voronoi.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 

src/libslic3r/Geometry/VoronoiUtils.cpp

@@ -1,11 +1,17 @@
 #include <boost/log/trivial.hpp>
-
+#include <libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp>
-#include <Arachne/utils/PolygonsSegmentIndex.hpp>
+#include <libslic3r/MultiMaterialSegmentation.hpp>
-#include <MultiMaterialSegmentation.hpp>
+#include <libslic3r/Geometry.hpp>
-#include <Geometry.hpp>
+#include <cmath>
+#include <cstdint>
+#include <utility>
+#include <vector>
+#include <cassert>
+#include <cstdlib>
 
 #include "VoronoiUtils.hpp"
-#include "libslic3r.h"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r::Geometry {
 

src/libslic3r/Geometry/VoronoiUtils.hpp

@@ -1,8 +1,15 @@
 #ifndef slic3r_VoronoiUtils_hpp_
 #define slic3r_VoronoiUtils_hpp_
 
+#include <boost/polygon/polygon.hpp>
+#include <iterator>
+#include <limits>
+
 #include "libslic3r/Geometry/Voronoi.hpp"
 #include "libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp"
+#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 using VD = Slic3r::Geometry::VoronoiDiagram;
 

src/libslic3r/Geometry/VoronoiUtilsCgal.cpp

@@ -1,15 +1,21 @@
-// Needed since the CGAL headers are not self-contained.
-#include <boost/next_prior.hpp>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 #include <CGAL/Arr_segment_traits_2.h>
 #include <CGAL/Surface_sweep_2_algorithms.h>
+#include <boost/variant/get.hpp>
+#include <vector>
+#include <cassert>
 
 #include "libslic3r/Geometry/Voronoi.hpp"
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
 #include "libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp"
 #include "libslic3r/MultiMaterialSegmentation.hpp"
-
 #include "VoronoiUtilsCgal.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+
+namespace CGAL {
+class MP_Float;
+}  // namespace CGAL
 
 using VD = Slic3r::Geometry::VoronoiDiagram;
 

src/libslic3r/Geometry/VoronoiUtilsCgal.hpp

@@ -1,6 +1,9 @@
 #ifndef slic3r_VoronoiUtilsCgal_hpp_
 #define slic3r_VoronoiUtilsCgal_hpp_
 
+#include <boost/polygon/polygon.hpp>
+#include <iterator>
+
 #include "Voronoi.hpp"
 #include "../Arachne/utils/PolygonsSegmentIndex.hpp"