[External] Update Clipper2 library

external_libraries/clipper/include/clipper2/clipper.minkowski.h

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  15 October 2022                                                 *
+* Date      :  28 January 2023                                                 *
 * Website   :  http://www.angusj.com                                           *
-* Copyright :  Angus Johnson 2010-2022                                         *
+* Copyright :  Angus Johnson 2010-2023                                         *
 * Purpose   :  Minkowski Sum and Difference                                    *
 * License   :  http://www.boost.org/LICENSE_1_0.txt                            *
 *******************************************************************************/
@@ -92,11 +92,12 @@ namespace Clipper2Lib
 
   inline PathsD MinkowskiSum(const PathD& pattern, const PathD& path, bool isClosed, int decimalPlaces = 2)
   {
+    int error_code = 0;
     double scale = pow(10, decimalPlaces);
-    Path64 pat64 = ScalePath<int64_t, double>(pattern, scale);
-    Path64 path64 = ScalePath<int64_t, double>(path, scale);
+    Path64 pat64 = ScalePath<int64_t, double>(pattern, scale, error_code);
+    Path64 path64 = ScalePath<int64_t, double>(path, scale, error_code);
     Paths64 tmp = detail::Union(detail::Minkowski(pat64, path64, true, isClosed), FillRule::NonZero);
-    return ScalePaths<double, int64_t>(tmp, 1 / scale);
+    return ScalePaths<double, int64_t>(tmp, 1 / scale, error_code);
   }
 
   inline Paths64 MinkowskiDiff(const Path64& pattern, const Path64& path, bool isClosed)
@@ -106,13 +107,14 @@ namespace Clipper2Lib
 
   inline PathsD MinkowskiDiff(const PathD& pattern, const PathD& path, bool isClosed, int decimalPlaces = 2)
   {
+    int error_code = 0;
     double scale = pow(10, decimalPlaces);
-    Path64 pat64 = ScalePath<int64_t, double>(pattern, scale); 
-    Path64 path64 = ScalePath<int64_t, double>(path, scale);
+    Path64 pat64 = ScalePath<int64_t, double>(pattern, scale, error_code);
+    Path64 path64 = ScalePath<int64_t, double>(path, scale, error_code);
     Paths64 tmp = detail::Union(detail::Minkowski(pat64, path64, false, isClosed), FillRule::NonZero);
-    return ScalePaths<double, int64_t>(tmp, 1 / scale);
+    return ScalePaths<double, int64_t>(tmp, 1 / scale, error_code);
   }
 
 } // Clipper2Lib namespace
 
-#endif  // CLIPPER_MINKOWSKI_H
+#endif  // CLIPPER_MINKOWSKI_H

external_libraries/clipper/include/clipper2/clipper.offset.h

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  15 October 2022                                                 *
+* Date      :  15 May 2023                                                     *
 * Website   :  http://www.angusj.com                                           *
-* Copyright :  Angus Johnson 2010-2022                                         *
+* Copyright :  Angus Johnson 2010-2023                                         *
 * Purpose   :  Path Offset (Inflate/Shrink)                                    *
 * License   :  http://www.boost.org/LICENSE_1_0.txt                            *
 *******************************************************************************/
@@ -11,6 +11,7 @@
 #define CLIPPER_OFFSET_H_
 
 #include "clipper.core.h"
