feat: use clipper c++ lib version 1.5.4

Updates to version 1.5.4 of the clipper2 library. Also retains
ClipType None instead of the renamed NoClip to prevent breaking changes.

Author: tirithen

clipper2c/src/conv.cpp

@@ -76,7 +76,7 @@ ClipperClipType to_c(Clipper2Lib::ClipType cliptype)
   ClipperClipType ct = NONE;
   switch (cliptype)
   {
-  case Clipper2Lib::ClipType::None:
+  case Clipper2Lib::ClipType::NoClip:
     break;
   case Clipper2Lib::ClipType::Intersection:
     ct = INTERSECTION;
@@ -251,7 +251,7 @@ Clipper2Lib::SvgReader *from_c(ClipperSvgReader *p)
 
 Clipper2Lib::ClipType from_c(ClipperClipType fr)
 {
-  Clipper2Lib::ClipType clipType = Clipper2Lib::ClipType::None;
+  Clipper2Lib::ClipType clipType = Clipper2Lib::ClipType::NoClip;
   switch (fr)
   {
   case NONE:
@@ -351,4 +351,4 @@ Clipper2Lib::PointInPolygonResult from_c(ClipperPointInPolygonResult result)
     break;
   };
   return res;
-}
+}

clipper2c/vendor/Clipper2/CPP/BenchMark/CMakeLists.txt

@@ -77,4 +77,4 @@ foreach(benchmark ${benchmark_srcs})
         Clipper2_bm
         Clipper2utils_bm
     )
-endforeach()
+endforeach()

clipper2c/vendor/Clipper2/CPP/BenchMark/GetIntersectPtBenchmark.cpp

@@ -3,7 +3,7 @@
 #include "clipper2/clipper.core.h"
 #include "CommonUtils.h"
 #include "ClipFileLoad.h"
-#include <iomanip>
+#include <iomanip> 
 #include <cstdlib>
 #include <random>
 
@@ -180,7 +180,7 @@ static inline Int128 multiply(int64_t lhs, int64_t rhs)
 
 static int64_t divide(Int128 dividend, Int128 divisor)
 {
-  // this function assumes that the parameter values will
+  // this function assumes that the parameter values will 
   // generate a result that fits into a 64bit integer.
   bool negate = (divisor.hi < 0) != (dividend.hi < 0);
   if (dividend.hi < 0) dividend = -dividend;
@@ -231,15 +231,15 @@ static int64_t divide(Int128 dividend, Int128 divisor)
       cntr.lo |= 0x8000000000000000LL;
     cntr.hi >>= 1;
   }
-  if (result.hi || (int64_t)result.lo < 0)
+  if (result.hi || (int64_t)result.lo < 0) 
     return negate ? INT64_MIN : INT64_MAX;
   else
     return negate ? -(int64_t)result.lo : result.lo;
 }
 
 static inline int64_t muldiv(Int128 lhs, int64_t rhs, Int128 divisor)
 {
-  // this function assumes that the parameter values will
+  // this function assumes that the parameter values will 
   // generate a result that fits into a 64bit integer.
   int64_t sign = (lhs.is_negative() != divisor.is_negative()) != (rhs < 0) ? -2 : 2;
   if (lhs.is_negative()) lhs.negate();
@@ -276,7 +276,7 @@ typedef std::function<bool(const Point64&, const Point64&,
   const Point64&, const Point64&, Point64&)> GipFunction;
 
 // GIP_Current: This is Clipper2's current GetIntersectPoint.
-// It's definitely the fastest function, but its accuracy declines
+// It's definitely the fastest function, but its accuracy declines 
 // a little when using very large 64bit integers (eg +/-10e17).
 static bool GIP_Current(const Point64& ln1a, const Point64& ln1b,
   const Point64& ln2a, const Point64& ln2b, Point64& ip)
@@ -333,8 +333,8 @@ static bool GIP_Func_F(const Point64& ln1a, const Point64& ln1b,
 }
 
 // GIP_F_Mod: GIP_Func_F except replaces nearbyint with static casts.
-// Surprisingly, while this function is faster that GIP_Func_F here,
-// it's much slower than both GIP_Func_F and GIP_Current when using it
+// Surprisingly, while this function is faster that GIP_Func_F here, 
+// it's much slower than both GIP_Func_F and GIP_Current when using it 
 // as a replacement for GetIntersectPoint() in clipper.core.h.
 static bool GIP_F_Mod(const Point64& ln1a, const Point64& ln1b,
   const Point64& ln2a, const Point64& ln2b, Point64& ip)
@@ -364,7 +364,7 @@ static bool GIP_F_Mod(const Point64& ln1a, const Point64& ln1b,
   return true;
 }
 
-// GIP_128: GetIntersectPoint using 128bit integer precision
+// GIP_128: GetIntersectPoint using 128bit integer precision 
 // This function is the most precise, but it's also very slow.
 static bool GIP_128(const Point64& ln1a, const Point64& ln1b,
   const Point64& ln2a, const Point64& ln2b, Point64& ip)
@@ -394,10 +394,10 @@ static inline GipFunction GetGipFunc(int64_t index)
 {
   switch (index)
   {
-  case 0: return GIP_Current;
+  case 0: return GIP_Current; 
   case 1: return GIP_Func_F;
   case 2: return GIP_F_Mod;
-  case 3: return GIP_128;
+  case 3: return GIP_128; 
   default: throw "Invalid function!";
   }
 }
@@ -407,9 +407,9 @@ static inline std::string GetGipFuncName(int64_t index)
   switch (index)
   {
   case 0: return "GIP_Current";
-  case 1: return "GIP_Func_F ";
-  case 2: return "GIP_F_Mod  ";
-  case 3: return "GIP_128    ";
+  case 1: return "GIP_Func_F "; 
+  case 2: return "GIP_F_Mod  "; 
+  case 3: return "GIP_128    "; 
   default: throw "Invalid function!";
   }
 }
