Clipper optimization:

1) Removed the already commented-out scaling / unscaling when doing
   "safe offsetting"
2) Removed some of the "safe offsetting" at calls where it never was used.
3) Reworked Clipper & ClipperUtils to pass Polygons / ExPolygons / Surfaces
   as input parameters without conversion to ClipperLib::Paths. This
   should save a lot of memory allocation and copying.
4) Reworked conversions from ClipperLib::Paths & PolyTree to Polygons /
   ExPolygons to use the move operator to avoid many unnecessary allocations.
5) Reworked some "union with safe ofsetting" to "offset_ex", which should
   be cheaper.

src/clipper/clipper.cpp

@@ -759,48 +759,6 @@ bool ClipperBase::AddPath(const Path &pg, PolyType PolyTyp, bool Closed)
   return result;
 }
 
-bool ClipperBase::AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed)
-{
-  CLIPPERLIB_PROFILE_FUNC();
-  std::vector<int> num_edges(ppg.size(), 0);
-  int num_edges_total = 0;
-  for (size_t i = 0; i < ppg.size(); ++ i) {
-    const Path &pg = ppg[i];
-    // Remove duplicate end point from a closed input path.
-    // Remove duplicate points from the end of the input path.
-    int highI = (int)pg.size() -1;
-    if (Closed) 
-      while (highI > 0 && (pg[highI] == pg[0])) 
-        --highI;
-    while (highI > 0 && (pg[highI] == pg[highI -1])) 
-      --highI;
-    if ((Closed && highI < 2) || (!Closed && highI < 1))
-      highI = -1;
-    num_edges[i] = highI + 1;
-    num_edges_total += highI + 1;
-  }
-  if (num_edges_total == 0)
-    return false;
-
-  // Allocate a new edge array.
-  std::vector<TEdge> edges(num_edges_total);
-  // Fill in the edge array.
-  bool result = false;
-  TEdge *p_edge = edges.data();
-  for (Paths::size_type i = 0; i < ppg.size(); ++i)
-    if (num_edges[i]) {
-      bool res = AddPathInternal(ppg[i], num_edges[i] - 1, PolyTyp, Closed, p_edge);
-      if (res) {
-        p_edge += num_edges[i];
-        result = true;
-      }
-    }
-  if (result)
-    // At least some edges were generated. Remember the edge array.
-    m_edges.emplace_back(std::move(edges));
-  return result;
-}
-
 bool ClipperBase::AddPathInternal(const Path &pg, int highI, PolyType PolyTyp, bool Closed, TEdge* edges)
 {
   CLIPPERLIB_PROFILE_FUNC();
@@ -1103,7 +1061,7 @@ bool Clipper::Execute(ClipType clipType, Paths &solution,
   CLIPPERLIB_PROFILE_FUNC();
   if (m_HasOpenPaths)
     throw clipperException("Error: PolyTree struct is needed for open path clipping.");
-  solution.resize(0);
+  solution.clear();
   m_SubjFillType = subjFillType;
   m_ClipFillType = clipFillType;
   m_ClipType = clipType;
@@ -3426,13 +3384,6 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType
 }
 //------------------------------------------------------------------------------
 
-void ClipperOffset::AddPaths(const Paths& paths, JoinType joinType, EndType endType)
-{
-  for (const Path &path : paths)
-    AddPath(path, joinType, endType);
-}
-//------------------------------------------------------------------------------
-
 void ClipperOffset::FixOrientations()
 {
   //fixup orientations of all closed paths if the orientation of the
@@ -3875,28 +3826,16 @@ void ReversePaths(Paths& p)
 }
 //------------------------------------------------------------------------------
 
-void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType)
+Paths SimplifyPolygon(const Path &in_poly, PolyFillType fillType)
 {
   Clipper c;
   c.StrictlySimple(true);
   c.AddPath(in_poly, ptSubject, true);
-  c.Execute(ctUnion, out_polys, fillType, fillType);
+  Paths out; 
+  c.Execute(ctUnion, out, fillType, fillType);
+  return out;
 }
-//------------------------------------------------------------------------------
 
-void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType)
-{
-  Clipper c;
-  c.StrictlySimple(true);
-  c.AddPaths(in_polys, ptSubject, true);
-  c.Execute(ctUnion, out_polys, fillType, fillType);
-}
-//------------------------------------------------------------------------------
-
-void SimplifyPolygons(Paths &polys, PolyFillType fillType)
-{
-  SimplifyPolygons(polys, polys, fillType);
-}
 //------------------------------------------------------------------------------
 
 inline double DistanceSqrd(const IntPoint& pt1, const IntPoint& pt2)

src/clipper/clipper.hpp

@@ -191,9 +191,16 @@ double Area(const Path &poly);
 inline bool Orientation(const Path &poly) { return Area(poly) >= 0; }
 int PointInPolygon(const IntPoint &pt, const Path &path);
 
-void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
+Paths SimplifyPolygon(const Path &in_poly, PolyFillType fillType = pftEvenOdd);
-void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
+template<typename PathsProvider>
-void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);
+inline Paths SimplifyPolygons(PathsProvider &&in_polys, PolyFillType fillType = pftEvenOdd) {
+    Clipper c;
+    c.StrictlySimple(true);
+    c.AddPaths(std::forward<PathsProvider>(in_polys), ptSubject, true);
+    Paths out;
+    c.Execute(ctUnion, out, fillType, fillType);
+    return out;
+}
 
 void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415);
 void CleanPolygon(Path& poly, double distance = 1.415);
@@ -300,7 +307,58 @@ public:
     m_HasOpenPaths(false) {}
   ~ClipperBase() { Clear(); }
   bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
