Merge branch 'main' into feature/texdisp-help-links

src/OrcaSlicer.cpp

@@ -20,6 +20,49 @@
     #endif /* SLIC3R_GUI */
 #endif /* WIN32 */
 
+#include <map>
+#include <vector>
+#include "libslic3r/PrintBase.hpp"
+#include "slic3r/Utils/json_diff.hpp"
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <cerrno>
+#include <utility>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include "libslic3r/LocalesUtils.hpp"
+#include <fstream>
+#include <exception>
+#include <set>
+#include "libslic3r/Color.hpp"
+#include "libslic3r/TriangleSelector.hpp"
+#include <algorithm>
+#include "libslic3r/Format/bbs_3mf.hpp"
+#include <cstdlib>
+#include <stdlib.h>
+#include <stdexcept>
+#include "libslic3r/Point.hpp"
+#include "libslic3r_version.h"
+#include "libslic3r/Semver.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/CustomGCode.hpp"
+#include <memory>
+#include <sstream>
+#include <iomanip>
+#include <iterator>
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/GCode/WipeTowerEstimate.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmoBase.hpp"
+#include <functional>
+#include "libslic3r/Arrange.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/GCode/ThumbnailData.hpp"
+#include "slic3r/GUI/3DScene.hpp"
+#include "slic3r/GUI/GLShader.hpp"
+#include <cassert>
+#include <boost/filesystem/exception.hpp>
+#include <signal.h>
+
 #include <cstdio>
 #include <string>
 #include <cstring>

src/OrcaSlicer.hpp

@@ -1,7 +1,14 @@
 #ifndef SLIC3R_HPP
 #define SLIC3R_HPP
 
+#include <map>
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Format/bbs_3mf.hpp"
+#include "libslic3r/GCode/ThumbnailData.hpp"
 #include <set>
+#include <string>
+#include <vector>
 
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Model.hpp"

src/dev-utils/OrcaSlicer_profile_validator.cpp

@@ -8,6 +8,28 @@
 #define NANOSVGRAST_IMPLEMENTATION
 #include "nanosvg/nanosvgrast.h"
 
+#include <vector>
+#include <boost/filesystem/path.hpp>
+#include <map>
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include <utility>
+#include "libslic3r/CustomGCode.hpp"
+#include <iterator>
+#include <boost/smart_ptr/make_shared_object.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/log/core/record_view.hpp>
+#include <boost/log/expressions/message.hpp>
+#include <cstddef>
+#include <exception>
+#include "libslic3r/PlaceholderParser.hpp"
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/value_semantic.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/errors.hpp>
+
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/GCode.hpp"
 #include "libslic3r/GCode/WipeTower.hpp"

src/dev-utils/encoding-check.cpp

@@ -1,3 +1,4 @@
+#include <iosfwd>
 #include <vector>
 #include <iostream>
 #include <fstream>

src/dev-utils/generate_system_cache.cpp

@@ -4,9 +4,19 @@
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/directory.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/value_semantic.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/errors.hpp>
+#include <exception>
+#include <cstddef>
 #include <iostream>
+#include <memory>
+#include "libslic3r/Config.hpp"
 
 using namespace Slic3r;
 namespace fs = boost::filesystem;

src/dev-utils/profile_include_dump.cpp

@@ -11,13 +11,19 @@
 #include "libslic3r/Utils.hpp"
 
 #include <boost/filesystem.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
 #include <boost/nowide/fstream.hpp>
 #include "nlohmann/json.hpp"
 
 #include <algorithm>
+#include <cstddef>
+#include <exception>
 #include <iostream>
+#include "libslic3r/Config.hpp"
 #include <map>
 #include <set>
+#include <stdexcept>
 #include <string>
 #include <vector>
 

src/libslic3r/AABBMesh.cpp

@@ -1,10 +1,19 @@
 #include "AABBMesh.hpp"
+#include "Point.hpp"
+#include <Eigen/Core>
 #include <Execution/ExecutionTBB.hpp>
 
+#include <igl/Hit.h>
+#include <cstddef>
+#include <cassert>
+#include <cmath>
+#include <algorithm>
 #include <libslic3r/AABBTreeIndirect.hpp>
 #include <libslic3r/TriangleMesh.hpp>
 
+#include <limits>
 #include <numeric>
+#include <vector>
 
 #ifdef SLIC3R_HOLE_RAYCASTER
 #include <libslic3r/SLA/Hollowing.hpp>

src/libslic3r/AABBMesh.hpp

@@ -1,6 +1,10 @@
 #ifndef PRUSASLICER_AABBMESH_H
 #define PRUSASLICER_AABBMESH_H
 
+#include <cstddef>
+#include <limits>
+#include <cmath>
+#include <cassert>
 #include <memory>
 #include <vector>
 

src/libslic3r/AABBTreeIndirect.hpp

@@ -6,15 +6,20 @@
 #ifndef slic3r_AABBTreeIndirect_hpp_
 #define slic3r_AABBTreeIndirect_hpp_
 
+#include <Eigen/Core>
 #include <algorithm>
+#include <cstddef>
+#include <cassert>
 #include <limits>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include <Eigen/Geometry>
 
 #include "BoundingBox.hpp"
 #include "Utils.hpp" // for next_highest_power_of_2()
+#include "libslic3r.h"
 
 // Definition of the ray intersection hit structure.
 #include <igl/Hit.h>

src/libslic3r/AABBTreeLines.hpp

@@ -6,9 +6,15 @@
 #include "libslic3r.h"
 #include "libslic3r/AABBTreeIndirect.hpp"
 #include "libslic3r/Line.hpp"
+#include <Eigen/Core>
 #include <algorithm>
+#include <cassert>
 #include <cmath>
+#include <cstddef>
+#include <tuple>
+#include <limits>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace Slic3r {

src/libslic3r/AStar.hpp

@@ -1,7 +1,11 @@
 #ifndef ASTAR_HPP
 #define ASTAR_HPP
 
+#include <cassert>
 #include <cmath> // std::isinf() is here
+#include <type_traits>
+#include <cstddef>
+#include <limits>
 #include <unordered_map>
 
 #include "libslic3r/MutablePriorityQueue.hpp"

src/libslic3r/Algorithm/LineSplit.cpp

@@ -1,8 +1,20 @@
 #include "LineSplit.hpp"
 
 #include "AABBTreeLines.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ClipperZUtils.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/ExPolygon.hpp"
 #include "SVG.hpp"
 #include "Utils.hpp"
+#include <limits>
+#include "libslic3r/libslic3r.h"
+#include <algorithm>
+#include <cstddef>
+#include <cassert>
+#include <vector>
+#include <utility>
 
 //#define DEBUG_SPLIT_LINE
 
@@ -14,7 +26,7 @@ static std::atomic<std::uint32_t> g_dbg_id = 0;
 #endif
 
 // Z for points from clip polygon
