Apply fix includes.

src/libslic3r/AABBMesh.cpp

@@ -3,12 +3,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "AABBMesh.hpp"
-#include <libslic3r/Execution/ExecutionTBB.hpp>
 
 #include <libslic3r/AABBTreeIndirect.hpp>
 #include <libslic3r/TriangleMesh.hpp>
+#include <igl/Hit.h>
+#include <algorithm>
 
-#include <numeric>
+#include "admesh/stl.h"
+#include "libslic3r/Point.hpp"
 
 #ifdef SLIC3R_HOLE_RAYCASTER
 #include <libslic3r/SLA/Hollowing.hpp>

src/libslic3r/AABBMesh.hpp

@@ -5,11 +5,14 @@
 #ifndef PRUSASLICER_AABBMESH_H
 #define PRUSASLICER_AABBMESH_H
 
-#include <memory>
-#include <vector>
-
 #include <libslic3r/Point.hpp>
 #include <libslic3r/TriangleMesh.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <memory>
+#include <vector>
+#include <cmath>
+#include <limits>
 
 // There is an implementation of a hole-aware raycaster that was eventually
 // not used in production version. It is now hidden under following define

src/libslic3r/Algorithm/RegionExpansion.cpp

@@ -8,8 +8,19 @@
 #include <libslic3r/ClipperZUtils.hpp>
 #include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Utils.hpp>
-
+#include <assert.h>
+#include <clipper/clipper_z.hpp>
 #include <numeric>
+#include <cmath>
+#include <iterator>
+#include <utility>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 namespace Algorithm {

src/libslic3r/Algorithm/RegionExpansion.hpp

@@ -5,10 +5,13 @@
 #ifndef SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 #define SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 
-#include <cstdint>
 #include <libslic3r/Point.hpp>
 #include <libslic3r/Polygon.hpp>
 #include <libslic3r/ExPolygon.hpp>
