godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clipper2: Update to 1.3.0

This commit is contained in:
Jakub Marcowski 2024-03-01 00:42:06 +01:00
parent 7d2ca2d8ac
commit 973448ec4c
No known key found for this signature in database
GPG Key ID: 10D9E07CFFBC0E6F
15 changed files with 1575 additions and 1480 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
COPYRIGHT.txt
View File

@ -185,7 +185,7 @@ License: MPL-2.0
Files: ./thirdparty/clipper2/ Files: ./thirdparty/clipper2/
Comment: Clipper2 Comment: Clipper2
Copyright: 2010-2013, Angus Johnson Copyright: 2010-2023, Angus Johnson
License: BSL-1.0 License: BSL-1.0
Files: ./thirdparty/cvtt/ Files: ./thirdparty/cvtt/

4
modules/navigation/2d/nav_mesh_generator_2d.cpp
View File

@ -789,7 +789,7 @@ void NavMeshGenerator2D::generator_bake_from_source_geometry_data(Ref<Navigation
const int rect_end_y = baking_rect.position[1] + baking_rect.size[1] + baking_rect_offset.y; const int rect_end_y = baking_rect.position[1] + baking_rect.size[1] + baking_rect_offset.y;
Rect64 clipper_rect = Rect64(rect_begin_x, rect_begin_y, rect_end_x, rect_end_y); Rect64 clipper_rect = Rect64(rect_begin_x, rect_begin_y, rect_end_x, rect_end_y);
RectClip rect_clip = RectClip(clipper_rect); RectClip64 rect_clip = RectClip64(clipper_rect);
traversable_polygon_paths = rect_clip.Execute(traversable_polygon_paths); traversable_polygon_paths = rect_clip.Execute(traversable_polygon_paths);
obstruction_polygon_paths = rect_clip.Execute(obstruction_polygon_paths); obstruction_polygon_paths = rect_clip.Execute(obstruction_polygon_paths);
@ -821,7 +821,7 @@ void NavMeshGenerator2D::generator_bake_from_source_geometry_data(Ref<Navigation
const int rect_end_y = baking_rect.position[1] + baking_rect.size[1] + baking_rect_offset.y - border_size; const int rect_end_y = baking_rect.position[1] + baking_rect.size[1] + baking_rect_offset.y - border_size;
Rect64 clipper_rect = Rect64(rect_begin_x, rect_begin_y, rect_end_x, rect_end_y); Rect64 clipper_rect = Rect64(rect_begin_x, rect_begin_y, rect_end_x, rect_end_y);
RectClip rect_clip = RectClip(clipper_rect); RectClip64 rect_clip = RectClip64(clipper_rect);
path_solution = rect_clip.Execute(path_solution); path_solution = rect_clip.Execute(path_solution);
} }

7
thirdparty/README.md vendored
View File

@ -94,14 +94,17 @@ Files extracted from upstream source:
## clipper2 ## clipper2
- Upstream: https://github.com/AngusJohnson/Clipper2 - Upstream: https://github.com/AngusJohnson/Clipper2
- Version: 1.2.2 (756c5079aacab5837e812a143c59dc48a09f22e7, 2023) - Version: 1.3.0 (98db5662e8dd1808a5a7b50c5605a2289bb390e8, 2023)
- License: BSL 1.0 - License: BSL 1.0
Files extracted from upstream source: Files extracted from upstream source:
- `CPP/Clipper2Lib` folder - `CPP/Clipper2Lib/` folder (in root)
- `LICENSE` - `LICENSE`
Apply the patches in the `patches/` folder when syncing on newer upstream
commits.
## cvtt ## cvtt

188
thirdparty/clipper2/include/clipper2/clipper.core.h vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 22 March 2023 * * Date : 24 November 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : Core Clipper Library structures and functions * * Purpose : Core Clipper Library structures and functions *
@ -19,6 +19,7 @@
#include <algorithm> #include <algorithm>
#include <climits> #include <climits>
#include <numeric> #include <numeric>
#include "clipper2/clipper.version.h"
#define CLIPPER2_THROW(exception) std::abort() #define CLIPPER2_THROW(exception) std::abort()
@ -44,15 +45,27 @@ namespace Clipper2Lib
"Invalid scale (either 0 or too large)"; "Invalid scale (either 0 or too large)";
static const char* non_pair_error = static const char* non_pair_error =
"There must be 2 values for each coordinate"; "There must be 2 values for each coordinate";
static const char* undefined_error =
"There is an undefined error in Clipper2";
#endif #endif
// error codes (2^n) // error codes (2^n)
const int precision_error_i = 1; // non-fatal const int precision_error_i = 1; // non-fatal
const int scale_error_i = 2; // non-fatal const int scale_error_i = 2; // non-fatal
const int non_pair_error_i = 4; // non-fatal const int non_pair_error_i = 4; // non-fatal
const int range_error_i = 64; const int undefined_error_i = 32; // fatal
const int range_error_i = 64;
#ifndef PI
static const double PI = 3.141592653589793238; static const double PI = 3.141592653589793238;
#endif
#ifdef CLIPPER2_MAX_PRECISION
const int MAX_DECIMAL_PRECISION = CLIPPER2_MAX_PRECISION;
#else
const int MAX_DECIMAL_PRECISION = 8; // see Discussions #564
#endif
static const int64_t MAX_COORD = INT64_MAX >> 2; static const int64_t MAX_COORD = INT64_MAX >> 2;
static const int64_t MIN_COORD = -MAX_COORD; static const int64_t MIN_COORD = -MAX_COORD;
static const int64_t INVALID = INT64_MAX; static const int64_t INVALID = INT64_MAX;
@ -72,6 +85,8 @@ namespace Clipper2Lib
CLIPPER2_THROW(Clipper2Exception(scale_error)); CLIPPER2_THROW(Clipper2Exception(scale_error));
case non_pair_error_i: case non_pair_error_i:
CLIPPER2_THROW(Clipper2Exception(non_pair_error)); CLIPPER2_THROW(Clipper2Exception(non_pair_error));
case undefined_error_i:
CLIPPER2_THROW(Clipper2Exception(undefined_error));
case range_error_i: case range_error_i:
CLIPPER2_THROW(Clipper2Exception(range_error)); CLIPPER2_THROW(Clipper2Exception(range_error));
} }
@ -80,6 +95,7 @@ namespace Clipper2Lib
#endif #endif
} }
//By far the most widely used filling rules for polygons are EvenOdd //By far the most widely used filling rules for polygons are EvenOdd
//and NonZero, sometimes called Alternate and Winding respectively. //and NonZero, sometimes called Alternate and Winding respectively.
//https://en.wikipedia.org/wiki/Nonzero-rule //https://en.wikipedia.org/wiki/Nonzero-rule
@ -132,10 +148,11 @@ namespace Clipper2Lib
return Point(x * scale, y * scale, z); return Point(x * scale, y * scale, z);
} }
void SetZ(const int64_t z_value) { z = z_value; }
friend std::ostream& operator<<(std::ostream& os, const Point& point) friend std::ostream& operator<<(std::ostream& os, const Point& point)
{ {
os << point.x << "," << point.y << "," << point.z << " "; os << point.x << "," << point.y << "," << point.z;
return os; return os;
} }
@ -172,7 +189,7 @@ namespace Clipper2Lib
friend std::ostream& operator<<(std::ostream& os, const Point& point) friend std::ostream& operator<<(std::ostream& os, const Point& point)
{ {
os << point.x << "," << point.y << " "; os << point.x << "," << point.y;
return os; return os;
} }
#endif #endif
@ -220,6 +237,14 @@ namespace Clipper2Lib
using Paths64 = std::vector< Path64>; using Paths64 = std::vector< Path64>;
using PathsD = std::vector< PathD>; using PathsD = std::vector< PathD>;
static const Point64 InvalidPoint64 = Point64(
(std::numeric_limits<int64_t>::max)(),
(std::numeric_limits<int64_t>::max)());
static const PointD InvalidPointD = PointD(
(std::numeric_limits<double>::max)(),
(std::numeric_limits<double>::max)());
// Rect ------------------------------------------------------------------------ // Rect ------------------------------------------------------------------------
template <typename T> template <typename T>
@ -235,19 +260,13 @@ namespace Clipper2Lib
T right; T right;
T bottom; T bottom;
Rect() :
left(0),
top(0),
right(0),
bottom(0) {}
Rect(T l, T t, T r, T b) : Rect(T l, T t, T r, T b) :
left(l), left(l),
top(t), top(t),
right(r), right(r),
bottom(b) {} bottom(b) {}
Rect(bool is_valid) Rect(bool is_valid = true)
{ {
if (is_valid) if (is_valid)
{ {
@ -255,11 +274,13 @@ namespace Clipper2Lib
} }
else else
{ {
left = top = std::numeric_limits<T>::max(); left = top = (std::numeric_limits<T>::max)();
right = bottom = -std::numeric_limits<int64_t>::max(); right = bottom = (std::numeric_limits<T>::lowest)();
} }
} }
bool IsValid() const { return left != (std::numeric_limits<T>::max)(); }
T Width() const { return right - left; } T Width() const { return right - left; }
T Height() const { return bottom - top; } T Height() const { return bottom - top; }
void Width(T width) { right = left + width; } void Width(T width) { right = left + width; }
@ -307,10 +328,13 @@ namespace Clipper2Lib
((std::max)(top, rec.top) <= (std::min)(bottom, rec.bottom)); ((std::max)(top, rec.top) <= (std::min)(bottom, rec.bottom));
}; };
bool operator==(const Rect<T>& other) const {
return left == other.left && right == other.right &&
top == other.top && bottom == other.bottom;
}
friend std::ostream& operator<<(std::ostream& os, const Rect<T>& rect) { friend std::ostream& operator<<(std::ostream& os, const Rect<T>& rect) {
os << "(" os << "(" << rect.left << "," << rect.top << "," << rect.right << "," << rect.bottom << ") ";
<< rect.left << "," << rect.top << "," << rect.right << "," << rect.bottom
<< ")";
return os; return os;
} }
}; };
@ -338,16 +362,22 @@ namespace Clipper2Lib
return result; return result;
} }
static const Rect64 MaxInvalidRect64 = Rect64( static const Rect64 InvalidRect64 = Rect64(
INT64_MAX, INT64_MAX, INT64_MIN, INT64_MIN); (std::numeric_limits<int64_t>::max)(),
static const RectD MaxInvalidRectD = RectD( (std::numeric_limits<int64_t>::max)(),
MAX_DBL, MAX_DBL, -MAX_DBL, -MAX_DBL); (std::numeric_limits<int64_t>::lowest)(),
(std::numeric_limits<int64_t>::lowest)());
static const RectD InvalidRectD = RectD(
(std::numeric_limits<double>::max)(),
(std::numeric_limits<double>::max)(),
(std::numeric_limits<double>::lowest)(),
(std::numeric_limits<double>::lowest)());
template <typename T> template <typename T>
Rect<T> GetBounds(const Path<T>& path) Rect<T> GetBounds(const Path<T>& path)
{ {
auto xmin = std::numeric_limits<T>::max(); auto xmin = (std::numeric_limits<T>::max)();
auto ymin = std::numeric_limits<T>::max(); auto ymin = (std::numeric_limits<T>::max)();
auto xmax = std::numeric_limits<T>::lowest(); auto xmax = std::numeric_limits<T>::lowest();
auto ymax = std::numeric_limits<T>::lowest(); auto ymax = std::numeric_limits<T>::lowest();
for (const auto& p : path) for (const auto& p : path)
@ -363,8 +393,8 @@ namespace Clipper2Lib
template <typename T> template <typename T>
Rect<T> GetBounds(const Paths<T>& paths) Rect<T> GetBounds(const Paths<T>& paths)
{ {
auto xmin = std::numeric_limits<T>::max(); auto xmin = (std::numeric_limits<T>::max)();
auto ymin = std::numeric_limits<T>::max(); auto ymin = (std::numeric_limits<T>::max)();
auto xmax = std::numeric_limits<T>::lowest(); auto xmax = std::numeric_limits<T>::lowest();
auto ymax = std::numeric_limits<T>::lowest(); auto ymax = std::numeric_limits<T>::lowest();
for (const Path<T>& path : paths) for (const Path<T>& path : paths)
@ -428,7 +458,7 @@ namespace Clipper2Lib
} }
template <typename T1, typename T2> template <typename T1, typename T2>
inline Path<T1> ScalePath(const Path<T2>& path, inline Path<T1> ScalePath(const Path<T2>& path,
double scale, int& error_code) double scale, int& error_code)
{ {
return ScalePath<T1, T2>(path, scale, scale, error_code); return ScalePath<T1, T2>(path, scale, scale, error_code);
@ -488,26 +518,6 @@ namespace Clipper2Lib
return result; return result;
} }
inline PathD Path64ToPathD(const Path64& path)
{
return TransformPath<double, int64_t>(path);
}
inline PathsD Paths64ToPathsD(const Paths64& paths)
{
return TransformPaths<double, int64_t>(paths);
}
inline Path64 PathDToPath64(const PathD& path)
{
return TransformPath<int64_t, double>(path);
}
inline Paths64 PathsDToPaths64(const PathsD& paths)
{
return TransformPaths<int64_t, double>(paths);
}
template<typename T> template<typename T>
inline double Sqr(T val) inline double Sqr(T val)
{ {
@ -560,48 +570,32 @@ namespace Clipper2Lib
} }
template<typename T> template<typename T>
inline Path<T> StripDuplicates(const Path<T>& path, bool is_closed_path) inline void StripDuplicates( Path<T>& path, bool is_closed_path)
{ {
if (path.size() == 0) return Path<T>(); //https://stackoverflow.com/questions/1041620/whats-the-most-efficient-way-to-erase-duplicates-and-sort-a-vector#:~:text=Let%27s%20compare%20three%20approaches%3A
Path<T> result; path.erase(std::unique(path.begin(), path.end()), path.end());
result.reserve(path.size()); if (is_closed_path)
typename Path<T>::const_iterator path_iter = path.cbegin(); while (path.size() > 1 && path.back() == path.front()) path.pop_back();
Point<T> first_pt = *path_iter++, last_pt = first_pt;
result.push_back(first_pt);
for (; path_iter != path.cend(); ++path_iter)
{
if (*path_iter != last_pt)
{
last_pt = *path_iter;
result.push_back(last_pt);
}
}
if (!is_closed_path) return result;
while (result.size() > 1 && result.back() == first_pt) result.pop_back();
return result;
} }
template<typename T> template<typename T>
inline Paths<T> StripDuplicates(const Paths<T>& paths, bool is_closed_path) inline void StripDuplicates( Paths<T>& paths, bool is_closed_path)
{ {
Paths<T> result; for (typename Paths<T>::iterator paths_citer = paths.begin();
result.reserve(paths.size()); paths_citer != paths.end(); ++paths_citer)
for (typename Paths<T>::const_iterator paths_citer = paths.cbegin();
paths_citer != paths.cend(); ++paths_citer)
{ {
result.push_back(StripDuplicates(*paths_citer, is_closed_path)); StripDuplicates(*paths_citer, is_closed_path);
} }
return result;
} }
// Miscellaneous ------------------------------------------------------------ // Miscellaneous ------------------------------------------------------------
inline void CheckPrecision(int& precision, int& error_code) inline void CheckPrecision(int& precision, int& error_code)
{ {
if (precision >= -8 && precision <= 8) return; if (precision >= -MAX_DECIMAL_PRECISION && precision <= MAX_DECIMAL_PRECISION) return;
error_code |= precision_error_i; // non-fatal error error_code |= precision_error_i; // non-fatal error
DoError(precision_error_i); // unless exceptions enabled DoError(precision_error_i); // does nothing unless exceptions enabled
precision = precision > 8 ? 8 : -8; precision = precision > 0 ? MAX_DECIMAL_PRECISION : -MAX_DECIMAL_PRECISION;
} }
inline void CheckPrecision(int& precision) inline void CheckPrecision(int& precision)
@ -693,29 +687,27 @@ namespace Clipper2Lib
//nb: This statement is premised on using Cartesian coordinates //nb: This statement is premised on using Cartesian coordinates
return Area<T>(poly) >= 0; return Area<T>(poly) >= 0;
} }
inline int64_t CheckCastInt64(double val)
{
if ((val >= max_coord) || (val <= min_coord)) return INVALID;
else return static_cast<int64_t>(val);
}
inline bool GetIntersectPoint(const Point64& ln1a, const Point64& ln1b, inline bool GetIntersectPoint(const Point64& ln1a, const Point64& ln1b,
const Point64& ln2a, const Point64& ln2b, Point64& ip) const Point64& ln2a, const Point64& ln2b, Point64& ip)
{ {
// https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection // https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
double dx1 = static_cast<double>(ln1b.x - ln1a.x); double dx1 = static_cast<double>(ln1b.x - ln1a.x);
double dy1 = static_cast<double>(ln1b.y - ln1a.y); double dy1 = static_cast<double>(ln1b.y - ln1a.y);
double dx2 = static_cast<double>(ln2b.x - ln2a.x); double dx2 = static_cast<double>(ln2b.x - ln2a.x);
double dy2 = static_cast<double>(ln2b.y - ln2a.y); double dy2 = static_cast<double>(ln2b.y - ln2a.y);
double det = dy1 * dx2 - dy2 * dx1; double det = dy1 * dx2 - dy2 * dx1;
if (det == 0.0) return 0; if (det == 0.0) return false;
double qx = dx1 * ln1a.y - dy1 * ln1a.x; double t = ((ln1a.x - ln2a.x) * dy2 - (ln1a.y - ln2a.y) * dx2) / det;
double qy = dx2 * ln2a.y - dy2 * ln2a.x; if (t <= 0.0) ip = ln1a; // ?? check further (see also #568)
ip.x = CheckCastInt64((dx1 * qy - dx2 * qx) / det); else if (t >= 1.0) ip = ln1b; // ?? check further
ip.y = CheckCastInt64((dy1 * qy - dy2 * qx) / det); else
return (ip.x != INVALID && ip.y != INVALID); {
ip.x = static_cast<int64_t>(ln1a.x + t * dx1);
ip.y = static_cast<int64_t>(ln1a.y + t * dy1);
}
return true;
} }
inline bool SegmentsIntersect(const Point64& seg1a, const Point64& seg1b, inline bool SegmentsIntersect(const Point64& seg1a, const Point64& seg1b,
@ -739,8 +731,9 @@ namespace Clipper2Lib
} }
} }
inline Point64 GetClosestPointOnSegment(const Point64& offPt, template<typename T>
const Point64& seg1, const Point64& seg2) inline Point<T> GetClosestPointOnSegment(const Point<T>& offPt,
const Point<T>& seg1, const Point<T>& seg2)
{ {
if (seg1.x == seg2.x && seg1.y == seg2.y) return seg1; if (seg1.x == seg2.x && seg1.y == seg2.y) return seg1;
double dx = static_cast<double>(seg2.x - seg1.x); double dx = static_cast<double>(seg2.x - seg1.x);
@ -750,9 +743,14 @@ namespace Clipper2Lib
static_cast<double>(offPt.y - seg1.y) * dy) / static_cast<double>(offPt.y - seg1.y) * dy) /
(Sqr(dx) + Sqr(dy)); (Sqr(dx) + Sqr(dy));
if (q < 0) q = 0; else if (q > 1) q = 1; if (q < 0) q = 0; else if (q > 1) q = 1;
return Point64( if constexpr (std::numeric_limits<T>::is_integer)
seg1.x + static_cast<int64_t>(nearbyint(q * dx)), return Point<T>(
seg1.y + static_cast<int64_t>(nearbyint(q * dy))); seg1.x + static_cast<T>(nearbyint(q * dx)),
seg1.y + static_cast<T>(nearbyint(q * dy)));
else
return Point<T>(
seg1.x + static_cast<T>(q * dx),
seg1.y + static_cast<T>(q * dy));
} }
enum class PointInPolygonResult { IsOn, IsInside, IsOutside }; enum class PointInPolygonResult { IsOn, IsInside, IsOutside };