@@ -476,7 +476,7 @@ static void BM_GIP(benchmark::State& state)
 
 static void CustomArguments(benchmark::internal::Benchmark* b)
 {
-  for (int i = 0; i < number_of_test_functions; ++i)
+  for (int i = 0; i < number_of_test_functions; ++i) 
     b->Args({ i });
 }
 
@@ -490,16 +490,16 @@ int main(int argc, char** argv)
   benchmark::Initialize(0, nullptr);
   BENCHMARK(BM_GIP)->Apply(CustomArguments);
 
-  // the closer test segments are to collinear, the less accurate
+  // the closer test segments are to collinear, the less accurate 
   // calculations will be in determining their intersection points.
   const double min_angle_degrees = 0.5;
   const double sine_min_angle = std::sin(min_angle_degrees *PI / 180.0);
 
   bool first_pass = true;
   for (int current_pow10 = 12; current_pow10 <= 18; ++current_pow10)
   {
-    // using random coordinates that are restricted to the specified
-    // power of 10 range, create multiple TestRecords containing
+    // using random coordinates that are restricted to the specified 
+    // power of 10 range, create multiple TestRecords containing 
     // segment pairs that intersect at their midpoints
     int64_t max_coord = static_cast<int64_t>(pow(10, current_pow10));
     for (int64_t i = 0; i < 100000; ++i)
@@ -511,7 +511,7 @@ int main(int argc, char** argv)
       Point64 ip4 = ReflectPoint(ip3, actual);
 
       // Exclude segments that are **almost** collinear.
-      if (std::abs(GetSineFrom3Points(ip1, actual, ip3)) < sine_min_angle) continue;
+      if (std::abs(GetSineFrom3Points(ip1, actual, ip3)) < sine_min_angle) continue;      
       // Alternatively, just exclude segments that are collinear
       //if (!CrossProduct(ip1, actual, ip3)) continue;
 
@@ -576,4 +576,4 @@ int main(int argc, char** argv)
     tests.clear();
   }
   return 0;
-}
+}

clipper2c/vendor/Clipper2/CPP/BenchMark/PointInPolygonBenchmark.cpp

@@ -195,7 +195,7 @@ inline PointInPolygonResult PIP2(const Point64& pt, const Path64& polygon)
 }
 
 /////////////////////////////////////////////////////////
-// PIP3: An entirely different algorithm for comparision.
+// PIP3: An entirely different algorithm for comparison.
 // "Optimal Reliable Point-in-Polygon Test and
 // Differential Coding Boolean Operations on Polygons"
 // by Jianqiang Hao et al.
@@ -252,7 +252,7 @@ static PointInPolygonResult PIP3(const Point64&pt, const Path64&path)
 // global data structures
 /////////////////////////////////////////////////////////
 