-  bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed);
+
+  template<typename PathsProvider>
+  bool AddPaths(PathsProvider &&paths_provider, PolyType PolyTyp, bool Closed)
+  {
+    size_t num_paths = paths_provider.size();
+    if (num_paths == 0)
+        return false;
+    if (num_paths == 1)
+        return AddPath(*paths_provider.begin(), PolyTyp, Closed);
+
+    std::vector<int> num_edges(num_paths, 0);
+    int num_edges_total = 0;
+    size_t i = 0;
+    for (const Path &pg : paths_provider) {
+      // Remove duplicate end point from a closed input path.
+      // Remove duplicate points from the end of the input path.
+      int highI = (int)pg.size() -1;
+      if (Closed) 
+        while (highI > 0 && (pg[highI] == pg[0])) 
+          --highI;
+      while (highI > 0 && (pg[highI] == pg[highI -1])) 
+        --highI;
+      if ((Closed && highI < 2) || (!Closed && highI < 1))
+        highI = -1;
+      num_edges[i ++] = highI + 1;
+      num_edges_total += highI + 1;
+    }
+    if (num_edges_total == 0)
+      return false;
+
+    // Allocate a new edge array.
+    std::vector<TEdge> edges(num_edges_total);
+    // Fill in the edge array.
+    bool result = false;
+    TEdge *p_edge = edges.data();
+    i = 0;
+    for (const Path &pg : paths_provider) {
+      if (num_edges[i]) {
+        bool res = AddPathInternal(pg, num_edges[i] - 1, PolyTyp, Closed, p_edge);
+        if (res) {
+          p_edge += num_edges[i];
+          result = true;
+        }
+      }
+      ++ i;
+    }
+    if (result)
+      // At least some edges were generated. Remember the edge array.
+      m_edges.emplace_back(std::move(edges));
+    return result;
+  }
+
   void Clear();
   IntRect GetBounds();
   // By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before clipping.
@@ -461,7 +519,11 @@ public:
     MiterLimit(miterLimit), ArcTolerance(roundPrecision), ShortestEdgeLength(shortestEdgeLength), m_lowest(-1, 0) {}
   ~ClipperOffset() { Clear(); }
   void AddPath(const Path& path, JoinType joinType, EndType endType);
-  void AddPaths(const Paths& paths, JoinType joinType, EndType endType);
+  template<typename PathsProvider>
+  void AddPaths(PathsProvider &&paths, JoinType joinType, EndType endType) {
+    for (const Path &path : paths)
+      AddPath(path, joinType, endType);
+  }
   void Execute(Paths& solution, double delta);
   void Execute(PolyTree& solution, double delta);
   void Clear();

src/libslic3r/Brim.cpp