69
thirdparty/clipper2/include/clipper2/clipper.engine.h vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 26 March 2023 * * Date : 22 November 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : This is the main polygon clipping module * * Purpose : This is the main polygon clipping module *
@ -10,9 +10,8 @@
#ifndef CLIPPER_ENGINE_H #ifndef CLIPPER_ENGINE_H
#define CLIPPER_ENGINE_H #define CLIPPER_ENGINE_H
constexpr auto CLIPPER2_VERSION = "1.2.2";
#include <cstdlib> #include <cstdlib>
#include <stdint.h> //#541
#include <iostream> #include <iostream>
#include <queue> #include <queue>
#include <vector> #include <vector>
@ -20,7 +19,7 @@ constexpr auto CLIPPER2_VERSION = "1.2.2";
#include <numeric> #include <numeric>
#include <memory> #include <memory>
#include "clipper.core.h" #include "clipper2/clipper.core.h"
namespace Clipper2Lib { namespace Clipper2Lib {
@ -91,10 +90,11 @@ namespace Clipper2Lib {
OutPt* pts = nullptr; OutPt* pts = nullptr;
PolyPath* polypath = nullptr; PolyPath* polypath = nullptr;
OutRecList* splits = nullptr; OutRecList* splits = nullptr;
OutRec* recursive_split = nullptr;
Rect64 bounds = {}; Rect64 bounds = {};
Path64 path; Path64 path;
bool is_open = false; bool is_open = false;
bool horz_done = false;
~OutRec() { ~OutRec() {
if (splits) delete splits; if (splits) delete splits;
// nb: don't delete the split pointers // nb: don't delete the split pointers
@ -179,6 +179,20 @@ namespace Clipper2Lib {
typedef std::vector<LocalMinima_ptr> LocalMinimaList; typedef std::vector<LocalMinima_ptr> LocalMinimaList;
typedef std::vector<IntersectNode> IntersectNodeList; typedef std::vector<IntersectNode> IntersectNodeList;
// ReuseableDataContainer64 ------------------------------------------------
class ReuseableDataContainer64 {
private:
friend class ClipperBase;
LocalMinimaList minima_list_;
std::vector<Vertex*> vertex_lists_;
void AddLocMin(Vertex& vert, PathType polytype, bool is_open);
public:
virtual ~ReuseableDataContainer64();
void Clear();
void AddPaths(const Paths64& paths, PathType polytype, bool is_open);
};
// ClipperBase ------------------------------------------------------------- // ClipperBase -------------------------------------------------------------
class ClipperBase { class ClipperBase {
@ -235,7 +249,6 @@ namespace Clipper2Lib {
void DoTopOfScanbeam(const int64_t top_y); void DoTopOfScanbeam(const int64_t top_y);
Active *DoMaxima(Active &e); Active *DoMaxima(Active &e);
void JoinOutrecPaths(Active &e1, Active &e2); void JoinOutrecPaths(Active &e1, Active &e2);
void CompleteSplit(OutPt* op1, OutPt* op2, OutRec& outrec);
void FixSelfIntersects(OutRec* outrec); void FixSelfIntersects(OutRec* outrec);
void DoSplitOp(OutRec* outRec, OutPt* splitOp); void DoSplitOp(OutRec* outRec, OutPt* splitOp);
@ -249,6 +262,8 @@ namespace Clipper2Lib {
inline void CheckJoinRight(Active& e, inline void CheckJoinRight(Active& e,
const Point64& pt, bool check_curr_x = false); const Point64& pt, bool check_curr_x = false);
protected: protected:
bool preserve_collinear_ = true;
bool reverse_solution_ = false;
int error_code_ = 0; int error_code_ = 0;
bool has_open_paths_ = false; bool has_open_paths_ = false;
bool succeeded_ = true; bool succeeded_ = true;
@ -256,8 +271,8 @@ namespace Clipper2Lib {
bool ExecuteInternal(ClipType ct, FillRule ft, bool use_polytrees); bool ExecuteInternal(ClipType ct, FillRule ft, bool use_polytrees);
void CleanCollinear(OutRec* outrec); void CleanCollinear(OutRec* outrec);
bool CheckBounds(OutRec* outrec); bool CheckBounds(OutRec* outrec);
bool CheckSplitOwner(OutRec* outrec, OutRecList* splits);
void RecursiveCheckOwners(OutRec* outrec, PolyPath* polypath); void RecursiveCheckOwners(OutRec* outrec, PolyPath* polypath);
void DeepCheckOwners(OutRec* outrec, PolyPath* polypath);
#ifdef USINGZ #ifdef USINGZ
ZCallback64 zCallback_ = nullptr; ZCallback64 zCallback_ = nullptr;
void SetZ(const Active& e1, const Active& e2, Point64& pt); void SetZ(const Active& e1, const Active& e2, Point64& pt);
@ -267,10 +282,13 @@ namespace Clipper2Lib {
void AddPaths(const Paths64& paths, PathType polytype, bool is_open); void AddPaths(const Paths64& paths, PathType polytype, bool is_open);
public: public:
virtual ~ClipperBase(); virtual ~ClipperBase();
int ErrorCode() { return error_code_; }; int ErrorCode() const { return error_code_; };
bool PreserveCollinear = true; void PreserveCollinear(bool val) { preserve_collinear_ = val; };
bool ReverseSolution = false; bool PreserveCollinear() const { return preserve_collinear_;};
void ReverseSolution(bool val) { reverse_solution_ = val; };
bool ReverseSolution() const { return reverse_solution_; };
void Clear(); void Clear();
void AddReuseableData(const ReuseableDataContainer64& reuseable_data);
#ifdef USINGZ #ifdef USINGZ
int64_t DefaultZ = 0; int64_t DefaultZ = 0;
#endif #endif
@ -330,12 +348,12 @@ namespace Clipper2Lib {
childs_.resize(0); childs_.resize(0);
} }
const PolyPath64* operator [] (size_t index) const PolyPath64* operator [] (size_t index) const
{ {
return childs_[index].get(); return childs_[index].get(); //std::unique_ptr
} }
const PolyPath64* Child(size_t index) const PolyPath64* Child(size_t index) const
{ {
return childs_[index].get(); return childs_[index].get();
} }
@ -375,24 +393,24 @@ namespace Clipper2Lib {
class PolyPathD : public PolyPath { class PolyPathD : public PolyPath {
private: private:
PolyPathDList childs_; PolyPathDList childs_;
double inv_scale_; double scale_;
PathD polygon_; PathD polygon_;
public: public:
explicit PolyPathD(PolyPathD* parent = nullptr) : PolyPath(parent) explicit PolyPathD(PolyPathD* parent = nullptr) : PolyPath(parent)
{ {
inv_scale_ = parent ? parent->inv_scale_ : 1.0; scale_ = parent ? parent->scale_ : 1.0;
} }
~PolyPathD() { ~PolyPathD() {
childs_.resize(0); childs_.resize(0);
} }
const PolyPathD* operator [] (size_t index) const PolyPathD* operator [] (size_t index) const
{ {
return childs_[index].get(); return childs_[index].get();
} }
const PolyPathD* Child(size_t index) const PolyPathD* Child(size_t index) const
{ {
return childs_[index].get(); return childs_[index].get();
} }
@ -400,14 +418,23 @@ namespace Clipper2Lib {
PolyPathDList::const_iterator begin() const { return childs_.cbegin(); } PolyPathDList::const_iterator begin() const { return childs_.cbegin(); }
PolyPathDList::const_iterator end() const { return childs_.cend(); } PolyPathDList::const_iterator end() const { return childs_.cend(); }
void SetInvScale(double value) { inv_scale_ = value; } void SetScale(double value) { scale_ = value; }
double InvScale() { return inv_scale_; } double Scale() const { return scale_; }
PolyPathD* AddChild(const Path64& path) override PolyPathD* AddChild(const Path64& path) override
{ {
int error_code = 0; int error_code = 0;
auto p = std::make_unique<PolyPathD>(this); auto p = std::make_unique<PolyPathD>(this);
PolyPathD* result = childs_.emplace_back(std::move(p)).get(); PolyPathD* result = childs_.emplace_back(std::move(p)).get();
result->polygon_ = ScalePath<double, int64_t>(path, inv_scale_, error_code); result->polygon_ = ScalePath<double, int64_t>(path, scale_, error_code);
return result;
}
PolyPathD* AddChild(const PathD& path)
{
auto p = std::make_unique<PolyPathD>(this);
PolyPathD* result = childs_.emplace_back(std::move(p)).get();
result->polygon_ = path;
return result; return result;
} }
@ -595,7 +622,7 @@ namespace Clipper2Lib {
if (ExecuteInternal(clip_type, fill_rule, true)) if (ExecuteInternal(clip_type, fill_rule, true))
{ {
polytree.Clear(); polytree.Clear();
polytree.SetInvScale(invScale_); polytree.SetScale(invScale_);
open_paths.clear(); open_paths.clear();
BuildTreeD(polytree, open_paths); BuildTreeD(polytree, open_paths);
} }

871
thirdparty/clipper2/include/clipper2/clipper.export.h vendored
View File

File diff suppressed because it is too large Load Diff

295
thirdparty/clipper2/include/clipper2/clipper.h vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 23 March 2023 * * Date : 18 November 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : This module provides a simple interface to the Clipper Library * * Purpose : This module provides a simple interface to the Clipper Library *
@ -14,11 +14,11 @@
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include "clipper.core.h" #include "clipper2/clipper.core.h"
#include "clipper.engine.h" #include "clipper2/clipper.engine.h"
#include "clipper.offset.h" #include "clipper2/clipper.offset.h"
#include "clipper.minkowski.h" #include "clipper2/clipper.minkowski.h"
#include "clipper.rectclip.h" #include "clipper2/clipper.rectclip.h"
namespace Clipper2Lib { namespace Clipper2Lib {
@ -161,60 +161,61 @@ namespace Clipper2Lib {
return ScalePaths<double, int64_t>(solution, 1 / scale, error_code); return ScalePaths<double, int64_t>(solution, 1 / scale, error_code);
} }
inline Path64 TranslatePath(const Path64& path, int64_t dx, int64_t dy) template <typename T>
inline Path<T> TranslatePath(const Path<T>& path, T dx, T dy)
{ {
Path64 result; Path<T> result;
result.reserve(path.size()); result.reserve(path.size());
std::transform(path.begin(), path.end(), back_inserter(result), std::transform(path.begin(), path.end(), back_inserter(result),
[dx, dy](const auto& pt) { return Point64(pt.x + dx, pt.y +dy); }); [dx, dy](const auto& pt) { return Point<T>(pt.x + dx, pt.y +dy); });
return result; return result;
} }
inline Path64 TranslatePath(const Path64& path, int64_t dx, int64_t dy)
{
return TranslatePath<int64_t>(path, dx, dy);
}
inline PathD TranslatePath(const PathD& path, double dx, double dy) inline PathD TranslatePath(const PathD& path, double dx, double dy)
{ {
PathD result; return TranslatePath<double>(path, dx, dy);
result.reserve(path.size()); }
std::transform(path.begin(), path.end(), back_inserter(result),
[dx, dy](const auto& pt) { return PointD(pt.x + dx, pt.y + dy); }); template <typename T>
inline Paths<T> TranslatePaths(const Paths<T>& paths, T dx, T dy)
{
Paths<T> result;
result.reserve(paths.size());
std::transform(paths.begin(), paths.end(), back_inserter(result),
[dx, dy](const auto& path) { return TranslatePath(path, dx, dy); });
return result; return result;
} }
inline Paths64 TranslatePaths(const Paths64& paths, int64_t dx, int64_t dy) inline Paths64 TranslatePaths(const Paths64& paths, int64_t dx, int64_t dy)
{ {
Paths64 result; return TranslatePaths<int64_t>(paths, dx, dy);
result.reserve(paths.size());
std::transform(paths.begin(), paths.end(), back_inserter(result),
[dx, dy](const auto& path) { return TranslatePath(path, dx, dy); });
return result;
} }
inline PathsD TranslatePaths(const PathsD& paths, double dx, double dy) inline PathsD TranslatePaths(const PathsD& paths, double dx, double dy)
{ {
PathsD result; return TranslatePaths<double>(paths, dx, dy);
result.reserve(paths.size());
std::transform(paths.begin(), paths.end(), back_inserter(result),
[dx, dy](const auto& path) { return TranslatePath(path, dx, dy); });
return result;
} }
inline Paths64 ExecuteRectClip(const Rect64& rect, inline Paths64 RectClip(const Rect64& rect, const Paths64& paths)
const Paths64& paths, bool convex_only = false)
{ {
if (rect.IsEmpty() || paths.empty()) return Paths64(); if (rect.IsEmpty() || paths.empty()) return Paths64();
RectClip rc(rect); RectClip64 rc(rect);
return rc.Execute(paths, convex_only); return rc.Execute(paths);
} }
inline Paths64 ExecuteRectClip(const Rect64& rect, inline Paths64 RectClip(const Rect64& rect, const Path64& path)
const Path64& path, bool convex_only = false)
{ {
if (rect.IsEmpty() || path.empty()) return Paths64(); if (rect.IsEmpty() || path.empty()) return Paths64();
RectClip rc(rect); RectClip64 rc(rect);
return rc.Execute(Paths64{ path }, convex_only); return rc.Execute(Paths64{ path });
} }
inline PathsD ExecuteRectClip(const RectD& rect, inline PathsD RectClip(const RectD& rect, const PathsD& paths, int precision = 2)
const PathsD& paths, bool convex_only = false, int precision = 2)
{ {
if (rect.IsEmpty() || paths.empty()) return PathsD(); if (rect.IsEmpty() || paths.empty()) return PathsD();
int error_code = 0; int error_code = 0;
@ -222,37 +223,31 @@ namespace Clipper2Lib {
if (error_code) return PathsD(); if (error_code) return PathsD();
const double scale = std::pow(10, precision); const double scale = std::pow(10, precision);
Rect64 r = ScaleRect<int64_t, double>(rect, scale); Rect64 r = ScaleRect<int64_t, double>(rect, scale);
RectClip rc(r); RectClip64 rc(r);
Paths64 pp = ScalePaths<int64_t, double>(paths, scale, error_code); Paths64 pp = ScalePaths<int64_t, double>(paths, scale, error_code);
if (error_code) return PathsD(); // ie: error_code result is lost if (error_code) return PathsD(); // ie: error_code result is lost
return ScalePaths<double, int64_t>( return ScalePaths<double, int64_t>(
rc.Execute(pp, convex_only), 1 / scale, error_code); rc.Execute(pp), 1 / scale, error_code);
} }
inline PathsD ExecuteRectClip(const RectD& rect, inline PathsD RectClip(const RectD& rect, const PathD& path, int precision = 2)
const PathD& path, bool convex_only = false, int precision = 2)
{ {
return ExecuteRectClip(rect, PathsD{ path }, convex_only, precision); return RectClip(rect, PathsD{ path }, precision);
} }
inline Paths64 ExecuteRectClipLines(const Rect64& rect, const Paths64& lines) inline Paths64 RectClipLines(const Rect64& rect, const Paths64& lines)
{ {
if (rect.IsEmpty() || lines.empty()) return Paths64(); if (rect.IsEmpty() || lines.empty()) return Paths64();
RectClipLines rcl(rect); RectClipLines64 rcl(rect);
return rcl.Execute(lines); return rcl.Execute(lines);
} }
inline Paths64 ExecuteRectClipLines(const Rect64& rect, const Path64& line) inline Paths64 RectClipLines(const Rect64& rect, const Path64& line)
{ {
return ExecuteRectClipLines(rect, Paths64{ line }); return RectClipLines(rect, Paths64{ line });
} }
inline PathsD ExecuteRectClipLines(const RectD& rect, const PathD& line, int precision = 2) inline PathsD RectClipLines(const RectD& rect, const PathsD& lines, int precision = 2)
{
return ExecuteRectClip(rect, PathsD{ line }, precision);
}
inline PathsD ExecuteRectClipLines(const RectD& rect, const PathsD& lines, int precision = 2)
{ {
if (rect.IsEmpty() || lines.empty()) return PathsD(); if (rect.IsEmpty() || lines.empty()) return PathsD();
int error_code = 0; int error_code = 0;
@ -260,13 +255,18 @@ namespace Clipper2Lib {
if (error_code) return PathsD(); if (error_code) return PathsD();
const double scale = std::pow(10, precision); const double scale = std::pow(10, precision);
Rect64 r = ScaleRect<int64_t, double>(rect, scale); Rect64 r = ScaleRect<int64_t, double>(rect, scale);
RectClipLines rcl(r); RectClipLines64 rcl(r);
Paths64 p = ScalePaths<int64_t, double>(lines, scale, error_code); Paths64 p = ScalePaths<int64_t, double>(lines, scale, error_code);
if (error_code) return PathsD(); if (error_code) return PathsD();
p = rcl.Execute(p); p = rcl.Execute(p);
return ScalePaths<double, int64_t>(p, 1 / scale, error_code); return ScalePaths<double, int64_t>(p, 1 / scale, error_code);
} }
inline PathsD RectClipLines(const RectD& rect, const PathD& line, int precision = 2)
{
return RectClipLines(rect, PathsD{ line }, precision);
}
namespace details namespace details
{ {
@ -290,14 +290,9 @@ namespace Clipper2Lib {
{ {
// return false if this child isn't fully contained by its parent // return false if this child isn't fully contained by its parent
// the following algorithm is a bit too crude, and doesn't account // checking for a single vertex outside is a bit too crude since
// for rounding errors. A better algorithm is to return false when // it doesn't account for rounding errors. It's better to check
// consecutive vertices are found outside the parent's polygon. // for consecutive vertices found outside the parent's polygon.
//const Path64& path = pp.Polygon();
//if (std::any_of(child->Polygon().cbegin(), child->Polygon().cend(),
// [path](const auto& pt) {return (PointInPolygon(pt, path) ==
// PointInPolygonResult::IsOutside); })) return false;
int outsideCnt = 0; int outsideCnt = 0;
for (const Point64& pt : child->Polygon()) for (const Point64& pt : child->Polygon())
@ -317,74 +312,68 @@ namespace Clipper2Lib {
} }
static void OutlinePolyPath(std::ostream& os, static void OutlinePolyPath(std::ostream& os,
bool isHole, size_t count, const std::string& preamble) size_t idx, bool isHole, size_t count, const std::string& preamble)
{ {
std::string plural = (count == 1) ? "." : "s."; std::string plural = (count == 1) ? "." : "s.";
if (isHole) if (isHole)
{ os << preamble << "+- Hole (" << idx << ") contains " << count <<
if (count) " nested polygon" << plural << std::endl;
os << preamble << "+- Hole with " << count <<
" nested polygon" << plural << std::endl;
else
os << preamble << "+- Hole" << std::endl;
}
else else
{ os << preamble << "+- Polygon (" << idx << ") contains " << count <<
if (count)
os << preamble << "+- Polygon with " << count <<
" hole" << plural << std::endl; " hole" << plural << std::endl;
else
os << preamble << "+- Polygon" << std::endl;
}
} }
static void OutlinePolyPath64(std::ostream& os, const PolyPath64& pp, static void OutlinePolyPath64(std::ostream& os, const PolyPath64& pp,
std::string preamble, bool last_child) size_t idx, std::string preamble)
{ {
OutlinePolyPath(os, pp.IsHole(), pp.Count(), preamble); OutlinePolyPath(os, idx, pp.IsHole(), pp.Count(), preamble);
preamble += (!last_child) ? "| " : " "; for (size_t i = 0; i < pp.Count(); ++i)
if (pp.Count()) if (pp.Child(i)->Count())
{ details::OutlinePolyPath64(os, *pp.Child(i), i, preamble + " ");
PolyPath64List::const_iterator it = pp.begin();
for (; it < pp.end() - 1; ++it)
OutlinePolyPath64(os, **it, preamble, false);
OutlinePolyPath64(os, **it, preamble, true);
}
} }
static void OutlinePolyPathD(std::ostream& os, const PolyPathD& pp, static void OutlinePolyPathD(std::ostream& os, const PolyPathD& pp,
std::string preamble, bool last_child) size_t idx, std::string preamble)
{ {
OutlinePolyPath(os, pp.IsHole(), pp.Count(), preamble); OutlinePolyPath(os, idx, pp.IsHole(), pp.Count(), preamble);
preamble += (!last_child) ? "| " : " "; for (size_t i = 0; i < pp.Count(); ++i)
if (pp.Count()) if (pp.Child(i)->Count())
{ details::OutlinePolyPathD(os, *pp.Child(i), i, preamble + " ");
PolyPathDList::const_iterator it = pp.begin(); }
for (; it < pp.end() - 1; ++it)
OutlinePolyPathD(os, **it, preamble, false); template<typename T, typename U>
OutlinePolyPathD(os, **it, preamble, true); inline constexpr void MakePathGeneric(const T an_array,
} size_t array_size, std::vector<U>& result)
{
result.reserve(array_size / 2);
for (size_t i = 0; i < array_size; i +=2)
#ifdef USINGZ
result.push_back( U{ an_array[i], an_array[i +1], 0} );
#else
result.push_back( U{ an_array[i], an_array[i + 1]} );
#endif
} }
} // end details namespace } // end details namespace
inline std::ostream& operator<< (std::ostream& os, const PolyTree64& pp) inline std::ostream& operator<< (std::ostream& os, const PolyTree64& pp)
{ {
PolyPath64List::const_iterator it = pp.begin(); std::string plural = (pp.Count() == 1) ? " polygon." : " polygons.";
for (; it < pp.end() - 1; ++it) os << std::endl << "Polytree with " << pp.Count() << plural << std::endl;
details::OutlinePolyPath64(os, **it, " ", false); for (size_t i = 0; i < pp.Count(); ++i)
details::OutlinePolyPath64(os, **it, " ", true); if (pp.Child(i)->Count())
details::OutlinePolyPath64(os, *pp.Child(i), i, " ");
os << std::endl << std::endl; os << std::endl << std::endl;
if (!pp.Level()) os << std::endl;
return os; return os;
} }
inline std::ostream& operator<< (std::ostream& os, const PolyTreeD& pp) inline std::ostream& operator<< (std::ostream& os, const PolyTreeD& pp)
{ {
PolyPathDList::const_iterator it = pp.begin(); std::string plural = (pp.Count() == 1) ? " polygon." : " polygons.";
for (; it < pp.end() - 1; ++it) os << std::endl << "Polytree with " << pp.Count() << plural << std::endl;
details::OutlinePolyPathD(os, **it, " ", false); for (size_t i = 0; i < pp.Count(); ++i)
details::OutlinePolyPathD(os, **it, " ", true); if (pp.Child(i)->Count())
details::OutlinePolyPathD(os, *pp.Child(i), i, " ");
os << std::endl << std::endl; os << std::endl << std::endl;
if (!pp.Level()) os << std::endl; if (!pp.Level()) os << std::endl;
return os; return os;
@ -415,22 +404,6 @@ namespace Clipper2Lib {
return true; return true;
} }
namespace details {
template<typename T, typename U>
inline constexpr void MakePathGeneric(const T list, size_t size,
std::vector<U>& result)
{
for (size_t i = 0; i < size; ++i)
#ifdef USINGZ
result[i / 2] = U{list[i], list[++i], 0};
#else
result[i / 2] = U{list[i], list[++i]};
#endif
}
} // end details namespace
template<typename T, template<typename T,
typename std::enable_if< typename std::enable_if<
std::is_integral<T>::value && std::is_integral<T>::value &&
@ -441,7 +414,7 @@ namespace Clipper2Lib {
const auto size = list.size() - list.size() % 2; const auto size = list.size() - list.size() % 2;
if (list.size() != size) if (list.size() != size)
DoError(non_pair_error_i); // non-fatal without exception handling DoError(non_pair_error_i); // non-fatal without exception handling
Path64 result(size / 2); // else ignores unpaired value Path64 result;
details::MakePathGeneric(list, size, result); details::MakePathGeneric(list, size, result);
return result; return result;
} }
@ -455,7 +428,7 @@ namespace Clipper2Lib {
{ {
// Make the compiler error on unpaired value (i.e. no runtime effects). // Make the compiler error on unpaired value (i.e. no runtime effects).
static_assert(N % 2 == 0, "MakePath requires an even number of arguments"); static_assert(N % 2 == 0, "MakePath requires an even number of arguments");
Path64 result(N / 2); Path64 result;
details::MakePathGeneric(list, N, result); details::MakePathGeneric(list, N, result);
return result; return result;
} }
@ -470,7 +443,7 @@ namespace Clipper2Lib {
const auto size = list.size() - list.size() % 2; const auto size = list.size() - list.size() % 2;
if (list.size() != size) if (list.size() != size)
DoError(non_pair_error_i); // non-fatal without exception handling DoError(non_pair_error_i); // non-fatal without exception handling
PathD result(size / 2); // else ignores unpaired value PathD result;
details::MakePathGeneric(list, size, result); details::MakePathGeneric(list, size, result);
return result; return result;
} }
@ -484,11 +457,44 @@ namespace Clipper2Lib {
{ {
// Make the compiler error on unpaired value (i.e. no runtime effects). // Make the compiler error on unpaired value (i.e. no runtime effects).
static_assert(N % 2 == 0, "MakePath requires an even number of arguments"); static_assert(N % 2 == 0, "MakePath requires an even number of arguments");
PathD result(N / 2); PathD result;
details::MakePathGeneric(list, N, result); details::MakePathGeneric(list, N, result);
return result; return result;
} }
#ifdef USINGZ
template<typename T2, std::size_t N>
inline Path64 MakePathZ(const T2(&list)[N])
{
static_assert(N % 3 == 0 && std::numeric_limits<T2>::is_integer,
"MakePathZ requires integer values in multiples of 3");
std::size_t size = N / 3;
Path64 result(size);
for (size_t i = 0; i < size; ++i)
result[i] = Point64(list[i * 3],
list[i * 3 + 1], list[i * 3 + 2]);
return result;
}
template<typename T2, std::size_t N>
inline PathD MakePathZD(const T2(&list)[N])
{
static_assert(N % 3 == 0,
"MakePathZD requires values in multiples of 3");
std::size_t size = N / 3;
PathD result(size);
if constexpr (std::numeric_limits<T2>::is_integer)
for (size_t i = 0; i < size; ++i)
result[i] = PointD(list[i * 3],
list[i * 3 + 1], list[i * 3 + 2]);
else
for (size_t i = 0; i < size; ++i)
result[i] = PointD(list[i * 3], list[i * 3 + 1],
static_cast<int64_t>(list[i * 3 + 2]));
return result;
}
#endif
inline Path64 TrimCollinear(const Path64& p, bool is_open_path = false) inline Path64 TrimCollinear(const Path64& p, bool is_open_path = false)
{ {
size_t len = p.size(); size_t len = p.size();
@ -644,8 +650,8 @@ namespace Clipper2Lib {
} }
template <typename T> template <typename T>
inline Path<T> SimplifyPath(const Path<T> path, inline Path<T> SimplifyPath(const Path<T> &path,
double epsilon, bool isOpenPath = false) double epsilon, bool isClosedPath = true)
{ {
const size_t len = path.size(), high = len -1; const size_t len = path.size(), high = len -1;
const double epsSqr = Sqr(epsilon); const double epsSqr = Sqr(epsilon);
@ -653,17 +659,17 @@ namespace Clipper2Lib {
std::vector<bool> flags(len); std::vector<bool> flags(len);
std::vector<double> distSqr(len); std::vector<double> distSqr(len);
size_t prior = high, curr = 0, start, next, prior2, next2; size_t prior = high, curr = 0, start, next, prior2;
if (isOpenPath) if (isClosedPath)
{
distSqr[0] = MAX_DBL;
distSqr[high] = MAX_DBL;
}
else
{ {
distSqr[0] = PerpendicDistFromLineSqrd(path[0], path[high], path[1]); distSqr[0] = PerpendicDistFromLineSqrd(path[0], path[high], path[1]);
distSqr[high] = PerpendicDistFromLineSqrd(path[high], path[0], path[high - 1]); distSqr[high] = PerpendicDistFromLineSqrd(path[high], path[0], path[high - 1]);
} }
else
{
distSqr[0] = MAX_DBL;
distSqr[high] = MAX_DBL;
}
for (size_t i = 1; i < high; ++i) for (size_t i = 1; i < high; ++i)
distSqr[i] = PerpendicDistFromLineSqrd(path[i], path[i - 1], path[i + 1]); distSqr[i] = PerpendicDistFromLineSqrd(path[i], path[i - 1], path[i + 1]);
@ -683,26 +689,25 @@ namespace Clipper2Lib {
next = GetNext(curr, high, flags); next = GetNext(curr, high, flags);
if (next == prior) break; if (next == prior) break;
// flag for removal the smaller of adjacent 'distances'
if (distSqr[next] < distSqr[curr]) if (distSqr[next] < distSqr[curr])
{ {
flags[next] = true; prior2 = prior;
next = GetNext(next, high, flags); prior = curr;
next2 = GetNext(next, high, flags);
distSqr[curr] = PerpendicDistFromLineSqrd(path[curr], path[prior], path[next]);
if (next != high || !isOpenPath)
distSqr[next] = PerpendicDistFromLineSqrd(path[next], path[curr], path[next2]);
curr = next; curr = next;
next = GetNext(next, high, flags);
} }
else else
{
flags[curr] = true;
curr = next;
next = GetNext(next, high, flags);
prior2 = GetPrior(prior, high, flags); prior2 = GetPrior(prior, high, flags);
flags[curr] = true;
curr = next;
next = GetNext(next, high, flags);
if (isClosedPath || ((curr != high) && (curr != 0)))
distSqr[curr] = PerpendicDistFromLineSqrd(path[curr], path[prior], path[next]); distSqr[curr] = PerpendicDistFromLineSqrd(path[curr], path[prior], path[next]);
if (prior != 0 || !isOpenPath) if (isClosedPath || ((prior != 0) && (prior != high)))
distSqr[prior] = PerpendicDistFromLineSqrd(path[prior], path[prior2], path[curr]); distSqr[prior] = PerpendicDistFromLineSqrd(path[prior], path[prior2], path[curr]);
}
} }
Path<T> result; Path<T> result;
result.reserve(len); result.reserve(len);
@ -712,13 +717,13 @@ namespace Clipper2Lib {
} }
template <typename T> template <typename T>
inline Paths<T> SimplifyPaths(const Paths<T> paths, inline Paths<T> SimplifyPaths(const Paths<T> &paths,
double epsilon, bool isOpenPath = false) double epsilon, bool isClosedPath = true)
{ {
Paths<T> result; Paths<T> result;
result.reserve(paths.size()); result.reserve(paths.size());
for (const auto& path : paths) for (const auto& path : paths)
result.push_back(SimplifyPath(path, epsilon, isOpenPath)); result.push_back(SimplifyPath(path, epsilon, isClosedPath));
return result; return result;
} }

4
thirdparty/clipper2/include/clipper2/clipper.minkowski.h vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 28 January 2023 * * Date : 1 November 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : Minkowski Sum and Difference * * Purpose : Minkowski Sum and Difference *
@ -13,7 +13,7 @@
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>
#include <string> #include <string>
#include "clipper.core.h" #include "clipper2/clipper.core.h"
namespace Clipper2Lib namespace Clipper2Lib
{ {

40
thirdparty/clipper2/include/clipper2/clipper.offset.h vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 22 March 2023 * * Date : 19 November 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : Path Offset (Inflate/Shrink) * * Purpose : Path Offset (Inflate/Shrink) *
@ -15,7 +15,9 @@
namespace Clipper2Lib { namespace Clipper2Lib {
enum class JoinType { Square, Round, Miter }; enum class JoinType { Square, Bevel, Round, Miter };
//Square : Joins are 'squared' at exactly the offset distance (more complex code)
//Bevel : Similar to Square, but the offset distance varies with angle (simple code & faster)
enum class EndType {Polygon, Joined, Butt, Square, Round}; enum class EndType {Polygon, Joined, Butt, Square, Round};
//Butt : offsets both sides of a path, with square blunt ends //Butt : offsets both sides of a path, with square blunt ends
@ -24,6 +26,7 @@ enum class EndType {Polygon, Joined, Butt, Square, Round};
//Joined : offsets both sides of a path, with joined ends //Joined : offsets both sides of a path, with joined ends
//Polygon: offsets only one side of a closed path //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 { class ClipperOffset {
private: private:
@ -31,27 +34,27 @@ private:
class Group { class Group {
public: public:
Paths64 paths_in; Paths64 paths_in;
Paths64 paths_out; std::vector<bool> is_hole_list;
Path64 path; std::vector<Rect64> bounds_list;
int lowest_path_idx = -1;
bool is_reversed = false; bool is_reversed = false;
JoinType join_type; JoinType join_type;
EndType end_type; EndType end_type;
Group(const Paths64& _paths, 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; int error_code_ = 0;
double delta_ = 0.0; double delta_ = 0.0;
double group_delta_ = 0.0; double group_delta_ = 0.0;
double abs_group_delta_ = 0.0;
double temp_lim_ = 0.0; double temp_lim_ = 0.0;
double steps_per_rad_ = 0.0; double steps_per_rad_ = 0.0;
double step_sin_ = 0.0; double step_sin_ = 0.0;
double step_cos_ = 0.0; double step_cos_ = 0.0;
PathD norms; PathD norms;
Path64 path_out;
Paths64 solution; Paths64 solution;
std::vector<Group> groups_; std::vector<Group> groups_;
JoinType join_type_ = JoinType::Square; JoinType join_type_ = JoinType::Bevel;
EndType end_type_ = EndType::Polygon; EndType end_type_ = EndType::Polygon;
double miter_limit_ = 0.0; double miter_limit_ = 0.0;
@ -62,15 +65,19 @@ private:
#ifdef USINGZ #ifdef USINGZ
ZCallback64 zCallback64_ = nullptr; ZCallback64 zCallback64_ = nullptr;
#endif #endif
DeltaCallback64 deltaCallback64_ = nullptr;
void DoSquare(Group& group, const Path64& path, size_t j, size_t k); size_t CalcSolutionCapacity();
void DoMiter(Group& group, const Path64& path, size_t j, size_t k, double cos_a); bool CheckReverseOrientation();
void DoRound(Group& group, const Path64& path, size_t j, size_t k, double angle); void DoBevel(const Path64& path, size_t j, size_t k);
void DoSquare(const Path64& path, size_t j, size_t k);
void DoMiter(const Path64& path, size_t j, size_t k, double cos_a);
void DoRound(const Path64& path, size_t j, size_t k, double angle);
void BuildNormals(const Path64& path); void BuildNormals(const Path64& path);
void OffsetPolygon(Group& group, Path64& path); void OffsetPolygon(Group& group, const Path64& path);
void OffsetOpenJoined(Group& group, Path64& path); void OffsetOpenJoined(Group& group, const Path64& path);
void OffsetOpenPath(Group& group, Path64& path); void OffsetOpenPath(Group& group, const Path64& path);
void OffsetPoint(Group& group, Path64& path, size_t j, size_t& k); void OffsetPoint(Group& group, const Path64& path, size_t j, size_t k);
void DoGroupOffset(Group &group); void DoGroupOffset(Group &group);
void ExecuteInternal(double delta); void ExecuteInternal(double delta);
public: public:
@ -91,6 +98,7 @@ public:
void Execute(double delta, Paths64& paths); void Execute(double delta, Paths64& paths);
void Execute(double delta, PolyTree64& polytree); void Execute(double delta, PolyTree64& polytree);
void Execute(DeltaCallback64 delta_cb, Paths64& paths);
double MiterLimit() const { return miter_limit_; } double MiterLimit() const { return miter_limit_; }
void MiterLimit(double miter_limit) { miter_limit_ = miter_limit; } void MiterLimit(double miter_limit) { miter_limit_ = miter_limit; }
@ -108,6 +116,8 @@ public:
#ifdef USINGZ #ifdef USINGZ
void SetZCallback(ZCallback64 cb) { zCallback64_ = cb; } void SetZCallback(ZCallback64 cb) { zCallback64_ = cb; }
#endif #endif
void SetDeltaCallback(DeltaCallback64 cb) { deltaCallback64_ = cb; }
}; };
} }

19
thirdparty/clipper2/include/clipper2/clipper.rectclip.h vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 9 February 2023 * * Date : 1 November 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : FAST rectangular clipping * * Purpose : FAST rectangular clipping *
@ -13,8 +13,7 @@
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>
#include <queue> #include <queue>
#include "clipper.h" #include "clipper2/clipper.core.h"
#include "clipper.core.h"
namespace Clipper2Lib namespace Clipper2Lib
{ {
@ -34,10 +33,10 @@ namespace Clipper2Lib
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// RectClip // RectClip64
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
class RectClip { class RectClip64 {
private: private:
void ExecuteInternal(const Path64& path); void ExecuteInternal(const Path64& path);
Path64 GetPath(OutPt2*& op); Path64 GetPath(OutPt2*& op);
@ -58,23 +57,23 @@ namespace Clipper2Lib
void AddCorner(Location prev, Location curr); void AddCorner(Location prev, Location curr);
void AddCorner(Location& loc, bool isClockwise); void AddCorner(Location& loc, bool isClockwise);
public: public:
explicit RectClip(const Rect64& rect) : explicit RectClip64(const Rect64& rect) :
rect_(rect), rect_(rect),
rect_as_path_(rect.AsPath()), rect_as_path_(rect.AsPath()),
rect_mp_(rect.MidPoint()) {} rect_mp_(rect.MidPoint()) {}
Paths64 Execute(const Paths64& paths, bool convex_only = false); Paths64 Execute(const Paths64& paths);
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// RectClipLines // RectClipLines64
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
class RectClipLines : public RectClip { class RectClipLines64 : public RectClip64 {
private: private:
void ExecuteInternal(const Path64& path); void ExecuteInternal(const Path64& path);
Path64 GetPath(OutPt2*& op); Path64 GetPath(OutPt2*& op);
public: public:
explicit RectClipLines(const Rect64& rect) : RectClip(rect) {}; explicit RectClipLines64(const Rect64& rect) : RectClip64(rect) {};
Paths64 Execute(const Paths64& paths); Paths64 Execute(const Paths64& paths);
}; };

6
thirdparty/clipper2/include/clipper2/clipper.version.h vendored Normal file
View File

@ -0,0 +1,6 @@
#ifndef CLIPPER_VERSION_H
#define CLIPPER_VERSION_H
constexpr auto CLIPPER2_VERSION = "1.3.0";
#endif // CLIPPER_VERSION_H

11
thirdparty/clipper2/clipper2-exceptions.patch → thirdparty/clipper2/patches/clipper2-exceptions.patch vendored
View File

@ -1,17 +1,17 @@
diff --git a/thirdparty/clipper2/include/clipper2/clipper.core.h b/thirdparty/clipper2/include/clipper2/clipper.core.h diff --git a/thirdparty/clipper2/include/clipper2/clipper.core.h b/thirdparty/clipper2/include/clipper2/clipper.core.h
index c7522cb900..086d1b659c 100644 index b3dddeeaa2..a77cdad5f4 100644
--- a/thirdparty/clipper2/include/clipper2/clipper.core.h --- a/thirdparty/clipper2/include/clipper2/clipper.core.h
+++ b/thirdparty/clipper2/include/clipper2/clipper.core.h +++ b/thirdparty/clipper2/include/clipper2/clipper.core.h
@@ -20,6 +20,8 @@ @@ -21,6 +21,8 @@
#include <climits>
#include <numeric> #include <numeric>
#include "clipper2/clipper.version.h"
+#define CLIPPER2_THROW(exception) std::abort() +#define CLIPPER2_THROW(exception) std::abort()
+ +
namespace Clipper2Lib namespace Clipper2Lib
{ {
@@ -65,16 +67,16 @@ namespace Clipper2Lib @@ -78,18 +80,18 @@ namespace Clipper2Lib
switch (error_code) switch (error_code)
{ {
case precision_error_i: case precision_error_i:
@ -23,6 +23,9 @@ index c7522cb900..086d1b659c 100644
case non_pair_error_i: case non_pair_error_i:
- throw Clipper2Exception(non_pair_error); - throw Clipper2Exception(non_pair_error);
+ CLIPPER2_THROW(Clipper2Exception(non_pair_error)); + CLIPPER2_THROW(Clipper2Exception(non_pair_error));
case undefined_error_i:
- throw Clipper2Exception(undefined_error);
+ CLIPPER2_THROW(Clipper2Exception(undefined_error));
case range_error_i: case range_error_i:
- throw Clipper2Exception(range_error); - throw Clipper2Exception(range_error);
+ CLIPPER2_THROW(Clipper2Exception(range_error)); + CLIPPER2_THROW(Clipper2Exception(range_error));

793
thirdparty/clipper2/src/clipper.engine.cpp vendored
View File

File diff suppressed because it is too large Load Diff

567
thirdparty/clipper2/src/clipper.offset.cpp vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 22 March 2023 * * Date : 28 November 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : Path Offset (Inflate/Shrink) * * Purpose : Path Offset (Inflate/Shrink) *
@ -20,38 +20,63 @@ const double floating_point_tolerance = 1e-12;
// Miscellaneous methods // Miscellaneous methods
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void GetBoundsAndLowestPolyIdx(const Paths64& paths, Rect64& r, int & idx) inline bool ToggleBoolIf(bool val, bool condition)
{ {
idx = -1; return condition ? !val : val;
r = MaxInvalidRect64;
int64_t lpx = 0;
for (int i = 0; i < static_cast<int>(paths.size()); ++i)
for (const Point64& p : paths[i])
{
if (p.y >= r.bottom)
{
if (p.y > r.bottom || p.x < lpx)
{
idx = i;
lpx = p.x;
r.bottom = p.y;
}
}
else if (p.y < r.top) r.top = p.y;
if (p.x > r.right) r.right = p.x;
else if (p.x < r.left) r.left = p.x;
}
//if (idx < 0) r = Rect64(0, 0, 0, 0);
//if (r.top == INT64_MIN) r.bottom = r.top;
//if (r.left == INT64_MIN) r.left = r.right;
} }
bool IsSafeOffset(const Rect64& r, double abs_delta) void GetMultiBounds(const Paths64& paths, std::vector<Rect64>& recList)
{ {
return r.left > min_coord + abs_delta && recList.reserve(paths.size());
r.right < max_coord - abs_delta && for (const Path64& path : paths)
r.top > min_coord + abs_delta && {
r.bottom < max_coord - abs_delta; if (path.size() < 1)
{
recList.push_back(InvalidRect64);
continue;
}
int64_t x = path[0].x, y = path[0].y;
Rect64 r = Rect64(x, y, x, y);
for (const Point64& pt : path)
{
if (pt.y > r.bottom) r.bottom = pt.y;
else if (pt.y < r.top) r.top = pt.y;
if (pt.x > r.right) r.right = pt.x;
else if (pt.x < r.left) r.left = pt.x;
}
recList.push_back(r);
}
}
bool ValidateBounds(std::vector<Rect64>& recList, double delta)
{
int64_t int_delta = static_cast<int64_t>(delta);
int64_t big = MAX_COORD - int_delta;
int64_t small = MIN_COORD + int_delta;
for (const Rect64& r : recList)
{
if (!r.IsValid()) continue; // ignore invalid paths
else if (r.left < small || r.right > big ||
r.top < small || r.bottom > big) return false;
}
return true;
}
int GetLowestClosedPathIdx(std::vector<Rect64>& boundsList)
{
int i = -1, result = -1;
Point64 botPt = Point64(INT64_MAX, INT64_MIN);
for (const Rect64& r : boundsList)
{
++i;
if (!r.IsValid()) continue; // ignore invalid paths
else if (r.bottom > botPt.y || (r.bottom == botPt.y && r.left < botPt.x))
{
botPt = Point64(r.left, r.bottom);
result = static_cast<int>(i);
}
}
return result;
} }
PointD GetUnitNormal(const Point64& pt1, const Point64& pt2) PointD GetUnitNormal(const Point64& pt1, const Point64& pt2)
@ -78,8 +103,7 @@ inline double Hypot(double x, double y)
} }
inline PointD NormalizeVector(const PointD& vec) inline PointD NormalizeVector(const PointD& vec)
{ {
double h = Hypot(vec.x, vec.y); double h = Hypot(vec.x, vec.y);
if (AlmostZero(h)) return PointD(0,0); if (AlmostZero(h)) return PointD(0,0);
double inverseHypot = 1 / h; double inverseHypot = 1 / h;
@ -126,6 +150,44 @@ inline void NegatePath(PathD& path)
} }
} }
//------------------------------------------------------------------------------
// ClipperOffset::Group methods
//------------------------------------------------------------------------------
ClipperOffset::Group::Group(const Paths64& _paths, JoinType _join_type, EndType _end_type):
paths_in(_paths), join_type(_join_type), end_type(_end_type)
{
bool is_joined =
(end_type == EndType::Polygon) ||
(end_type == EndType::Joined);
for (Path64& p: paths_in)
StripDuplicates(p, is_joined);
// get bounds of each path --> bounds_list
GetMultiBounds(paths_in, bounds_list);
if (end_type == EndType::Polygon)
{
is_hole_list.reserve(paths_in.size());
for (const Path64& path : paths_in)
is_hole_list.push_back(Area(path) < 0);
lowest_path_idx = GetLowestClosedPathIdx(bounds_list);
// the lowermost path must be an outer path, so if its orientation is negative,
// then flag the whole group is 'reversed' (will negate delta etc.)
// as this is much more efficient than reversing every path.
is_reversed = (lowest_path_idx >= 0) && is_hole_list[lowest_path_idx];
if (is_reversed) is_hole_list.flip();
}
else
{
lowest_path_idx = -1;
is_reversed = false;
is_hole_list.resize(paths_in.size());
}
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// ClipperOffset methods // ClipperOffset methods
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -148,10 +210,10 @@ void ClipperOffset::BuildNormals(const Path64& path)
norms.clear(); norms.clear();
norms.reserve(path.size()); norms.reserve(path.size());
if (path.size() == 0) return; if (path.size() == 0) return;
Path64::const_iterator path_iter, path_last_iter = --path.cend(); Path64::const_iterator path_iter, path_stop_iter = --path.cend();
for (path_iter = path.cbegin(); path_iter != path_last_iter; ++path_iter) for (path_iter = path.cbegin(); path_iter != path_stop_iter; ++path_iter)
norms.push_back(GetUnitNormal(*path_iter,*(path_iter +1))); norms.push_back(GetUnitNormal(*path_iter,*(path_iter +1)));
norms.push_back(GetUnitNormal(*path_last_iter, *(path.cbegin()))); norms.push_back(GetUnitNormal(*path_stop_iter, *(path.cbegin())));
} }
inline PointD TranslatePoint(const PointD& pt, double dx, double dy) inline PointD TranslatePoint(const PointD& pt, double dx, double dy)
@ -201,19 +263,39 @@ PointD IntersectPoint(const PointD& pt1a, const PointD& pt1b,
} }
} }
void ClipperOffset::DoSquare(Group& group, const Path64& path, size_t j, size_t k) void ClipperOffset::DoBevel(const Path64& path, size_t j, size_t k)
{
PointD pt1, pt2;
if (j == k)
{
double abs_delta = std::abs(group_delta_);
pt1 = PointD(path[j].x - abs_delta * norms[j].x, path[j].y - abs_delta * norms[j].y);
pt2 = PointD(path[j].x + abs_delta * norms[j].x, path[j].y + abs_delta * norms[j].y);
}
else
{
pt1 = PointD(path[j].x + group_delta_ * norms[k].x, path[j].y + group_delta_ * norms[k].y);
pt2 = PointD(path[j].x + group_delta_ * norms[j].x, path[j].y + group_delta_ * norms[j].y);
}
path_out.push_back(Point64(pt1));
path_out.push_back(Point64(pt2));
}
void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
{ {
PointD vec; PointD vec;
if (j == k) if (j == k)
vec = PointD(norms[0].y, -norms[0].x); vec = PointD(norms[j].y, -norms[j].x);
else else
vec = GetAvgUnitVector( vec = GetAvgUnitVector(
PointD(-norms[k].y, norms[k].x), PointD(-norms[k].y, norms[k].x),
PointD(norms[j].y, -norms[j].x)); PointD(norms[j].y, -norms[j].x));
double abs_delta = std::abs(group_delta_);
// now offset the original vertex delta units along unit vector // now offset the original vertex delta units along unit vector
PointD ptQ = PointD(path[j]); PointD ptQ = PointD(path[j]);
ptQ = TranslatePoint(ptQ, abs_group_delta_ * vec.x, abs_group_delta_ * vec.y); ptQ = TranslatePoint(ptQ, abs_delta * vec.x, abs_delta * vec.y);
// get perpendicular vertices // get perpendicular vertices
PointD pt1 = TranslatePoint(ptQ, group_delta_ * vec.y, group_delta_ * -vec.x); PointD pt1 = TranslatePoint(ptQ, group_delta_ * vec.y, group_delta_ * -vec.x);
PointD pt2 = TranslatePoint(ptQ, group_delta_ * -vec.y, group_delta_ * vec.x); PointD pt2 = TranslatePoint(ptQ, group_delta_ * -vec.y, group_delta_ * vec.x);
@ -227,8 +309,8 @@ void ClipperOffset::DoSquare(Group& group, const Path64& path, size_t j, size_t
pt.z = ptQ.z; pt.z = ptQ.z;
#endif #endif
//get the second intersect point through reflecion //get the second intersect point through reflecion
group.path.push_back(Point64(ReflectPoint(pt, ptQ))); path_out.push_back(Point64(ReflectPoint(pt, ptQ)));
group.path.push_back(Point64(pt)); path_out.push_back(Point64(pt));
} }
else else
{ {
@ -237,57 +319,67 @@ void ClipperOffset::DoSquare(Group& group, const Path64& path, size_t j, size_t
#ifdef USINGZ #ifdef USINGZ
pt.z = ptQ.z; pt.z = ptQ.z;
#endif #endif
group.path.push_back(Point64(pt)); path_out.push_back(Point64(pt));
//get the second intersect point through reflecion //get the second intersect point through reflecion
group.path.push_back(Point64(ReflectPoint(pt, ptQ))); path_out.push_back(Point64(ReflectPoint(pt, ptQ)));
} }
} }
void ClipperOffset::DoMiter(Group& group, const Path64& path, size_t j, size_t k, double cos_a) void ClipperOffset::DoMiter(const Path64& path, size_t j, size_t k, double cos_a)
{ {
double q = group_delta_ / (cos_a + 1); double q = group_delta_ / (cos_a + 1);
#ifdef USINGZ #ifdef USINGZ
group.path.push_back(Point64( path_out.push_back(Point64(
path[j].x + (norms[k].x + norms[j].x) * q, path[j].x + (norms[k].x + norms[j].x) * q,
path[j].y + (norms[k].y + norms[j].y) * q, path[j].y + (norms[k].y + norms[j].y) * q,
path[j].z)); path[j].z));
#else #else
group.path.push_back(Point64( path_out.push_back(Point64(
path[j].x + (norms[k].x + norms[j].x) * q, path[j].x + (norms[k].x + norms[j].x) * q,
path[j].y + (norms[k].y + norms[j].y) * q)); path[j].y + (norms[k].y + norms[j].y) * q));
#endif #endif
} }
void ClipperOffset::DoRound(Group& group, const Path64& path, size_t j, size_t k, double angle) void ClipperOffset::DoRound(const Path64& path, size_t j, size_t k, double angle)
{ {
if (deltaCallback64_) {
// when deltaCallback64_ is assigned, group_delta_ won't be constant,
// so we'll need to do the following calculations for *every* vertex.
double abs_delta = std::fabs(group_delta_);
double arcTol = (arc_tolerance_ > floating_point_tolerance ?
std::min(abs_delta, arc_tolerance_) :
std::log10(2 + abs_delta) * default_arc_tolerance);
double steps_per_360 = std::min(PI / std::acos(1 - arcTol / abs_delta), abs_delta * PI);
step_sin_ = std::sin(2 * PI / steps_per_360);
step_cos_ = std::cos(2 * PI / steps_per_360);
if (group_delta_ < 0.0) step_sin_ = -step_sin_;
steps_per_rad_ = steps_per_360 / (2 * PI);
}
Point64 pt = path[j]; Point64 pt = path[j];
PointD offsetVec = PointD(norms[k].x * group_delta_, norms[k].y * group_delta_); PointD offsetVec = PointD(norms[k].x * group_delta_, norms[k].y * group_delta_);
if (j == k) offsetVec.Negate(); if (j == k) offsetVec.Negate();
#ifdef USINGZ #ifdef USINGZ
group.path.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z)); path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z));
#else #else
group.path.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y)); path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y));
#endif #endif
if (angle > -PI + 0.01) // avoid 180deg concave int steps = static_cast<int>(std::ceil(steps_per_rad_ * std::abs(angle))); // #448, #456
for (int i = 1; i < steps; ++i) // ie 1 less than steps
{ {
int steps = static_cast<int>(std::ceil(steps_per_rad_ * std::abs(angle))); // #448, #456 offsetVec = PointD(offsetVec.x * step_cos_ - step_sin_ * offsetVec.y,
for (int i = 1; i < steps; ++i) // ie 1 less than steps offsetVec.x * step_sin_ + offsetVec.y * step_cos_);
{
offsetVec = PointD(offsetVec.x * step_cos_ - step_sin_ * offsetVec.y,
offsetVec.x * step_sin_ + offsetVec.y * step_cos_);
#ifdef USINGZ #ifdef USINGZ
group.path.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z)); path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z));
#else #else
group.path.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y)); path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y));
#endif #endif
}
} }
group.path.push_back(GetPerpendic(path[j], norms[j], group_delta_)); path_out.push_back(GetPerpendic(path[j], norms[j], group_delta_));
} }
void ClipperOffset::OffsetPoint(Group& group, Path64& path, size_t j, size_t& k) void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size_t k)
{ {
// Let A = change in angle where edges join // Let A = change in angle where edges join
// A == 0: ie no change in angle (flat join) // A == 0: ie no change in angle (flat join)
@ -302,50 +394,57 @@ void ClipperOffset::OffsetPoint(Group& group, Path64& path, size_t j, size_t& k)
if (sin_a > 1.0) sin_a = 1.0; if (sin_a > 1.0) sin_a = 1.0;
else if (sin_a < -1.0) sin_a = -1.0; else if (sin_a < -1.0) sin_a = -1.0;
if (cos_a > 0.99) // almost straight - less than 8 degrees if (deltaCallback64_) {
{ group_delta_ = deltaCallback64_(path, norms, j, k);
group.path.push_back(GetPerpendic(path[j], norms[k], group_delta_)); if (group.is_reversed) group_delta_ = -group_delta_;
if (cos_a < 0.9998) // greater than 1 degree (#424)
group.path.push_back(GetPerpendic(path[j], norms[j], group_delta_)); // (#418)
} }
else if (cos_a > -0.99 && (sin_a * group_delta_ < 0)) if (std::fabs(group_delta_) <= floating_point_tolerance)
{
path_out.push_back(path[j]);
return;
}
if (cos_a > -0.99 && (sin_a * group_delta_ < 0)) // test for concavity first (#593)
{ {
// is concave // is concave
group.path.push_back(GetPerpendic(path[j], norms[k], group_delta_)); path_out.push_back(GetPerpendic(path[j], norms[k], group_delta_));
// this extra point is the only (simple) way to ensure that // this extra point is the only (simple) way to ensure that
// path reversals are fully cleaned with the trailing clipper // path reversals are fully cleaned with the trailing clipper
group.path.push_back(path[j]); // (#405) path_out.push_back(path[j]); // (#405)
group.path.push_back(GetPerpendic(path[j], norms[j], group_delta_)); path_out.push_back(GetPerpendic(path[j], norms[j], group_delta_));
} }
else if (join_type_ == JoinType::Round) else if (cos_a > 0.999 && join_type_ != JoinType::Round)
DoRound(group, path, j, k, std::atan2(sin_a, cos_a)); {
// almost straight - less than 2.5 degree (#424, #482, #526 & #724)
DoMiter(path, j, k, cos_a);
}
else if (join_type_ == JoinType::Miter) else if (join_type_ == JoinType::Miter)
{ {
// miter unless the angle is so acute the miter would exceeds ML // miter unless the angle is sufficiently acute to exceed ML
if (cos_a > temp_lim_ - 1) DoMiter(group, path, j, k, cos_a); if (cos_a > temp_lim_ - 1) DoMiter(path, j, k, cos_a);
else DoSquare(group, path, j, k); else DoSquare(path, j, k);
} }
// don't bother squaring angles that deviate < ~20 degrees because else if (join_type_ == JoinType::Round)
// squaring will be indistinguishable from mitering and just be a lot slower DoRound(path, j, k, std::atan2(sin_a, cos_a));
else if (cos_a > 0.9) else if ( join_type_ == JoinType::Bevel)
DoMiter(group, path, j, k, cos_a); DoBevel(path, j, k);
else else
DoSquare(group, path, j, k); DoSquare(path, j, k);
k = j;
} }
void ClipperOffset::OffsetPolygon(Group& group, Path64& path) void ClipperOffset::OffsetPolygon(Group& group, const Path64& path)
{ {
for (Path64::size_type i = 0, j = path.size() -1; i < path.size(); j = i, ++i) path_out.clear();
OffsetPoint(group, path, i, j); for (Path64::size_type j = 0, k = path.size() -1; j < path.size(); k = j, ++j)
group.paths_out.push_back(group.path); OffsetPoint(group, path, j, k);
solution.push_back(path_out);
} }
void ClipperOffset::OffsetOpenJoined(Group& group, Path64& path) void ClipperOffset::OffsetOpenJoined(Group& group, const Path64& path)
{ {
OffsetPolygon(group, path); OffsetPolygon(group, path);
std::reverse(path.begin(), path.end()); Path64 reverse_path(path);
std::reverse(reverse_path.begin(), reverse_path.end());
//rebuild normals // BuildNormals(path); //rebuild normals // BuildNormals(path);
std::reverse(norms.begin(), norms.end()); std::reverse(norms.begin(), norms.end());
@ -353,41 +452,36 @@ void ClipperOffset::OffsetOpenJoined(Group& group, Path64& path)
norms.erase(norms.begin()); norms.erase(norms.begin());
NegatePath(norms); NegatePath(norms);
group.path.clear(); OffsetPolygon(group, reverse_path);
OffsetPolygon(group, path);
} }
void ClipperOffset::OffsetOpenPath(Group& group, Path64& path) void ClipperOffset::OffsetOpenPath(Group& group, const Path64& path)
{ {
// do the line start cap // do the line start cap
switch (end_type_) if (deltaCallback64_) group_delta_ = deltaCallback64_(path, norms, 0, 0);
if (std::fabs(group_delta_) <= floating_point_tolerance)
path_out.push_back(path[0]);
else
{ {
case EndType::Butt: switch (end_type_)
#ifdef USINGZ {
group.path.push_back(Point64( case EndType::Butt:
path[0].x - norms[0].x * group_delta_, DoBevel(path, 0, 0);
path[0].y - norms[0].y * group_delta_, break;
path[0].z)); case EndType::Round:
#else DoRound(path, 0, 0, PI);
group.path.push_back(Point64( break;
path[0].x - norms[0].x * group_delta_, default:
path[0].y - norms[0].y * group_delta_)); DoSquare(path, 0, 0);
#endif break;
group.path.push_back(GetPerpendic(path[0], norms[0], group_delta_)); }
break;
case EndType::Round:
DoRound(group, path, 0,0, PI);
break;
default:
DoSquare(group, path, 0, 0);
break;
} }
size_t highI = path.size() - 1; size_t highI = path.size() - 1;
// offset the left side going forward // offset the left side going forward
for (Path64::size_type i = 1, k = 0; i < highI; ++i) for (Path64::size_type j = 1, k = 0; j < highI; k = j, ++j)
OffsetPoint(group, path, i, k); OffsetPoint(group, path, j, k);
// reverse normals // reverse normals
for (size_t i = highI; i > 0; --i) for (size_t i = highI; i > 0; --i)
@ -395,60 +489,46 @@ void ClipperOffset::OffsetOpenPath(Group& group, Path64& path)
norms[0] = norms[highI]; norms[0] = norms[highI];
// do the line end cap // do the line end cap
switch (end_type_) if (deltaCallback64_)
group_delta_ = deltaCallback64_(path, norms, highI, highI);
if (std::fabs(group_delta_) <= floating_point_tolerance)
path_out.push_back(path[highI]);
else
{ {
case EndType::Butt: switch (end_type_)
#ifdef USINGZ {
group.path.push_back(Point64( case EndType::Butt:
path[highI].x - norms[highI].x * group_delta_, DoBevel(path, highI, highI);
path[highI].y - norms[highI].y * group_delta_, break;
path[highI].z)); case EndType::Round:
#else DoRound(path, highI, highI, PI);
group.path.push_back(Point64( break;
path[highI].x - norms[highI].x * group_delta_, default:
path[highI].y - norms[highI].y * group_delta_)); DoSquare(path, highI, highI);
#endif break;
group.path.push_back(GetPerpendic(path[highI], norms[highI], group_delta_)); }
break;
case EndType::Round:
DoRound(group, path, highI, highI, PI);
break;
default:
DoSquare(group, path, highI, highI);
break;
} }
for (size_t i = highI, k = 0; i > 0; --i) for (size_t j = highI, k = 0; j > 0; k = j, --j)
OffsetPoint(group, path, i, k); OffsetPoint(group, path, j, k);
group.paths_out.push_back(group.path); solution.push_back(path_out);
} }
void ClipperOffset::DoGroupOffset(Group& group) void ClipperOffset::DoGroupOffset(Group& group)
{ {
Rect64 r;
int idx = -1;
//the lowermost polygon must be an outer polygon. So we can use that as the
//designated orientation for outer polygons (needed for tidy-up clipping)
GetBoundsAndLowestPolyIdx(group.paths_in, r, idx);
if (idx < 0) return;
if (group.end_type == EndType::Polygon) if (group.end_type == EndType::Polygon)
{ {
double area = Area(group.paths_in[idx]); // a straight path (2 points) can now also be 'polygon' offset
//if (area == 0) return; // probably unhelpful (#430) // where the ends will be treated as (180 deg.) joins
group.is_reversed = (area < 0); if (group.lowest_path_idx < 0) delta_ = std::abs(delta_);
if (group.is_reversed) group_delta_ = -delta_; group_delta_ = (group.is_reversed) ? -delta_ : delta_;
else group_delta_ = delta_;
}
else
{
group.is_reversed = false;
group_delta_ = std::abs(delta_) * 0.5;
} }
abs_group_delta_ = std::fabs(group_delta_); else
group_delta_ = std::abs(delta_);// *0.5;
// do range checking double abs_delta = std::fabs(group_delta_);
if (!IsSafeOffset(r, abs_group_delta_)) if (!ValidateBounds(group.bounds_list, abs_delta))
{ {
DoError(range_error_i); DoError(range_error_i);
error_code_ |= range_error_i; error_code_ |= range_error_i;
@ -458,80 +538,98 @@ void ClipperOffset::DoGroupOffset(Group& group)
join_type_ = group.join_type; join_type_ = group.join_type;
end_type_ = group.end_type; end_type_ = group.end_type;
//calculate a sensible number of steps (for 360 deg for the given offset
if (group.join_type == JoinType::Round || group.end_type == EndType::Round) if (group.join_type == JoinType::Round || group.end_type == EndType::Round)
{ {
// calculate a sensible number of steps (for 360 deg for the given offset)
// arcTol - when arc_tolerance_ is undefined (0), the amount of // arcTol - when arc_tolerance_ is undefined (0), the amount of
// curve imprecision that's allowed is based on the size of the // curve imprecision that's allowed is based on the size of the
// offset (delta). Obviously very large offsets will almost always // offset (delta). Obviously very large offsets will almost always
// require much less precision. See also offset_triginometry2.svg // require much less precision. See also offset_triginometry2.svg
double arcTol = (arc_tolerance_ > floating_point_tolerance ? double arcTol = (arc_tolerance_ > floating_point_tolerance ?
std::min(abs_group_delta_, arc_tolerance_) : std::min(abs_delta, arc_tolerance_) :
std::log10(2 + abs_group_delta_) * default_arc_tolerance); std::log10(2 + abs_delta) * default_arc_tolerance);
double steps_per_360 = PI / std::acos(1 - arcTol / abs_group_delta_);
if (steps_per_360 > abs_group_delta_ * PI)
steps_per_360 = abs_group_delta_ * PI; //ie avoids excessive precision
double steps_per_360 = std::min(PI / std::acos(1 - arcTol / abs_delta), abs_delta * PI);
step_sin_ = std::sin(2 * PI / steps_per_360); step_sin_ = std::sin(2 * PI / steps_per_360);
step_cos_ = std::cos(2 * PI / steps_per_360); step_cos_ = std::cos(2 * PI / steps_per_360);
if (group_delta_ < 0.0) step_sin_ = -step_sin_; if (group_delta_ < 0.0) step_sin_ = -step_sin_;
steps_per_rad_ = steps_per_360 / (2 *PI); steps_per_rad_ = steps_per_360 / (2 * PI);
} }
bool is_joined = std::vector<Rect64>::const_iterator path_rect_it = group.bounds_list.cbegin();
(end_type_ == EndType::Polygon) || std::vector<bool>::const_iterator is_hole_it = group.is_hole_list.cbegin();
(end_type_ == EndType::Joined); Paths64::const_iterator path_in_it = group.paths_in.cbegin();
Paths64::const_iterator path_iter; for ( ; path_in_it != group.paths_in.cend(); ++path_in_it, ++path_rect_it, ++is_hole_it)
for(path_iter = group.paths_in.cbegin(); path_iter != group.paths_in.cend(); ++path_iter)
{ {
Path64 path = StripDuplicates(*path_iter, is_joined); if (!path_rect_it->IsValid()) continue;
Path64::size_type cnt = path.size(); Path64::size_type pathLen = path_in_it->size();
if (cnt == 0 || ((cnt < 3) && group.end_type == EndType::Polygon)) path_out.clear();
continue;
group.path.clear(); if (pathLen == 1) // single point
if (cnt == 1) // single point - only valid with open paths
{ {
if (group_delta_ < 1) continue; if (group_delta_ < 1) continue;
const Point64& pt = (*path_in_it)[0];
//single vertex so build a circle or square ... //single vertex so build a circle or square ...
if (group.join_type == JoinType::Round) if (group.join_type == JoinType::Round)
{ {
double radius = abs_group_delta_; double radius = abs_delta;
group.path = Ellipse(path[0], radius, radius); int steps = static_cast<int>(std::ceil(steps_per_rad_ * 2 * PI)); //#617
path_out = Ellipse(pt, radius, radius, steps);
#ifdef USINGZ #ifdef USINGZ
for (auto& p : group.path) p.z = path[0].z; for (auto& p : path_out) p.z = pt.z;
#endif #endif
} }
else else
{ {
int d = (int)std::ceil(abs_group_delta_); int d = (int)std::ceil(abs_delta);
r = Rect64(path[0].x - d, path[0].y - d, path[0].x + d, path[0].y + d); Rect64 r = Rect64(pt.x - d, pt.y - d, pt.x + d, pt.y + d);
group.path = r.AsPath(); path_out = r.AsPath();
#ifdef USINGZ #ifdef USINGZ
for (auto& p : group.path) p.z = path[0].z; for (auto& p : path_out) p.z = pt.z;
#endif #endif
} }
group.paths_out.push_back(group.path); solution.push_back(path_out);
} continue;
else } // end of offsetting a single point
{
if ((cnt == 2) && (group.end_type == EndType::Joined))
{
if (group.join_type == JoinType::Round)
end_type_ = EndType::Round;
else
end_type_ = EndType::Square;
}
BuildNormals(path); // when shrinking outer paths, make sure they can shrink this far (#593)
if (end_type_ == EndType::Polygon) OffsetPolygon(group, path); // also when shrinking holes, make sure they too can shrink this far (#715)
else if (end_type_ == EndType::Joined) OffsetOpenJoined(group, path); if ((group_delta_ > 0) == ToggleBoolIf(*is_hole_it, group.is_reversed) &&
else OffsetOpenPath(group, path); (std::min(path_rect_it->Width(), path_rect_it->Height()) <= -group_delta_ * 2) )
} continue;
if ((pathLen == 2) && (group.end_type == EndType::Joined))
end_type_ = (group.join_type == JoinType::Round) ?
EndType::Round :
EndType::Square;
BuildNormals(*path_in_it);
if (end_type_ == EndType::Polygon) OffsetPolygon(group, *path_in_it);
else if (end_type_ == EndType::Joined) OffsetOpenJoined(group, *path_in_it);
else OffsetOpenPath(group, *path_in_it);
} }
solution.reserve(solution.size() + group.paths_out.size()); }
copy(group.paths_out.begin(), group.paths_out.end(), back_inserter(solution));
group.paths_out.clear();
size_t ClipperOffset::CalcSolutionCapacity()
{
size_t result = 0;
for (const Group& g : groups_)
result += (g.end_type == EndType::Joined) ? g.paths_in.size() * 2 : g.paths_in.size();
return result;
}
bool ClipperOffset::CheckReverseOrientation()
{
// nb: this assumes there's consistency in orientation between groups
bool is_reversed_orientation = false;
for (const Group& g : groups_)
if (g.end_type == EndType::Polygon)
{
is_reversed_orientation = g.is_reversed;
break;
}
return is_reversed_orientation;
} }
void ClipperOffset::ExecuteInternal(double delta) void ClipperOffset::ExecuteInternal(double delta)
@ -539,29 +637,29 @@ void ClipperOffset::ExecuteInternal(double delta)
error_code_ = 0; error_code_ = 0;
solution.clear(); solution.clear();
if (groups_.size() == 0) return; if (groups_.size() == 0) return;
solution.reserve(CalcSolutionCapacity());
if (std::abs(delta) < 0.5) if (std::abs(delta) < 0.5) // ie: offset is insignificant
{ {
Paths64::size_type sol_size = 0;
for (const Group& group : groups_) sol_size += group.paths_in.size();
solution.reserve(sol_size);
for (const Group& group : groups_) for (const Group& group : groups_)
{
solution.reserve(solution.size() + group.paths_in.size());
copy(group.paths_in.begin(), group.paths_in.end(), back_inserter(solution)); copy(group.paths_in.begin(), group.paths_in.end(), back_inserter(solution));
} return;
} }
else
{
temp_lim_ = (miter_limit_ <= 1) ?
2.0 :
2.0 / (miter_limit_ * miter_limit_);
delta_ = delta; temp_lim_ = (miter_limit_ <= 1) ?
std::vector<Group>::iterator git; 2.0 :
for (git = groups_.begin(); git != groups_.end(); ++git) 2.0 / (miter_limit_ * miter_limit_);
{
DoGroupOffset(*git); delta_ = delta;
if (!error_code_) continue; // all OK std::vector<Group>::iterator git;
solution.clear(); for (git = groups_.begin(); git != groups_.end(); ++git)
} {
DoGroupOffset(*git);
if (!error_code_) continue; // all OK
solution.clear();
} }
} }
@ -572,19 +670,17 @@ void ClipperOffset::Execute(double delta, Paths64& paths)
ExecuteInternal(delta); ExecuteInternal(delta);
if (!solution.size()) return; if (!solution.size()) return;
paths = solution; bool paths_reversed = CheckReverseOrientation();
//clean up self-intersections ... //clean up self-intersections ...
Clipper64 c; Clipper64 c;
c.PreserveCollinear = false; c.PreserveCollinear(false);
//the solution should retain the orientation of the input //the solution should retain the orientation of the input
c.ReverseSolution = reverse_solution_ != groups_[0].is_reversed; c.ReverseSolution(reverse_solution_ != paths_reversed);
#ifdef USINGZ #ifdef USINGZ
if (zCallback64_) { if (zCallback64_) { c.SetZCallback(zCallback64_); }
c.SetZCallback(zCallback64_);
}
#endif #endif
c.AddSubject(solution); c.AddSubject(solution);
if (groups_[0].is_reversed) if (paths_reversed)
c.Execute(ClipType::Union, FillRule::Negative, paths); c.Execute(ClipType::Union, FillRule::Negative, paths);
else else
c.Execute(ClipType::Union, FillRule::Positive, paths); c.Execute(ClipType::Union, FillRule::Positive, paths);
@ -598,21 +694,30 @@ void ClipperOffset::Execute(double delta, PolyTree64& polytree)
ExecuteInternal(delta); ExecuteInternal(delta);
if (!solution.size()) return; if (!solution.size()) return;
bool paths_reversed = CheckReverseOrientation();
//clean up self-intersections ... //clean up self-intersections ...
Clipper64 c; Clipper64 c;
c.PreserveCollinear = false; c.PreserveCollinear(false);
//the solution should retain the orientation of the input //the solution should retain the orientation of the input
c.ReverseSolution = reverse_solution_ != groups_[0].is_reversed; c.ReverseSolution (reverse_solution_ != paths_reversed);
#ifdef USINGZ #ifdef USINGZ
if (zCallback64_) { if (zCallback64_) {
c.SetZCallback(zCallback64_); c.SetZCallback(zCallback64_);
} }
#endif #endif
c.AddSubject(solution); c.AddSubject(solution);
if (groups_[0].is_reversed)
if (paths_reversed)
c.Execute(ClipType::Union, FillRule::Negative, polytree); c.Execute(ClipType::Union, FillRule::Negative, polytree);
else else
c.Execute(ClipType::Union, FillRule::Positive, polytree); c.Execute(ClipType::Union, FillRule::Positive, polytree);
} }
void ClipperOffset::Execute(DeltaCallback64 delta_cb, Paths64& paths)
{
deltaCallback64_ = delta_cb;
Execute(1.0, paths);
}
} // namespace } // namespace

179
thirdparty/clipper2/src/clipper.rectclip.cpp vendored
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 14 February 2023 * * Date : 8 September 2023 *
* Website : http://www.angusj.com * * Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : FAST rectangular clipping * * Purpose : FAST rectangular clipping *
@ -24,11 +24,11 @@ namespace Clipper2Lib {
for (const Point64& pt : path2) for (const Point64& pt : path2)
{ {
PointInPolygonResult pip = PointInPolygon(pt, path1); PointInPolygonResult pip = PointInPolygon(pt, path1);
switch (pip) switch (pip)
{ {
case PointInPolygonResult::IsOutside: ++io_count; break; case PointInPolygonResult::IsOutside: ++io_count; break;
case PointInPolygonResult::IsInside: --io_count; break; case PointInPolygonResult::IsInside: --io_count; break;
default: continue; default: continue;
} }
if (std::abs(io_count) > 1) break; if (std::abs(io_count) > 1) break;
} }
@ -66,6 +66,56 @@ namespace Clipper2Lib {
return true; return true;
} }
inline bool IsHorizontal(const Point64& pt1, const Point64& pt2)
{
return pt1.y == pt2.y;
}
inline bool GetSegmentIntersection(const Point64& p1,
const Point64& p2, const Point64& p3, const Point64& p4, Point64& ip)
{
double res1 = CrossProduct(p1, p3, p4);
double res2 = CrossProduct(p2, p3, p4);
if (res1 == 0)
{
ip = p1;
if (res2 == 0) return false; // segments are collinear
else if (p1 == p3 || p1 == p4) return true;
//else if (p2 == p3 || p2 == p4) { ip = p2; return true; }
else if (IsHorizontal(p3, p4)) return ((p1.x > p3.x) == (p1.x < p4.x));
else return ((p1.y > p3.y) == (p1.y < p4.y));
}
else if (res2 == 0)
{
ip = p2;
if (p2 == p3 || p2 == p4) return true;
else if (IsHorizontal(p3, p4)) return ((p2.x > p3.x) == (p2.x < p4.x));
else return ((p2.y > p3.y) == (p2.y < p4.y));
}
if ((res1 > 0) == (res2 > 0)) return false;
double res3 = CrossProduct(p3, p1, p2);
double res4 = CrossProduct(p4, p1, p2);
if (res3 == 0)
{
ip = p3;
if (p3 == p1 || p3 == p2) return true;
else if (IsHorizontal(p1, p2)) return ((p3.x > p1.x) == (p3.x < p2.x));
else return ((p3.y > p1.y) == (p3.y < p2.y));
}
else if (res4 == 0)
{
ip = p4;
if (p4 == p1 || p4 == p2) return true;
else if (IsHorizontal(p1, p2)) return ((p4.x > p1.x) == (p4.x < p2.x));
else return ((p4.y > p1.y) == (p4.y < p2.y));
}
if ((res3 > 0) == (res4 > 0)) return false;
// segments must intersect to get here
return GetIntersectPoint(p1, p2, p3, p4, ip);
}
inline bool GetIntersection(const Path64& rectPath, inline bool GetIntersection(const Path64& rectPath,
const Point64& p, const Point64& p2, Location& loc, Point64& ip) const Point64& p, const Point64& p2, Location& loc, Point64& ip)
{ {
@ -74,100 +124,84 @@ namespace Clipper2Lib {
switch (loc) switch (loc)
{ {
case Location::Left: case Location::Left:
if (SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true)) if (GetSegmentIntersection(p, p2, rectPath[0], rectPath[3], ip)) return true;
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip); else if ((p.y < rectPath[0].y) && GetSegmentIntersection(p, p2, rectPath[0], rectPath[1], ip))
else if (p.y < rectPath[0].y &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true))
{ {
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip);
loc = Location::Top; loc = Location::Top;
return true;
} }
else if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true)) else if (GetSegmentIntersection(p, p2, rectPath[2], rectPath[3], ip))
{ {
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip);
loc = Location::Bottom; loc = Location::Bottom;
return true;
} }
else return false; else return false;
break;
case Location::Top: case Location::Top:
if (SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true)) if (GetSegmentIntersection(p, p2, rectPath[0], rectPath[1], ip)) return true;
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip); else if ((p.x < rectPath[0].x) && GetSegmentIntersection(p, p2, rectPath[0], rectPath[3], ip))
else if (p.x < rectPath[0].x &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true))
{ {
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip);
loc = Location::Left; loc = Location::Left;
return true;
} }
else if (p.x > rectPath[1].x && else if (GetSegmentIntersection(p, p2, rectPath[1], rectPath[2], ip))
SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true))
{ {
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip);
loc = Location::Right; loc = Location::Right;
return true;
} }
else return false; else return false;
break;
case Location::Right: case Location::Right:
if (SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true)) if (GetSegmentIntersection(p, p2, rectPath[1], rectPath[2], ip)) return true;
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip); else if ((p.y < rectPath[1].y) && GetSegmentIntersection(p, p2, rectPath[0], rectPath[1], ip))
else if (p.y < rectPath[0].y &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true))
{ {
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip);
loc = Location::Top; loc = Location::Top;
return true;
} }
else if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true)) else if (GetSegmentIntersection(p, p2, rectPath[2], rectPath[3], ip))
{ {
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip);
loc = Location::Bottom; loc = Location::Bottom;
return true;
} }
else return false; else return false;
break;
case Location::Bottom: case Location::Bottom:
if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true)) if (GetSegmentIntersection(p, p2, rectPath[2], rectPath[3], ip)) return true;
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip); else if ((p.x < rectPath[3].x) && GetSegmentIntersection(p, p2, rectPath[0], rectPath[3], ip))
else if (p.x < rectPath[3].x &&
SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true))
{ {
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip);
loc = Location::Left; loc = Location::Left;
return true;
} }
else if (p.x > rectPath[2].x && else if (GetSegmentIntersection(p, p2, rectPath[1], rectPath[2], ip))
SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true))
{ {
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip);
loc = Location::Right; loc = Location::Right;
return true;
} }
else return false; else return false;
break;
default: // loc == rInside default: // loc == rInside
if (SegmentsIntersect(p, p2, rectPath[0], rectPath[3], true)) if (GetSegmentIntersection(p, p2, rectPath[0], rectPath[3], ip))
{ {
GetIntersectPoint(p, p2, rectPath[0], rectPath[3], ip);
loc = Location::Left; loc = Location::Left;
return true;
} }
else if (SegmentsIntersect(p, p2, rectPath[0], rectPath[1], true)) else if (GetSegmentIntersection(p, p2, rectPath[0], rectPath[1], ip))
{ {
GetIntersectPoint(p, p2, rectPath[0], rectPath[1], ip);
loc = Location::Top; loc = Location::Top;
return true;
} }
else if (SegmentsIntersect(p, p2, rectPath[1], rectPath[2], true)) else if (GetSegmentIntersection(p, p2, rectPath[1], rectPath[2], ip))
{ {
GetIntersectPoint(p, p2, rectPath[1], rectPath[2], ip);
loc = Location::Right; loc = Location::Right;
return true;
} }
else if (SegmentsIntersect(p, p2, rectPath[2], rectPath[3], true)) else if (GetSegmentIntersection(p, p2, rectPath[2], rectPath[3], ip))
{ {
GetIntersectPoint(p, p2, rectPath[2], rectPath[3], ip);
loc = Location::Bottom; loc = Location::Bottom;
return true;
} }
else return false; else return false;
break;
} }
return true;
} }
inline Location GetAdjacentLocation(Location loc, bool isClockwise) inline Location GetAdjacentLocation(Location loc, bool isClockwise)
@ -281,7 +315,7 @@ namespace Clipper2Lib {
// RectClip64 // RectClip64
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
OutPt2* RectClip::Add(Point64 pt, bool start_new) OutPt2* RectClip64::Add(Point64 pt, bool start_new)
{ {
// this method is only called by InternalExecute. // this method is only called by InternalExecute.
// Later splitting & rejoining won't create additional op's, // Later splitting & rejoining won't create additional op's,
@ -312,7 +346,7 @@ namespace Clipper2Lib {
return result; return result;
} }
void RectClip::AddCorner(Location prev, Location curr) void RectClip64::AddCorner(Location prev, Location curr)
{ {
if (HeadingClockwise(prev, curr)) if (HeadingClockwise(prev, curr))
Add(rect_as_path_[static_cast<int>(prev)]); Add(rect_as_path_[static_cast<int>(prev)]);
@ -320,7 +354,7 @@ namespace Clipper2Lib {
Add(rect_as_path_[static_cast<int>(curr)]); Add(rect_as_path_[static_cast<int>(curr)]);
} }
void RectClip::AddCorner(Location& loc, bool isClockwise) void RectClip64::AddCorner(Location& loc, bool isClockwise)
{ {
if (isClockwise) if (isClockwise)
{ {
@ -334,7 +368,7 @@ namespace Clipper2Lib {
} }
} }
void RectClip::GetNextLocation(const Path64& path, void RectClip64::GetNextLocation(const Path64& path,
Location& loc, int& i, int highI) Location& loc, int& i, int highI)
{ {
switch (loc) switch (loc)
@ -389,7 +423,7 @@ namespace Clipper2Lib {
} //switch } //switch
} }
void RectClip::ExecuteInternal(const Path64& path) void RectClip64::ExecuteInternal(const Path64& path)
{ {
int i = 0, highI = static_cast<int>(path.size()) - 1; int i = 0, highI = static_cast<int>(path.size()) - 1;
Location prev = Location::Inside, loc; Location prev = Location::Inside, loc;
@ -474,7 +508,7 @@ namespace Clipper2Lib {
// intersect pt but we'll also need the first intersect pt (ip2) // intersect pt but we'll also need the first intersect pt (ip2)
loc = prev; loc = prev;
GetIntersection(rect_as_path_, prev_pt, path[i], loc, ip2); GetIntersection(rect_as_path_, prev_pt, path[i], loc, ip2);
if (crossing_prev != Location::Inside) if (crossing_prev != Location::Inside && crossing_prev != loc) //579
AddCorner(crossing_prev, loc); AddCorner(crossing_prev, loc);
if (first_cross_ == Location::Inside) if (first_cross_ == Location::Inside)
@ -546,7 +580,7 @@ namespace Clipper2Lib {
} }
} }
void RectClip::CheckEdges() void RectClip64::CheckEdges()
{ {
for (size_t i = 0; i < results_.size(); ++i) for (size_t i = 0; i < results_.size(); ++i)
{ {
@ -606,7 +640,7 @@ namespace Clipper2Lib {
} }
} }
void RectClip::TidyEdges(int idx, OutPt2List& cw, OutPt2List& ccw) void RectClip64::TidyEdges(int idx, OutPt2List& cw, OutPt2List& ccw)
{ {
if (ccw.empty()) return; if (ccw.empty()) return;
bool isHorz = ((idx == 1) || (idx == 3)); bool isHorz = ((idx == 1) || (idx == 3));
@ -619,7 +653,7 @@ namespace Clipper2Lib {
p1 = cw[i]; p1 = cw[i];
if (!p1 || p1->next == p1->prev) if (!p1 || p1->next == p1->prev)
{ {
cw[i++]->edge = nullptr; cw[i++] = nullptr;
j = 0; j = 0;
continue; continue;
} }
@ -784,7 +818,7 @@ namespace Clipper2Lib {
} }
} }
Path64 RectClip::GetPath(OutPt2*& op) Path64 RectClip64::GetPath(OutPt2*& op)
{ {
if (!op || op->next == op->prev) return Path64(); if (!op || op->next == op->prev) return Path64();
@ -814,13 +848,13 @@ namespace Clipper2Lib {
return result; return result;
} }
Paths64 RectClip::Execute(const Paths64& paths, bool convex_only) Paths64 RectClip64::Execute(const Paths64& paths)
{ {
Paths64 result; Paths64 result;
if (rect_.IsEmpty()) return result; if (rect_.IsEmpty()) return result;
for (const auto& path : paths) for (const Path64& path : paths)
{ {
if (path.size() < 3) continue; if (path.size() < 3) continue;
path_bounds_ = GetBounds(path); path_bounds_ = GetBounds(path);
if (!rect_.Intersects(path_bounds_)) if (!rect_.Intersects(path_bounds_))
@ -833,13 +867,10 @@ namespace Clipper2Lib {
} }
ExecuteInternal(path); ExecuteInternal(path);
if (!convex_only) CheckEdges();
{ for (int i = 0; i < 4; ++i)
CheckEdges(); TidyEdges(i, edges_[i * 2], edges_[i * 2 + 1]);
for (int i = 0; i < 4; ++i)
TidyEdges(i, edges_[i * 2], edges_[i * 2 + 1]);
}
for (OutPt2*& op : results_) for (OutPt2*& op : results_)
{ {
Path64 tmp = GetPath(op); Path64 tmp = GetPath(op);
@ -850,26 +881,24 @@ namespace Clipper2Lib {
//clean up after every loop //clean up after every loop
op_container_ = std::deque<OutPt2>(); op_container_ = std::deque<OutPt2>();
results_.clear(); results_.clear();
for (OutPt2List edge : edges_) edge.clear(); for (OutPt2List &edge : edges_) edge.clear();
start_locs_.clear(); start_locs_.clear();
} }
return result; return result;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// RectClipLines // RectClipLines64
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Paths64 RectClipLines::Execute(const Paths64& paths) Paths64 RectClipLines64::Execute(const Paths64& paths)
{ {
Paths64 result; Paths64 result;
if (rect_.IsEmpty()) return result; if (rect_.IsEmpty()) return result;
for (const auto& path : paths) for (const auto& path : paths)
{ {
if (path.size() < 2) continue;
Rect64 pathrec = GetBounds(path); Rect64 pathrec = GetBounds(path);
if (!rect_.Intersects(pathrec)) continue; if (!rect_.Intersects(pathrec)) continue;
ExecuteInternal(path); ExecuteInternal(path);
@ -888,7 +917,7 @@ namespace Clipper2Lib {
return result; return result;
} }
void RectClipLines::ExecuteInternal(const Path64& path) void RectClipLines64::ExecuteInternal(const Path64& path)
{ {
if (rect_.IsEmpty() || path.size() < 2) return; if (rect_.IsEmpty() || path.size() < 2) return;
@ -958,7 +987,7 @@ namespace Clipper2Lib {
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
} }
Path64 RectClipLines::GetPath(OutPt2*& op) Path64 RectClipLines64::GetPath(OutPt2*& op)
{ {
Path64 result; Path64 result;
if (!op || op == op->next) return result; if (!op || op == op->next) return result;