+#include "clipper.engine.h"
 
 namespace Clipper2Lib {
 
@@ -23,47 +24,58 @@ enum class EndType {Polygon, Joined, Butt, Square, Round};
 //Joined : offsets both sides of a path, with joined ends
 //Polygon: offsets only one side of a closed path
 
+typedef std::function<double(const Path64& path, const PathD& path_normals, size_t curr_idx, size_t prev_idx)> DeltaCallback64;
+
 class ClipperOffset {
 private:
 
 	class Group {
 	public:
-		Paths64 paths_in_;
-		Paths64 paths_out_;
-		Path64 path_;
-		bool is_reversed_ = false;
-		JoinType join_type_;
-		EndType end_type_;
-		Group(const Paths64& paths, JoinType join_type, EndType end_type) :
-			paths_in_(paths), join_type_(join_type), end_type_(end_type) {}
+		Paths64 paths_in;
+		Paths64 paths_out;
+		Path64 path;
+		bool is_reversed = false;
+		JoinType join_type;
+		EndType end_type;
+		Group(const Paths64& _paths, JoinType _join_type, EndType _end_type) :
+			paths_in(_paths), join_type(_join_type), end_type(_end_type) {}
 	};
 
+	int   error_code_ = 0;
+	double delta_ = 0.0;
 	double group_delta_ = 0.0;
-	double abs_group_delta_ = 0.0;
 	double temp_lim_ = 0.0;
 	double steps_per_rad_ = 0.0;
+	double step_sin_ = 0.0;
+	double step_cos_ = 0.0;
 	PathD norms;
 	Paths64 solution;
 	std::vector<Group> groups_;
 	JoinType join_type_ = JoinType::Square;
-
+	EndType end_type_ = EndType::Polygon;
+
 	double miter_limit_ = 0.0;
 	double arc_tolerance_ = 0.0;
-	bool merge_groups_ = true;
 	bool preserve_collinear_ = false;
 	bool reverse_solution_ = false;
 
+#ifdef USINGZ
+	ZCallback64 zCallback64_ = nullptr;
+#endif
+	DeltaCallback64 deltaCallback64_ = nullptr;
+
 	void DoSquare(Group& group, const Path64& path, size_t j, size_t k);
 	void DoMiter(Group& group, const Path64& path, size_t j, size_t k, double cos_a);
 	void DoRound(Group& group, const Path64& path, size_t j, size_t k, double angle);
 	void BuildNormals(const Path64& path);
 	void OffsetPolygon(Group& group, Path64& path);
 	void OffsetOpenJoined(Group& group, Path64& path);
-	void OffsetOpenPath(Group& group, Path64& path, EndType endType);
-	void OffsetPoint(Group& group, Path64& path, size_t j, size_t& k);
-	void DoGroupOffset(Group &group, double delta);
+	void OffsetOpenPath(Group& group, Path64& path);
+	void OffsetPoint(Group& group, Path64& path, size_t j, size_t k);
+	void DoGroupOffset(Group &group);
+	void ExecuteInternal(double delta);
 public:
-	ClipperOffset(double miter_limit = 2.0,
+	explicit ClipperOffset(double miter_limit = 2.0,
 		double arc_tolerance = 0.0,
 		bool preserve_collinear = false, 
 		bool reverse_solution = false) :
@@ -73,13 +85,14 @@ class ClipperOffset {
 
 	~ClipperOffset() { Clear(); };
 
+	int ErrorCode() { return error_code_; };
 	void AddPath(const Path64& path, JoinType jt_, EndType et_);
 	void AddPaths(const Paths64& paths, JoinType jt_, EndType et_);
-	void AddPath(const PathD &p, JoinType jt_, EndType et_);
-	void AddPaths(const PathsD &p, JoinType jt_, EndType et_);
 	void Clear() { groups_.clear(); norms.clear(); };
 
-	Paths64 Execute(double delta);
+	void Execute(double delta, Paths64& paths);
+	void Execute(double delta, PolyTree64& polytree);
+	void Execute(DeltaCallback64 delta_cb, Paths64& paths);
 
 	double MiterLimit() const { return miter_limit_; }
 	void MiterLimit(double miter_limit) { miter_limit_ = miter_limit; }
@@ -88,20 +101,18 @@ class ClipperOffset {
 	double ArcTolerance() const { return arc_tolerance_; }
 	void ArcTolerance(double arc_tolerance) { arc_tolerance_ = arc_tolerance; }
 
-	//MergeGroups: A path group is one or more paths added via the AddPath or
-	//AddPaths methods. By default these path groups will be offset
-	//independently of other groups and this may cause overlaps (intersections).
-	//However, when MergeGroups is enabled, any overlapping offsets will be
-	//merged (via a clipping union operation) to remove overlaps.
-	bool MergeGroups() const { return merge_groups_; }
-	void MergeGroups(bool merge_groups) { merge_groups_ = merge_groups; }
-
 	bool PreserveCollinear() const { return preserve_collinear_; }
 	void PreserveCollinear(bool preserve_collinear){preserve_collinear_ = preserve_collinear;}
 
 	bool ReverseSolution() const { return reverse_solution_; }
 	void ReverseSolution(bool reverse_solution) {reverse_solution_ = reverse_solution;}
+
+#ifdef USINGZ
+	void SetZCallback(ZCallback64 cb) { zCallback64_ = cb; }
+#endif
+	void SetDeltaCallback(DeltaCallback64 cb) { deltaCallback64_ = cb; }
+
 };
 
 }
-#endif /* CLIPPER_OFFSET_H_ */
+#endif /* CLIPPER_OFFSET_H_ */

external_libraries/clipper/include/clipper2/clipper.rectclip.h

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  15 October 2022                                                 *
+* Date      :  30 May 2023                                                     *
 * Website   :  http://www.angusj.com                                           *
-* Copyright :  Angus Johnson 2010-2022                                         *
+* Copyright :  Angus Johnson 2010-2023                                         *
 * Purpose   :  FAST rectangular clipping                                       *
 * License   :  http://www.boost.org/LICENSE_1_0.txt                            *
 *******************************************************************************/
@@ -12,35 +12,71 @@
 
 #include <cstdlib>
 #include <vector>
+#include <queue>
 #include "clipper.h"
 #include "clipper.core.h"
 
-namespace Clipper2Lib 
+namespace Clipper2Lib
 {
 
   enum class Location { Left, Top, Right, Bottom, Inside };
 
+  class OutPt2;
+  typedef std::vector<OutPt2*> OutPt2List;
+
+  class OutPt2 {
+  public:
+    Point64 pt;
+    size_t owner_idx;
+    OutPt2List* edge;
+    OutPt2* next;
+    OutPt2* prev;
+  };
+
+  //------------------------------------------------------------------------------
+  // RectClip64
+  //------------------------------------------------------------------------------
+
   class RectClip64 {
   private:
+    void ExecuteInternal(const Path64& path);
+    Path64 GetPath(OutPt2*& op);
+  protected:
     const Rect64 rect_;
-    const Point64 mp_;
-    const Path64 rectPath_;
-    Path64 result_;
+    const Path64 rect_as_path_;
+    const Point64 rect_mp_;
+    Rect64 path_bounds_;
+    std::deque<OutPt2> op_container_;
+    OutPt2List results_;  // each path can be broken into multiples
+    OutPt2List edges_[8]; // clockwise and counter-clockwise
     std::vector<Location> start_locs_;
-
-    void Reset();
+    void CheckEdges();
+    void TidyEdges(int idx, OutPt2List& cw, OutPt2List& ccw);
     void GetNextLocation(const Path64& path,
       Location& loc, int& i, int highI);
+    OutPt2* Add(Point64 pt, bool start_new = false);
     void AddCorner(Location prev, Location curr);
     void AddCorner(Location& loc, bool isClockwise);
-
   public:
-    RectClip64(const Rect64& rect) :
+    explicit RectClip64(const Rect64& rect) :
       rect_(rect),
-      mp_(rect.MidPoint()),
-      rectPath_(rect.AsPath()) {}
-    Path64 Execute(const Path64& path);
+      rect_as_path_(rect.AsPath()),
+      rect_mp_(rect.MidPoint()) {}
+    Paths64 Execute(const Paths64& paths);
+  };
+
+  //------------------------------------------------------------------------------
+  // RectClipLines64
+  //------------------------------------------------------------------------------
+
+  class RectClipLines64 : public RectClip64 {
+  private:
+    void ExecuteInternal(const Path64& path);
+    Path64 GetPath(OutPt2*& op);
+  public:
+    explicit RectClipLines64(const Rect64& rect) : RectClip64(rect) {};
+    Paths64 Execute(const Paths64& paths);
   };
 
 } // Clipper2Lib namespace
-#endif  // CLIPPER_RECTCLIP_H
+#endif  // CLIPPER_RECTCLIP_H