@@ -139,7 +139,7 @@ static ExPolygons top_level_outer_brim_area(const Print &print, const ConstPrint
         Polygons   no_brim_area_object;
         for (const ExPolygon &ex_poly : object->layers().front()->lslices) {
             if ((brim_type == BrimType::btOuterOnly || brim_type == BrimType::btOuterAndInner) && is_top_outer_brim)
-                append(brim_area_object, diff_ex(offset_ex(ex_poly.contour, brim_width + brim_offset), offset_ex(ex_poly.contour, brim_offset)));
+                append(brim_area_object, diff_ex(offset(ex_poly.contour, brim_width + brim_offset), offset(ex_poly.contour, brim_offset)));
 
             if (brim_type == BrimType::btOuterOnly || brim_type == BrimType::btNoBrim)
                 append(no_brim_area_object, offset(ex_poly.holes, -no_brim_offset));
@@ -183,14 +183,14 @@ static ExPolygons inner_brim_area(const Print &print, const ConstPrintObjectPtrs
                 if (top_outer_brim)
                     no_brim_area_object.emplace_back(ex_poly);
                 else
-                    append(brim_area_object, diff_ex(offset_ex(ex_poly.contour, brim_width + brim_offset), offset_ex(ex_poly.contour, brim_offset)));
+                    append(brim_area_object, diff_ex(offset(ex_poly.contour, brim_width + brim_offset), offset(ex_poly.contour, brim_offset)));
             }
 
             if (brim_type == BrimType::btInnerOnly || brim_type == BrimType::btOuterAndInner)
                 append(brim_area_object, diff_ex(offset_ex(ex_poly.holes, -brim_offset), offset_ex(ex_poly.holes, -brim_width - brim_offset)));
 
             if (brim_type == BrimType::btInnerOnly || brim_type == BrimType::btNoBrim)
-                append(no_brim_area_object, offset_ex(ex_poly.contour, no_brim_offset));
+                append(no_brim_area_object, to_expolygons(offset(ex_poly.contour, no_brim_offset)));
 
             if (brim_type == BrimType::btOuterOnly || brim_type == BrimType::btNoBrim)
                 append(no_brim_area_object, offset_ex(ex_poly.holes, -no_brim_offset));
@@ -317,7 +317,7 @@ static void make_inner_brim(const Print &print, const ConstPrintObjectPtrs &top_
         islands_ex = offset_ex(islands_ex, -float(flow.scaled_spacing()), jtSquare);
     }
 
-    loops = union_pt_chained_outside_in(loops, false);
+    loops = union_pt_chained_outside_in(loops);
     std::reverse(loops.begin(), loops.end());
     extrusion_entities_append_loops(brim.entities, std::move(loops), erSkirt, float(flow.mm3_per_mm()),
                                     float(flow.width()), float(print.skirt_first_layer_height()));
@@ -342,7 +342,7 @@ ExtrusionEntityCollection make_brim(const Print &print, PrintTryCancel try_cance
             poly.douglas_peucker(SCALED_RESOLUTION);
         polygons_append(loops, offset(islands, -0.5f * float(flow.scaled_spacing())));
     }
-    loops = union_pt_chained_outside_in(loops, false);
+    loops = union_pt_chained_outside_in(loops);
 
     std::vector<Polylines> loops_pl_by_levels;
     {

src/libslic3r/ClipperUtils.hpp

@@ -12,72 +12,231 @@ using Slic3r::ClipperLib::jtMiter;
 using Slic3r::ClipperLib::jtRound;
 using Slic3r::ClipperLib::jtSquare;
 
+static constexpr const float ClipperSafetyOffset = 10.f;
+
 #define CLIPPERUTILS_UNSAFE_OFFSET
 
-// #define CLIPPERUTILS_OFFSET_SCALE
-
-#ifdef CLIPPERUTILS_OFFSET_SCALE
-    // Factor to convert from coord_t (which is int32) to an int64 type used by the Clipper library
-    // for general offsetting (the offset(), offset2(), offset_ex() functions) and for the safety offset,
-    // which is optionally executed by other functions (union, intersection, diff).
-    // This scaling (cca 130t) is applied over the usual SCALING_FACTOR.
-    // By the way, is the scalling for offset needed at all?
-    // The reason to apply this scaling may be to match the resolution of the double mantissa.
-    #define CLIPPER_OFFSET_POWER_OF_2 17
-    // 2^17=131072
-    #define CLIPPER_OFFSET_SCALE (1 << CLIPPER_OFFSET_POWER_OF_2)
-    #define CLIPPER_OFFSET_SCALE_ROUNDING_DELTA ((1 << (CLIPPER_OFFSET_POWER_OF_2 - 1)) - 1)
-    #define CLIPPER_MAX_COORD_UNSCALED (ClipperLib::hiRange / CLIPPER_OFFSET_SCALE)
-#endif // CLIPPERUTILS_OFFSET_SCALE
-
 namespace Slic3r {
 
-//-----------------------------------------------------------
+namespace ClipperUtils {
-// legacy code from Clipper documentation
+    class PathsProviderIteratorBase {
-void AddOuterPolyNodeToExPolygons(ClipperLib::PolyNode& polynode, Slic3r::ExPolygons *expolygons);
+    public:
-Slic3r::ExPolygons PolyTreeToExPolygons(ClipperLib::PolyTree& polytree);
+        using value_type        = Points;
-//-----------------------------------------------------------
+        using difference_type   = std::ptrdiff_t;
+        using pointer           = const Points*;
+        using reference         = const Points&;
+        using iterator_category = std::input_iterator_tag;
+    };
 
-ClipperLib::Path   Slic3rMultiPoint_to_ClipperPath(const Slic3r::MultiPoint &input);
+    class EmptyPathsProvider {
-ClipperLib::Paths  Slic3rMultiPoints_to_ClipperPaths(const Polygons &input);
+    public:
-ClipperLib::Paths  Slic3rMultiPoints_to_ClipperPaths(const ExPolygons &input);
+        struct iterator : public PathsProviderIteratorBase {
-ClipperLib::Paths  Slic3rMultiPoints_to_ClipperPaths(const Polylines &input);
+        public:
-Slic3r::Polygon    ClipperPath_to_Slic3rPolygon(const ClipperLib::Path &input);
+            constexpr const Points& operator*() { assert(false); return *static_cast<Points*>(nullptr); }
-Slic3r::Polyline   ClipperPath_to_Slic3rPolyline(const ClipperLib::Path &input);
+            // all iterators point to end.
-Slic3r::Polygons   ClipperPaths_to_Slic3rPolygons(const ClipperLib::Paths &input);
+            constexpr bool operator==(const iterator &rhs) const { return true; }
-Slic3r::Polylines  ClipperPaths_to_Slic3rPolylines(const ClipperLib::Paths &input);
+            constexpr bool operator!=(const iterator &rhs) const { return false; }
-Slic3r::ExPolygons ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input);
+            constexpr const Points& operator++(int) { assert(false); return *static_cast<Points*>(nullptr); }
+            constexpr iterator& operator++() { assert(false); return *this; }
+        };
+
+        constexpr EmptyPathsProvider() {}
+        static constexpr iterator cend()   throw() { return iterator{}; }
+        static constexpr iterator end()    throw() { return cend(); }
+        static constexpr iterator cbegin() throw() { return cend(); }
+        static constexpr iterator begin()  throw() { return cend(); }
+        static constexpr size_t   size()   throw() { return 0; }
+    };
+
+    class SinglePathProvider {
+    public:
+        SinglePathProvider(const Points &points) : m_points(points) {}
+
+        struct iterator : public PathsProviderIteratorBase {
+        public:
+            explicit iterator(const Points &points) : m_ptr(&points) {}
+            const Points& operator*() const { return *m_ptr; }
+            bool operator==(const iterator &rhs) const { return m_ptr == rhs.m_ptr; }
+            bool operator!=(const iterator &rhs) const { return !(*this == rhs); }
+            const Points& operator++(int) { auto out = m_ptr; m_ptr = &s_end; return *out; }
+            iterator& operator++() { m_ptr = &s_end; return *this; }
+        private:
+            const Points *m_ptr;
+        };
+
+        iterator cbegin() const { return iterator(m_points); }
+        iterator begin()  const { return this->cbegin(); }
+        iterator cend()   const { return iterator(s_end); }
+        iterator end()    const { return this->cend(); }
+        size_t   size()   const { return 1; }
+
+    private:
+        const  Points &m_points;
+        static Points  s_end;
+    };
+
+    template<typename MultiPointType>
+    class MultiPointsProvider {
+    public:
+        MultiPointsProvider(const std::vector<MultiPointType> &multipoints) : m_multipoints(multipoints) {}
+
+        struct iterator : public PathsProviderIteratorBase {
+        public:
+            explicit iterator(typename std::vector<MultiPointType>::const_iterator it) : m_it(it) {}
+            const Points& operator*() const { return m_it->points; }
+            bool operator==(const iterator &rhs) const { return m_it == rhs.m_it; }
+            bool operator!=(const iterator &rhs) const { return !(*this == rhs); }
+            const Points& operator++(int) { return (m_it ++)->points; }
+            iterator& operator++() { ++ m_it; return *this; }
+        private:
+            typename std::vector<MultiPointType>::const_iterator m_it;
+        };
+
+        iterator cbegin() const { return iterator(m_multipoints.begin()); }
+        iterator begin()  const { return this->cbegin(); }
+        iterator cend()   const { return iterator(m_multipoints.end()); }
+        iterator end()    const { return this->cend(); }
+        size_t   size()   const { return m_multipoints.size(); }
+
+    private:
+        const std::vector<MultiPointType> &m_multipoints;
+    };
+
+    using PolygonsProvider  = MultiPointsProvider<Polygon>;
+    using PolylinesProvider = MultiPointsProvider<Polyline>;
+
+    struct ExPolygonProvider {
+        ExPolygonProvider(const ExPolygon &expoly) : m_expoly(expoly) {}
+
+        struct iterator : public PathsProviderIteratorBase {
+        public:
+            explicit iterator(const ExPolygon &expoly, int idx) : m_expoly(expoly), m_idx(idx) {}
+            const Points& operator*() const { return (m_idx == 0) ? m_expoly.contour.points : m_expoly.holes[m_idx - 1].points; }
+            bool operator==(const iterator &rhs) const { assert(m_expoly == rhs.m_expoly); return m_idx == rhs.m_idx; }
+            bool operator!=(const iterator &rhs) const { return !(*this == rhs); }
+            const Points& operator++(int) { const Points &out = **this; ++ m_idx; return out; }
+            iterator& operator++() { ++ m_idx; return *this; }
+        private:
+            const ExPolygon &m_expoly;
+            int              m_idx;
+        };
+
+        iterator cbegin() const { return iterator(m_expoly, 0); }
+        iterator begin()  const { return this->cbegin(); }
+        iterator cend()   const { return iterator(m_expoly, m_expoly.holes.size() + 1); }
+        iterator end()    const { return this->cend(); }
+        size_t   size()   const { return m_expoly.holes.size() + 1; }
+
+    private:
+        const ExPolygon &m_expoly;
+    };
+
+    struct ExPolygonsProvider {
+        ExPolygonsProvider(const ExPolygons &expolygons) : m_expolygons(expolygons) {
+            m_size = 0;
+            for (const ExPolygon &expoly : expolygons)
+                m_size += expoly.holes.size() + 1;
+        }
+
+        struct iterator : public PathsProviderIteratorBase {
+        public:
+            explicit iterator(ExPolygons::const_iterator it) : m_it_expolygon(it), m_idx_contour(0) {}
+            const Points& operator*() const { return (m_idx_contour == 0) ? m_it_expolygon->contour.points : m_it_expolygon->holes[m_idx_contour - 1].points; }
+            bool operator==(const iterator &rhs) const { return m_it_expolygon == rhs.m_it_expolygon && m_idx_contour == rhs.m_idx_contour; }
+            bool operator!=(const iterator &rhs) const { return !(*this == rhs); }
+            iterator& operator++() { 
+                if (++ m_idx_contour == m_it_expolygon->holes.size() + 1) {
+                    ++ m_it_expolygon;
+                    m_idx_contour = 0;
+                }
+                return *this;
+            }
+            const Points& operator++(int) { 
+                const Points &out = **this;
+                ++ (*this);
+                return out;
+            }
+        private:
+            ExPolygons::const_iterator  m_it_expolygon;
+            int                         m_idx_contour;
+        };
+
+        iterator cbegin() const { return iterator(m_expolygons.cbegin()); }
+        iterator begin()  const { return this->cbegin(); }
+        iterator cend()   const { return iterator(m_expolygons.cend()); }
+        iterator end()    const { return this->cend(); }
+        size_t   size()   const { return m_size; }
+
+    private:
+        const ExPolygons &m_expolygons;
+        size_t            m_size;
+    };
+
+    struct SurfacesProvider {
+        SurfacesProvider(const Surfaces &surfaces) : m_surfaces(surfaces) {
+            m_size = 0;
+            for (const Surface &surface : surfaces)
+                m_size += surface.expolygon.holes.size() + 1;
+        }
+
+        struct iterator : public PathsProviderIteratorBase {
+        public:
+            explicit iterator(Surfaces::const_iterator it) : m_it_surface(it), m_idx_contour(0) {}
+            const Points& operator*() const { return (m_idx_contour == 0) ? m_it_surface->expolygon.contour.points : m_it_surface->expolygon.holes[m_idx_contour - 1].points; }
+            bool operator==(const iterator &rhs) const { return m_it_surface == rhs.m_it_surface && m_idx_contour == rhs.m_idx_contour; }
+            bool operator!=(const iterator &rhs) const { return !(*this == rhs); }
+            iterator& operator++() { 
+                if (++ m_idx_contour == m_it_surface->expolygon.holes.size() + 1) {
+                    ++ m_it_surface;
+                    m_idx_contour = 0;
+                }
+                return *this;
+            }
+            const Points& operator++(int) { 
+                const Points &out = **this;
+                ++ (*this);
+                return out;
+            }
+        private:
+            Surfaces::const_iterator  m_it_surface;
+            int                       m_idx_contour;
+        };
+
+        iterator cbegin() const { return iterator(m_surfaces.cbegin()); }
+        iterator begin()  const { return this->cbegin(); }
+        iterator cend()   const { return iterator(m_surfaces.cend()); }
+        iterator end()    const { return this->cend(); }
+        size_t   size()   const { return m_size; }
+
+    private:
+        const Surfaces &m_surfaces;
+        size_t          m_size;
+    };
+}
+
+ExPolygons ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input);
 
 // offset Polygons
-ClipperLib::Paths _offset(ClipperLib::Path &&input, ClipperLib::EndType endType, const float delta, ClipperLib::JoinType joinType, double miterLimit);
+Slic3r::Polygons offset(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter,  double miterLimit = 3);
-ClipperLib::Paths _offset(ClipperLib::Paths &&input, ClipperLib::EndType endType, const float delta, ClipperLib::JoinType joinType, double miterLimit);
-inline Slic3r::Polygons offset(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter,  double miterLimit = 3)
-    { return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoint_to_ClipperPath(polygon), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }
 
 #ifdef CLIPPERUTILS_UNSAFE_OFFSET
-inline Slic3r::Polygons offset(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
+Slic3r::Polygons offset(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3);
-    { return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoints_to_ClipperPaths(polygons), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }
 #endif // CLIPPERUTILS_UNSAFE_OFFSET
 
 // offset Polylines
-inline Slic3r::Polygons offset(const Slic3r::Polyline &polyline, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3)
+Slic3r::Polygons offset(const Slic3r::Polyline &polyline, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3);
-    { return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoint_to_ClipperPath(polyline), ClipperLib::etOpenButt, delta, joinType, miterLimit)); }
+Slic3r::Polygons offset(const Slic3r::Polylines &polylines, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3);
-inline Slic3r::Polygons offset(const Slic3r::Polylines &polylines, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3)
-    { return ClipperPaths_to_Slic3rPolygons(_offset(Slic3rMultiPoints_to_ClipperPaths(polylines), ClipperLib::etOpenButt, delta, joinType, miterLimit)); }
 
 // offset expolygons and surfaces
 ClipperLib::Paths _offset(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType, double miterLimit);
 ClipperLib::Paths _offset(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType, double miterLimit);
 inline Slic3r::Polygons offset(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
-    { return ClipperPaths_to_Slic3rPolygons(_offset(expolygon, delta, joinType, miterLimit)); }
+    { return to_polygons(_offset(expolygon, delta, joinType, miterLimit)); }
 inline Slic3r::Polygons offset(const Slic3r::ExPolygons &expolygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
-    { return ClipperPaths_to_Slic3rPolygons(_offset(expolygons, delta, joinType, miterLimit)); }
+    { return to_polygons(_offset(expolygons, delta, joinType, miterLimit)); }
-inline Slic3r::ExPolygons offset_ex(const Slic3r::Polygon &polygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
-    { return ClipperPaths_to_Slic3rExPolygons(_offset(Slic3rMultiPoint_to_ClipperPath(polygon), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }    
 
 #ifdef CLIPPERUTILS_UNSAFE_OFFSET
-inline Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
+Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3);
-    { return ClipperPaths_to_Slic3rExPolygons(_offset(Slic3rMultiPoints_to_ClipperPaths(polygons), ClipperLib::etClosedPolygon, delta, joinType, miterLimit)); }
 #endif // CLIPPERUTILS_UNSAFE_OFFSET
 
 inline Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygon &expolygon, const float delta, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3)
@@ -101,141 +260,68 @@ Slic3r::ExPolygons offset2_ex(const Slic3r::ExPolygons &expolygons, const float
     const float delta2, ClipperLib::JoinType joinType = ClipperLib::jtMiter, 
     double miterLimit = 3);
 
-Slic3r::Polygons _clipper(ClipperLib::ClipType clipType,
+Slic3r::Polylines _clipper_pl(ClipperLib::ClipType clipType, const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false);
-    const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
+Slic3r::Polylines _clipper_pl(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false);
-Slic3r::ExPolygons _clipper_ex(ClipperLib::ClipType clipType,
+Slic3r::Lines _clipper_ln(ClipperLib::ClipType clipType, const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false);
-    const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
-Slic3r::Polylines _clipper_pl(ClipperLib::ClipType clipType,
-    const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
-Slic3r::Polylines _clipper_pl(ClipperLib::ClipType clipType,
-    const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
-Slic3r::Lines _clipper_ln(ClipperLib::ClipType clipType,
-    const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false);
 
-// diff
+Slic3r::Polygons diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false);
-inline Slic3r::Polygons
+Slic3r::Polygons diff(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool do_safety_offset = false);
-diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
+Slic3r::ExPolygons diff_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false);
+Slic3r::ExPolygons diff_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool do_safety_offset = false);
+
+inline Slic3r::Polylines diff_pl(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false)
 {
-    return _clipper(ClipperLib::ctDifference, subject, clip, safety_offset_);
+    return _clipper_pl(ClipperLib::ctDifference, subject, clip, do_safety_offset);
 }
 
-inline Slic3r::ExPolygons
+inline Slic3r::Polylines diff_pl(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false)
-diff_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
 {
-    return _clipper_ex(ClipperLib::ctDifference, subject, clip, safety_offset_);
+    return _clipper_pl(ClipperLib::ctDifference, subject, clip, do_safety_offset);
 }
 
-inline Slic3r::ExPolygons
+inline Slic3r::Lines diff_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false)
-diff_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
 {
-    return _clipper_ex(ClipperLib::ctDifference, to_polygons(subject), to_polygons(clip), safety_offset_);
+    return _clipper_ln(ClipperLib::ctDifference, subject, clip, do_safety_offset);
 }
 
-inline Slic3r::Polygons
+Slic3r::Polygons intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false);
-diff(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
+Slic3r::Polygons intersection(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool do_safety_offset = false);
+Slic3r::ExPolygons intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false);
+Slic3r::ExPolygons intersection_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool do_safety_offset = false);
+
+inline Slic3r::Polylines intersection_pl(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false)
 {
-    return _clipper(ClipperLib::ctDifference, to_polygons(subject), to_polygons(clip), safety_offset_);
+    return _clipper_pl(ClipperLib::ctIntersection, subject, clip, do_safety_offset);
 }
 
-inline Slic3r::Polylines
+inline Slic3r::Polylines intersection_pl(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false)
-diff_pl(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
 {
-    return _clipper_pl(ClipperLib::ctDifference, subject, clip, safety_offset_);
+    return _clipper_pl(ClipperLib::ctIntersection, subject, clip, do_safety_offset);
 }
 
-inline Slic3r::Polylines
+inline Slic3r::Lines intersection_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false)
-diff_pl(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
 {
-    return _clipper_pl(ClipperLib::ctDifference, subject, clip, safety_offset_);
+    return _clipper_ln(ClipperLib::ctIntersection, subject, clip, do_safety_offset);
 }
 
-inline Slic3r::Lines
+inline Slic3r::Lines intersection_ln(const Slic3r::Line &subject, const Slic3r::Polygons &clip, bool do_safety_offset = false)
-diff_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
-{
-    return _clipper_ln(ClipperLib::ctDifference, subject, clip, safety_offset_);
-}
-
-// intersection
-inline Slic3r::Polygons
-intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
-{
-    return _clipper(ClipperLib::ctIntersection, subject, clip, safety_offset_);
-}
-
-inline Slic3r::ExPolygons
-intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
-{
-    return _clipper_ex(ClipperLib::ctIntersection, subject, clip, safety_offset_);
-}
-
-inline Slic3r::ExPolygons
-intersection_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
-{
-    return _clipper_ex(ClipperLib::ctIntersection, to_polygons(subject), to_polygons(clip), safety_offset_);
-}
-
-inline Slic3r::Polygons
-intersection(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_ = false)
-{
-    return _clipper(ClipperLib::ctIntersection, to_polygons(subject), to_polygons(clip), safety_offset_);
-}
-
-inline Slic3r::Polylines
-intersection_pl(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
-{
-    return _clipper_pl(ClipperLib::ctIntersection, subject, clip, safety_offset_);
-}
-
-inline Slic3r::Polylines
-intersection_pl(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
-{
-    return _clipper_pl(ClipperLib::ctIntersection, subject, clip, safety_offset_);
-}
-
-inline Slic3r::Lines intersection_ln(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
-{
-    return _clipper_ln(ClipperLib::ctIntersection, subject, clip, safety_offset_);
-}
-
-inline Slic3r::Lines intersection_ln(const Slic3r::Line &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false)
 {
     Slic3r::Lines lines;
     lines.emplace_back(subject);
-    return _clipper_ln(ClipperLib::ctIntersection, lines, clip, safety_offset_);
+    return _clipper_ln(ClipperLib::ctIntersection, lines, clip, do_safety_offset);
 }
 
-// union
+Slic3r::Polygons union_(const Slic3r::Polygons &subject, bool do_safety_offset = false);
-inline Slic3r::Polygons union_(const Slic3r::Polygons &subject, bool safety_offset_ = false)
+Slic3r::Polygons union_(const Slic3r::ExPolygons &subject, bool do_safety_offset = false);
-{
+Slic3r::Polygons union_(const Slic3r::Polygons &subject, const Slic3r::Polygons &subject2, bool do_safety_offset = false);
-    return _clipper(ClipperLib::ctUnion, subject, Slic3r::Polygons(), safety_offset_);
+Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, bool do_safety_offset = false);
-}
+Slic3r::ExPolygons union_ex(const Slic3r::ExPolygons &subject);
+Slic3r::ExPolygons union_ex(const Slic3r::Surfaces &subject);
 
-inline Slic3r::Polygons union_(const Slic3r::Polygons &subject, const Slic3r::Polygons &subject2, bool safety_offset_ = false)
+ClipperLib::PolyTree union_pt(const Slic3r::Polygons &subject);
-{
+ClipperLib::PolyTree union_pt(const Slic3r::ExPolygons &subject);
-    return _clipper(ClipperLib::ctUnion, subject, subject2, safety_offset_);
-}
 
-inline Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, bool safety_offset_ = false)
+Slic3r::Polygons union_pt_chained_outside_in(const Slic3r::Polygons &subject);
-{
-    return _clipper_ex(ClipperLib::ctUnion, subject, Slic3r::Polygons(), safety_offset_);
-}
-
-inline Slic3r::ExPolygons union_ex(const Slic3r::ExPolygons &subject, bool safety_offset_ = false)
-{
-    return _clipper_ex(ClipperLib::ctUnion, to_polygons(subject), Slic3r::Polygons(), safety_offset_);
-}
-
-inline Slic3r::ExPolygons union_ex(const Slic3r::Surfaces &subject, bool safety_offset_ = false)
-{
-    return _clipper_ex(ClipperLib::ctUnion, to_polygons(subject), Slic3r::Polygons(), safety_offset_);
-}
-
-ClipperLib::PolyTree union_pt(const Slic3r::Polygons &subject, bool safety_offset_ = false);
-ClipperLib::PolyTree union_pt(const Slic3r::ExPolygons &subject, bool safety_offset_ = false);
-ClipperLib::PolyTree union_pt(Slic3r::Polygons &&subject, bool safety_offset_ = false);
-ClipperLib::PolyTree union_pt(Slic3r::ExPolygons &&subject, bool safety_offset_ = false);
-
-Slic3r::Polygons union_pt_chained_outside_in(const Slic3r::Polygons &subject, bool safety_offset_ = false);
 
 ClipperLib::PolyNodes order_nodes(const ClipperLib::PolyNodes &nodes);
 
@@ -283,7 +369,7 @@ void traverse_pt(const ClipperLib::PolyNode *tree, Polygons *out)
     if (!tree) return; // terminates recursion
     
     // Push the contour of the current level
-    out->emplace_back(ClipperPath_to_Slic3rPolygon(tree->Contour));
+    out->emplace_back(tree->Contour);
     
     // Do the recursion for all the children.
     traverse_pt<ordering>(tree->Childs, out);
@@ -302,13 +388,13 @@ void traverse_pt(const ClipperLib::PolyNode *tree, ExPolygons *out)
     }
     
     ExPolygon level;
-    level.contour = ClipperPath_to_Slic3rPolygon(tree->Contour);
+    level.contour.points = tree->Contour;
     
     foreach_node<ordering>(tree->Childs, 
                            [out, &level] (const ClipperLib::PolyNode *node) {
         
         // Holes are collected here. 
-        level.holes.emplace_back(ClipperPath_to_Slic3rPolygon(node->Contour));
+        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.
@@ -331,8 +417,6 @@ void traverse_pt(const ClipperLib::PolyNodes &nodes, ExOrJustPolygons *retval)
 Slic3r::Polygons simplify_polygons(const Slic3r::Polygons &subject, bool preserve_collinear = false);
 Slic3r::ExPolygons simplify_polygons_ex(const Slic3r::Polygons &subject, bool preserve_collinear = false);
 
-void safety_offset(ClipperLib::Paths* paths);
-
 Polygons top_level_islands(const Slic3r::Polygons &polygons);
 
 ClipperLib::Path mittered_offset_path_scaled(const Points &contour, const std::vector<float> &deltas, double miter_limit);

src/libslic3r/ExPolygon.hpp

@@ -83,8 +83,8 @@ inline bool operator!=(const ExPolygon &lhs, const ExPolygon &rhs) { return lhs.
 inline size_t number_polygons(const ExPolygons &expolys)
 {
     size_t n_polygons = 0;
-    for (ExPolygons::const_iterator it = expolys.begin(); it != expolys.end(); ++ it)
+    for (const ExPolygon &ex : expolys)
-        n_polygons += it->holes.size() + 1;
+        n_polygons += ex.holes.size() + 1;
     return n_polygons;
 }
 

src/libslic3r/Fill/FillConcentric.cpp

@@ -33,7 +33,7 @@ void FillConcentric::_fill_surface_single(
 
     // generate paths from the outermost to the innermost, to avoid
     // adhesion problems of the first central tiny loops
-    loops = union_pt_chained_outside_in(loops, false);
+    loops = union_pt_chained_outside_in(loops);
     
     // split paths using a nearest neighbor search
     size_t iPathFirst = polylines_out.size();

src/libslic3r/Layer.cpp

@@ -185,7 +185,7 @@ void Layer::make_perimeters()
 	                }
 	                // merge the surfaces assigned to each group
 	                for (std::pair<const unsigned short,Surfaces> &surfaces_with_extra_perimeters : slices)
-	                    new_slices.append(offset_ex(to_expolygons(surfaces_with_extra_perimeters.second), 10.f), surfaces_with_extra_perimeters.second.front());
+	                    new_slices.append(offset_ex(to_expolygons(surfaces_with_extra_perimeters.second), ClipperSafetyOffset), surfaces_with_extra_perimeters.second.front());
 	            }
 	            
 	            // make perimeters

src/libslic3r/Polygon.cpp

@@ -70,7 +70,7 @@ double Polygon::area() const
 
 bool Polygon::is_counter_clockwise() const
 {
-    return ClipperLib::Orientation(Slic3rMultiPoint_to_ClipperPath(*this));
+    return ClipperLib::Orientation(this->points);
 }
 
 bool Polygon::is_clockwise() const

src/libslic3r/Polygon.hpp

@@ -222,6 +222,24 @@ inline Polylines to_polylines(Polygons &&polys)
     return polylines;
 }
 
+inline Polygons to_polygons(const std::vector<Points> &paths)
+{
+    Polygons out;
+    out.reserve(paths.size());
+    for (const Points &path : paths)
+        out.emplace_back(path);
+    return out;
+}
+
+inline Polygons to_polygons(std::vector<Points> &&paths)
+{
+    Polygons out;
+    out.reserve(paths.size());
+    for (const Points &path : paths)
+        out.emplace_back(std::move(path));
+    return out;
+}
+
 } // Slic3r
 
 // start Boost

src/libslic3r/Polyline.hpp

@@ -124,6 +124,24 @@ inline Lines to_lines(const Polylines &polys)
     return lines;
 }
 
+inline Polylines to_polylines(const std::vector<Points> &paths)
+{
+    Polylines out;
+    out.reserve(paths.size());
+    for (const Points &path : paths)
+        out.emplace_back(path);
+    return out;
+}
+
+inline Polylines to_polylines(std::vector<Points> &&paths)
+{
+    Polylines out;
+    out.reserve(paths.size());
+    for (const Points &path : paths)
+        out.emplace_back(std::move(path));
+    return out;
+}
+
 inline void polylines_append(Polylines &dst, const Polylines &src) 
 { 
     dst.insert(dst.end(), src.begin(), src.end());

src/libslic3r/SLA/ConcaveHull.cpp

@@ -42,9 +42,10 @@ Point ConcaveHull::centroid(const Points &pp)
 
 // As it shows, the current offset_ex in ClipperUtils hangs if used in jtRound
 // mode
-static ClipperLib::Paths fast_offset(const ClipperLib::Paths &paths,
+template<typename PolygonsProvider>
-                                     coord_t                  delta,
+static ClipperLib::Paths fast_offset(PolygonsProvider             &&paths,
-                                     ClipperLib::JoinType     jointype)
+                                     coord_t                        delta,
+                                     ClipperLib::JoinType           jointype)
 {
     using ClipperLib::ClipperOffset;
     using ClipperLib::etClosedPolygon;
@@ -61,7 +62,7 @@ static ClipperLib::Paths fast_offset(const ClipperLib::Paths &paths,
             return {};
         }
 
-    offs.AddPaths(paths, jointype, etClosedPolygon);
+    offs.AddPaths(std::forward<PolygonsProvider>(paths), jointype, etClosedPolygon);
 
     Paths result;
     offs.Execute(result, static_cast<double>(delta));
@@ -157,11 +158,9 @@ ExPolygons ConcaveHull::to_expolygons() const
 
 ExPolygons offset_waffle_style_ex(const ConcaveHull &hull, coord_t delta)
 {
-    ClipperLib::Paths paths = Slic3rMultiPoints_to_ClipperPaths(hull.polygons());
+    ExPolygons ret = ClipperPaths_to_Slic3rExPolygons(
-    paths = fast_offset(paths, 2 * delta, ClipperLib::jtRound);
+        fast_offset(fast_offset(ClipperUtils::PolygonsProvider(hull.polygons()), 2 * delta, ClipperLib::jtRound), -delta, ClipperLib::jtRound));
-    paths = fast_offset(paths, -delta, ClipperLib::jtRound);
+    for (ExPolygon &p : ret) p.holes.clear();
-    ExPolygons ret = ClipperPaths_to_Slic3rExPolygons(paths);
-    for (ExPolygon &p : ret) p.holes = {};
     return ret;
 }
 

src/libslic3r/SLA/Pad.cpp

@@ -179,10 +179,10 @@ PadSkeleton divide_blueprint(const ExPolygons &bp)
     ret.outer.reserve(size_t(ptree.Total()));
 
     for (ClipperLib::PolyTree::PolyNode *node : ptree.Childs) {
-        ExPolygon poly(ClipperPath_to_Slic3rPolygon(node->Contour));
+        ExPolygon poly;
+        poly.contour.points = std::move(node->Contour);
         for (ClipperLib::PolyTree::PolyNode *child : node->Childs) {
-            poly.holes.emplace_back(
+            poly.holes.emplace_back(std::move(child->Contour));
-                ClipperPath_to_Slic3rPolygon(child->Contour));
 
             traverse_pt(child->Childs, &ret.inner);
         }
@@ -342,18 +342,18 @@ public:
 template<class...Args>
 ExPolygon offset_contour_only(const ExPolygon &poly, coord_t delta, Args...args)
 {
-    ExPolygons tmp = offset_ex(poly.contour, float(delta), args...);
+    Polygons tmp = offset(poly.contour, float(delta), args...);
 
     if (tmp.empty()) return {};
 
     Polygons holes = poly.holes;
     for (auto &h : holes) h.reverse();
 
-    tmp = diff_ex(to_polygons(tmp), holes);
+    ExPolygons tmp2 = diff_ex(tmp, holes);
 
-    if (tmp.empty()) return {};
+    if (tmp2.empty()) return {};
 
-    return tmp.front();
+    return std::move(tmp2.front());
 }
 
 bool add_cavity(Contour3D &pad, ExPolygon &top_poly, const PadConfig3D &cfg,

src/libslic3r/TriangleMesh.cpp

@@ -1799,9 +1799,9 @@ void TriangleMeshSlicer::make_expolygons(const Polygons &loops, const float clos
     
     // append to the supplied collection
     if (safety_offset > 0)
-        expolygons_append(*slices, offset2_ex(union_ex(loops, false), +safety_offset, -safety_offset));
+        expolygons_append(*slices, offset2_ex(union_ex(loops), +safety_offset, -safety_offset));
     else
-        expolygons_append(*slices, union_ex(loops, false));
+        expolygons_append(*slices, union_ex(loops));
 }
 
 void TriangleMeshSlicer::make_expolygons(std::vector<IntersectionLine> &lines, const float closing_radius, ExPolygons* slices) const

src/slic3r/GUI/3DBed.cpp

@@ -194,7 +194,7 @@ bool Bed3D::set_shape(const Pointfs& shape, const std::string& custom_texture, c
     const BoundingBox& bed_bbox = poly.contour.bounding_box();
     calc_gridlines(poly, bed_bbox);
 
-    m_polygon = offset_ex(poly.contour, (float)bed_bbox.radius() * 1.7f, jtRound, scale_(0.5))[0].contour;
+    m_polygon = offset(poly.contour, (float)bed_bbox.radius() * 1.7f, jtRound, scale_(0.5))[0];
 
     reset();
     m_texture.reset();