+#include <stddef.h>
+#include <cstdint>
+#include <algorithm>
+#include <vector>
 
 namespace Slic3r {
 namespace Algorithm {

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp

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

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp

@@ -4,7 +4,10 @@
 #ifndef BEADING_STRATEGY_H
 #define BEADING_STRATEGY_H
 
+#include <math.h>
 #include <memory>
+#include <string>
+#include <vector>
 
 #include "libslic3r/libslic3r.h"
 

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp

@@ -3,13 +3,16 @@
 
 #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 <boost/log/trivial.hpp>
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp

@@ -4,8 +4,11 @@
 #ifndef BEADING_STRATEGY_FACTORY_H
 #define BEADING_STRATEGY_FACTORY_H
 
+#include <math.h>
+
 #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 <assert.h>
 #include <numeric>
+#include <algorithm>
+#include <vector>
+
 #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 <stddef.h>
+#include <cassert>
+#include <utility>
 
 #include "LimitedBeadingStrategy.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
 {
 

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/PerimeterOrder.cpp

@@ -1,5 +1,10 @@
 #include <stack>
+#include <algorithm>
+#include <cmath>
+
 #include "PerimeterOrder.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Arachne::PerimeterOrder {
 

src/libslic3r/Arachne/PerimeterOrder.hpp

@@ -1,7 +1,13 @@
 #ifndef slic3r_GCode_PerimeterOrder_hpp_
 #define slic3r_GCode_PerimeterOrder_hpp_
 
+#include <stddef.h>
+#include <limits>
+#include <vector>
+
 #include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r::Arachne::PerimeterOrder {
 

src/libslic3r/Arachne/SkeletalTrapezoidation.cpp

@@ -3,20 +3,23 @@
 
 #include "SkeletalTrapezoidation.hpp"
 
-#include <stack>
-#include <functional>
-#include <sstream>
-#include <queue>
 #include <boost/log/trivial.hpp>
-
+#include <assert.h>
-#include "utils/linearAlg2D.hpp"
+#include <stdlib.h>
-#include "libslic3r/Utils.hpp"
+#include <boost/polygon/polygon.hpp>
-#include "libslic3r/SVG.hpp"
+#include <queue>
-#include "libslic3r/Geometry/VoronoiVisualUtils.hpp"
+#include <algorithm>
-#include "libslic3r/Geometry/VoronoiUtilsCgal.hpp"
+#include <cmath>
-#include "libslic3r/EdgeGrid.hpp"
+#include <cstdint>
+#include <limits>
+#include <utility>
 
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
+#include "ankerl/unordered_dense.h"
+#include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
 
 #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).
 

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

src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp

@@ -4,11 +4,16 @@
 #include "SkeletalTrapezoidationGraph.hpp"
 
 #include <ankerl/unordered_dense.h>
-
 #include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <algorithm>
+#include <iostream>
 
-#include "utils/linearAlg2D.hpp"
 #include "../Line.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
+#include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/SkeletalTrapezoidationGraph.hpp

@@ -5,14 +5,19 @@
 #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/WallToolPaths.cpp

@@ -1,21 +1,29 @@
 // Copyright (c) 2022 Ultimaker B.V.
 // CuraEngine is released under the terms of the AGPLv3 or higher.
 
+#include <assert.h>
+#include <math.h>
+#include <stdint.h>
 #include <algorithm> //For std::partition_copy and std::min_element.
+#include <limits>
+#include <memory>
 
 #include "WallToolPaths.hpp"
-
 #include "SkeletalTrapezoidation.hpp"
 #include "utils/linearAlg2D.hpp"
 #include "utils/SparseLineGrid.hpp"
-#include "libslic3r/EdgeGrid.hpp"
 #include "libslic3r/Geometry.hpp"
 #include "utils/PolylineStitcher.hpp"
-#include "libslic3r/SVG.hpp"
-#include "libslic3r/Utils.hpp"
 #include "libslic3r/ClipperUtils.hpp"
-
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
-#include <boost/log/trivial.hpp>
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 //#define ARACHNE_STITCH_PATCH_DEBUG
 

src/libslic3r/Arachne/WallToolPaths.hpp

@@ -4,14 +4,22 @@
 #ifndef CURAENGINE_WALLTOOLPATHS_H
 #define CURAENGINE_WALLTOOLPATHS_H
 
-#include <memory>
-
 #include <ankerl/unordered_dense.h>
+#include <stddef.h>
+#include <memory>
+#include <utility>
+#include <vector>
 
 #include "BeadingStrategy/BeadingStrategyFactory.hpp"
 #include "utils/ExtrusionLine.hpp"
 #include "../Polygon.hpp"
 #include "../PrintConfig.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+
+namespace boost {
+template <class T> struct hash;
+}  // namespace boost
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/ExtrusionLine.cpp

@@ -1,11 +1,22 @@
 //Copyright (c) 2020 Ultimaker B.V.
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
+#include <stdlib.h>
 #include <algorithm>
+#include <cmath>
 
 #include "ExtrusionLine.hpp"
-#include "linearAlg2D.hpp"
 #include "../../PerimeterGenerator.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,26 @@
 #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 "ExtrusionJunction.hpp"
 #include "../../Polyline.hpp"
 #include "../../Polygon.hpp"
 #include "../../BoundingBox.hpp"
 #include "../../ExtrusionEntity.hpp"
 #include "../../Flow.hpp"
-#include <clipper/clipper_z.hpp>
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 struct ThickPolyline;
+class Flow;
 }
 
 namespace Slic3r::Arachne

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,10 +4,18 @@
 #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 "SparsePointGrid.hpp"
 #include "PolygonsPointIndex.hpp"
 #include "../../Polygon.hpp"
-#include <cassert>
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/SquareGrid.cpp

@@ -3,6 +3,10 @@
 
 #include "SquareGrid.hpp"
 
+#include <cassert>
+
+#include "libslic3r/Point.hpp"
+
 using namespace Slic3r::Arachne;
 
 

src/libslic3r/Arachne/utils/SquareGrid.hpp

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

src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.cpp

@@ -4,6 +4,10 @@
 ///|/
 #include "ArrangeSettingsDb_AppCfg.hpp"
 
+#include "LocalesUtils.hpp"
+#include "libslic3r/AppConfig.hpp"
+#include "libslic3r/Arrange/ArrangeSettingsView.hpp"
+
 namespace Slic3r {
 
 ArrangeSettingsDb_AppCfg::ArrangeSettingsDb_AppCfg(AppConfig *appcfg) : m_appcfg{appcfg}

src/libslic3r/Arrange/ArrangeSettingsDb_AppCfg.hpp

@@ -5,11 +5,14 @@
 #ifndef ARRANGESETTINGSDB_APPCFG_HPP
 #define ARRANGESETTINGSDB_APPCFG_HPP
 
+#include <string>
+
 #include "ArrangeSettingsView.hpp"
 #include "libslic3r/AppConfig.hpp"
 #include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
+class AppConfig;
 
 class ArrangeSettingsDb_AppCfg: public arr2::ArrangeSettingsDb
 {

src/libslic3r/Arrange/Core/Beds.cpp

@@ -4,6 +4,12 @@
 ///|/
 #include "Beds.hpp"
 
+#include <algorithm>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+
 namespace Slic3r { namespace arr2 {
 
 BoundingBox bounding_box(const InfiniteBed &bed)

src/libslic3r/Arrange/Core/Beds.hpp

@@ -5,14 +5,19 @@
 #ifndef BEDS_HPP
 #define BEDS_HPP
 
-#include <numeric>
-
 #include <libslic3r/Point.hpp>
 #include <libslic3r/ExPolygon.hpp>
 #include <libslic3r/BoundingBox.hpp>
 #include <libslic3r/ClipperUtils.hpp>
-
 #include <boost/variant.hpp>
+#include <boost/variant/variant.hpp>
+#include <numeric>
+#include <cmath>
+#include <limits>
+#include <type_traits>
+
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
 

src/libslic3r/Arrange/Core/NFP/EdgeCache.cpp

@@ -3,7 +3,12 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "EdgeCache.hpp"
+
+#include <iterator>
+
 #include "CircularEdgeIterator.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r { namespace arr2 {
 

src/libslic3r/Arrange/Core/NFP/EdgeCache.hpp

@@ -5,9 +5,16 @@
 #ifndef EDGECACHE_HPP
 #define EDGECACHE_HPP
 
-#include <vector>
-
 #include <libslic3r/ExPolygon.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
 

src/libslic3r/Arrange/Core/NFP/NFP.cpp

@@ -6,18 +6,33 @@
 #define NFP_CPP
 
 #include "NFP.hpp"
-#include "CircularEdgeIterator.hpp"
 
+#include "CircularEdgeIterator.hpp"
 #include "NFPConcave_Tesselate.hpp"
+#include "libslic3r/Arrange/Core/Beds.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/libslic3r.h"
 
 #if !defined(_MSC_VER) && defined(__SIZEOF_INT128__) && !defined(__APPLE__)
 namespace Slic3r { using LargeInt = __int128; }
 #else
 #include <boost/multiprecision/integer.hpp>
+
 namespace Slic3r { using LargeInt = boost::multiprecision::int128_t; }
 #endif
 
 #include <boost/rational.hpp>
+#include <assert.h>
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <utility>
+#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/Arrange/Core/NFP/NFP.hpp

@@ -7,6 +7,11 @@
 
 #include <libslic3r/ExPolygon.hpp>
 #include <libslic3r/Arrange/Core/Beds.hpp>
+#include <stdint.h>
+#include <boost/variant.hpp>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 

src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.cpp

@@ -2,16 +2,22 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "NFP.hpp"
-#include "NFPConcave_CGAL.hpp"
-
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/partition_2.h>
 #include <CGAL/Partition_traits_2.h>
 #include <CGAL/property_map.h>
 #include <CGAL/Polygon_vertical_decomposition_2.h>
+#include <stddef.h>
+#include <iterator>
+#include <utility>
+#include <vector>
 
+#include "NFP.hpp"
+#include "NFPConcave_CGAL.hpp"
 #include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/Arrange/Core/NFP/NFPConcave_CGAL.hpp

@@ -7,6 +7,8 @@
 
 #include <libslic3r/ExPolygon.hpp>
 
+#include "libslic3r/Polygon.hpp"
+
 namespace Slic3r {
 
 Polygons convex_decomposition_cgal(const Polygon &expoly);

src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.cpp

@@ -6,8 +6,15 @@
 
 #include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Tesselate.hpp>
+#include <stddef.h>
+#include <algorithm>
+#include <iterator>
+#include <vector>
 
 #include "NFP.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp

@@ -7,6 +7,8 @@
 
 #include <libslic3r/ExPolygon.hpp>
 
+#include "libslic3r/Polygon.hpp"
+
 namespace Slic3r {
 
 Polygons convex_decomposition_tess(const Polygon &expoly);

src/libslic3r/Arrange/Items/ArrangeItem.cpp

@@ -4,13 +4,13 @@
 ///|/
 #include "ArrangeItem.hpp"
 
-#include "libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp"
+#include <numeric>
 
+#include "libslic3r/Arrange/Core/NFP/NFPConcave_Tesselate.hpp"
 #include "libslic3r/Arrange/ArrangeImpl.hpp" // IWYU pragma: keep
 #include "libslic3r/Arrange/Tasks/ArrangeTaskImpl.hpp" // IWYU pragma: keep
 #include "libslic3r/Arrange/Tasks/FillBedTaskImpl.hpp" // IWYU pragma: keep
 #include "libslic3r/Arrange/Tasks/MultiplySelectionTaskImpl.hpp" // IWYU pragma: keep
-
 #include "libslic3r/Geometry/ConvexHull.hpp"
 
 namespace Slic3r { namespace arr2 {

src/libslic3r/Arrange/Items/ArrangeItem.hpp

@@ -5,29 +5,40 @@
 #ifndef ARRANGEITEM_HPP
 #define ARRANGEITEM_HPP
 
-#include <optional>
 #include <boost/variant.hpp>
+#include <libslic3r/ClipperUtils.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <optional>
+#include <algorithm>
+#include <initializer_list>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/AnyPtr.hpp"
-
 #include "libslic3r/Arrange/Core/PackingContext.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFPArrangeItemTraits.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFP.hpp"
-
 #include "libslic3r/Arrange/Items/MutableItemTraits.hpp"
-
 #include "libslic3r/Arrange/Arrange.hpp"
 #include "libslic3r/Arrange/Tasks/ArrangeTask.hpp"
 #include "libslic3r/Arrange/Tasks/FillBedTask.hpp"
 #include "libslic3r/Arrange/Tasks/MultiplySelectionTask.hpp"
-
 #include "libslic3r/Arrange/Items/ArbitraryDataStore.hpp"
-
+#include "libslic3r/Arrange/Core/ArrangeBase.hpp"
-#include <libslic3r/ClipperUtils.hpp>
+#include "libslic3r/Arrange/Core/ArrangeItemTraits.hpp"
+#include "libslic3r/Arrange/Core/DataStoreTraits.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
+struct InfiniteBed;
 
 inline bool check_polygons_are_convex(const Polygons &pp) {
     return std::all_of(pp.begin(), pp.end(), [](const Polygon &p) {

src/libslic3r/Arrange/Items/SimpleArrangeItem.hpp

@@ -5,22 +5,30 @@
 #ifndef SIMPLEARRANGEITEM_HPP
 #define SIMPLEARRANGEITEM_HPP
 
-#include "libslic3r/Arrange/Core/PackingContext.hpp"
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
+#include "libslic3r/Arrange/Core/PackingContext.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFPArrangeItemTraits.hpp"
 #include "libslic3r/Arrange/Core/NFP/NFP.hpp"
-
 #include "libslic3r/Arrange/Arrange.hpp"
 #include "libslic3r/Arrange/Tasks/ArrangeTask.hpp"
 #include "libslic3r/Arrange/Tasks/FillBedTask.hpp"
 #include "libslic3r/Arrange/Tasks/MultiplySelectionTask.hpp"
-
 #include "libslic3r/Polygon.hpp"
 #include "libslic3r/Geometry/ConvexHull.hpp"
-
 #include "MutableItemTraits.hpp"
+#include "libslic3r/Arrange/Core/ArrangeItemTraits.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ObjectID.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r { namespace arr2 {
+struct InfiniteBed;
 
 class SimpleArrangeItem {
     Polygon m_shape;

src/libslic3r/Arrange/Scene.hpp

@@ -5,13 +5,29 @@
 #ifndef ARR2_SCENE_HPP
 #define ARR2_SCENE_HPP
 
+#include <stddef.h>
+#include <boost/variant.hpp>
+#include <boost/variant/variant.hpp>
 #include <any>
 #include <string_view>
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <set>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/ObjectID.hpp"
 #include "libslic3r/AnyPtr.hpp"
 #include "libslic3r/Arrange/ArrangeSettingsView.hpp"
 #include "libslic3r/Arrange/SegmentedRectangleBed.hpp"
+#include "libslic3r/Arrange/Core/Beds.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r { namespace arr2 {
 

src/libslic3r/Arrange/SceneBuilder.cpp

@@ -7,12 +7,22 @@
 
 #include "SceneBuilder.hpp"
 
+#include <cmath>
+#include <limits>
+#include <numeric>
+
 #include "libslic3r/Model.hpp"
 #include "libslic3r/Print.hpp"
 #include "libslic3r/SLAPrint.hpp"
-
 #include "libslic3r/Arrange/Core/ArrangeItemTraits.hpp"
 #include "libslic3r/Geometry/ConvexHull.hpp"
+#include "libslic3r/Arrange/Scene.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Geometry.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/SLA/Pad.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/TriangleMeshSlicer.hpp"
 
 namespace Slic3r { namespace arr2 {
 

src/libslic3r/Arrange/SceneBuilder.hpp

@@ -5,9 +5,27 @@
 #ifndef SCENEBUILDER_HPP
 #define SCENEBUILDER_HPP
 
-#include "Scene.hpp"
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
+#include "Scene.hpp"
 #include "Core/ArrangeItemTraits.hpp"
+#include "libslic3r/AnyPtr.hpp"
+#include "libslic3r/Arrange/Core/Beds.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Model.hpp"
+#include "libslic3r/ObjectID.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/BlacklistedLibraryCheck.cpp

@@ -5,9 +5,6 @@
 ///|/
 #include "BlacklistedLibraryCheck.hpp"
 
-#include <cstdio>
-#include <boost/nowide/convert.hpp>
-
 #ifdef  WIN32
 #include <psapi.h>
 # endif //WIN32

src/libslic3r/BoundingBox.cpp

@@ -8,10 +8,13 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BoundingBox.hpp"
-#include <algorithm>
-#include <assert.h>
 
-#include <Eigen/Dense>
+#include <assert.h>
+#include <algorithm>
+
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/BoundingBox.hpp

@@ -6,12 +6,17 @@
 #ifndef slic3r_BoundingBox_hpp_
 #define slic3r_BoundingBox_hpp_
 
+#include <assert.h>
+#include <algorithm>
+#include <vector>
+
 #include "libslic3r.h"
 #include "Exception.hpp"
 #include "Point.hpp"
 #include "Polygon.hpp"
 
 namespace Slic3r {
+class BoundingBox;
 
 template <typename PointType, typename APointsType = std::vector<PointType>>
 class BoundingBoxBase

src/libslic3r/BranchingTree/BranchingTree.cpp

@@ -3,13 +3,16 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BranchingTree.hpp"
-#include "PointCloud.hpp"
 
-#include <numeric>
+#include <stddef.h>
 #include <optional>
 #include <algorithm>
 
+#include "PointCloud.hpp"
 #include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/BoundingBox.hpp"
+
+struct indexed_triangle_set;
 
 namespace Slic3r { namespace branchingtree {
 

src/libslic3r/BranchingTree/BranchingTree.hpp

@@ -7,8 +7,15 @@
 
 // For indexed_triangle_set
 #include <admesh/stl.h>
+#include <optional>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+
+struct indexed_triangle_set;
 
 namespace Slic3r { namespace branchingtree {
 

src/libslic3r/BranchingTree/PointCloud.cpp

@@ -4,10 +4,15 @@
 ///|/
 #include "PointCloud.hpp"
 
+#include <igl/random_points_on_mesh.h> // IWYU pragma: keep
+#include <array>
+#include <limits>
+
 #include "libslic3r/Tesselate.hpp"
 #include "libslic3r/SLA/SupportTreeUtils.hpp"
-
+#include "admesh/stl.h"
-#include <igl/random_points_on_mesh.h> // IWYU pragma: keep
+#include "libslic3r/BranchingTree/BranchingTree.hpp"
+#include "libslic3r/SLA/Pad.hpp"
 
 namespace Slic3r { namespace branchingtree {
 

src/libslic3r/BranchingTree/PointCloud.hpp

@@ -5,15 +5,28 @@
 #ifndef POINTCLOUD_HPP
 #define POINTCLOUD_HPP
 
+#include <assert.h>
+#include <stddef.h>
+#include <boost/geometry.hpp>
 #include <optional>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <cmath>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 #include "BranchingTree.hpp"
-
 //#include "libslic3r/Execution/Execution.hpp"
 #include "libslic3r/MutablePriorityQueue.hpp"
-
 #include "libslic3r/BoostAdapter.hpp"
 #include "boost/geometry/index/rtree.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+
+struct indexed_triangle_set;
 
 namespace Slic3r { namespace branchingtree {
 

src/libslic3r/BridgeDetector.cpp

@@ -5,9 +5,19 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BridgeDetector.hpp"
+
+#include <stddef.h>
+#include <algorithm>
+
 #include "ClipperUtils.hpp"
 #include "Geometry.hpp"
-#include <algorithm>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/BridgeDetector.hpp

@@ -6,6 +6,15 @@
 #ifndef slic3r_BridgeDetector_hpp_
 #define slic3r_BridgeDetector_hpp_
 
+#include <cmath>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <algorithm>
+#include <limits>
+#include <tuple>
+#include <utility>
+
 #include "ClipperUtils.hpp"
 #include "Line.hpp"
 #include "Point.hpp"
@@ -14,10 +23,6 @@
 #include "PrincipalComponents2D.hpp"
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
-#include <cmath>
-#include <string>
-#include <unordered_map>
-#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/Brim.cpp

@@ -3,26 +3,42 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "clipper/clipper_z.hpp"
+#include <boost/thread/lock_guard.hpp>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <algorithm>
+#include <numeric>
+#include <unordered_set>
+#include <mutex>
+#include <cmath>
+#include <functional>
+#include <utility>
+#include <vector>
 
+#include "clipper/clipper_z.hpp"
 #include "ClipperUtils.hpp"
 #include "EdgeGrid.hpp"
 #include "Layer.hpp"
 #include "Print.hpp"
 #include "ShortestPath.hpp"
 #include "libslic3r.h"
-
+#include "libslic3r/BoundingBox.hpp"
-#include <algorithm>
+#include "libslic3r/ExPolygon.hpp"
-#include <numeric>
+#include "libslic3r/ExtrusionEntity.hpp"
-#include <unordered_set>
+#include "libslic3r/ExtrusionEntityCollection.hpp"
-#include <mutex>
+#include "libslic3r/ExtrusionRole.hpp"
-
+#include "libslic3r/Flow.hpp"
-#include <tbb/parallel_for.h>
+#include "libslic3r/Geometry.hpp"
-#include <boost/thread/lock_guard.hpp>
+#include "libslic3r/LayerRegion.hpp"
-
+#include "libslic3r/Line.hpp"
-#ifndef NDEBUG
+#include "libslic3r/Point.hpp"
-    // #define BRIM_DEBUG_TO_SVG
+#include "libslic3r/Polygon.hpp"
-#endif
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/PrintBase.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 #if defined(BRIM_DEBUG_TO_SVG)
     #include "SVG.hpp"

src/libslic3r/BuildVolume.cpp

@@ -3,12 +3,23 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "BuildVolume.hpp"
+
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
 #include "ClipperUtils.hpp"
 #include "Geometry/ConvexHull.hpp"
 #include "libslic3r/GCode/GCodeProcessor.hpp"
 #include "Point.hpp"
-
+#include "admesh/stl.h"
-#include <boost/log/trivial.hpp>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Geometry/Circle.hpp"
+#include "libslic3r/Polygon.hpp"
 
 namespace Slic3r {
 

src/libslic3r/BuildVolume.hpp

@@ -5,13 +5,18 @@
 #ifndef slic3r_BuildVolume_hpp_
 #define slic3r_BuildVolume_hpp_
 
+#include <admesh/stl.h>
+#include <string_view>
+#include <utility>
+#include <vector>
+
 #include "Point.hpp"
 #include "Geometry/Circle.hpp"
 #include "Polygon.hpp"
 #include "BoundingBox.hpp"
-#include <admesh/stl.h>
+#include "libslic3r/libslic3r.h"
 
-#include <string_view>
+struct indexed_triangle_set;
 
 namespace Slic3r {
 

src/libslic3r/ClipperUtils.cpp

@@ -10,9 +10,16 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ClipperUtils.hpp"
-#include "Geometry.hpp"
+
+#include <stddef.h>
+#include <cmath>
+
 #include "ShortestPath.hpp"
-#include "Utils.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Surface.hpp"
+#include "libslic3r/libslic3r.h"
 
 // #define CLIPPER_UTILS_TIMING
 
@@ -20,7 +27,9 @@
     // time limit for one ClipperLib operation (union / diff / offset), in ms
     #define CLIPPER_UTILS_TIME_LIMIT_DEFAULT 50
     #include <boost/current_function.hpp>
+
     #include "Timer.hpp"
+
     #define CLIPPER_UTILS_TIME_LIMIT_SECONDS(limit) Timing::TimeLimitAlarm time_limit_alarm(uint64_t(limit) * 1000000000l, BOOST_CURRENT_FUNCTION)
     #define CLIPPER_UTILS_TIME_LIMIT_MILLIS(limit) Timing::TimeLimitAlarm time_limit_alarm(uint64_t(limit) * 1000000l, BOOST_CURRENT_FUNCTION)
 #else
@@ -1272,12 +1281,6 @@ static void variable_offset_inner_raw(const ExPolygon &expoly, const std::vector
     holes.reserve(expoly.holes.size());
     for (const Polygon &hole : expoly.holes)
         append(holes, fix_after_outer_offset(mittered_offset_path_scaled(hole.points, deltas[1 + &hole - expoly.holes.data()], miter_limit), ClipperLib::pftNegative, false));
-#ifndef NDEBUG
-    // Offsetting a hole curve of a C shape may close the C into a ring with a new hole inside, thus creating a hole inside a hole shape, thus a hole will be created with negative area
-    // and the following test will fail.
-//    for (auto &c : holes)
-//        assert(ClipperLib::Area(c) > 0.);
-#endif /* NDEBUG */
 }
 
 Polygons variable_offset_inner(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit)
@@ -1351,12 +1354,6 @@ static void variable_offset_outer_raw(const ExPolygon &expoly, const std::vector
     contours = fix_after_outer_offset(mittered_offset_path_scaled(expoly.contour.points, deltas.front(), miter_limit), ClipperLib::pftPositive, false);
     // Inflating a contour must not remove it.
     assert(contours.size() >= 1);
-#ifndef NDEBUG
-    // Offsetting a positive curve of a C shape may close the C into a ring with hole shape, thus a hole will be created with negative area
-    // and the following test will fail.
-//  for (auto &c : contours)
-//      assert(ClipperLib::Area(c) > 0.);
-#endif /* NDEBUG */
 
     // 2) Offset the holes one by one, collect the results.
     holes.reserve(expoly.holes.size());

src/libslic3r/ClipperUtils.hpp

@@ -8,10 +8,20 @@
 
 //#define SLIC3R_USE_CLIPPER2
 
+#include <assert.h>
+#include <cstddef>
+#include <iterator>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
 #include "Polygon.hpp"
 #include "Surface.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
 
 #ifdef SLIC3R_USE_CLIPPER2
 

src/libslic3r/Color.cpp

@@ -2,10 +2,11 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "libslic3r.h"
+#include <stdio.h>
-#include "Color.hpp"
-
 #include <random>
+#include <cmath>
+
+#include "Color.hpp"
 
 static const float INV_255 = 1.0f / 255.0f;
 

src/libslic3r/Color.hpp

@@ -5,8 +5,11 @@
 #ifndef slic3r_Color_hpp_
 #define slic3r_Color_hpp_
 
+#include <assert.h>
 #include <array>
 #include <algorithm>
+#include <string>
+#include <vector>
 
 #include "Point.hpp"
 

src/libslic3r/Config.cpp

@@ -19,36 +19,34 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Config.hpp"
-#include "format.hpp"
-#include "Utils.hpp"
-#include "LocalesUtils.hpp"
 
 #include <assert.h>
-#include <fstream>
-#include <iostream>
-#include <iomanip>
-#include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/erase.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
-#include <boost/config.hpp>
-#include <boost/foreach.hpp>
-#include <boost/lexical_cast.hpp>
 #include <boost/nowide/cstdlib.hpp>
 #include <boost/nowide/iostream.hpp>
 #include <boost/nowide/fstream.hpp>
 #include <boost/nowide/cstdio.hpp>
 #include <boost/property_tree/ini_parser.hpp>
-#include <boost/format.hpp>
 #include <string.h>
-
 #include <LibBGCode/binarize/binarize.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/multi_index_container.hpp>
+#include <cereal/cereal.hpp>
+#include <core/core.hpp>
+#include <iostream>
+#include <iomanip>
+#include <cstddef>
+#include <set>
 
-//FIXME for GCodeFlavor and gcfMarlin (for forward-compatibility conversion)
+#include "format.hpp"
-// This is not nice, likely it would be better to pass the ConfigSubstitutionContext to handle_legacy().
+#include "Utils.hpp"
-#include "PrintConfig.hpp"
+#include "LocalesUtils.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Semver.hpp"
 
 namespace Slic3r {
 
@@ -1432,6 +1430,7 @@ t_config_option_keys DynamicConfig::equal(const DynamicConfig &other) const
 }
 
 #include <cereal/types/polymorphic.hpp> // IWYU pragma: keep
+
 CEREAL_REGISTER_TYPE(Slic3r::ConfigOption)
 CEREAL_REGISTER_TYPE(Slic3r::ConfigOptionSingle<double>)
 CEREAL_REGISTER_TYPE(Slic3r::ConfigOptionSingle<int>)

src/libslic3r/Config.hpp

@@ -23,6 +23,17 @@
 #define slic3r_Config_hpp_
 
 #include <assert.h>
+#include <float.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/format/format_fwd.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/property_tree/ptree_fwd.hpp>
+#include <cereal/access.hpp>
+#include <cereal/types/base_class.hpp>
+#include <ctype.h>
+#include <boost/container_hash/hash.hpp>
+#include <cereal/cereal.hpp>
 #include <map>
 #include <climits>
 #include <limits>
@@ -35,20 +46,19 @@
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include <float.h>
+#include <algorithm>
+#include <cmath>
+#include <initializer_list>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <variant>
+
 #include "libslic3r.h"
 #include "clonable_ptr.hpp"
 #include "Exception.hpp"
 #include "Point.hpp"
-
+#include "LocalesUtils.hpp"
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/format/format_fwd.hpp>
-#include <boost/functional/hash.hpp>
-#include <boost/property_tree/ptree_fwd.hpp>
-
-#include <cereal/access.hpp>
-#include <cereal/types/base_class.hpp>
 
 namespace Slic3r {
     struct FloatOrPercent
@@ -254,6 +264,7 @@ enum ForwardCompatibilitySubstitutionRule
 class  ConfigDef;
 class  ConfigOption;
 class  ConfigOptionDef;
+
 // For forward definition of ConfigOption in ConfigOptionUniquePtr, we have to define a custom deleter.
 struct ConfigOptionDeleter { void operator()(ConfigOption* p); };
 using  ConfigOptionUniquePtr = std::unique_ptr<ConfigOption, ConfigOptionDeleter>;

src/libslic3r/CustomGCode.cpp

@@ -3,9 +3,12 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "CustomGCode.hpp"
+
+#include <assert.h>
+
 #include "Config.hpp"
 #include "GCode.hpp"
-#include "libslic3r/GCode/GCodeWriter.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 namespace Slic3r {
 

src/libslic3r/CustomGCode.hpp

@@ -5,8 +5,10 @@
 #ifndef slic3r_CustomGCode_hpp_
 #define slic3r_CustomGCode_hpp_
 
+#include <stddef.h>
 #include <string>
 #include <vector>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CutSurface.cpp

@@ -27,18 +27,42 @@
 //#define DEBUG_OUTPUT_DIR std::string("C:/data/temp/cutSurface/")
 
 using namespace Slic3r;
-#include "ExPolygonsIndex.hpp"
-
 #include <CGAL/Polygon_mesh_processing/corefinement.h>
 #include <CGAL/Exact_integer.h>
 #include <CGAL/Surface_mesh.h>
 #include <CGAL/Cartesian_converter.h>
-#include <tbb/parallel_for.h>
+#include <assert.h>
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+#include <boost/property_map/property_map.hpp>
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <optional>
+#include <queue>
+#include <set>
+#include <tuple>
+#include <utility>
 
+#include "ExPolygonsIndex.hpp"
 // libslic3r
 #include "TriangleMesh.hpp" // its_merge
 #include "Utils.hpp" // next_highest_power_of_2
 #include "ClipperUtils.hpp" // union_ex + offset_ex
+#include "admesh/stl.h"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/Emboss.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace priv {
 
@@ -521,9 +545,10 @@ void store(const Emboss::IProjection &projection, const Point &point_to_project,
 } // namespace privat
 
 #ifdef DEBUG_OUTPUT_DIR
-#include "libslic3r/SVG.hpp"
 #include <boost/log/trivial.hpp>
 #include <filesystem>
+
+#include "libslic3r/SVG.hpp"
 #endif // DEBUG_OUTPUT_DIR
 
 SurfaceCut Slic3r::cut_surface(const ExPolygons &shapes,
@@ -1779,6 +1804,7 @@ priv::VDistances priv::calc_distances(const SurfacePatches &patches,
 
 #include "libslic3r/AABBTreeLines.hpp"
 #include "libslic3r/Line.hpp"
+
 // functions for choose_best_distance
 namespace priv {
 
@@ -2560,6 +2586,7 @@ void priv::create_face_types(FaceTypeMap           &map,
 
 #include <CGAL/Polygon_mesh_processing/clip.h>
 #include <CGAL/Polygon_mesh_processing/corefinement.h>
+
 bool priv::clip_cut(SurfacePatch &cut, CutMesh clipper)
 {
     CutMesh& tm = cut.mesh; 

src/libslic3r/CutSurface.hpp

@@ -5,12 +5,19 @@
 #ifndef slic3r_CutSurface_hpp_
 #define slic3r_CutSurface_hpp_
 
-#include <vector>
 #include <admesh/stl.h> // indexed_triangle_set
+#include <vector>
+#include <string>
+
 #include "ExPolygon.hpp"
 #include "Emboss.hpp" // IProjection
+#include "libslic3r/BoundingBox.hpp"
 
 namespace Slic3r{
+namespace Emboss {
+class IProject3d;
+class IProjection;
+}  // namespace Emboss
 
 /// <summary>
 /// Represents cutted surface from object

src/libslic3r/CutUtils.cpp

@@ -4,14 +4,23 @@
 ///|/
 
 #include "CutUtils.hpp"
+
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stddef.h>
+#include <Eigen/Geometry>
+#include <cmath>
+#include <string>
+#include <utility>
+
 #include "Geometry.hpp"
 #include "libslic3r.h"
 #include "Model.hpp"
 #include "TriangleMeshSlicer.hpp"
-#include "TriangleSelector.hpp"
+#include "admesh/stl.h"
-#include "ObjectID.hpp"
+#include "libslic3r/BoundingBox.hpp"
-
+#include "libslic3r/Point.hpp"
-#include <boost/log/trivial.hpp>
+#include "libslic3r/TriangleMesh.hpp"
 
 namespace Slic3r {
 

src/libslic3r/EdgeGrid.cpp

@@ -2,12 +2,13 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <float.h>
+#include <math.h>
 #include <algorithm>
 #include <vector>
-#include <float.h>
 #include <unordered_map>
-
+#include <cstdint>
-#include <png.h>
+#include <set>
 
 #include "libslic3r.h"
 #include "ClipperUtils.hpp"
@@ -15,6 +16,9 @@
 #include "Geometry.hpp"
 #include "SVG.hpp"
 #include "PNGReadWrite.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
 
 // #define EDGE_GRID_DEBUG_OUTPUT
 

src/libslic3r/EdgeGrid.hpp

@@ -7,10 +7,22 @@
 
 #include <stdint.h>
 #include <math.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "Point.hpp"
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 namespace EdgeGrid {

src/libslic3r/ElephantFootCompensation.cpp

@@ -2,7 +2,13 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "clipper/clipper_z.hpp"
+#include <stddef.h>
+#include <cmath>
+#include <cassert>
+#include <algorithm>
+#include <limits>
+#include <utility>
+#include <vector>
 
 #include "libslic3r.h"
 #include "ClipperUtils.hpp"
@@ -11,11 +17,10 @@
 #include "ElephantFootCompensation.hpp"
 #include "Flow.hpp"
 #include "Geometry.hpp"
-#include "SVG.hpp"
 #include "Utils.hpp"
-
+#include "libslic3r/BoundingBox.hpp"
-#include <cmath>
+#include "libslic3r/Point.hpp"
-#include <cassert>
+#include "libslic3r/Polygon.hpp"
 
 // #define CONTOUR_DISTANCE_DEBUG_SVG
 

src/libslic3r/ElephantFootCompensation.hpp

@@ -5,9 +5,10 @@
 #ifndef slic3r_ElephantFootCompensation_hpp_
 #define slic3r_ElephantFootCompensation_hpp_
 
+#include <vector>
+
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
-#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/Emboss.cpp

@@ -2,24 +2,36 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include <numeric>
-#include "Emboss.hpp"
-#include <stdio.h>
-#include <numeric>
-#include <cstdlib>
 #include <boost/nowide/convert.hpp>
 #include <boost/log/trivial.hpp>
+#include <numeric>
+#include <cstdlib>
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <iterator>
+#include <limits>
+
+#include "Emboss.hpp"
 #include "IntersectionPoints.hpp"
+#include "admesh/stl.h"
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include "libslic3r/EmbossShape.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/TextConfiguration.hpp"
 
 #define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation
 
+#include <libslic3r/Triangulation.hpp> // CGAL project
+
 // Explicit horror include (used to be implicit) - libslic3r "officialy" does not depend on imgui.
 #include "../../bundled_deps/imgui/imgui/imstb_truetype.h" // stbtt_fontinfo
 #include "Utils.hpp" // ScopeGuard
-
-#include <libslic3r/Triangulation.hpp> // CGAL project
 #include "libslic3r.h"
-
 // to heal shape
 #include "libslic3r/ClipperUtils.hpp" // union_ex + for boldness(polygon extend(offset))
 #include "libslic3r/ExPolygonsIndex.hpp"
@@ -58,6 +70,7 @@ namespace {
 // for debug purpose only
 // NOTE: check scale when store svg !!
 #include "libslic3r/SVG.hpp" // for visualize_heal
+
 Points get_unique_intersections(const Slic3r::IntersectionsLines &intersections); // fast forward declaration
 static std::string visualize_heal_svg_filepath = "C:/data/temp/heal.svg";
 void               visualize_heal(const std::string &svg_filepath, const ExPolygons &expolygons)
@@ -1349,7 +1362,6 @@ ExPolygonsWithIds Emboss::text2vshapes(FontFileWithCache &font_with_cache, const
     return result;
 }
 
-#include <boost/range/adaptor/reversed.hpp>
 unsigned Emboss::get_count_lines(const std::wstring& ws)
 {
     if (ws.empty())
@@ -2051,6 +2063,7 @@ double Emboss::get_align_y_offset_in_mm(FontProp::VerticalAlign align, unsigned
 
 #ifdef REMOVE_SPIKES
 #include <Geometry.hpp>
+
 void remove_spikes(Polygon &polygon, const SpikeDesc &spike_desc)
 {
     enum class Type {

src/libslic3r/Emboss.hpp

@@ -5,16 +5,26 @@
 #ifndef slic3r_Emboss_hpp_
 #define slic3r_Emboss_hpp_
 
+#include <admesh/stl.h> // indexed_triangle_set
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <vector>
 #include <set>
 #include <optional>
 #include <memory>
-#include <admesh/stl.h> // indexed_triangle_set
+#include <Eigen/Geometry>
+#include <functional>
+#include <map>
+#include <string>
+#include <utility>
+
 #include "Polygon.hpp"
 #include "ExPolygon.hpp"
 #include "EmbossShape.hpp" // ExPolygonsWithIds
 #include "BoundingBox.hpp"
 #include "TextConfiguration.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 

src/libslic3r/ExPolygon.cpp

@@ -10,19 +10,23 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <ankerl/unordered_dense.h>
+#include <string.h>
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <limits>
+
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
-#include "Exception.hpp"
 #include "Geometry/MedialAxis.hpp"
 #include "Polygon.hpp"
 #include "Line.hpp"
 #include "ClipperUtils.hpp"
-#include "SVG.hpp"
+#include "libslic3r/MultiPoint.hpp"
-#include <algorithm>
+#include "libslic3r/Point.hpp"
-#include <cassert>
+#include "libslic3r/Polyline.hpp"
-#include <list>
+#include "libslic3r/libslic3r.h"
-
-#include <ankerl/unordered_dense.h>
 
 namespace Slic3r {
 

src/libslic3r/ExPolygon.hpp

@@ -12,15 +12,27 @@
 #ifndef slic3r_ExPolygon_hpp_
 #define slic3r_ExPolygon_hpp_
 
+#include <assert.h>
+#include <oneapi/tbb/scalable_allocator.h>
+#include <stdint.h>
+#include <vector>
+#include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <utility>
+
 #include "Point.hpp"
 #include "libslic3r.h"
 #include "Polygon.hpp"
 #include "Polyline.hpp"
-#include <vector>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Line.hpp"
 
 namespace Slic3r {
 
 class ExPolygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 
 class ExPolygon
@@ -493,6 +505,7 @@ bool        remove_small_and_small_holes(ExPolygons &expolygons, double min_area
 
 // start Boost
 #include <boost/polygon/polygon.hpp>
+
 namespace boost { namespace polygon {
     template <>
         struct polygon_traits<Slic3r::ExPolygon> {

src/libslic3r/ExPolygonsIndex.cpp

@@ -1,4 +1,13 @@
 #include "ExPolygonsIndex.hpp"
+
+#include <assert.h>
+#include <algorithm>
+#include <utility>
+
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/Polygon.hpp"
+
 using namespace Slic3r;
 
 // IMPROVE: use one dimensional vector for polygons offset with searching by std::lower_bound

src/libslic3r/ExPolygonsIndex.hpp

@@ -1,7 +1,11 @@
 #ifndef slic3r_ExPolygonsIndex_hpp_
 #define slic3r_ExPolygonsIndex_hpp_
 
+#include <cstdint>
+#include <vector>
+
 #include "ExPolygon.hpp"
+
 namespace Slic3r {
 
 /// <summary>

src/libslic3r/Extruder.cpp

@@ -8,8 +8,15 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "Extruder.hpp"
+
+#include <assert.h>
+#include <math.h>
+#include <algorithm>
+
 #include "libslic3r/GCode/GCodeWriter.hpp"
 #include "PrintConfig.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/Extruder.hpp

@@ -10,6 +10,8 @@
 #ifndef slic3r_Extruder_hpp_
 #define slic3r_Extruder_hpp_
 
+#include <utility>
+
 #include "libslic3r.h"
 #include "Point.hpp"
 

src/libslic3r/ExtrusionEntity.cpp

@@ -6,15 +6,18 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ExtrusionEntity.hpp"
+
+#include <limits>
+#include <iterator>
+
 #include "ExtrusionEntityCollection.hpp"
 #include "ExPolygon.hpp"
 #include "ClipperUtils.hpp"
 #include "Exception.hpp"
-#include "Extruder.hpp"
 #include "Flow.hpp"
-#include <cmath>
+#include "libslic3r/Polygon.hpp"
-#include <limits>
+#include "libslic3r/Polyline.hpp"
-#include <sstream>
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/ExtrusionEntity.hpp

@@ -8,20 +8,28 @@
 #ifndef slic3r_ExtrusionEntity_hpp_
 #define slic3r_ExtrusionEntity_hpp_
 
+#include <assert.h>
+#include <stddef.h>
+#include <optional>
+#include <string_view>
+#include <numeric>
+#include <cmath>
+#include <limits>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "ExtrusionRole.hpp"
 #include "Flow.hpp"
 #include "Polygon.hpp"
 #include "Polyline.hpp"
-
+#include "libslic3r/ExPolygon.hpp"
-#include <assert.h>
+#include "libslic3r/Point.hpp"
-#include <optional>
-#include <string_view>
-#include <numeric>
 
 namespace Slic3r {
 
 class ExPolygon;
+
 using ExPolygons = std::vector<ExPolygon>;
 class ExtrusionEntityCollection;
 class Extruder;

src/libslic3r/ExtrusionEntityCollection.cpp

@@ -7,10 +7,11 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include "ExtrusionEntityCollection.hpp"
-#include "ShortestPath.hpp"
+
 #include <algorithm>
-#include <cmath>
+#include <limits>
-#include <map>
+
+#include "libslic3r/ExtrusionEntity.hpp"
 
 namespace Slic3r {
 

src/libslic3r/ExtrusionEntityCollection.hpp

@@ -7,9 +7,18 @@
 #ifndef slic3r_ExtrusionEntityCollection_hpp_
 #define slic3r_ExtrusionEntityCollection_hpp_
 
+#include <stddef.h>
+#include <iterator>
+#include <utility>
+#include <vector>
+
 #include "libslic3r.h"
 #include "Exception.hpp"
 #include "ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 

src/libslic3r/ExtrusionSimulator.cpp

@@ -7,18 +7,23 @@
 //#undef SLIC3R_DEBUG
 //#define NDEBUG
 
-#include <cmath>
-#include <cassert>
-
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/box.hpp>
 #include <boost/geometry/geometries/point.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
-
 #include <boost/multi_array.hpp>
+#include <string.h>
+#include <cmath>
+#include <cassert>
+#include <algorithm>
+#include <complex>
+#include <utility>
+#include <vector>
 
 #include "libslic3r.h"
 #include "ExtrusionSimulator.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
 
 #ifndef M_PI
 #define M_PI 3.1415926535897932384626433832795

src/libslic3r/ExtrusionSimulator.hpp

@@ -8,6 +8,7 @@
 #include "libslic3r.h"
 #include "ExtrusionEntity.hpp"
 #include "BoundingBox.hpp"
+#include "libslic3r/Point.hpp"
 
 namespace Slic3r {
 

src/libslic3r/Fill/Fill.cpp

@@ -9,7 +9,16 @@
 ///|/
 #include <assert.h>
 #include <stdio.h>
+#include <oneapi/tbb/scalable_allocator.h>
+#include <stdint.h>
+#include <boost/container/vector.hpp>
 #include <memory>
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <set>
+#include <utility>
+#include <vector>
 
 #include "../ClipperUtils.hpp"
 #include "../Geometry.hpp"
@@ -19,15 +28,30 @@
 #include "../Surface.hpp"
 // for Arachne based infills
 #include "../PerimeterGenerator.hpp"
-
 #include "FillBase.hpp"
 #include "FillRectilinear.hpp"
 #include "FillLightning.hpp"
-#include "FillConcentric.hpp"
 #include "FillEnsuring.hpp"
 #include "libslic3r/Polygon.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/ExtrusionEntityCollection.hpp"
+#include "libslic3r/ExtrusionRole.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/LayerRegion.hpp"
+#include "libslic3r/MultiMaterialSegmentation.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
+namespace FillAdaptive {
+struct Octree;
+}  // namespace FillAdaptive
+namespace FillLightning {
+class Generator;
+}  // namespace FillLightning
 
 //static constexpr const float NarrowInfillAreaThresholdMM = 3.f;
 
@@ -446,10 +470,6 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
 {
 	this->clear_fills();
 
-#ifdef SLIC3R_DEBUG_SLICE_PROCESSING
-//	this->export_region_fill_surfaces_to_svg_debug("10_fill-initial");
-#endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
-
     std::vector<SurfaceFill>  surface_fills       = group_fills(*this);
     const Slic3r::BoundingBox bbox                = this->object()->bounding_box();
     const auto                resolution          = this->object()->print()->config().gcode_resolution.value;

src/libslic3r/Fill/Fill3DHoneycomb.cpp

@@ -3,11 +3,20 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
 #include "../ClipperUtils.hpp"
 #include "../ShortestPath.hpp"
-#include "../Surface.hpp"
-
 #include "Fill3DHoneycomb.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/Fill/Fill3DHoneycomb.hpp

@@ -7,12 +7,15 @@
 #define slic3r_Fill3DHoneycomb_hpp_
 
 #include <map>
+#include <utility>
 
 #include "libslic3r/libslic3r.h"
-
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
+class Point;
 
 class Fill3DHoneycomb : public Fill
 {

src/libslic3r/Fill/FillAdaptive.cpp

@@ -2,32 +2,41 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
-#include "../ClipperUtils.hpp"
-#include "../ExPolygon.hpp"
-#include "../Surface.hpp"
-#include "../Geometry.hpp"
-#include "../Layer.hpp"
-#include "../Print.hpp"
-#include "../ShortestPath.hpp"
-
-#include "FillAdaptive.hpp"
-
 // for indexed_triangle_set
 #include <admesh/stl.h>
-
+#include <assert.h>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/static_assert.hpp>
 #include <cstdlib>
 #include <cmath>
 #include <algorithm>
 #include <numeric>
+#include <array>
+#include <iterator>
+#include <limits>
+#include <optional>
+
+#include "../ClipperUtils.hpp"
+#include "../ExPolygon.hpp"
+#include "../Geometry.hpp"
+#include "../Layer.hpp"
+#include "../Print.hpp"
+#include "../ShortestPath.hpp"
+#include "FillAdaptive.hpp"
+#include "libslic3r/Fill/FillAdaptive.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "tcbspan/span.hpp"
 
 // Boost pool: Don't use mutexes to synchronize memory allocation.
 #define BOOST_POOL_NO_MT
 #include <boost/pool/object_pool.hpp>
-
 #include <boost/geometry.hpp>
-#include <boost/geometry/geometries/point.hpp>
 #include <boost/geometry/geometries/segment.hpp>
-#include <boost/geometry/index/rtree.hpp>
 
 
 namespace Slic3r {
@@ -508,10 +517,6 @@ static void generate_infill_lines_recursive(
     }
 }
 
-#ifndef NDEBUG
-//    #define ADAPTIVE_CUBIC_INFILL_DEBUG_OUTPUT
-#endif
-
 #ifdef ADAPTIVE_CUBIC_INFILL_DEBUG_OUTPUT
 static void export_infill_lines_to_svg(const ExPolygon &expoly, const Polylines &polylines, const std::string &path, const Points &pts = Points())
 {

src/libslic3r/Fill/FillAdaptive.hpp

@@ -15,7 +15,16 @@
 #ifndef slic3r_FillAdaptive_hpp_
 #define slic3r_FillAdaptive_hpp_
 
+#include <Eigen/Geometry>
+#include <memory>
+#include <utility>
+#include <vector>
+
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/libslic3r.h"
 
 struct indexed_triangle_set;
 
@@ -27,6 +36,7 @@ namespace FillAdaptive
 {
 
 struct Octree;
+
 // To keep the definition of Octree opaque, we have to define a custom deleter.
 struct OctreeDeleter { void operator()(Octree *p); };
 using  OctreePtr = std::unique_ptr<Octree, OctreeDeleter>;

src/libslic3r/Fill/FillBase.cpp

@@ -8,7 +8,14 @@
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
 #include <stdio.h>
+#include <boost/log/trivial.hpp>
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
 #include <numeric>
+#include <algorithm>
+#include <cmath>
+#include <limits>
 
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/EdgeGrid.hpp"
@@ -18,7 +25,6 @@
 #include "libslic3r/PrintConfig.hpp"
 #include "libslic3r/Surface.hpp"
 #include "libslic3r/libslic3r.h"
-
 #include "FillBase.hpp"
 #include "FillConcentric.hpp"
 #include "FillHoneycomb.hpp"
@@ -30,8 +36,8 @@
 #include "FillAdaptive.hpp"
 #include "FillLightning.hpp"
 #include "FillEnsuring.hpp"
-
+#include "libslic3r/Config.hpp"
-#include <boost/log/trivial.hpp>
+#include "libslic3r/Line.hpp"
 
 // #define INFILL_DEBUG_OUTPUT
 
@@ -925,9 +931,6 @@ void mark_boundary_segments_touching_infill(
                 BoundingBoxf bbox_seg;
                 bbox_seg.merge(seg_pt1);
                 bbox_seg.merge(seg_pt2);
-#ifdef INFILL_DEBUG_OUTPUT
-                //if (this->infill_bbox.overlap(bbox_seg)) this->perimeter_overlaps.push_back({ segment.first, segment.second });
-#endif // INFILL_DEBUG_OUTPUT
                 if (this->infill_bbox.overlap(bbox_seg) && line_rounded_thick_segment_collision(seg_pt1, seg_pt2, *this->infill_pt1, *this->infill_pt2, this->radius, interval)) {
                     // The boundary segment intersects with the infill segment thickened by radius.
                     // Interval is specified in Euclidian length from seg_pt1 to seg_pt2.
@@ -1083,9 +1086,6 @@ void mark_boundary_segments_touching_infill(
                 assert(grid.bbox().contains(b.cast<coord_t>()));
                 grid.visit_cells_intersecting_line(a.cast<coord_t>(), b.cast<coord_t>(), visitor);
 #endif
-#ifdef INFILL_DEBUG_OUTPUT
-//                export_infill_to_svg(boundary, boundary_parameters, boundary_intersections, infill, distance_colliding * 2, debug_out_path("%s-%03d-%03d-%03d.svg", "FillBase-mark_boundary_segments_touching_infill-step", iRun, iStep, int(point_idx)), { polyline });
-#endif // INFILL_DEBUG_OUTPUT
 			}
 #ifdef INFILL_DEBUG_OUTPUT
             Polylines perimeter_overlaps;

src/libslic3r/Fill/FillBase.hpp

@@ -14,9 +14,13 @@
 #include <memory.h>
 #include <float.h>
 #include <stdint.h>
+#include <math.h>
+#include <stddef.h>
 #include <stdexcept>
-
 #include <type_traits>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/BoundingBox.hpp"
@@ -24,10 +28,16 @@
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
 
 class Surface;
+class PrintConfig;
+class PrintObjectConfig;
+
 enum InfillPattern : int;
 
 namespace FillAdaptive {

src/libslic3r/Fill/FillConcentric.cpp

@@ -7,12 +7,22 @@
 ///|/
 ///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
 ///|/
+#include <assert.h>
+#include <stddef.h>
+#include <algorithm>
+#include <vector>
+
 #include "../ClipperUtils.hpp"
 #include "../ExPolygon.hpp"
-#include "../Surface.hpp"
 #include "libslic3r/Arachne/WallToolPaths.hpp"
-
 #include "FillConcentric.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/Fill/FillBase.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r {
 

src/libslic3r/Fill/FillConcentric.hpp

@@ -11,9 +11,14 @@
 #ifndef slic3r_FillConcentric_hpp_
 #define slic3r_FillConcentric_hpp_
 
+#include <utility>
+
 #include "FillBase.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Polyline.hpp"
 
 namespace Slic3r {
+class Point;
 
 class FillConcentric : public Fill
 {