-static constexpr auto CLIP_IDX = std::numeric_limits<ClipperLib_Z::cInt>::max();
+static constexpr auto CLIP_IDX = std::numeric_limits<coord_t>::max();
 
 static void cb_split_line(const ClipperZUtils::ZPoint& e1bot,
                    const ClipperZUtils::ZPoint& e1top,
@@ -91,14 +103,7 @@ SplittedLine do_split_line(const ClipperZUtils::ZPath& path, const ExPolygons& c
                 clip_path.emplace_back(ClipperZUtils::to_zpath<false>(hole.points, CLIP_IDX));
         }
 
-        ClipperLib_Z::Clipper zclipper;
-        zclipper.PreserveCollinear(true);
-        zclipper.ZFillFunction(cb_split_line);
-        zclipper.AddPaths(clip_path, ClipperLib_Z::ptClip, true);
-        zclipper.AddPath(path, ClipperLib_Z::ptSubject, false);
-        ClipperLib_Z::PolyTree polytree;
-        zclipper.Execute(ClipperLib_Z::ctIntersection, polytree, ClipperLib_Z::pftNonZero, ClipperLib_Z::pftNonZero);
-        ClipperLib_Z::PolyTreeToPaths(std::move(polytree), intersections);
+        intersections = ClipperZUtils::clip_zpaths(ctIntersection, ClipperZUtils::ZPaths{ path }, true, clip_path, cb_split_line, true);
     }
     if (intersections.empty()) {
         return {};

src/libslic3r/Algorithm/LineSplit.hpp

@@ -2,6 +2,12 @@
 #define SRC_LIBSLIC3R_ALGORITHM_LINE_SPLIT_HPP_
 
 #include "ClipperZUtils.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Point.hpp"
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+#include "libslic3r/ExPolygon.hpp"
 
 namespace Slic3r {
 namespace Algorithm {
@@ -50,7 +56,7 @@ SplittedLine split_line(const PathType& path, const ExPolygons& clip, bool close
     // Convert the input path into an open ZPath
     ClipperZUtils::ZPath p;
     p.reserve(path.size() + (closed ? 1 : 0));
-    ClipperLib_Z::cInt z = 0;
+    coord_t z = 0;
     for (const auto& point : path) {
         p.emplace_back(point.x(), point.y(), z);
         z++;

src/libslic3r/Algorithm/RegionExpansion.cpp

@@ -1,16 +1,30 @@
 #include "RegionExpansion.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Polyline.hpp"
+#include "libslic3r/Polygon.hpp"
 
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cassert>
+#include <iterator>
+#include <cstdint>
 #include <libslic3r/AABBTreeIndirect.hpp>
 #include <libslic3r/ClipperZUtils.hpp>
 #include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Utils.hpp>
 
+#include <math.h>
 #include <numeric>
+#include <vector>
+#include <utility>
 
 namespace Slic3r {
 namespace Algorithm {
 
-// Calculating radius discretization according to ClipperLib offsetter code, see void ClipperOffset::DoOffset(double delta)
+// Calculating radius discretization according to the Clipper offsetter code, see ClipperOffset::DoGroupOffset()
 inline double clipper_round_offset_error(double offset, double arc_tolerance)
 {
     static constexpr const double def_arc_tolerance = 0.25;
@@ -61,7 +75,6 @@ RegionExpansionParameters RegionExpansionParameters::build(
 
     // Accuracy of the offsetter for wave propagation.
     out.arc_tolerance        = scaled<double>(0.1);
-    out.shortest_edge_length = out.initial_step * ClipperOffsetShortestEdgeFactor;
 
     // Maximum inflation of seed contours over the boundary. Used to trim boundary to speed up
     // clipping during wave propagation. Needs to be in sync with the offsetter accuracy.
@@ -75,25 +88,20 @@ RegionExpansionParameters RegionExpansionParameters::build(
 
 // similar to expolygons_to_zpaths(), but each contour is expanded before converted to zpath.
 // The expanded contours are then opened (the first point is repeated at the end).
-static ClipperLib_Z::Paths expolygons_to_zpaths_expanded_opened(
+static ClipperZUtils::ZPaths expolygons_to_zpaths_expanded_opened(
     const ExPolygons &src, const float expansion, coord_t &base_idx)
 {
-    ClipperLib_Z::Paths out;
+    ClipperZUtils::ZPaths out;
     out.reserve(2 * std::accumulate(src.begin(), src.end(), size_t(0),
         [](const size_t acc, const ExPolygon &expoly) { return acc + expoly.num_contours(); }));
-    ClipperLib::ClipperOffset offsetter;
-    offsetter.ShortestEdgeLength = expansion * ClipperOffsetShortestEdgeFactor;
-    ClipperLib::Paths expansion_cache;
     for (const ExPolygon &expoly : src) {
         for (size_t icontour = 0; icontour < expoly.num_contours(); ++ icontour) {
-            // Execute reorients the contours so that the outer most contour has a positive area. Thus the output
-            // contours will be CCW oriented even though the input paths are CW oriented.
-            // Offset is applied after contour reorientation, thus the signum of the offset value is reversed.
-            offsetter.Clear();
-            offsetter.AddPath(expoly.contour_or_hole(icontour).points, ClipperLib::jtSquare, ClipperLib::etClosedPolygon);
-            expansion_cache.clear();
-            offsetter.Execute(expansion_cache, icontour == 0 ? expansion : -expansion);
-            append(out, ClipperZUtils::to_zpaths<true>(expansion_cache, base_idx));
+            // Orient CCW, then grow the contour and shrink the holes. The output contours are CCW.
+            Polygon contour = expoly.contour_or_hole(icontour);
+            if (! contour.is_counter_clockwise())
+                contour.reverse();
+            for (const Polygon &expanded : offset(contour, icontour == 0 ? expansion : -expansion, jtSquare))
+                out.emplace_back(ClipperZUtils::to_zpath<true>(expanded.points, base_idx));
         }
         ++ base_idx;
     }
@@ -104,21 +112,21 @@ static ClipperLib_Z::Paths expolygons_to_zpaths_expanded_opened(
 // Thus some pieces of the clipped polygons may now become split at the ends of the source polygons.
 // Those ends are sorted lexicographically in "splits".
 // Reconnect those split pieces.
-static inline void merge_splits(ClipperLib_Z::Paths &paths, std::vector<std::pair<ClipperLib_Z::IntPoint, int>> &splits)
+static inline void merge_splits(ClipperZUtils::ZPaths &paths, std::vector<std::pair<ClipperZUtils::ZPoint, int>> &splits)
 {
     for (auto it_path = paths.begin(); it_path != paths.end(); ) {
-        ClipperLib_Z::Path &path = *it_path;
+        ClipperZUtils::ZPath &path = *it_path;
         assert(path.size() >= 2);
         bool merged = false;
         if (path.size() >= 2) {
-            const ClipperLib_Z::IntPoint &front = path.front();
-            const ClipperLib_Z::IntPoint &back  = path.back();
+            const ClipperZUtils::ZPoint &front = path.front();
+            const ClipperZUtils::ZPoint &back  = path.back();
             // The path before clipping was supposed to cross the clipping boundary or be fully out of it.
             // Thus the clipped contour is supposed to become open, with one exception: The anchor expands into a closed hole.
             if (front.x() != back.x() || front.y() != back.y()) {
                 // Look up the ends in "splits", possibly join the contours.
                 // "splits" maps into the other piece connected to the same end point.
-                auto find_end = [&splits](const ClipperLib_Z::IntPoint &pt) -> std::pair<ClipperLib_Z::IntPoint, int>* {
+                auto find_end = [&splits](const ClipperZUtils::ZPoint &pt) -> std::pair<ClipperZUtils::ZPoint, int>* {
                     auto it = std::lower_bound(splits.begin(), splits.end(), pt,
                         [](const auto &l, const auto &r){ return ClipperZUtils::zpoint_lower(l.first, r); });
                     return it != splits.end() && it->first == pt ? &(*it) : nullptr;
@@ -136,7 +144,7 @@ static inline void merge_splits(ClipperLib_Z::Paths &paths, std::vector<std::pai
                         end->second = int(it_path - paths.begin());
                     } else {
                         // Open end was found and matched with end->second
-                        ClipperLib_Z::Path &other_path = paths[end->second];
+                        ClipperZUtils::ZPath &other_path = paths[end->second];
                         polylines_merge(other_path, other_path.front() == end->first, std::move(path), end_front);
                         if (std::next(it_path) == paths.end()) {
                             paths.pop_back();
@@ -212,36 +220,29 @@ std::vector<WaveSeed> wave_seeds(
     using Intersection  = ClipperZUtils::ClipperZIntersectionVisitor::Intersection;
     using Intersections = ClipperZUtils::ClipperZIntersectionVisitor::Intersections;
 
-    ClipperLib_Z::Paths segments;
-    Intersections       intersections;
+    ClipperZUtils::ZPaths segments;
+    Intersections         intersections;
 
-    coord_t             idx_boundary_begin = 1;
-    coord_t             idx_boundary_end   = idx_boundary_begin;
-    coord_t             idx_src_end;
+    coord_t               idx_boundary_begin = 1;
+    coord_t               idx_boundary_end   = idx_boundary_begin;
+    coord_t               idx_src_end;
 
     {
-        ClipperLib_Z::Clipper zclipper;
         ClipperZUtils::ClipperZIntersectionVisitor visitor(intersections);
-        zclipper.ZFillFunction(visitor.clipper_callback());
         // as closed contours
-        zclipper.AddPaths(ClipperZUtils::expolygons_to_zpaths(boundary, idx_boundary_end), ClipperLib_Z::ptClip, true);
+        ClipperZUtils::ZPaths zboundary = ClipperZUtils::expolygons_to_zpaths(boundary, idx_boundary_end);
         // as open contours
-        std::vector<std::pair<ClipperLib_Z::IntPoint, int>> zsrc_splits;
-        {
-            idx_src_end = idx_boundary_end;
-            ClipperLib_Z::Paths zsrc = expolygons_to_zpaths_expanded_opened(src, tiny_expansion, idx_src_end);
-            zclipper.AddPaths(zsrc, ClipperLib_Z::ptSubject, false);
-            zsrc_splits.reserve(zsrc.size());
-            for (const ClipperLib_Z::Path &path : zsrc) {
-                assert(path.size() >= 2);
-                assert(path.front() == path.back());
-                zsrc_splits.emplace_back(path.front(), -1);
-            }
-            std::sort(zsrc_splits.begin(), zsrc_splits.end(), [](const auto &l, const auto &r){ return ClipperZUtils::zpoint_lower(l.first, r.first); });
+        std::vector<std::pair<ClipperZUtils::ZPoint, int>> zsrc_splits;
+        idx_src_end = idx_boundary_end;
+        ClipperZUtils::ZPaths zsrc = expolygons_to_zpaths_expanded_opened(src, tiny_expansion, idx_src_end);
+        zsrc_splits.reserve(zsrc.size());
+        for (const ClipperZUtils::ZPath &path : zsrc) {
+            assert(path.size() >= 2);
+            assert(path.front() == path.back());
+            zsrc_splits.emplace_back(path.front(), -1);
         }
-        ClipperLib_Z::PolyTree polytree;
-        zclipper.Execute(ClipperLib_Z::ctIntersection, polytree, ClipperLib_Z::pftNonZero, ClipperLib_Z::pftNonZero);
-        ClipperLib_Z::PolyTreeToPaths(std::move(polytree), segments);
+        std::sort(zsrc_splits.begin(), zsrc_splits.end(), [](const auto &l, const auto &r){ return ClipperZUtils::zpoint_lower(l.first, r.first); });
+        segments = ClipperZUtils::clip_zpaths(ctIntersection, zsrc, true, zboundary, visitor.clipper_callback());
         merge_splits(segments, zsrc_splits);
     }
 
@@ -256,10 +257,10 @@ std::vector<WaveSeed> wave_seeds(
     WaveSeeds out;
     out.reserve(segments.size());
     int iseed = 0;
-    for (const ClipperLib_Z::Path &path : segments) {
+    for (const ClipperZUtils::ZPath &path : segments) {
         assert(path.size() >= 2);
-        ClipperLib_Z::IntPoint front = path.front();
-        ClipperLib_Z::IntPoint back  = path.back();
+        ClipperZUtils::ZPoint front = path.front();
+        ClipperZUtils::ZPoint back  = path.back();
         // Both ends of a seed segment are supposed to be inside a single boundary expolygon.
         // Thus as long as the seed contour is not closed, it should be open at a boundary point.
         assert((front == back && front.z() >= idx_boundary_end && front.z() < idx_src_end) || 
@@ -280,7 +281,7 @@ std::vector<WaveSeed> wave_seeds(
             // boundary ID is not directly available).
             coord_t src_z = -1, boundary_z = -1;
             // Scan all path points for the information we need.
-            for (const ClipperLib_Z::IntPoint &point : path) {
+            for (const ClipperZUtils::ZPoint &point : path) {
                 if (point.z() >= idx_boundary_end && point.z() < idx_src_end && src_z < 0)
                     src_z = point.z();
                 else if (point.z() >= idx_boundary_begin && point.z() < idx_boundary_end && boundary_z < 0)
@@ -311,7 +312,7 @@ std::vector<WaveSeed> wave_seeds(
             // See https://github.com/prusa3d/PrusaSlicer/issues/12469.
             // Segement is open, yet its first point seems to be part of boundary polygon.
             // Take the first point with src polygon index.
-            for (const ClipperLib_Z::IntPoint &point : path) {
+            for (const ClipperZUtils::ZPoint &point : path) {
                 if (point.z() >= idx_boundary_end) {
                     front = point;
                     back = point;
@@ -360,17 +361,13 @@ std::vector<WaveSeed> wave_seeds(
     return out;
 }
 
-static ClipperLib::Paths wavefront_initial(ClipperLib::ClipperOffset &co, const ClipperLib::Paths &polylines, float offset)
+static Polygons wavefront_initial(const VecOfPoints &polylines, float offset, double arc_tolerance)
 {
-    ClipperLib::Paths out;
+    Polygons out;
     out.reserve(polylines.size());
-    ClipperLib::Paths out_this;
-    for (const ClipperLib::Path &path : polylines) {
+    for (const Points &path : polylines) {
         assert(path.size() >= 2);
-        co.Clear();
-        co.AddPath(path, jtRound, path.front() == path.back() ? ClipperLib::etClosedLine : ClipperLib::etOpenRound);
-        co.Execute(out_this, offset);
-        append(out, std::move(out_this));
+        append(out, Slic3r::offset(Polyline(path), offset, jtRound, arc_tolerance, path.front() == path.back() ? etClosedLine : etOpenRound));
     }
     return out;
 }
@@ -378,43 +375,24 @@ static ClipperLib::Paths wavefront_initial(ClipperLib::ClipperOffset &co, const
 // Input polygons may consist of multiple expolygons, even nested expolygons.
 // After inflation some polygons may thus overlap, however the overlap is being resolved during the successive
 // clipping operation, thus it is not being done here.
-static ClipperLib::Paths wavefront_step(ClipperLib::ClipperOffset &co, const ClipperLib::Paths &polygons, float offset)
+static Polygons wavefront_step(const Polygons &polygons, float offset, double arc_tolerance)
 {
-    ClipperLib::Paths out;
+    Polygons out;
     out.reserve(polygons.size());
-    ClipperLib::Paths out_this;
-    for (const ClipperLib::Path &polygon : polygons) {
-        co.Clear();
-        // Execute reorients the contours so that the outer most contour has a positive area. Thus the output
-        // contours will be CCW oriented even though the input paths are CW oriented.
-        // Offset is applied after contour reorientation, thus the signum of the offset value is reversed.
-        co.AddPath(polygon, jtRound, ClipperLib::etClosedPolygon);
-        bool ccw = ClipperLib::Orientation(polygon);
-        co.Execute(out_this, ccw ? offset : - offset);
-        if (! ccw) {
-            // Reverse the resulting contours.
-            for (ClipperLib::Path &path : out_this)
-                std::reverse(path.begin(), path.end());
-        }
-        append(out, std::move(out_this));
-    }
+    for (const Polygon &polygon : polygons)
+        // CCW contours grow, CW holes shrink.
+        append(out, Slic3r::offset(polygon, offset, jtRound, arc_tolerance));
     return out;
 }
 
-static ClipperLib::Paths wavefront_clip(const ClipperLib::Paths &wavefront, const Polygons &clipping)
+static Polygons wavefront_clip(const Polygons &wavefront, const Polygons &clipping)
 {
-    ClipperLib::Clipper clipper;
-    clipper.AddPaths(wavefront, ClipperLib::ptSubject, true);
-    clipper.AddPaths(ClipperUtils::PolygonsProvider(clipping),  ClipperLib::ptClip, true);
-    ClipperLib::Paths out;
-    clipper.Execute(ClipperLib::ctIntersection, out, ClipperLib::pftPositive, ClipperLib::pftPositive);
-    return out;
+    return intersection(wavefront, clipping, pftPositive);
 }
 
 static Polygons propagate_wave_from_boundary(
-    ClipperLib::ClipperOffset   &co,
     // Seed of the wave: Open polylines very close to the boundary.
-    const ClipperLib::Paths     &seed,
+    const VecOfPoints           &seed,
     // Boundary inside which the waveform will propagate.
     const ExPolygon             &boundary,
     // How much to inflate the seed lines to produce the first wave area.
@@ -425,25 +403,24 @@ static Polygons propagate_wave_from_boundary(
     const size_t                 num_other_steps,
     // Maximum inflation of seed contours over the boundary. Used to trim boundary to speed up
     // clipping during wave propagation.
-    const float                  max_inflation)
+    const float                  max_inflation,
+    // Accuracy of the round offsets.
+    const double                 arc_tolerance)
 {
     assert(! seed.empty() && seed.front().size() >= 2);
     Polygons clipping = ClipperUtils::clip_clipper_polygons_with_subject_bbox(boundary, get_extents<true>(seed).inflated(max_inflation));
-    ClipperLib::Paths polygons = wavefront_clip(wavefront_initial(co, seed, initial_step), clipping);
+    Polygons polygons = wavefront_clip(wavefront_initial(seed, initial_step, arc_tolerance), clipping);
     // Now offset the remaining 
     for (size_t ioffset = 0; ioffset < num_other_steps; ++ ioffset)
-        polygons = wavefront_clip(wavefront_step(co, polygons, other_step), clipping);
-    return to_polygons(polygons);
+        polygons = wavefront_clip(wavefront_step(polygons, other_step, arc_tolerance), clipping);
+    return polygons;
 }
 
 // Resulting regions are sorted by boundary id and source id.
 std::vector<RegionExpansion> propagate_waves(const WaveSeeds &seeds, const ExPolygons &boundary, const RegionExpansionParameters &params)
 {
     std::vector<RegionExpansion> out;
-    ClipperLib::Paths            paths;
-    ClipperLib::ClipperOffset co;
-    co.ArcTolerance       = params.arc_tolerance;
-    co.ShortestEdgeLength = params.shortest_edge_length;
+    VecOfPoints                  paths;
     for (auto it_seed = seeds.begin(); it_seed != seeds.end();) {
         auto it = it_seed;
         paths.clear();
@@ -452,7 +429,7 @@ std::vector<RegionExpansion> propagate_waves(const WaveSeeds &seeds, const ExPol
         // Propagate the wavefront while clipping it with the trimmed boundary.
         // Collect the expanded polygons, merge them with the source polygons.
         RegionExpansion re;
-        for (Polygon &polygon : propagate_wave_from_boundary(co, paths, boundary[it_seed->boundary], params.initial_step, params.other_step, params.num_other_steps, params.max_inflation))
+        for (Polygon &polygon : propagate_wave_from_boundary(paths, boundary[it_seed->boundary], params.initial_step, params.other_step, params.num_other_steps, params.max_inflation, params.arc_tolerance))
             out.push_back({ std::move(polygon), it_seed->src, it_seed->boundary });
         it_seed = it;
     }

src/libslic3r/Algorithm/RegionExpansion.hpp

@@ -1,10 +1,12 @@
 #ifndef SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 #define SRC_LIBSLIC3R_ALGORITHM_REGION_EXPANSION_HPP_
 
+#include <cstddef>
 #include <cstdint>
 #include <libslic3r/Point.hpp>
 #include <libslic3r/Polygon.hpp>
 #include <libslic3r/ExPolygon.hpp>
+#include <vector>
 
 namespace Slic3r {
 namespace Algorithm {
@@ -25,7 +27,6 @@ struct RegionExpansionParameters
 
     // Accuracy of the offsetter for wave propagation.
     double                 arc_tolerance;
-    double                 shortest_edge_length;
 
     static RegionExpansionParameters build(
         // Scaled expansion value

src/libslic3r/AnyPtr.hpp

@@ -1,6 +1,7 @@
 #ifndef ANYPTR_HPP
 #define ANYPTR_HPP
 
+#include <boost/variant/variant.hpp>
 #include <memory>
 #include <type_traits>
 #include <boost/variant.hpp>

src/libslic3r/AppConfig.cpp

@@ -1,3 +1,8 @@
+#include "Technologies.hpp"
+#include "Config.hpp"
+#include "PrintConfig.hpp"
+#include "calib.hpp"
+#include "Semver.hpp"
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/Format/DRC.hpp"
@@ -9,9 +14,18 @@
 #include "LocalesUtils.hpp"
 #include "Thread.hpp"
 #include "format.hpp"
+#include "libslic3r_version.h"
 #include "nlohmann/json.hpp"
 
 #include <algorithm>
+#include <string>
+#include <exception>
+#include <boost/none.hpp>
+#include <cstddef>
+#include <system_error>
+#include <chrono>
+#include <map>
+#include <cstring>
 #include <utility>
 #include <vector>
 #include <stdexcept>
@@ -304,6 +318,9 @@ void AppConfig::set_defaults()
     if (get(SETTING_OPENGL_SHOW_FPS_OVERLAY).empty())
         set_bool(SETTING_OPENGL_SHOW_FPS_OVERLAY, false);
 
+    if (get(SETTING_OPENGL_SHOW_RENDER_TIMINGS).empty())
+        set_bool(SETTING_OPENGL_SHOW_RENDER_TIMINGS, false);
+
     if (get(SETTING_OPENGL_REALISTIC_MODE).empty())
         set_bool(SETTING_OPENGL_REALISTIC_MODE, false);
 
@@ -316,8 +333,9 @@ void AppConfig::set_defaults()
     if (get(SETTING_OPENGL_SHADING_MODEL).empty())
         set(SETTING_OPENGL_SHADING_MODEL, "gouraud");
 
-    if (get(SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS).empty())
-        set_bool(SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS, false);
+    // Replaces the on/off setting, whose shadows turned with the camera.
+    if (get(SETTING_OPENGL_REALISTIC_SHADOWS).empty())
+        set(SETTING_OPENGL_REALISTIC_SHADOWS, get_bool(SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS) ? "orbit" : "off");
 
     if (get(SETTING_OPENGL_PHONG_SMOOTH_NORMALS).empty())
         set_bool(SETTING_OPENGL_PHONG_SMOOTH_NORMALS, false);

src/libslic3r/AppConfig.hpp

@@ -5,8 +5,11 @@
 #include <chrono>
 #include <map>
 #include <string>
+#include "LocalesUtils.hpp"
 #include "nlohmann/json.hpp"
 #include <boost/algorithm/string/trim_all.hpp>
+#include <utility>
+#include <vector>
 
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Semver.hpp"
@@ -37,10 +40,13 @@ using namespace nlohmann;
 #define SETTING_OPENGL_SCENE_CACHE "opengl_scene_cache"
 #define SETTING_OPENGL_SKIP_IDENTICAL_FRAMES "opengl_skip_identical_frames"
 #define SETTING_OPENGL_SHOW_FPS_OVERLAY "opengl_show_fps_overlay"
+#define SETTING_OPENGL_SHOW_RENDER_TIMINGS "opengl_show_render_timings"
 #define SETTING_OPENGL_REALISTIC_MODE "opengl_realistic_mode"
 #define SETTING_OPENGL_REALISTIC_PHONG "opengl_realistic_phong"
 #define SETTING_OPENGL_SHADING_MODEL "opengl_shading_model"
 #define SETTING_OPENGL_PHONG_BASIC_PLATE_SHADOWS "opengl_phong_basic_plate_shadows"
+// off, static (light fixed in the world) or orbit (light turning with the camera)
+#define SETTING_OPENGL_REALISTIC_SHADOWS "opengl_realistic_shadows"
 #define SETTING_OPENGL_PHONG_SSAO "opengl_phong_ssao"
 #define SETTING_OPENGL_PHONG_SMOOTH_NORMALS "opengl_phong_smooth_normals"
 #define SETTING_OPENGL_REALISTIC_PREVIEW "opengl_realistic_preview"

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategy.cpp

@@ -2,7 +2,9 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include "BeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
+#include <vector>
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.cpp

@@ -12,6 +12,7 @@
 #include "DistributedBeadingStrategy.hpp"
 #include "RedistributeBeadingStrategy.hpp"
 #include "OuterWallInsetBeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne {

src/libslic3r/Arachne/BeadingStrategy/DistributedBeadingStrategy.cpp

@@ -6,6 +6,7 @@
 #include <cassert>
 
 #include "DistributedBeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp

@@ -3,10 +3,12 @@
 
 #include <boost/log/trivial.hpp>
 #include <cassert>
+#include <string>
 #include <utility>
 #include <cstddef>
 
 #include "LimitedBeadingStrategy.hpp"
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 

src/libslic3r/Arachne/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <utility>
 
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/BeadingStrategy/RedistributeBeadingStrategy.cpp

@@ -7,6 +7,7 @@
 #include <numeric>
 #include <utility>
 
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/BeadingStrategy/WideningBeadingStrategy.cpp

@@ -4,8 +4,11 @@
 #include "WideningBeadingStrategy.hpp"
 
 #include <algorithm>
+#include <string>
 #include <utility>
+#include <vector>
 
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/SkeletalTrapezoidation.cpp

@@ -10,10 +10,18 @@
 #include <cmath>
 #include <cstdint>
 #include <limits>
+#include <math.h>
+#include <list>
+#include <memory>
 #include <utility>
 #include <cassert>
 #include <cstdlib>
+#include <vector>
 
+#include "libslic3r/Point.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 #include "libslic3r/Geometry/VoronoiUtils.hpp"
 #include "ankerl/unordered_dense.h"
 #include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"

src/libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp

@@ -4,10 +4,12 @@
 #ifndef SKELETAL_TRAPEZOIDATION_EDGE_H
 #define SKELETAL_TRAPEZOIDATION_EDGE_H
 
+#include <cassert>
 #include <memory> // smart pointers
 #include <list>
 #include <vector>
 
+#include "libslic3r/libslic3r.h"
 #include "utils/ExtrusionJunction.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/SkeletalTrapezoidationGraph.cpp

@@ -6,11 +6,17 @@
 #include <ankerl/unordered_dense.h>
 #include <boost/log/trivial.hpp>
 #include <algorithm>
+#include <cstdint>
 #include <iostream>
 #include <cassert>
 #include <cinttypes>
+#include <optional>
+#include <utility>
 
 #include "../Line.hpp"
+#include "libslic3r/Arachne/utils/HalfEdge.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Arachne/utils/HalfEdgeNode.hpp"
 #include "libslic3r/Arachne/SkeletalTrapezoidationEdge.hpp"
 #include "libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp"
 #include "libslic3r/Point.hpp"

src/libslic3r/Arachne/SkeletalTrapezoidationJoint.hpp

@@ -6,6 +6,7 @@
 
 #include <memory> // smart pointers
 
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
 
 namespace Slic3r::Arachne

src/libslic3r/Arachne/WallToolPaths.cpp

@@ -2,12 +2,31 @@
 // CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include <algorithm> //For std::partition_copy and std::min_element.
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <cassert>
+#include <cmath>
+#include <math.h>
+#include <limits>
 #include <unordered_set>
 
 #include "WallToolPaths.hpp"
 
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
+#include "libslic3r/Line.hpp"
+#include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
+#include "libslic3r/Flow.hpp"
+#include "libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp"
+#include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
+#include "libslic3r/Arachne/utils/SparsePointGrid.hpp"
+#include "libslic3r/Arachne/utils/SquareGrid.hpp"
 #include "SkeletalTrapezoidation.hpp"
 #include "../ClipperUtils.hpp"
+#include "libslic3r/libslic3r.h"
 #include "utils/linearAlg2D.hpp"
 #include "EdgeGrid.hpp"
 #include "utils/SparseLineGrid.hpp"
@@ -17,6 +36,8 @@
 #include "Utils.hpp"
 
 #include <boost/log/trivial.hpp>
+#include <utility>
+#include <vector>
 
 //#define ARACHNE_STITCH_PATCH_DEBUG
 
@@ -263,10 +284,8 @@ std::unique_ptr<LocToLineGrid>                                               cre
  */
 void fixSelfIntersections(const coord_t epsilon, Polygons &thiss)
 {
-    if (epsilon < 1) {
-        ClipperLib::SimplifyPolygons(ClipperUtils::PolygonsProvider(thiss), ClipperLib::pftEvenOdd);
+    if (epsilon < 1)
         return;
-    }
 
     const int64_t half_epsilon = (epsilon + 1) / 2;
 
@@ -304,8 +323,6 @@ void fixSelfIntersections(const coord_t epsilon, Polygons &thiss)
             }
         }
     }
-
-    ClipperLib::SimplifyPolygons(ClipperUtils::PolygonsProvider(thiss), ClipperLib::pftEvenOdd);
 }
 
 /*!
@@ -352,18 +369,11 @@ void removeDegenerateVerts(Polygons &thiss)
 
 void removeSmallAreas(Polygons &thiss, const double min_area_size, const bool remove_holes)
 {
-    auto to_path = [](const Polygon &poly) -> ClipperLib::Path {
-        ClipperLib::Path out;
-        for (const Point &pt : poly.points)
-            out.emplace_back(ClipperLib::cInt(pt.x()), ClipperLib::cInt(pt.y()));
-        return out;
-    };
-
     auto new_end = thiss.end();
     if (remove_holes) {
         for (auto it = thiss.begin(); it < new_end;) {
             // All polygons smaller than target are removed by replacing them with a polygon from the back of the vector.
-            if (fabs(ClipperLib::Area(to_path(*it))) < min_area_size) {
+            if (fabs(it->area()) < min_area_size) {
                 --new_end;
                 *it = std::move(*new_end);
                 continue; // Don't increment the iterator such that the polygon just swapped in is checked next.
@@ -374,7 +384,7 @@ void removeSmallAreas(Polygons &thiss, const double min_area_size, const bool re
         // For each polygon, computes the signed area, move small outlines at the end of the vector and keep pointer on small holes
         Polygons small_holes;
         for (auto it = thiss.begin(); it < new_end;) {
-            if (double area = ClipperLib::Area(to_path(*it)); fabs(area) < min_area_size) {
+            if (double area = it->area(); fabs(area) < min_area_size) {
                 if (area >= 0) {
                     --new_end;
                     if (it < new_end) {
@@ -773,7 +783,7 @@ void WallToolPaths::separateOutInnerContour()
     //To get a correct shape, we need to make the outside contour positive and any holes inside negative.
     //This can be done by applying the even-odd rule to the shape. This rule is not sensitive to the winding order of the polygon.
     //The even-odd rule would be incorrect if the polygon self-intersects, but that should never be generated by the skeletal trapezoidation.
-    inner_contour = union_(inner_contour, ClipperLib::PolyFillType::pftEvenOdd);
+    inner_contour = union_(inner_contour, pftEvenOdd);
 }
 
 const Polygons& WallToolPaths::getInnerContour()

src/libslic3r/Arachne/WallToolPaths.hpp

@@ -4,10 +4,16 @@
 #ifndef CURAENGINE_WALLTOOLPATHS_H
 #define CURAENGINE_WALLTOOLPATHS_H
 
+#include <cstddef>
+#include <boost/container_hash/hash.hpp>
 #include <memory>
 #include <ankerl/unordered_dense.h>
+#include <vector>
+#include <utility>
 
 #include "BeadingStrategy/BeadingStrategyFactory.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Point.hpp"
 #include "utils/ExtrusionLine.hpp"
 #include "../Polygon.hpp"
 #include "../PrintConfig.hpp"

src/libslic3r/Arachne/utils/ExtrusionJunction.hpp

@@ -6,6 +6,9 @@
 #define UTILS_EXTRUSION_JUNCTION_H
 
 #include "../../Point.hpp"
+#include "libslic3r/libslic3r.h"
+#include <cstddef>
+#include <vector>
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/ExtrusionLine.cpp

@@ -2,11 +2,17 @@
 //CuraEngine is released under the terms of the AGPLv3 or higher.
 
 #include <algorithm>
+#include <cassert>
 #include <cmath>
+#include <cstdint>
 #include <cstdlib>
+#include <vector>
 
 #include "ExtrusionLine.hpp"
 #include "../../VariableWidth.hpp"
+#include "libslic3r/ClipperZUtils.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Point.hpp"
 #include "libslic3r/Arachne/utils/ExtrusionJunction.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/ExtrusionEntity.hpp"
@@ -287,9 +293,9 @@ double ExtrusionLine::area() const
 } // namespace Slic3r::Arachne
 
 namespace Slic3r {
-void extrusion_paths_append(ExtrusionPaths &dst, const ClipperLib_Z::Paths &extrusion_paths, const ExtrusionRole role, const Flow &flow)
+void extrusion_paths_append(ExtrusionPaths &dst, const ClipperZUtils::ZPaths &extrusion_paths, const ExtrusionRole role, const Flow &flow)
 {
-    for (const ClipperLib_Z::Path &extrusion_path : extrusion_paths) {
+    for (const ClipperZUtils::ZPath &extrusion_path : extrusion_paths) {
         ThickPolyline thick_polyline = Arachne::to_thick_polyline(extrusion_path);
         Slic3r::append(dst, thick_polyline_to_multi_path(thick_polyline, role, flow, scaled<float>(0.05), float(SCALED_EPSILON)).paths);
     }

src/libslic3r/Arachne/utils/ExtrusionLine.hpp

@@ -5,7 +5,7 @@
 #ifndef UTILS_EXTRUSION_LINE_H
 #define UTILS_EXTRUSION_LINE_H
 
-#include <clipper/clipper_z.hpp>
+#include "../../ClipperZUtils.hpp"
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -22,6 +22,7 @@
 #include "../../BoundingBox.hpp"
 #include "../../ExtrusionEntity.hpp"
 #include "../../Flow.hpp"
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
 
 namespace Slic3r {
@@ -294,7 +295,7 @@ using VariableWidthLines = std::vector<ExtrusionLine>; //<! The ExtrusionLines g
 
 namespace Slic3r {
 
-void extrusion_paths_append(ExtrusionPaths &dst, const ClipperLib_Z::Paths &extrusion_paths, const ExtrusionRole role, const Flow &flow);
+void extrusion_paths_append(ExtrusionPaths &dst, const ClipperZUtils::ZPaths &extrusion_paths, const ExtrusionRole role, const Flow &flow);
 void extrusion_paths_append(ExtrusionPaths &dst, const Arachne::ExtrusionLine &extrusion, const ExtrusionRole role, const Flow &flow);
 
 } // namespace Slic3r

src/libslic3r/Arachne/utils/PolygonsPointIndex.hpp

@@ -4,6 +4,9 @@
 #ifndef UTILS_POLYGONS_POINT_INDEX_H
 #define UTILS_POLYGONS_POINT_INDEX_H
 
+#include <utility>
+#include <functional>
+#include <cstddef>
 #include <vector>
 
 #include "../../Point.hpp"

src/libslic3r/Arachne/utils/PolygonsSegmentIndex.hpp

@@ -6,7 +6,10 @@
 
 #include <vector>
 
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Point.hpp"
 #include "PolygonsPointIndex.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne
 {

src/libslic3r/Arachne/utils/PolylineStitcher.cpp

@@ -4,6 +4,7 @@
 #include "PolylineStitcher.hpp"
 
 #include "ExtrusionLine.hpp"
+#include "libslic3r/Point.hpp"
 #include "libslic3r/Arachne/utils/PolygonsPointIndex.hpp"
 #include "libslic3r/Polygon.hpp"
 

src/libslic3r/Arachne/utils/SparseGrid.hpp

@@ -6,11 +6,14 @@
 #define UTILS_SPARSE_GRID_H
 
 #include <cassert>
+#include <unordered_map>
+#include <cstddef>
 #include <vector>
 #include <functional>
 
 #include "../../Point.hpp"
 #include "SquareGrid.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/utils/SparseLineGrid.hpp

@@ -6,10 +6,15 @@
 #define UTILS_SPARSE_LINE_GRID_H
 
 #include <cassert>
+#include <cstddef>
+#include <utility>
+#include <unordered_map>
 #include <vector>
 #include <functional>
 
+#include "libslic3r/Point.hpp"
 #include "SparseGrid.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/utils/SparsePointGrid.hpp

@@ -6,9 +6,13 @@
 #define UTILS_SPARSE_POINT_GRID_H
 
 #include <cassert>
+#include <cstddef>
+#include <cstdint>
 #include <vector>
 
+#include "libslic3r/Point.hpp"
 #include "SparseGrid.hpp"
+#include "libslic3r/libslic3r.h"
 
 namespace Slic3r::Arachne {
 

src/libslic3r/Arachne/utils/SquareGrid.cpp

@@ -4,7 +4,11 @@
 #include "SquareGrid.hpp"
 
 #include <cassert>
+#include <cstdint>
+#include <utility>
+#include <functional>
 
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Point.hpp"
 
 using namespace Slic3r::Arachne;

src/libslic3r/Arachne/utils/linearAlg2D.hpp

@@ -5,6 +5,9 @@
 #define UTILS_LINEAR_ALG_2D_H
 
 #include "../../Point.hpp"
+#include <cstdint>
+#include <math.h>
+#include <cmath>
 
 namespace Slic3r::Arachne::LinearAlg2D
 {

src/libslic3r/ArcFitter.cpp

@@ -1,8 +1,14 @@
 #include "ArcFitter.hpp"
+#include "Point.hpp"
+#include "Circle.hpp"
+#include "MultiPoint.hpp"
 #include "Polyline.hpp"
+#include "libslic3r.h"
 
 #include <cmath>
 #include <cassert>
+#include <vector>
+#include <cstddef>
 
 namespace Slic3r {
 

src/libslic3r/ArcFitter.hpp

@@ -2,6 +2,9 @@
 #define slic3r_ArcFitter_hpp_
 
 #include "Circle.hpp"
+#include <cstddef>
+#include "Point.hpp"
+#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/Arrange.cpp

@@ -1,9 +1,28 @@
 #include "Arrange.hpp"
+#include "ExPolygon.hpp"
+#include "Point.hpp"
 #include "Print.hpp"
 #include "BoundingBox.hpp"
+#include "PrintConfig.hpp"
 #include "libslic3r.h"
 
+#include <Eigen/Core>
+#include <boost/geometry/index/parameters.hpp>
+#include <functional>
+#include <algorithm>
+#include <cstdlib>
+#include <cmath>
+#include <cstddef>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <array>
+#include <boost/geometry/index/predicates.hpp>
+#include <iterator>
+#include <exception>
 #include <libnest2d/backends/libslic3r/geometries.hpp>
+#include "libnest2d/common.hpp"
+#include "libnest2d/geometry_traits_nfp.hpp"
+#include "libnest2d/nester.hpp"
+#include "libnest2d/geometry_traits.hpp"
 #include <libnest2d/optimizers/nlopt/subplex.hpp>
 #include <libnest2d/placers/nfpplacer.hpp>
 #include <libnest2d/selections/firstfit.hpp>
@@ -13,6 +32,11 @@
 #include <ClipperUtils.hpp>
 
 #include <boost/geometry/index/rtree.hpp>
+#include <utility>
+#include <vector>
+#include <tuple>
+#include <set>
+#include <string>
 
 #if defined(_MSC_VER) && defined(__clang__)
 #define BOOST_NO_CXX17_HDR_STRING_VIEW
@@ -55,7 +79,7 @@ namespace Slic3r {
 
 template<class Tout = double, class = FloatingOnly<Tout>, int...EigenArgs>
 inline constexpr Eigen::Matrix<Tout, 2, EigenArgs...> unscaled(
-    const Slic3r::ClipperLib::IntPoint &v) noexcept
+    const Slic3r::Point &v) noexcept
 {
     return Eigen::Matrix<Tout, 2, EigenArgs...>{unscaled<Tout>(v.x()),
                                                 unscaled<Tout>(v.y())};
@@ -405,7 +429,7 @@ protected:
         // 2) X distance of item corner to bed corner (low weight)
         // 3) item row occupancy (useful when rotation is enabled)
         // 4）需要允许往屏蔽区域的左边或下边去一点，不然很多物体可能认为摆不进去，实际上我们最后是可以做平移的
-    double dist_for_BOTTOM_LEFT(Box ibb, const ClipperLib::IntPoint& origin_pack)
+    double dist_for_BOTTOM_LEFT(Box ibb, const Slic3r::Point& origin_pack)
     {
         double dist_corner_y = ibb.minCorner().y() - origin_pack.y();
         double dist_corner_x = ibb.minCorner().x() - origin_pack.x();
@@ -421,7 +445,7 @@ protected:
         return bindist;
     }
 
-    double dist_to_bin(const Box& ibb, const ClipperLib::IntPoint& origin_pack, typename Packer::PlacementConfig::Alignment starting_point_alignment)
+    double dist_to_bin(const Box& ibb, const Slic3r::Point& origin_pack, typename Packer::PlacementConfig::Alignment starting_point_alignment)
     {
         double bindist = 0;
         if (starting_point_alignment == PConfig::Alignment::BOTTOM_LEFT)
@@ -439,7 +463,7 @@ protected:
     // as it possibly can be but at the same time, it has to provide
     // reasonable results.
     std::tuple<double /*score*/, Box /*farthest point from bin center*/>
-    objfunc(const Item &item, const ClipperLib::IntPoint &origin_pack)
+    objfunc(const Item &item, const Slic3r::Point &origin_pack)
     {
         const double bin_area = m_bin_area;
         const SpatIndex& spatindex = m_rtree;
@@ -1014,7 +1038,12 @@ void _arrange(
 inline Box to_nestbin(const BoundingBox &bb) { return Box{{bb.min(X), bb.min(Y)}, {bb.max(X), bb.max(Y)}};}
 inline Circle to_nestbin(const CircleBed &c) { return Circle({c.center()(0), c.center()(1)}, c.radius()); }
 inline ExPolygon to_nestbin(const Polygon &p) { return ExPolygon{p}; }
-inline Box to_nestbin(const InfiniteBed &bed) { return Box::infinite({bed.center.x(), bed.center.y()}); }
+// libnest2d's infinite box reaches the int64 limit, where Clipper2's double math is no longer exact.
+inline Box to_nestbin(const InfiniteBed &bed)
+{
+    const coord_t r = coord_t(1) << 50;
+    return Box{{bed.center.x() - r, bed.center.y() - r}, {bed.center.x() + r, bed.center.y() + r}};
+}
 
 inline coord_t width(const BoundingBox& box) { return box.max.x() - box.min.x(); }
 inline coord_t height(const BoundingBox& box) { return box.max.y() - box.min.y(); }
@@ -1122,8 +1151,6 @@ void arrange(ArrangePolygons &      arrangables,
              const BedT &           bed,
              const ArrangeParams &  params)
 {
-    namespace clppr = Slic3r::ClipperLib;
-
     std::vector<Item> items, fixeditems;
     items.reserve(arrangables.size());
 

src/libslic3r/Arrange.hpp

@@ -2,8 +2,17 @@
 #define ARRANGE_HPP
 
 #include "ExPolygon.hpp"
+#include "Point.hpp"
+#include "Polygon.hpp"
 #include "PrintConfig.hpp"
 #include "Print.hpp"
+#include <cmath>
+#include "libslic3r.h"
+#include <vector>
+#include <string>
+#include <functional>
+#include <iostream>
+#include <ostream>
 
 #define BED_SHRINK_SEQ_PRINT 5
 

src/libslic3r/BoundingBox.cpp

@@ -1,5 +1,8 @@
 #include "BoundingBox.hpp"
+#include "Point.hpp"
 #include "Polygon.hpp"
+#include "libslic3r.h"
+#include <Eigen/Core>
 #include <algorithm>
 #include <assert.h>
 

src/libslic3r/BoundingBox.hpp

@@ -5,7 +5,10 @@
 #include "Exception.hpp"
 #include "Point.hpp"
 #include "Polygon.hpp"
+#include <cassert>
+#include <cstddef>
 #include <ostream>
+#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/BridgeDetector.cpp

@@ -1,7 +1,18 @@
 #include "BridgeDetector.hpp"
+#include "BoundingBox.hpp"
 #include "ClipperUtils.hpp"
+#include "ExPolygon.hpp"
 #include "Geometry.hpp"
+#include "libslic3r.h"
+#include "Polygon.hpp"
+#include "Line.hpp"
+#include "Polyline.hpp"
+#include "Point.hpp"
 #include <algorithm>
+#include <utility>
+#include <vector>
+#include <cstddef>
+#include <cmath>
 
 namespace Slic3r {
 

src/libslic3r/BridgeDetector.hpp

@@ -9,7 +9,14 @@
 #include "PrincipalComponents2D.hpp"
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
+#include <cmath>
+#include <cstdlib>
+#include <limits>
 #include <string>
+#include <vector>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/Brim.cpp

@@ -1,18 +1,37 @@
+#include "BoundingBox.hpp"
+#include "BrimEarsPoint.hpp"
 #include "ClipperUtils.hpp"
 #include "EdgeGrid.hpp"
+#include "ExPolygon.hpp"
+#include "Flow.hpp"
+#include "Geometry.hpp"
+#include "ExtrusionEntity.hpp"
 #include "Layer.hpp"
+#include "Point.hpp"
+#include "ObjectID.hpp"
+#include "Polygon.hpp"
+#include "Line.hpp"
+#include "MultiPoint.hpp"
+#include "Polyline.hpp"
 #include "Print.hpp"
+#include "PrintBase.hpp"
 #include "ShortestPath.hpp"
 #include "libslic3r.h"
 #include "PrintConfig.hpp"
 #include "MaterialType.hpp"
 #include "Model.hpp"
 #include <algorithm>
+#include <cstddef>
+#include <cmath>
 #include <cstdint>
 #include <limits>
+#include <map>
+#include <string>
 #include <tbb/parallel_for.h>
 
 #include <boost/log/trivial.hpp>
+#include <utility>
+#include <vector>
 
 #ifndef NDEBUG
     // #define BRIM_DEBUG_TO_SVG

src/libslic3r/Brim.hpp

@@ -4,8 +4,10 @@
 #include "ExPolygon.hpp"
 #include "ObjectID.hpp"
 #include "Point.hpp"
+#include "Polygon.hpp"
 
 #include<map>
+#include <utility>
 #include<vector>
 
 namespace Slic3r {

src/libslic3r/BrimEarsPoint.hpp

@@ -1,7 +1,10 @@
 #ifndef BRIMEARSPOINT_HPP
 #define BRIMEARSPOINT_HPP
 
+#include <cstdlib>
+#include "libslic3r.h"
 #include <libslic3r/Point.hpp>
+#include <vector>
 
 
 namespace Slic3r {

src/libslic3r/BuildVolume.cpp

@@ -1,11 +1,24 @@
 #include "BuildVolume.hpp"
+#include "BoundingBox.hpp"
 #include "ClipperUtils.hpp"
+#include "Polygon.hpp"
+#include "Geometry/Circle.hpp"
+#include "ExtrusionEntity.hpp"
 #include "TriangleMesh.hpp"
 #include "Geometry/ConvexHull.hpp"
 #include "GCode/GCodeProcessor.hpp"
 #include "Point.hpp"
+#include "libslic3r.h"
 
+#include <algorithm>
 #include <boost/log/trivial.hpp>
+#include <vector>
+#include <cassert>
+#include <cstdlib>
+#include <limits>
+#include <utility>
+#include <cstddef>
+#include <string_view>
 
 namespace Slic3r {
 

src/libslic3r/BuildVolume.hpp

@@ -5,9 +5,13 @@
 #include "Geometry/Circle.hpp"
 #include "Polygon.hpp"
 #include "BoundingBox.hpp"
+#include "libslic3r.h"
 #include <admesh/stl.h>
 
+#include <array>
 #include <string_view>
+#include <vector>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/CadDocument.cpp

@@ -1,8 +1,14 @@
 #include "libslic3r/CAD/CadDocument.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/CAD/SketchEngine.hpp"
+#include "libslic3r/CAD/GeometryEngine.hpp"
 #include "libslic3r/CAD/SketchConstraints.hpp"
 #include "libslic3r/CAD/SketchSolver.hpp"
 #include "libslic3r/CAD/SketchImport.hpp"   // transform_regions for imported art
 
+#include <Standard_Handle.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <Standard_TypeDef.hxx>
 #include <array>
 
 #include <Standard_Failure.hxx>
@@ -26,6 +32,10 @@
 #include <BRepOffsetAPI_DraftAngle.hxx>
 #include <Bnd_Box.hxx>
 #include <BRepBndLib.hxx>
+#include <functional>
+#include <exception>
+#include <cstdint>
+#include <cereal/cereal.hpp>
 #include <gp_Pln.hxx>
 #include <TopTools_ListOfShape.hxx>
 #include <BRepPrimAPI_MakeCylinder.hxx>
@@ -69,12 +79,18 @@
 #include <cmath>
 #include <cctype>
 #include <cstdio>
+#include <math.h>
+#include <map>
+#include <set>
 #include <stdexcept>
 #include <algorithm>
 #include <sstream>
 
 #include <cereal/archives/binary.hpp>
 #include <BRepTools.hxx>
+#include <string>
+#include <vector>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/CadDocument.hpp

@@ -1,16 +1,20 @@
 #ifndef slic3r_CadDocument_hpp_
 #define slic3r_CadDocument_hpp_
 
+#include "libslic3r/Point.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/CAD/SketchEngine.hpp"
 #include "libslic3r/CAD/GeometryEngine.hpp"   // FaceGroup
 #include "libslic3r/Color.hpp"            // ColorRGBA (per-body display colour override)
 
+#include <TopoDS_Face.hxx>
 #include <TopoDS_Shape.hxx>
 #include <TopoDS_Wire.hxx>
 #include <cereal/cereal.hpp>
 #include <cereal/types/vector.hpp>
 #include <cereal/types/string.hpp>
+#include <cstdint>
+#include <cstddef>
 #include <map>
 #include <cereal/types/map.hpp>
 #include <string>

src/libslic3r/CAD/GeometryEngine.cpp

@@ -1,12 +1,25 @@
 #include "libslic3r/CAD/GeometryEngine.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
 #include <BRepMesh_IncrementalMesh.hxx>
 #include <BRep_Tool.hxx>
 #include <BRepAdaptor_Surface.hxx>
 #include <BRepLProp_SLProps.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <cstddef>
+#include <algorithm>
+#include <GeomAbs_SurfaceType.hxx>
+#include <TopAbs_Orientation.hxx>
+#include <Standard_Handle.hxx>
+#include <cstdint>
+#include <Poly_Triangle.hxx>
+#include <GeomAbs_CurveType.hxx>
 #include <gp_Cylinder.hxx>
 #include <BRepFilletAPI_MakeFillet.hxx>
 #include <BRepFilletAPI_MakeChamfer.hxx>
+#include <math.h>
+#include <gp_Mat.hxx>
 #include <stdexcept>
 #include <TopExp_Explorer.hxx>
 #include <TopoDS.hxx>
@@ -43,6 +56,9 @@
 #include <array>
 #include <map>
 #include <cmath>
+#include <vector>
+#include <string>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/GeometryEngine.hpp

@@ -1,6 +1,7 @@
 #ifndef slic3r_GeometryEngine_hpp_
 #define slic3r_GeometryEngine_hpp_
 
+#include "libslic3r/Point.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 
 #include <BRepPrimAPI_MakeBox.hxx>
@@ -8,6 +9,8 @@
 #include <BRepPrimAPI_MakeSphere.hxx>
 #include <BRepPrimAPI_MakeCone.hxx>
 #include <BRepPrimAPI_MakeTorus.hxx>
+#include <TopoDS_Shape.hxx>
+#include <array>
 #include <gp_Ax2.hxx>
 #include <TopoDS_Solid.hxx>
 #include <TopoDS_Face.hxx>

src/libslic3r/CAD/SketchConstraints.cpp

@@ -1,6 +1,11 @@
 #include "libslic3r/CAD/SketchConstraints.hpp"
+#include "libslic3r/Point.hpp"
+#include <Eigen/Core>
 #include <Eigen/Dense>
+#include <algorithm>
 #include <cmath>
+#include <cstddef>
+#include <vector>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchConstraints.hpp

@@ -2,6 +2,7 @@
 #define slic3r_SketchConstraints_hpp_
 
 #include "libslic3r/Point.hpp"
+#include <Eigen/Core>
 #include <vector>
 #include <Eigen/Dense>
 

src/libslic3r/CAD/SketchEngine.cpp

@@ -1,7 +1,18 @@
 #include "libslic3r/CAD/SketchEngine.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 
+#include <Standard_Handle.hxx>
+#include <GeomAbs_SurfaceType.hxx>
+#include <GeomAbs_JoinType.hxx>
+#include <TopAbs_ShapeEnum.hxx>
+#include <Standard_TypeDef.hxx>
+#include <TopAbs_Orientation.hxx>
+#include <Poly_Triangle.hxx>
+#include <TopAbs_State.hxx>
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 #include <limits>
 
 #include <BRepBuilderAPI_MakeWire.hxx>
@@ -47,8 +58,11 @@
 #include <TopoDS_Wire.hxx>
 #include <GeomAPI_IntCS.hxx>
 #include <map>
+#include <math.h>
 #include <tuple>
 #include <stdexcept>
+#include <vector>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchImport.cpp

@@ -1,5 +1,8 @@
 #include "libslic3r/CAD/SketchImport.hpp"
 
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/Point.hpp"
+#include "libslic3r/EmbossShape.hpp"
 #include "libslic3r/Emboss.hpp"
 #include "libslic3r/NSVGUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
@@ -9,6 +12,11 @@
 
 #include <algorithm>
 #include <limits>
+#include <vector>
+#include <string>
+#include <memory>
+#include <utility>
+#include <nanosvg/nanosvg.h>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchInference.cpp

@@ -1,7 +1,13 @@
 #include "libslic3r/CAD/SketchInference.hpp"
+#include "libslic3r/CAD/SketchEngine.hpp"
+#include "libslic3r/Point.hpp"
 
 #include <algorithm>
 #include <cmath>
+#include <vector>
+#include <cstddef>
+#include <optional>
+#include <math.h>
 
 namespace Slic3r {
 

src/libslic3r/CAD/SketchInference.hpp

@@ -1,7 +1,9 @@
 #ifndef slic3r_SketchInference_hpp_
 #define slic3r_SketchInference_hpp_
 
+#include "libslic3r/Point.hpp"
 #include "libslic3r/CAD/SketchEngine.hpp"
+#include <math.h>
 #include <vector>
 #include <optional>
 #include <cmath>

src/libslic3r/CAD/SketchSolver.cpp

@@ -1,5 +1,7 @@
 #include "libslic3r/CAD/SketchSolver.hpp"
+#include "libslic3r/CAD/SketchEngine.hpp"
 
+#include <math.h>
 #include <slvs.h>
 
 #include <cmath>
@@ -7,6 +9,8 @@
 #include <functional>
 #include <map>
 #include <unordered_map>
+#include <vector>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CAD/ThreadStandards.cpp

@@ -1,4 +1,6 @@
 #include "libslic3r/CAD/ThreadStandards.hpp"
+#include <vector>
+#include <string>
 
 namespace Slic3r {
 

src/libslic3r/CMakeLists.txt

@@ -94,12 +94,9 @@ set(lisbslic3r_sources
     calib.hpp
     Circle.cpp
     Circle.hpp
-    clipper.cpp
-    clipper.hpp
     ClipperUtils.cpp
     ClipperUtils.hpp
-    Clipper2Utils.cpp
-    Clipper2Utils.hpp
+    ClipperZUtils.cpp
     ClipperZUtils.hpp
     Color.cpp
     Color.hpp
@@ -716,7 +713,6 @@ target_link_libraries(libslic3r
         ${OCCT_LIBS}
         boost_libs
         cereal::cereal
-        clipper
         Clipper2
         draco::draco
         glu-libtess

src/libslic3r/CSGMesh/CSGMesh.hpp

@@ -2,7 +2,11 @@
 #define CSGMESH_HPP
 
 #include <libslic3r/AnyPtr.hpp>
+#include <libslic3r/Point.hpp>
+#include <libslic3r/TriangleMesh.hpp>
 #include <admesh/stl.h>
+#include <string>
+#include <utility>
 
 namespace Slic3r { namespace csg {
 

src/libslic3r/CSGMesh/CSGMeshCopy.hpp

@@ -1,7 +1,11 @@
 #ifndef CSGMESHCOPY_HPP
 #define CSGMESHCOPY_HPP
 
+#include "libslic3r/AnyPtr.hpp"
 #include "CSGMesh.hpp"
+#include "libslic3r/libslic3r.h"
+#include <utility>
+#include <cstddef>
 
 namespace Slic3r { namespace csg {
 

src/libslic3r/CSGMesh/ModelToCSGMesh.hpp

@@ -3,9 +3,13 @@
 
 #include "CSGMesh.hpp"
 
+#include "libslic3r/Point.hpp"
+#include "libslic3r/TriangleMesh.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/SLA/Hollowing.hpp"
 #include "libslic3r/MeshSplitImpl.hpp"
+#include <utility>
+#include <memory>
 
 namespace Slic3r { namespace csg {
 

src/libslic3r/CSGMesh/PerformCSGMeshBooleans.hpp

@@ -1,11 +1,17 @@
 #ifndef PERFORMCSGMESHBOOLEANS_HPP
 #define PERFORMCSGMESHBOOLEANS_HPP
 
+#include <cstddef>
 #include <stack>
+#include <utility>
+#include <tuple>
 #include <vector>
 
+#include <boost/log/trivial.hpp>
+
 #include "CSGMesh.hpp"
 
+#include "libslic3r/libslic3r.h"
 #include "libslic3r/Execution/ExecutionTBB.hpp"
 //#include "libslic3r/Execution/ExecutionSeq.hpp"
 #include "libslic3r/MeshBoolean.hpp"

src/libslic3r/CSGMesh/SliceCSGMesh.hpp

@@ -3,8 +3,16 @@
 
 #include "CSGMesh.hpp"
 
+#include <cstddef>
+#include <functional>
+#include <cassert>
 #include <stack>
+#include <vector>
+#include <utility>
 
+#include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/libslic3r.h"
+#include "libslic3r/Execution/Execution.hpp"
 #include "libslic3r/TriangleMeshSlicer.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/Execution/ExecutionTBB.hpp"

src/libslic3r/CSGMesh/TriangleMeshAdapter.hpp

@@ -3,6 +3,7 @@
 
 #include "CSGMesh.hpp"
 
+#include "libslic3r/Point.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 
 namespace Slic3r { namespace csg {

src/libslic3r/Channel.hpp

@@ -1,6 +1,9 @@
 #ifndef slic3r_Channel_hpp_
 #define slic3r_Channel_hpp_
 
+#include <boost/optional/optional.hpp>
+#include <boost/none.hpp>
+#include <cstddef>
 #include <memory>
 #include <deque>
 #include <condition_variable>

src/libslic3r/Circle.cpp

@@ -2,8 +2,14 @@
 
 #include <cmath>
 #include <cassert>
+#include <cstddef>
+#include <utility>
+#include <math.h>
 #include "Geometry.hpp"
+#include "Point.hpp"
+#include "Line.hpp"
 #include "Polygon.hpp"
+#include "libslic3r.h"
 
 
 //BBS: Refer to ArcWelderLib for the arc fitting functions

src/libslic3r/Circle.hpp

@@ -3,6 +3,8 @@
 
 #include "Point.hpp"
 #include "Line.hpp"
+#include "libslic3r.h"
+#include <cmath>
 
 namespace Slic3r {
 

src/libslic3r/Clipper2Utils.cpp

@@ -1,228 +0,0 @@
-#include "Clipper2Utils.hpp"
-#include "libslic3r.h"
-#include "clipper2/clipper.h"
-
-namespace Slic3r {
-
-//BBS: FIXME
-Slic3r::Polylines Paths64_to_polylines(const Clipper2Lib::Paths64& in)
-{
-    Slic3r::Polylines out;
-    out.reserve(in.size());
-    for (const Clipper2Lib::Path64& path64 : in) {
-        Slic3r::Points points;
-        points.reserve(path64.size());
-        for (const Clipper2Lib::Point64& point64 : path64)
-            points.emplace_back(Slic3r::Point(point64.x, point64.y));
-        out.emplace_back(Slic3r::Polyline(points));
-    }
-    return out;
-}
-
-//BBS: FIXME
-template <typename Container>
-Clipper2Lib::Paths64 Slic3rPoints_to_Paths64(const Container& in)
-{
-    Clipper2Lib::Paths64 out;
-    out.reserve(in.size());
-    for (const auto& item : in) {
-        Clipper2Lib::Path64 path;
-        path.reserve(item.size());
-        for (const Slic3r::Point& point : item.points)
-            path.emplace_back(Clipper2Lib::Point64(point.x(), point.y()));
-        out.emplace_back(std::move(path));
-    }
-    return out;
-}
-
-Clipper2Lib::Paths64 Slic3rPolylines_to_Paths64(const Polylines& in)
-{
-    return Slic3rPoints_to_Paths64(in);
-}
-
-Points Path64ToPoints(const Clipper2Lib::Path64& path64)
-{
-    Points points;
-    points.reserve(path64.size());
-    for (const Clipper2Lib::Point64 &point64 : path64) points.emplace_back(Slic3r::Point(point64.x, point64.y));
-    return points;
-}
-
-static ExPolygons PolyTreeToExPolygons(Clipper2Lib::PolyTree64 &&polytree)
-{
-    struct Inner
-    {
-        static void PolyTreeToExPolygonsRecursive(Clipper2Lib::PolyTree64 &&polynode, ExPolygons *expolygons)
-        {
-            size_t cnt = expolygons->size();
-            expolygons->resize(cnt + 1);
-            (*expolygons)[cnt].contour.points = Path64ToPoints(polynode.Polygon());
-
-            (*expolygons)[cnt].holes.resize(polynode.Count());
-            for (int i = 0; i < polynode.Count(); ++i) {
-                (*expolygons)[cnt].holes[i].points = Path64ToPoints(polynode[i]->Polygon());
-                // Add outer polygons contained by (nested within) holes.
-                for (int j = 0; j < polynode[i]->Count(); ++j) PolyTreeToExPolygonsRecursive(std::move(*polynode[i]->Child(j)), expolygons);
-            }
-        }
-
-        static size_t PolyTreeCountExPolygons(const Clipper2Lib::PolyPath64& polynode)
-        {
-            size_t cnt = 1;
-            for (size_t i = 0; i < polynode.Count(); ++i) {
-                for (size_t j = 0; j < polynode.Child(i)->Count(); ++j) cnt += PolyTreeCountExPolygons(*polynode.Child(i)->Child(j));
-            }
-            return cnt;
-        }
-    };
-
-    ExPolygons retval;
-    size_t     cnt = 0;
-    for (int i = 0; i < polytree.Count(); ++i) cnt += Inner::PolyTreeCountExPolygons(*polytree[i]);
-    retval.reserve(cnt);
-    for (int i = 0; i < polytree.Count(); ++i) Inner::PolyTreeToExPolygonsRecursive(std::move(*polytree[i]), &retval);
-    return retval;
-}
-
-void SimplifyPolyTree(const Clipper2Lib::PolyPath64 &polytree, double epsilon, Clipper2Lib::PolyPath64 &result)
-{
-    for (const auto &child : polytree) {
-        Clipper2Lib::PolyPath64 *newchild = result.AddChild(Clipper2Lib::SimplifyPath(child->Polygon(), epsilon));
-        SimplifyPolyTree(*child, epsilon, *newchild);
-    }
-}
-
-Clipper2Lib::Paths64 Slic3rPolygons_to_Paths64(const Polygons &in)
-{
-    Clipper2Lib::Paths64 out;
-    out.reserve(in.size());
-    for (const Polygon &poly : in) {
-        Clipper2Lib::Path64 path;
-        path.reserve(poly.points.size());
-        for (const Slic3r::Point &point : poly.points) path.emplace_back(Clipper2Lib::Point64(point.x(), point.y()));
-        out.emplace_back(std::move(path));
-    }
-    return out;
-}
-
-Clipper2Lib::Paths64 Slic3rExPolygons_to_Paths64(const ExPolygons& in)
-{
-    Clipper2Lib::Paths64 out;
-    out.reserve(in.size());
-    for (const ExPolygon& expolygon : in) {
-        for (size_t i = 0; i < expolygon.num_contours(); i++) {
-            const auto         &poly = expolygon.contour_or_hole(i);
-            Clipper2Lib::Path64 path;
-            path.reserve(poly.points.size());
-            for (const Slic3r::Point &point : poly.points) path.emplace_back(Clipper2Lib::Point64(point.x(), point.y()));
-            out.emplace_back(std::move(path));
-        }
-    }
-    return out;
-}
-
-Polylines _clipper2_pl_open(Clipper2Lib::ClipType clipType, const Slic3r::Polylines& subject, const Slic3r::Polygons& clip)
-{
-    Clipper2Lib::Clipper64 c;
-    c.AddOpenSubject(Slic3rPoints_to_Paths64(subject));
-    c.AddClip(Slic3rPoints_to_Paths64(clip));
-
-    Clipper2Lib::ClipType ct = clipType;
-    Clipper2Lib::FillRule fr = Clipper2Lib::FillRule::NonZero;
-    Clipper2Lib::Paths64 solution, solution_open;
-    c.Execute(ct, fr, solution, solution_open);
-
-    Slic3r::Polylines out;
-    out.reserve(solution.size() + solution_open.size());
-    polylines_append(out, Paths64_to_polylines(solution));
-    polylines_append(out, Paths64_to_polylines(solution_open));
-
-    return out;
-}
-
-Slic3r::Polylines intersection_pl_2(const Slic3r::Polylines& subject, const Slic3r::Polygons& clip)
-    { return _clipper2_pl_open(Clipper2Lib::ClipType::Intersection, subject, clip); }
-Slic3r::Polylines  diff_pl_2(const Slic3r::Polylines& subject, const Slic3r::Polygons& clip)
-    { return _clipper2_pl_open(Clipper2Lib::ClipType::Difference, subject, clip); }
-
-ExPolygons union_ex_2(const Polygons& polygons)
-{
-    Clipper2Lib::Clipper64 c;
-    c.AddSubject(Slic3rPolygons_to_Paths64(polygons));
-
-    Clipper2Lib::ClipType ct = Clipper2Lib::ClipType::Union;
-    Clipper2Lib::FillRule fr = Clipper2Lib::FillRule::NonZero;
-    Clipper2Lib::PolyTree64 solution;
-    c.Execute(ct, fr, solution);
-
-    ExPolygons results = PolyTreeToExPolygons(std::move(solution));
-
-    return results;
-}
-
-ExPolygons union_ex_2(const ExPolygons &expolygons)
-{
-    Clipper2Lib::Clipper64 c;
-    c.AddSubject(Slic3rExPolygons_to_Paths64(expolygons));
-
-    Clipper2Lib::ClipType   ct = Clipper2Lib::ClipType::Union;
-    Clipper2Lib::FillRule   fr = Clipper2Lib::FillRule::NonZero;
-    Clipper2Lib::PolyTree64 solution;
-    c.Execute(ct, fr, solution);
-
-    ExPolygons results = PolyTreeToExPolygons(std::move(solution));
-
-    return results;
-}
-
-// 对 ExPolygons 进行偏移
-ExPolygons offset_ex_2(const ExPolygons &expolygons, double delta)
-{
-    Clipper2Lib::Paths64 subject = Slic3rExPolygons_to_Paths64(expolygons);
-    Clipper2Lib::ClipperOffset offsetter;
-    offsetter.AddPaths(subject, Clipper2Lib::JoinType::Round, Clipper2Lib::EndType::Polygon);
-    Clipper2Lib::PolyPath64 polytree;
-    offsetter.Execute(delta, polytree);
-    ExPolygons results = PolyTreeToExPolygons(std::move(polytree));
-
-    return results;
-}
-
-ExPolygons offset_ex_2(const ExPolygons &expolygons, double delta, Clipper2Lib::JoinType joinType)
-{
-    Clipper2Lib::Paths64 subject = Slic3rExPolygons_to_Paths64(expolygons);
-    Clipper2Lib::ClipperOffset offsetter;
-    offsetter.AddPaths(subject, joinType, Clipper2Lib::EndType::Polygon);
-    Clipper2Lib::PolyPath64 polytree;
-    offsetter.Execute(delta, polytree);
-    ExPolygons results = PolyTreeToExPolygons(std::move(polytree));
-
-    return results;
-}
-
-ExPolygons offset2_ex_2(const ExPolygons& expolygons, double delta1, double delta2)
-{
-    // 1st offset
-    Clipper2Lib::Paths64       subject = Slic3rExPolygons_to_Paths64(expolygons);
-    Clipper2Lib::ClipperOffset offsetter;
-    offsetter.AddPaths(subject, Clipper2Lib::JoinType::Round, Clipper2Lib::EndType::Polygon);
-    Clipper2Lib::PolyPath64 polytree;
-    offsetter.Execute(delta1, polytree);
-
-    // simplify the result
-    Clipper2Lib::PolyPath64 polytree2;
-    SimplifyPolyTree(polytree, SCALED_EPSILON, polytree2);
-
-    // 2nd offset
-    offsetter.Clear();
-    offsetter.AddPaths(Clipper2Lib::PolyTreeToPaths64(polytree2), Clipper2Lib::JoinType::Round, Clipper2Lib::EndType::Polygon);
-    polytree.Clear();
-    offsetter.Execute(delta2, polytree);
-
-    // convert back to expolygons
-    ExPolygons results = PolyTreeToExPolygons(std::move(polytree));
-
-    return results;
-}
-
-}

src/libslic3r/Clipper2Utils.hpp

@@ -1,22 +0,0 @@
-#ifndef slic3r_Clipper2Utils_hpp_
-#define slic3r_Clipper2Utils_hpp_
-
-#include "ExPolygon.hpp"
-#include "Polygon.hpp"
-#include "Polyline.hpp"
-#include "clipper2/clipper.h"
-
-namespace Slic3r {
-
-Clipper2Lib::Paths64 Slic3rPolylines_to_Paths64(const Slic3r::Polylines& in);
-Slic3r::Polylines  Paths64_to_polylines(const Clipper2Lib::Paths64& in);
-Slic3r::Polylines  intersection_pl_2(const Slic3r::Polylines& subject, const Slic3r::Polygons& clip);
-Slic3r::Polylines  diff_pl_2(const Slic3r::Polylines& subject, const Slic3r::Polygons& clip);
-ExPolygons         union_ex_2(const Polygons &expolygons);
-ExPolygons         union_ex_2(const ExPolygons &expolygons);
-ExPolygons         offset_ex_2(const ExPolygons &expolygons, double delta);
-ExPolygons         offset_ex_2(const ExPolygons &expolygons, double delta, Clipper2Lib::JoinType joinType);
-ExPolygons         offset2_ex_2(const ExPolygons &expolygons, double delta1, double delta2);
-}
-
-#endif

src/libslic3r/Clipper2ZUtils.hpp

@@ -1,167 +0,0 @@
-#ifndef slic3r_Clipper2ZUtils_hpp_
-#define slic3r_Clipper2ZUtils_hpp_
-#include <numeric>
-#include <vector>
-#include <algorithm>
-
-#include <clipper2/clipper2_z.hpp>
-#include <libslic3r/Point.hpp>
-namespace Slic3r { namespace Clipper2ZUtils {
-
-using ZPoint64  = Clipper2Lib_Z::Point64;
-using ZPoints64 = Clipper2Lib_Z::Path64;
-using ZPath64  = Clipper2Lib_Z::Path64;
-using ZPaths64 = Clipper2Lib_Z::Paths64;
-
-inline bool zpoint64_lower(const ZPoint64 &l, const ZPoint64 &r) {
-    return l.x < r.x || (l.x == r.x && (l.y < r.y || (l.y == r.y && l.z < r.z)));
-}
-
-// Convert a single path to zpath with a given Z coordinate.
-// If Open, then duplicate the first point at the end.
-template<bool Open = false>
-inline ZPath64 to_zpath64(const Points &path, int64_t z)
-{
-    ZPath64 out;
-    if (!path.empty()) {
-        out.reserve(path.size() + (Open ? 1 : 0));
-        for (const Point &p : path) out.emplace_back(p.x(), p.y(), z);
-        if (Open) out.emplace_back(out.front());
-    }
-    return out;
-}
-
-template<bool Open = false>
-inline ZPath64 to_zpath64(const Clipper2Lib_Z::Path64 &path, int64_t z)
-{
-    ZPath64 out;
-    if (!path.empty()) {
-        out.reserve(path.size() + (Open ? 1 : 0));
-        for (const Clipper2Lib_Z::Point64 &p : path) out.emplace_back(p.x, p.y, z);
-        if (Open) out.emplace_back(out.front());
-    }
-    return out;
-}
-
-// Convert multiple paths to zpaths with a given Z coordinate.
-template<bool Open = false>
-inline ZPaths64 to_zpaths64(const VecOfPoints &paths, int64_t z)
-{
-    ZPaths64 out;
-    out.reserve(paths.size());
-    for (const Points &path : paths) out.emplace_back(to_zpath64<Open>(path, z));
-    return out;
-}
-
-template<bool Open = false>
-inline ZPaths64 to_zpaths64(const Clipper2Lib_Z::Paths64 &paths, int64_t z)
-{
-    ZPaths64 out;
-    out.reserve(paths.size());
-    for (const Clipper2Lib_Z::Path64 &path : paths) out.emplace_back(to_zpath64<Open>(path, z));
-    return out;
-}
-
-// Convert multiple expolygons into zpaths with Z specified by index
-// offset by base_idx.
-template<bool Open = false>
-inline ZPaths64 expolygons_to_zpaths64(const ExPolygons &src, int64_t &base_idx)
-{
-    ZPaths64 out;
-    out.reserve(std::accumulate(src.begin(), src.end(), size_t(0),
-        [](const size_t acc, const ExPolygon &expoly) { return acc + expoly.num_contours(); }));
-    for (const ExPolygon &expoly : src) {
-        out.emplace_back(to_zpath64<Open>(expoly.contour.points, base_idx));
-        for (const Polygon &hole : expoly.holes)
-            out.emplace_back(to_zpath64<Open>(hole.points, base_idx));
-        ++base_idx;
-    }
-    return out;
-}
-
-// Convert multiple expolygons into zpaths with the same Z.
-template<bool Open = false>
-inline ZPaths64 expolygons_to_zpaths64_with_same_z(const ExPolygons &src, int64_t z)
-{
-    ZPaths64 out;
-    out.reserve(std::accumulate(src.begin(), src.end(), size_t(0),
-        [](const size_t acc, const ExPolygon &expoly) { return acc + expoly.num_contours(); }));
-    for (const ExPolygon &expoly : src) {
-        out.emplace_back(to_zpath64<Open>(expoly.contour.points, z));
-        for (const Polygon &hole : expoly.holes)
-            out.emplace_back(to_zpath64<Open>(hole.points, z));
-    }
-    return out;
-}
-
-// Convert a zpath back to 2D Points.
-// If Open, then duplicate the first point at the end.
-template<bool Open = false>
-inline Points from_zpath64(const ZPath64 &path)
-{
-    Points out;
-    if (!path.empty()) {
-        out.reserve(path.size() + (Open ? 1 : 0));
-        for (const ZPoint64 &p : path) out.emplace_back(p.x, p.y);
-        if (Open) out.emplace_back(out.front());
-    }
-    return out;
-}
-
-// Convert multiple zpaths back to 2D paths.
-template<bool Open = false>
-inline void from_zpaths64(const ZPaths64 &paths, VecOfPoints &out)
-{
-    out.reserve(out.size() + paths.size());
-    for (const ZPath64 &path : paths) out.emplace_back(from_zpath64<Open>(path));
-}
-template<bool Open = false>
-inline VecOfPoints from_zpaths64(const ZPaths64 &paths)
-{
-    VecOfPoints out;
-    from_zpaths64<Open>(paths, out);
-    return out;
-}
-
-// Intersection visitor for Clipper2 (zCallback_).
-class Clipper2ZIntersectionVisitor
-{
-public:
-    using Intersection  = std::pair<int64_t, int64_t>;
-    using Intersections = std::vector<Intersection>;
-
-    Clipper2ZIntersectionVisitor(Intersections &intersections) : m_intersections(intersections) {}
-
-    void reset() { m_intersections.clear(); }
-
-    void operator()(const ZPoint64 &e1bot, const ZPoint64 &e1top, const ZPoint64 &e2bot, const ZPoint64 &e2top, ZPoint64 &pt)
-    {
-        std::array<int64_t, 4> srcs{e1bot.z, e1top.z, e2bot.z, e2top.z};
-        std::sort(srcs.begin(), srcs.end());
-        auto it = std::unique(srcs.begin(), srcs.end());
-        int new_size = std::distance(srcs.begin(), it);
-        assert(new_size == 1 || new_size == 2);
-        if (new_size == 1) {
-            pt.z = srcs[0];
-        }
-        else if(new_size == 2){
-            m_intersections.emplace_back(srcs[0], srcs[1]);
-            pt.z = -int64_t(m_intersections.size());
-        }
-    }
-
-    auto clipper_callback()
-    {
-        return [this](const ZPoint64 &e1bot, const ZPoint64 &e1top,
-                      const ZPoint64 &e2bot, const ZPoint64 &e2top, ZPoint64 &pt) {
-            return (*this)(e1bot, e1top, e2bot, e2top, pt); };
-    }
-
-    const Intersections &intersections() const { return m_intersections; }
-
-private:
-    Intersections &m_intersections;
-};
-
-}} // namespace Slic3r::Clipper2ZUtils
-#endif // slic3r_Clipper2ZUtils_hpp_

src/libslic3r/ClipperUtils.hpp

@@ -1,24 +1,40 @@
 #ifndef slic3r_ClipperUtils_hpp_
 #define slic3r_ClipperUtils_hpp_
 
+#include "Point.hpp"
+#include "Polyline.hpp"
+#include "Line.hpp"
 #include "libslic3r.h"
-#include "clipper.hpp"
 #include "ExPolygon.hpp"
 #include "Polygon.hpp"
 #include "Surface.hpp"
+#include <cstddef>
+#include <iterator>
+#include <cassert>
+#include <vector>
+
+namespace Slic3r {
+
+// Offset joins and ends, fill rules and boolean operations, named as in Clipper1.
+enum JoinType { jtSquare, jtRound, jtMiter };
+enum EndType { etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound };
+enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
+enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
+
+} // namespace Slic3r
 
 // import these wherever we're included
-using Slic3r::ClipperLib::jtMiter;
-using Slic3r::ClipperLib::jtRound;
-using Slic3r::ClipperLib::jtSquare;
+using Slic3r::jtMiter;
+using Slic3r::jtRound;
+using Slic3r::jtSquare;
 
 namespace Slic3r {
 
 static constexpr const float                        ClipperSafetyOffset     = 10.f;
 
-static constexpr const Slic3r::ClipperLib::JoinType DefaultJoinType         = Slic3r::ClipperLib::jtMiter;
+static constexpr const JoinType                     DefaultJoinType         = jtMiter;
 
-static constexpr const Slic3r::ClipperLib::EndType DefaultEndType           = Slic3r::ClipperLib::etOpenButt;
+static constexpr const EndType                      DefaultEndType          = etOpenButt;
 
 //FIXME evaluate the default miter limit. 3 seems to be extreme, Cura uses 1.2.
 // Mitter Limit 3 is useful for perimeter generator, where sharp corners are extruded without needing a gap fill.
@@ -26,7 +42,7 @@ static constexpr const Slic3r::ClipperLib::EndType DefaultEndType           = Sl
 // is extended excessively.
 static constexpr const double                       DefaultMiterLimit       = 3.;
 
-static constexpr const Slic3r::ClipperLib::JoinType DefaultLineJoinType     = Slic3r::ClipperLib::jtSquare;
+static constexpr const JoinType                     DefaultLineJoinType     = jtSquare;
 // Miter limit is ignored for jtSquare.
 static constexpr const double                       DefaultLineMiterLimit   = 0.;
 
@@ -304,12 +320,12 @@ namespace ClipperUtils {
     };
 
     
-    // For ClipperLib with Z coordinates.
+    // Points with a Z coordinate.
     using ZPoint  = Vec3i32;
     using ZPoints = std::vector<Vec3i32>;
 
     // Clip source polygon to be used as a clipping polygon with a bouding box around the source (to be clipped) polygon.
-    // Useful as an optimization for expensive ClipperLib operations, for example when clipping source polygons one by one
+    // Useful as an optimization for expensive Clipper operations, for example when clipping source polygons one by one
     // with a set of polygons covering the whole layer below.
     void                   clip_clipper_polygon_with_subject_bbox(const Points &src, const BoundingBox &bbox, Points &out, const bool get_entire_polygons = false);
     void                   clip_clipper_polygon_with_subject_bbox(const ZPoints &src, const BoundingBox &bbox, ZPoints &out);
@@ -323,31 +339,28 @@ namespace ClipperUtils {
 
     }
 
-// Perform union of input polygons using the non-zero rule, convert to ExPolygons.
-ExPolygons ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input, bool do_union = false);
-
 // offset Polygons
 // Wherever applicable, please use the expand() / shrink() variants instead, they convey their purpose better.
-Slic3r::Polygons offset(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons offset(const Slic3r::Polygon &polygon, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
 
 // offset Polylines
 // Wherever applicable, please use the expand() / shrink() variants instead, they convey their purpose better.
 // Input polygons for negative offset shall be "normalized": There must be no overlap / intersections between the input polygons.
-Slic3r::Polygons   offset(const Slic3r::Polyline &polyline, const float delta, ClipperLib::JoinType joinType = DefaultLineJoinType, double miterLimit = DefaultLineMiterLimit, ClipperLib::EndType end_type = DefaultEndType);
-Slic3r::Polygons   offset(const Slic3r::Polyline3 &polyline, const float delta, ClipperLib::JoinType joinType = DefaultLineJoinType, double miterLimit = DefaultLineMiterLimit, ClipperLib::EndType end_type = DefaultEndType);
-Slic3r::Polygons   offset(const Slic3r::Polylines &polylines, const float delta, ClipperLib::JoinType joinType = DefaultLineJoinType, double miterLimit = DefaultLineMiterLimit, ClipperLib::EndType end_type = DefaultEndType);
-Slic3r::Polygons   offset(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::Polygons   offset(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::Polygons   offset(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::Polygons   offset(const Slic3r::Surfaces &surfaces, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::Polygons   offset(const Slic3r::SurfacesPtr &surfaces, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::ExPolygons offset_ex(const Slic3r::Surfaces &surfaces, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::ExPolygons offset_ex(const Slic3r::SurfacesPtr &surfaces, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons   offset(const Slic3r::Polyline &polyline, const float delta, JoinType joinType = DefaultLineJoinType, double miterLimit = DefaultLineMiterLimit, EndType end_type = DefaultEndType);
+Slic3r::Polygons   offset(const Slic3r::Polyline3 &polyline, const float delta, JoinType joinType = DefaultLineJoinType, double miterLimit = DefaultLineMiterLimit, EndType end_type = DefaultEndType);
+Slic3r::Polygons   offset(const Slic3r::Polylines &polylines, const float delta, JoinType joinType = DefaultLineJoinType, double miterLimit = DefaultLineMiterLimit, EndType end_type = DefaultEndType);
+Slic3r::Polygons   offset(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons   offset(const Slic3r::ExPolygon &expolygon, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons   offset(const Slic3r::ExPolygons &expolygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons   offset(const Slic3r::Surfaces &surfaces, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons   offset(const Slic3r::SurfacesPtr &surfaces, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygon &expolygon, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygons &expolygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::ExPolygons offset_ex(const Slic3r::Surfaces &surfaces, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::ExPolygons offset_ex(const Slic3r::SurfacesPtr &surfaces, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
 // BBS
-inline Slic3r::ExPolygons offset_ex(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit)
+inline Slic3r::ExPolygons offset_ex(const Slic3r::Polygon &polygon, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit)
 {
     Slic3r::Polygons temp;
     temp.push_back(polygon);
@@ -356,8 +369,8 @@ inline Slic3r::ExPolygons offset_ex(const Slic3r::Polygon &polygon, const float
 }
 
 // convert stroke to path by offsetting of contour
-Polygons contour_to_polygons(const Polygon &polygon, const float line_width, ClipperLib::JoinType join_type = DefaultJoinType, double miter_limit = DefaultMiterLimit);
-Polygons contour_to_polygons(const Polygons &polygon, const float line_width, ClipperLib::JoinType join_type = DefaultJoinType, double miter_limit = DefaultMiterLimit);
+Polygons contour_to_polygons(const Polygon &polygon, const float line_width, JoinType join_type = DefaultJoinType, double miter_limit = DefaultMiterLimit);
+Polygons contour_to_polygons(const Polygons &polygon, const float line_width, JoinType join_type = DefaultJoinType, double miter_limit = DefaultMiterLimit);
 
 inline Slic3r::Polygons   union_safety_offset   (const Slic3r::Polygons   &polygons)   { return offset   (polygons,   ClipperSafetyOffset); }
 inline Slic3r::Polygons   union_safety_offset   (const Slic3r::ExPolygons &expolygons) { return offset   (expolygons, ClipperSafetyOffset); }
@@ -370,62 +383,62 @@ Slic3r::ExPolygons union_safety_offset_ex(const Slic3r::Polygons &polygons);
 Slic3r::ExPolygons union_safety_offset_ex(const Slic3r::ExPolygons &expolygons);
 
 // Aliases for the various offset(...) functions, conveying the purpose of the offset.
-inline Slic3r::Polygons   expand(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::Polygons   expand(const Slic3r::Polygon &polygon, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset(polygon, delta, joinType, miterLimit); }
-inline Slic3r::Polygons   expand(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::Polygons   expand(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset(polygons, delta, joinType, miterLimit); }
-inline Slic3r::Polygons   expand(const Slic3r::ExPolygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::Polygons   expand(const Slic3r::ExPolygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset(polygons, delta, joinType, miterLimit); }
-inline Slic3r::ExPolygons expand_ex(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::ExPolygons expand_ex(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset_ex(polygons, delta, joinType, miterLimit); }
 // Input polygons for shrinking shall be "normalized": There must be no overlap / intersections between the input polygons.
-inline Slic3r::Polygons   shrink(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::Polygons   shrink(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset(polygons, -delta, joinType, miterLimit); }
-inline Slic3r::ExPolygons shrink_ex(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::ExPolygons shrink_ex(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset_ex(polygons, -delta, joinType, miterLimit); }
-inline Slic3r::ExPolygons shrink_ex(const Slic3r::ExPolygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::ExPolygons shrink_ex(const Slic3r::ExPolygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset_ex(polygons, -delta, joinType, miterLimit); }
 
 // Wherever applicable, please use the opening() / closing() variants instead, they convey their purpose better.
 // Input polygons for negative offset shall be "normalized": There must be no overlap / intersections between the input polygons.
-Slic3r::Polygons   offset2(const Slic3r::ExPolygons &expolygons, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::ExPolygons offset2_ex(const Slic3r::ExPolygons &expolygons, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::ExPolygons offset2_ex(const Slic3r::Surfaces &surfaces, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons   offset2(const Slic3r::ExPolygons &expolygons, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::ExPolygons offset2_ex(const Slic3r::ExPolygons &expolygons, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::ExPolygons offset2_ex(const Slic3r::Surfaces &surfaces, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
 
 // BBS
-Slic3r::ExPolygons _clipper_ex(ClipperLib::ClipType clipType,
+Slic3r::ExPolygons _clipper_ex(ClipType clipType,
     const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
 
 
 // Offset outside, then inside produces morphological closing. All deltas should be positive.
-Slic3r::Polygons          closing(const Slic3r::Polygons &polygons, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-inline Slic3r::Polygons   closing(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+Slic3r::Polygons          closing(const Slic3r::Polygons &polygons, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+inline Slic3r::Polygons   closing(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { return closing(polygons, delta, delta, joinType, miterLimit); }
-Slic3r::ExPolygons        closing_ex(const Slic3r::Polygons &polygons, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-inline Slic3r::ExPolygons closing_ex(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+Slic3r::ExPolygons        closing_ex(const Slic3r::Polygons &polygons, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+inline Slic3r::ExPolygons closing_ex(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { return closing_ex(polygons, delta, delta, joinType, miterLimit); }
-inline Slic3r::ExPolygons closing_ex(const Slic3r::ExPolygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::ExPolygons closing_ex(const Slic3r::ExPolygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset2_ex(polygons, delta, - delta, joinType, miterLimit); }
-inline Slic3r::ExPolygons closing_ex(const Slic3r::Surfaces &surfaces, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::ExPolygons closing_ex(const Slic3r::Surfaces &surfaces, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset2_ex(surfaces, delta, - delta, joinType, miterLimit); }
 
 // Offset inside, then outside produces morphological opening. All deltas should be positive.
 // Input polygons for opening shall be "normalized": There must be no overlap / intersections between the input polygons.
-Slic3r::Polygons          opening(const Slic3r::Polygons &polygons, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::Polygons          opening(const Slic3r::ExPolygons &expolygons, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-Slic3r::Polygons          opening(const Slic3r::Surfaces &surfaces, const float delta1, const float delta2, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
-inline Slic3r::Polygons   opening(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+Slic3r::Polygons          opening(const Slic3r::Polygons &polygons, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons          opening(const Slic3r::ExPolygons &expolygons, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+Slic3r::Polygons          opening(const Slic3r::Surfaces &surfaces, const float delta1, const float delta2, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit);
+inline Slic3r::Polygons   opening(const Slic3r::Polygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { return opening(polygons, delta, delta, joinType, miterLimit); }
-inline Slic3r::Polygons   opening(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::Polygons   opening(const Slic3r::ExPolygons &expolygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { return opening(expolygons, delta, delta, joinType, miterLimit); }
-inline Slic3r::Polygons   opening(const Slic3r::Surfaces &surfaces, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::Polygons   opening(const Slic3r::Surfaces &surfaces, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { return opening(surfaces, delta, delta, joinType, miterLimit); }
-inline Slic3r::ExPolygons opening_ex(const Slic3r::ExPolygons &polygons, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::ExPolygons opening_ex(const Slic3r::ExPolygons &polygons, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset2_ex(polygons, - delta, delta, joinType, miterLimit); }
-inline Slic3r::ExPolygons opening_ex(const Slic3r::Surfaces &surfaces, const float delta, ClipperLib::JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
+inline Slic3r::ExPolygons opening_ex(const Slic3r::Surfaces &surfaces, const float delta, JoinType joinType = DefaultJoinType, double miterLimit = DefaultMiterLimit) 
     { assert(delta > 0); return offset2_ex(surfaces, - delta, delta, joinType, miterLimit); }
 
-Slic3r::Lines _clipper_ln(ClipperLib::ClipType clipType, const Slic3r::Lines &subject, const Slic3r::Polygons &clip);
+Slic3r::Lines _clipper_ln(ClipType clipType, const Slic3r::Lines &subject, const Slic3r::Polygons &clip);
 
 // Safety offset is applied to the clipping polygons only.
 Slic3r::Polygons   diff(const Slic3r::Polygon &subject, const Slic3r::Polygon &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
@@ -489,13 +502,14 @@ inline Slic3r::ExPolygons diff_ex(const Slic3r::ExPolygons& subject, const Slic3
 
 inline Slic3r::Lines diff_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip)
 {
-    return _clipper_ln(ClipperLib::ctDifference, subject, clip);
+    return _clipper_ln(ctDifference, subject, clip);
 }
 
 // Safety offset is applied to the clipping polygons only.
 Slic3r::Polygons   intersection(const Slic3r::Polygon &subject, const Slic3r::Polygon &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 Slic3r::Polygons   intersection(const Slic3r::Polygons &subject, const Slic3r::ExPolygon &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 Slic3r::Polygons   intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
+Slic3r::Polygons   intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, PolyFillType fill_type);
 Slic3r::Polygons   intersection(const Slic3r::ExPolygon &subject, const Slic3r::ExPolygon &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 // Optimized version clipping the "clipping" polygon using clip_clipper_polygon_with_subject_bbox().
 // To be used with complex clipping polygons, where majority of the clipping polygons are outside of the source polygon.
@@ -534,135 +548,42 @@ void restore_source_path_order(const Slic3r::Polyline &source, Slic3r::Polylines
 
 inline Slic3r::Lines intersection_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip)
 {
-    return _clipper_ln(ClipperLib::ctIntersection, subject, clip);
+    return _clipper_ln(ctIntersection, subject, clip);
 }
 
 inline Slic3r::Lines intersection_ln(const Slic3r::Line &subject, const Slic3r::Polygons &clip)
 {
     Slic3r::Lines lines;
     lines.emplace_back(subject);
-    return _clipper_ln(ClipperLib::ctIntersection, lines, clip);
+    return _clipper_ln(ctIntersection, lines, clip);
 }
 
 Slic3r::Polygons union_(const Slic3r::Polygons &subject);
 Slic3r::Polygons union_(const Slic3r::ExPolygons &subject);
-Slic3r::Polygons union_(const Slic3r::Polygons &subject, const ClipperLib::PolyFillType fillType);
+Slic3r::Polygons union_(const Slic3r::Polygons &subject, const PolyFillType fillType);
 Slic3r::Polygons union_(const Slic3r::Polygons &subject, const Slic3r::Polygons &subject2);
 // May be used to "heal" unusual models (3DLabPrints etc.) by providing fill_type (pftEvenOdd, pftNonZero, pftPositive, pftNegative).
-Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, ClipperLib::PolyFillType fill_type = ClipperLib::pftNonZero);
+Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, PolyFillType fill_type = pftNonZero);
 Slic3r::ExPolygons union_ex(const Slic3r::ExPolygons &subject);
 Slic3r::ExPolygons union_ex(const Slic3r::ExPolygons &subject, const Slic3r::Polygons &subject2);
 Slic3r::ExPolygons union_ex(const Slic3r::Surfaces &subject);
 
 Slic3r::ExPolygons union_ex(const Slic3r::ExPolygons& poly1, const Slic3r::ExPolygons& poly2, bool safety_offset_ = false);
 
-// Convert polygons / expolygons into ClipperLib::PolyTree using ClipperLib::pftEvenOdd, thus union will NOT be performed.
-// If the contours are not intersecting, their orientation shall not be modified by union_pt().
-ClipperLib::PolyTree union_pt(const Slic3r::Polygons &subject);
-ClipperLib::PolyTree union_pt(const Slic3r::ExPolygons &subject);
-
 Slic3r::ExPolygons xor_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygon &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 Slic3r::ExPolygons xor_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 
 Slic3r::Polygons union_pt_chained_outside_in(const Slic3r::Polygons &subject);
 
-ClipperLib::PolyNodes order_nodes(const ClipperLib::PolyNodes &nodes);
-
-// Implementing generalized loop (foreach) over a list of nodes which can be
-// ordered or unordered (performance gain) based on template parameter
-enum class e_ordering {
-    ON,
-    OFF
-};
-
-// Create a template struct, template functions can not be partially specialized
-template<e_ordering o, class Fn> struct _foreach_node {
-    void operator()(const ClipperLib::PolyNodes &nodes, Fn &&fn);
-};
-
-// Specialization with NO ordering
-template<class Fn> struct _foreach_node<e_ordering::OFF, Fn> {
-    void operator()(const ClipperLib::PolyNodes &nodes, Fn &&fn)
-    {
-        for (auto &n : nodes) fn(n);    
-    }
-};
-
-// Specialization with ordering
-template<class Fn> struct _foreach_node<e_ordering::ON, Fn> {
-    void operator()(const ClipperLib::PolyNodes &nodes, Fn &&fn)
-    {
-        auto ordered_nodes = order_nodes(nodes);
-        for (auto &n : nodes) fn(n);    
-    }
-};
-
-// Wrapper function for the foreach_node which can deduce arguments automatically
-template<e_ordering o, class Fn>
-void foreach_node(const ClipperLib::PolyNodes &nodes, Fn &&fn)
-{
-    _foreach_node<o, Fn>()(nodes, std::forward<Fn>(fn));
-}
-
-// Collecting polygons of the tree into a list of Polygons, holes have clockwise
-// orientation.
-template<e_ordering ordering = e_ordering::OFF>
-void traverse_pt(const ClipperLib::PolyNode *tree, Polygons *out)
-{
-    if (!tree) return; // terminates recursion
-    
-    // Push the contour of the current level
-    out->emplace_back(tree->Contour);
-    
-    // Do the recursion for all the children.
-    traverse_pt<ordering>(tree->Childs, out);
-}
-
-// Collecting polygons of the tree into a list of ExPolygons.
-template<e_ordering ordering = e_ordering::OFF>
-void traverse_pt(const ClipperLib::PolyNode *tree, ExPolygons *out)
-{
-    if (!tree) return;
-    else if(tree->IsHole()) {
-        // Levels of holes are skipped and handled together with the
-        // contour levels.
-        traverse_pt<ordering>(tree->Childs, out);
-        return;
-    }
-    
-    ExPolygon level;
-    level.contour.points = tree->Contour;
-    
-    foreach_node<ordering>(tree->Childs, 
-                           [out, &level] (const ClipperLib::PolyNode *node) {
-        
-        // Holes are collected here. 
-        level.holes.emplace_back(node->Contour);
-        
-        // By doing a recursion, a new level expoly is created with the contour
-        // and holes of the lower level. Doing this for all the childs.
-        traverse_pt<ordering>(node->Childs, out);
-    }); 
-    
-    out->emplace_back(level);
-}
-
-template<e_ordering o = e_ordering::OFF, class ExOrJustPolygons>
-void traverse_pt(const ClipperLib::PolyNodes &nodes, ExOrJustPolygons *retval)
-{
-    foreach_node<o>(nodes, [&retval](const ClipperLib::PolyNode *node) {
-        traverse_pt<o>(node, retval);
-    });
-}
-
-
 /* OTHER */
 Slic3r::Polygons simplify_polygons(const Slic3r::Polygons &subject);
 Slic3r::ExPolygons simplify_polygons_ex(const Slic3r::Polygons &subject);
 
 Polygons top_level_islands(const Slic3r::Polygons &polygons);
+// Top level expolygons of the even-odd union, the ones nested in their holes go to `nested`.
+ExPolygons top_level_expolygons(const ExPolygons &expolygons, ExPolygons *nested = nullptr);
 
-ClipperLib::Path mittered_offset_path_scaled(const Points &contour, const std::vector<float> &deltas, double miter_limit);
+Points mittered_offset_path_scaled(const Points &contour, const std::vector<float> &deltas, double miter_limit);
 Polygons  variable_offset_inner(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit = 2.);
 Polygons  variable_offset_outer(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit = 2.);
 ExPolygons variable_offset_outer_ex(const ExPolygon &expoly, const std::vector<std::vector<float>> &deltas, double miter_limit = 2.);

src/libslic3r/ClipperZUtils.cpp

@@ -0,0 +1,79 @@
+#include "ClipperZUtils.hpp"
+#include "ClipperUtils.hpp"
+
+#include <clipper2/clipper2_z.hpp>
+#include <cstddef>
+
+namespace Slic3r {
+namespace ClipperZUtils {
+
+namespace C2 = Clipper2Lib_Z;
+
+static C2::Paths64 to_paths64(const ZPaths &paths)
+{
+    C2::Paths64 out;
+    out.reserve(paths.size());
+    for (const ZPath &path : paths) {
+        C2::Path64 &dst = out.emplace_back();
+        dst.reserve(path.size());
+        for (const ZPoint &pt : path)
+            dst.emplace_back(pt.x(), pt.y(), pt.z());
+    }
+    return out;
+}
+
+static void append_zpaths(const C2::Paths64 &paths, ZPaths &out)
+{
+    out.reserve(out.size() + paths.size());
+    for (const C2::Path64 &path : paths) {
+        ZPath &dst = out.emplace_back();
+        dst.reserve(path.size());
+        for (const C2::Point64 &pt : path)
+            dst.emplace_back(pt.x, pt.y, pt.z);
+    }
+}
+
+double area(const ZPath &path)
+{
+    const size_t size = path.size();
+    if (size < 3)
+        return 0.;
+    double a = 0.;
+    for (size_t i = 0, j = size - 1; i < size; j = i ++)
+        a += (double(path[j].x()) + path[i].x()) * (double(path[j].y()) - path[i].y());
+    return -a * 0.5;
+}
+
+ZPaths clip_zpaths(ClipType clip_type, const ZPaths &subject, bool subject_open, const ZPaths &clip, const ZFillCallback &zfill, bool preserve_collinear)
+{
+    C2::Clipper64 clipper;
+    clipper.PreserveCollinear(preserve_collinear);
+    if (zfill)
+        clipper.SetZCallback([&zfill](const C2::Point64 &e1bot, const C2::Point64 &e1top, const C2::Point64 &e2bot, const C2::Point64 &e2top, C2::Point64 &pt) {
+            // Clipper2 already copied Z from a coincident input vertex.
+            auto coincident = [&pt](const C2::Point64 &p) { return p.x == pt.x && p.y == pt.y; };
+            if (coincident(e1bot) || coincident(e1top) || coincident(e2bot) || coincident(e2top))
+                return;
+            ZPoint zpt(pt.x, pt.y, pt.z);
+            zfill(ZPoint(e1bot.x, e1bot.y, e1bot.z), ZPoint(e1top.x, e1top.y, e1top.z),
+                  ZPoint(e2bot.x, e2bot.y, e2bot.z), ZPoint(e2top.x, e2top.y, e2top.z), zpt);
+            pt.z = zpt.z();
+        });
+    if (subject_open)
+        clipper.AddOpenSubject(to_paths64(subject));
+    else
+        clipper.AddSubject(to_paths64(subject));
+    clipper.AddClip(to_paths64(clip));
+    const C2::ClipType type = clip_type == ctIntersection ? C2::ClipType::Intersection :
+                              clip_type == ctUnion        ? C2::ClipType::Union :
+                              clip_type == ctDifference   ? C2::ClipType::Difference : C2::ClipType::Xor;
+    C2::Paths64 closed, open;
+    clipper.Execute(type, C2::FillRule::NonZero, closed, open);
+    ZPaths out;
+    append_zpaths(closed, out);
+    append_zpaths(open, out);
+    return out;
+}
+
+} // namespace ClipperZUtils
+} // namespace Slic3r

src/libslic3r/ClipperZUtils.hpp

@@ -1,10 +1,16 @@
 #ifndef slic3r_ClipperZUtils_hpp_
 #define slic3r_ClipperZUtils_hpp_
 
+#include "libslic3r.h"
+#include <cstddef>
+#include <algorithm>
+#include <cassert>
+#include <functional>
 #include <numeric>
+#include <utility>
 #include <vector>
 
-#include <clipper/clipper_z.hpp>
+#include <libslic3r/ClipperUtils.hpp>
 #include <libslic3r/Point.hpp>
 #include <libslic3r/ExPolygon.hpp>
 
@@ -12,10 +18,13 @@ namespace Slic3r {
 
 namespace ClipperZUtils {
 
-using ZPoint  = ClipperLib_Z::IntPoint;
-using ZPoints = ClipperLib_Z::Path;
-using ZPath   = ClipperLib_Z::Path;
-using ZPaths  = ClipperLib_Z::Paths;
+using ZPoint  = Vec3crd;
+using ZPoints = std::vector<ZPoint, PointsAllocator<ZPoint>>;
+using ZPath   = ZPoints;
+using ZPaths  = std::vector<ZPath, PointsAllocator<ZPath>>;
+
+// Sets Z of an intersection point from the edges crossing there.
+using ZFillCallback = std::function<void(const ZPoint &e1bot, const ZPoint &e1top, const ZPoint &e2bot, const ZPoint &e2top, ZPoint &pt)>;
 
 inline bool zpoint_lower(const ZPoint &l, const ZPoint &r)
 {
@@ -101,6 +110,12 @@ inline VecOfPoints from_zpaths(const ZPaths &paths)
     return out;
 }
 
+// Signed area, positive for a CCW path.
+double area(const ZPath &path);
+
+// Non-zero rule boolean, the subject may be open. zfill only sees intersections off the input vertices.
+ZPaths clip_zpaths(ClipType clip_type, const ZPaths &subject, bool subject_open, const ZPaths &clip, const ZFillCallback &zfill, bool preserve_collinear = false);
+
 class ClipperZIntersectionVisitor {
 public:
     using Intersection  = std::pair<coord_t, coord_t>;
@@ -126,8 +141,8 @@ public:
             }
         }
     }
-    ClipperLib_Z::ZFillCallback clipper_callback() {
-        return [this](const ZPoint &e1bot, const ZPoint &e1top, 
+    ZFillCallback clipper_callback() {
+        return [this](const ZPoint &e1bot, const ZPoint &e1top,
                  const ZPoint &e2bot, const ZPoint &e2top, ZPoint &pt)
         { return (*this)(e1bot, e1top, e2bot, e2top, pt); };
     }

src/libslic3r/Color.cpp

@@ -1,7 +1,15 @@
 #include "libslic3r.h"
 #include "Color.hpp"
 
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
 #include <random>
+#include <string>
+#include <vector>
 
 static const float INV_255 = 1.0f / 255.0f;
 

src/libslic3r/ColorDecomposeRecipe.cpp

@@ -9,7 +9,9 @@
 #include <cstdio>
 #include <fstream>
 #include <limits>
+#include <string>
 #include <utility>
+#include <vector>
 
 namespace Slic3r {
 namespace {

src/libslic3r/Config.cpp

@@ -1,4 +1,6 @@
 #include "Config.hpp"
+#include "Exception.hpp"
+#include "Point.hpp"
 #include "format.hpp"
 #include "Utils.hpp"
 #include "LocalesUtils.hpp"
@@ -6,7 +8,20 @@
 
 #include <algorithm>
 #include <assert.h>
+#include <cmath>
+#include <boost/algorithm/string/join.hpp>
+#include <cstdlib>
+#include <exception>
+#include <cctype>
+#include <boost/algorithm/string/trim.hpp>
 #include <fstream>
+#include <functional>
+#include <set>
+#include <initializer_list>
+#include <map>
+#include <list>
+#include <optional>
+#include <memory>
 #include <sstream>
 #include <iostream>
 #include <iomanip>
@@ -26,8 +41,15 @@
 #include <boost/nowide/fstream.hpp>
 #include <boost/property_tree/ini_parser.hpp>
 #include <boost/format.hpp>
+#include <stdexcept>
 #include <string.h>
+#include <string>
+#include <vector>
+#include <utility>
+#include <system_error>
 //BBS: add json support
+#include "libslic3r.h"
+#include "libslic3r_version.h"
 #include "nlohmann/json.hpp"
 
 using namespace nlohmann;

src/libslic3r/Config.hpp

@@ -3,6 +3,11 @@
 
 #include <assert.h>
 #include <algorithm>
+#include <boost/container_hash/hash.hpp>
+#include <cctype>
+#include <initializer_list>
+#include <limits>
+#include <cmath>
 #include <map>
 #include <climits>
 #include <cfloat>
@@ -10,10 +15,15 @@
 #include <cstdlib>
 #include <functional>
 #include <iostream>
+#include <memory>
 #include <optional>
+#include <sstream>
+#include <set>
 #include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
+#include "LocalesUtils.hpp"
 #include "libslic3r.h"
 #include "clonable_ptr.hpp"
 #include "Exception.hpp"

src/libslic3r/ContourZ.cpp

@@ -2,14 +2,18 @@
 #include "ExtrusionEntity.hpp"
 #include "ExtrusionEntityCollection.hpp"
 #include "Layer.hpp"
+#include "Line.hpp"
 #include "Point.hpp"
 #include "Print.hpp"
 #include "SLA/IndexedMesh.hpp"
 #include "libslic3r.h"
+#include <Eigen/Core>
 #include <cfloat>
 #include <cmath>
 #include <initializer_list>
+#include <math.h>
 #include <string>
+#include <utility>
 
 namespace Slic3r {
 

src/libslic3r/CustomGCode.cpp

@@ -2,6 +2,10 @@
 #include "Config.hpp"
 #include "GCode.hpp"
 #include "GCodeWriter.hpp"
+#include <vector>
+#include <utility>
+#include <cstddef>
+#include <cassert>
 
 namespace Slic3r {
 

src/libslic3r/CustomGCode.hpp

@@ -1,7 +1,10 @@
 #ifndef slic3r_CustomGCode_hpp_
 #define slic3r_CustomGCode_hpp_
 
+#include <map>
+#include <cstddef>
 #include <string>
+#include <utility>
 #include <vector>
 #include <nlohmann/json.hpp>
 

src/libslic3r/CutSurface.cpp

@@ -1,4 +1,38 @@
 #include "CutSurface.hpp"
+#include "libslic3r/Emboss.hpp"
+#include <vector>
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Surface_mesh/Surface_mesh.h>
+#include "libslic3r/Point.hpp"
+#include "libslic3r/ExPolygon.hpp"
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <utility>
+#include "libslic3r/BoundingBox.hpp"
+#include <cstddef>
+#include "libslic3r/Polygon.hpp"
+#include <cassert>
+#include <array>
+#include <cmath>
+#include <math.h>
+#include <algorithm>
+#include <queue>
+#include <CGAL/enum.h>
+#include <CGAL/Kernel/global_functions_3.h>
+#include <CGAL/Named_function_parameters.h>
+#include "libslic3r/AABBTreeIndirect.hpp"
+#include <cstdlib>
+#include "libslic3r/libslic3r.h"
+#include <boost/property_map/property_map.hpp>
+#include <CGAL/Polygon_mesh_processing/self_intersections.h>
+#include <CGAL/AABB_face_graph_triangle_primitive.h>
+#include <CGAL/AABB_traits.h>
+#include <CGAL/AABB_tree.h>
+#include <CGAL/boost/graph/graph_traits_Surface_mesh.h>
+#include <iterator>
+#include <optional>
+#include <CGAL/Surface_mesh/IO/OFF.h>
 
 /// models_input.obj - Check transormation of model to each others
 /// projection_center.obj - circle representing center of projection with correct distance
@@ -3519,7 +3553,7 @@ ExPolygon priv::to_expoly(const SurfacePatch &patch, const Project &projection,
 {
     Polygons polys = unproject_loops(patch, projection, depth_range);
     // should not be used when no opposit triangle are counted so should not create overlaps
-    ClipperLib::PolyFillType fill_type = ClipperLib::PolyFillType::pftEvenOdd;
+    PolyFillType fill_type = pftEvenOdd;
     ExPolygons expolys = Slic3r::union_ex(polys, fill_type);
     if (expolys.size() == 1)
         return expolys.front();

src/libslic3r/CutSurface.hpp

@@ -1,6 +1,8 @@
 #ifndef slic3r_CutSurface_hpp_
 #define slic3r_CutSurface_hpp_
 
+#include "libslic3r/BoundingBox.hpp"
+#include <string>
 #include <vector>
 #include <admesh/stl.h> // indexed_triangle_set
 #include "ExPolygon.hpp"

src/libslic3r/CutUtils.cpp

@@ -1,13 +1,24 @@
 
 #include "CutUtils.hpp"
 #include "Geometry.hpp"
+#include "Point.hpp"
+#include "TriangleMesh.hpp"
 #include "libslic3r.h"
 #include "Model.hpp"
 #include "TriangleMeshSlicer.hpp"
 #include "TriangleSelector.hpp"
 #include "ObjectID.hpp"
 
+#include <algorithm>
 #include <boost/log/trivial.hpp>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <utility>
+#include <cstddef>
+#include <optional>
+#include <math.h>
+#include <cmath>
 
 namespace Slic3r {
 

src/libslic3r/CutUtils.hpp

@@ -5,6 +5,7 @@
 #include "Point.hpp"
 #include "Model.hpp"
 
+#include <optional>
 #include <vector>
 
 namespace Slic3r {

src/libslic3r/EdgeGrid.cpp

@@ -1,10 +1,21 @@
 #include <algorithm>
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <utility>
+#include <cmath>
+#include <set>
 #include <vector>
 #include <float.h>
 #include <unordered_map>
 
 #include <png.h>
 
+#include "Polygon.hpp"
+#include "Point.hpp"
+#include "Polyline.hpp"
+#include "ExPolygon.hpp"
+#include "Line.hpp"
 #include "libslic3r.h"
 #include "ClipperUtils.hpp"
 #include "EdgeGrid.hpp"

src/libslic3r/EdgeGrid.hpp

@@ -1,12 +1,24 @@
 #ifndef slic3r_EdgeGrid_hpp_
 #define slic3r_EdgeGrid_hpp_
 
+#include <cstddef>
+#include <cassert>
+#include <limits>
+#include <cstdlib>
+#include <algorithm>
 #include <stdint.h>
 #include <math.h>
+#include <vector>
+#include <utility>
+#include <string>
 
+#include "Line.hpp"
 #include "Point.hpp"
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
+#include "libslic3r.h"
+#include "Polygon.hpp"
+#include "Polyline.hpp"
 
 namespace Slic3r {
 namespace EdgeGrid {

src/libslic3r/ElephantFootCompensation.cpp

@@ -1,5 +1,6 @@
-#include "clipper/clipper_z.hpp"
-
+#include "Point.hpp"
+#include "BoundingBox.hpp"
+#include "Polygon.hpp"
 #include "libslic3r.h"
 #include "ClipperUtils.hpp"
 #include "EdgeGrid.hpp"
@@ -10,8 +11,14 @@
 #include "SVG.hpp"
 #include "Utils.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <cassert>
+#include <cstddef>
+#include <vector>
+#include <utility>
+#include <math.h>
+#include <limits>
 
 // #define CONTOUR_DISTANCE_DEBUG_SVG
 

src/libslic3r/Emboss.cpp

@@ -1,12 +1,35 @@
+#include <cmath>
+#include <cassert>
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <cstdint>
+#include <memory>
+#include <cstdio>
+#include <cctype>
+#include <limits>
+#include <math.h>
+#include <Eigen/Geometry>
+#include <Eigen/Core>
 #include <numeric>
 #include "Emboss.hpp"
+#include <optional>
 #include <stdio.h>
 #include <numeric>
 #include <cstdlib>
 #include <boost/nowide/convert.hpp>
 #include <boost/log/trivial.hpp>
 #include <ClipperUtils.hpp> // union_ex + for boldness(polygon extend(offset))
+#include "ExPolygon.hpp"
+#include <vector>
+#include "AABBTreeIndirect.hpp"
+#include <utility>
+#include "EmbossShape.hpp"
+#include <string>
 #include "IntersectionPoints.hpp"
+#include "Polygon.hpp"
+#include "TextConfiguration.hpp"
+#include "Point.hpp"
 
 #define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation
 #include "imgui/imstb_truetype.h" // stbtt_fontinfo
@@ -404,18 +427,89 @@ bool Emboss::divide_segments_for_close_point(ExPolygons &expolygons, double dist
     return true;
 }
 
+// Clipper1's CleanPolygon(): removes vertices closer than `distance` to a neighbour or to the line through their neighbours.
+static void clean_polygon(Points &points, double distance)
+{
+    auto points_are_close = [](const Point &a, const Point &b, double dist2) {
+        const double dx = double(a.x() - b.x()), dy = double(a.y() - b.y());
+        return dx * dx + dy * dy <= dist2;
+    };
+    auto distance_from_line2 = [](const Point &pt, const Point &ln1, const Point &ln2) {
+        const double A = double(ln1.y() - ln2.y());
+        const double B = double(ln2.x() - ln1.x());
+        const double C = A * pt.x() + B * pt.y() - (A * ln1.x() + B * ln1.y());
+        return (C * C) / (A * A + B * B);
+    };
+    auto slopes_near_collinear = [&distance_from_line2](const Point &pt1, const Point &pt2, const Point &pt3, double dist2) {
+        if (std::abs(pt1.x() - pt2.x()) > std::abs(pt1.y() - pt2.y())) {
+            if ((pt1.x() > pt2.x()) == (pt1.x() < pt3.x()))
+                return distance_from_line2(pt1, pt2, pt3) < dist2;
+            if ((pt2.x() > pt1.x()) == (pt2.x() < pt3.x()))
+                return distance_from_line2(pt2, pt1, pt3) < dist2;
+            return distance_from_line2(pt3, pt1, pt2) < dist2;
+        }
+        if ((pt1.y() > pt2.y()) == (pt1.y() < pt3.y()))
+            return distance_from_line2(pt1, pt2, pt3) < dist2;
+        if ((pt2.y() > pt1.y()) == (pt2.y() < pt3.y()))
+            return distance_from_line2(pt2, pt1, pt3) < dist2;
+        return distance_from_line2(pt3, pt1, pt2) < dist2;
+    };
+
+    size_t size = points.size();
+    if (size == 0)
+        return;
+    std::vector<size_t> next(size), prev(size);
+    std::vector<char>   done(size, 0);
+    for (size_t i = 0; i < size; ++i) {
+        next[i]       = (i + 1) % size;
+        prev[next[i]] = i;
+    }
+    auto exclude = [&next, &prev, &done](size_t op) {
+        const size_t result = prev[op];
+        next[result]        = next[op];
+        prev[next[op]]      = result;
+        done[result]        = 0;
+        return result;
+    };
+    const double dist2 = distance * distance;
+    size_t       op    = 0;
+    while (! done[op] && next[op] != prev[op]) {
+        if (points_are_close(points[op], points[prev[op]], dist2)) {
+            op = exclude(op);
+            -- size;
+        } else if (points_are_close(points[prev[op]], points[next[op]], dist2)) {
+            exclude(next[op]);
+            op = exclude(op);
+            size -= 2;
+        } else if (slopes_near_collinear(points[prev[op]], points[op], points[next[op]], dist2)) {
+            op = exclude(op);
+            -- size;
+        } else {
+            done[op] = 1;
+            op       = next[op];
+        }
+    }
+    if (size < 3)
+        size = 0;
+    Points out;
+    out.reserve(size);
+    for (size_t i = 0; i < size; ++i) {
+        out.emplace_back(points[op]);
+        op = next[op];
+    }
+    points = std::move(out);
+}
+
 HealedExPolygons Emboss::heal_polygons(const Polygons &shape, bool is_non_zero, unsigned int max_iteration)
 {
     const double clean_distance = 1.415; // little grater than sqrt(2)
-    ClipperLib::PolyFillType fill_type = is_non_zero ? 
-        ClipperLib::pftNonZero : ClipperLib::pftEvenOdd;
+    PolyFillType fill_type = is_non_zero ? pftNonZero : pftEvenOdd;
 
     // When edit this code check that font 'ALIENATE.TTF' and glyph 'i' still work
     // fix of self intersections
-    // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Functions/SimplifyPolygon.htm
-    ClipperLib::Paths paths = ClipperLib::SimplifyPolygons(ClipperUtils::PolygonsProvider(shape), fill_type);
-    ClipperLib::CleanPolygons(paths, clean_distance);
-    Polygons polygons = to_polygons(paths);
+    Polygons polygons = union_(shape, fill_type);
+    for (Polygon &polygon : polygons)
+        clean_polygon(polygon.points, clean_distance);
     polygons.erase(std::remove_if(polygons.begin(), polygons.end(), 
         [](const Polygon &p) { return p.size() < 3; }), polygons.end());
     

src/libslic3r/Emboss.hpp

@@ -1,11 +1,19 @@
 #ifndef slic3r_Emboss_hpp_
 #define slic3r_Emboss_hpp_
 
+#include <string>
+#include <map>
+#include <utility>
+#include <cassert>
+#include <cstddef>
+#include <functional>
+#include <cstdint>
 #include <vector>
 #include <set>
 #include <optional>
 #include <memory>
 #include <admesh/stl.h> // indexed_triangle_set
+#include "Point.hpp"
 #include "Polygon.hpp"
 #include "ExPolygon.hpp"
 #include "EmbossShape.hpp" // ExPolygonsWithIds
@@ -165,7 +173,7 @@ namespace Emboss
     /// Fix duplicit points and self intersections in polygons.
     /// Also try to reduce amount of points and remove useless polygon parts
     /// </summary>
-    /// <param name="is_non_zero">Fill type ClipperLib::pftNonZero for overlapping otherwise </param>
+    /// <param name="is_non_zero">Fill type pftNonZero for overlapping otherwise </param>
     /// <param name="max_iteration">Look at heal_expolygon()::max_iteration</param>
     /// <returns>Healed shapes with flag is fully healed</returns>
     HealedExPolygons heal_polygons(const Polygons &shape, bool is_non_zero = true, unsigned max_iteration = 10);