-const Path64 points_of_interest_outside =
+const Path64 points_of_interest_outside = 
   MakePath({ 21887,10420, 21726,10825, 21662,10845, 21617,10890 });
 const Path64 points_of_interest_inside =
   MakePath({ 21887,10430, 21843,10520, 21810,10686, 21900,10461 });
@@ -393,11 +393,11 @@ int main(int argc, char** argv)
     std::endl;
 
   //////////////////////////////////////////////////////////////
-  // 1. Very basic error testing
+  // 1. Very basic error testing 
   //////////////////////////////////////////////////////////////
 
   std::cout << std::endl << SetConsoleTextColor(yellow_bold) <<
-    "Tests for errors #1:" << SetConsoleTextColor(reset) << std::endl <<
+    "Tests for errors #1:" << SetConsoleTextColor(reset) << std::endl << 
     "(Reusing 'TestPolytreeHoles' tests)" << std::endl << std::endl;
 
   // 1a. use const paths (PolytreeHoleOwner2.txt) with changing points of interest
@@ -412,7 +412,7 @@ int main(int argc, char** argv)
   if (!ifs || !ifs.good()) return 1;
   LoadTestNum(ifs, 1, paths, subject_open, clip, _, __, ___, ____);
   ifs.close();
-
+    
   for (int i = 0; i < 3; ++i) DoErrorTest1(i);
 
   // 1b. Use a const point of interest (10,10) against various paths
@@ -451,7 +451,7 @@ int main(int argc, char** argv)
 
   std::cout << std::endl << SetConsoleTextColor(cyan_bold) <<
     "Benchmarking ..." << SetConsoleTextColor(reset) << std::endl;
-  std::cout << "Note: function performance varies depending on the proportion of edges" <<
+  std::cout << "Note: function performance varies depending on the proportion of edges" << 
     std::endl << "that intersect with an imaginary horizontal line passing through the" <<
     std::endl << "point of interest." << std::endl << std::endl;
 
@@ -479,7 +479,7 @@ int main(int argc, char** argv)
   BENCHMARK(BM_PIP2)->Apply(CustomArguments); // modified Clipper2
   BENCHMARK(BM_PIP3)->Apply(CustomArguments); // Hao et al. (2018)
   benchmark::RunSpecifiedBenchmarks(benchmark::CreateDefaultDisplayReporter());
-
+  
   std::cout << std::endl << std::endl << SetConsoleTextColor(yellow_bold) <<
     "Benchmarks 2:" << SetConsoleTextColor(reset) << std::endl;
 
@@ -521,4 +521,4 @@ int main(int argc, char** argv)
     break;
   }
 
-}
+}

clipper2c/vendor/Clipper2/CPP/BenchMark/StripDuplicateBenchmark.cpp

@@ -5,13 +5,13 @@
 
 using namespace Clipper2Lib;
 
-// globals
+// globals 
 Paths64 test_paths;
 
 // Previous (slow) StripDuplicates function - copies path
 template <typename T>
-inline Path<T> StripDuplicates1(const Path<T> &path, bool is_closed_path)
-{
+inline Path<T> StripDuplicates1(const Path<T> &path, bool is_closed_path) 
+{  
   if (path.size() == 0) return Path<T>();
   Path<T> result;
   result.reserve(path.size());
@@ -42,24 +42,24 @@ inline void StripDuplicates2(Path<T>& path, bool is_closed_path)
 
 static void StripDuplicates_OLD(benchmark::State &state)
 {
-  for (auto _ : state)
+  for (auto _ : state) 
   {
     for (Path64& p: test_paths)
       p = StripDuplicates1(p, true);
   }
 }
 
-static void StripDuplicates_NEW(benchmark::State &state)
+static void StripDuplicates_NEW(benchmark::State &state) 
 {
   for (auto _ : state) {
     for (Path64& p : test_paths)
-      StripDuplicates2(p, true);
+      StripDuplicates2(p, true); 
   }
 }
 
 
 int main(int argc, char** argv)
-{
+{  
   const size_t max_paths = 5;
   const int width = 6000, height = 4000, count = 10000;
   test_paths.reserve(max_paths);
@@ -70,4 +70,4 @@ int main(int argc, char** argv)
   BENCHMARK(StripDuplicates_OLD);
   BENCHMARK(StripDuplicates_NEW);
   benchmark::RunSpecifiedBenchmarks(benchmark::CreateDefaultDisplayReporter());
-}
+}