godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-14 13:41:12 +00:00
Code Releases Wiki Activity

clipper2: Update to 1.5.2

Browse Source
This commit is contained in:
Jakub Marcowski
2025-02-10 14:49:33 +01:00
parent 261e7d32d3
commit 100225c081
15 changed files with 625 additions and 376 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
COPYRIGHT.txt
View File

@@ -200,7 +200,7 @@ License: MPL-2.0
Files: thirdparty/clipper2/* Files: thirdparty/clipper2/*
Comment: Clipper2 Comment: Clipper2
Copyright: 2010-2024, Angus Johnson Copyright: 2010-2025, Angus Johnson
License: BSL-1.0 License: BSL-1.0
Files: thirdparty/cvtt/* Files: thirdparty/cvtt/*

4
thirdparty/README.md vendored
View File

@@ -107,7 +107,7 @@ Files extracted from upstream source:
## clipper2 ## clipper2
- Upstream: https://github.com/AngusJohnson/Clipper2 - Upstream: https://github.com/AngusJohnson/Clipper2
- Version: 1.4.0 (736ddb0b53d97fd5f65dd3d9bbf8a0993eaf387c, 2024) - Version: 1.5.2 (6901921c4be75126d1de60bfd24bd86a61319fd0, 2025)
- License: BSL 1.0 - License: BSL 1.0
Files extracted from upstream source: Files extracted from upstream source:
@@ -118,7 +118,7 @@ Files extracted from upstream source:
Patches: Patches:
- `0001-disable-exceptions.patch` (GH-80796) - `0001-disable-exceptions.patch` (GH-80796)
- `0002-llvm-disable-int1280-math.patch` (GH-95964) - `0002-llvm-disable-int128-math.patch` (GH-95964)
## cvtt ## cvtt

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

@@ -1,26 +1,23 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 12 May 2024 * * Date : 12 May 2024 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2024 *
* Purpose : Core Clipper Library structures and functions * * Purpose : Core Clipper Library structures and functions *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#ifndef CLIPPER_CORE_H #ifndef CLIPPER_CORE_H
#define CLIPPER_CORE_H #define CLIPPER_CORE_H
#include "clipper2/clipper.version.h"
#include <cstdint> #include <cstdint>
#include <cstdlib>
#include <cmath>
#include <vector> #include <vector>
#include <string> #include <string>
#include <iostream> #include <iostream>
#include <algorithm> #include <algorithm>
#include <climits>
#include <numeric> #include <numeric>
#include <optional> #include <cmath>
#include "clipper2/clipper.version.h"
#define CLIPPER2_THROW(exception) std::abort() #define CLIPPER2_THROW(exception) std::abort()
@@ -33,7 +30,7 @@ namespace Clipper2Lib
public: public:
explicit Clipper2Exception(const char* description) : explicit Clipper2Exception(const char* description) :
m_descr(description) {} m_descr(description) {}
virtual const char* what() const throw() override { return m_descr.c_str(); } virtual const char* what() const noexcept override { return m_descr.c_str(); }
private: private:
std::string m_descr; std::string m_descr;
}; };
@@ -90,6 +87,9 @@ namespace Clipper2Lib
CLIPPER2_THROW(Clipper2Exception(undefined_error)); CLIPPER2_THROW(Clipper2Exception(undefined_error));
case range_error_i: case range_error_i:
CLIPPER2_THROW(Clipper2Exception(range_error)); CLIPPER2_THROW(Clipper2Exception(range_error));
// Should never happen, but adding this to stop a compiler warning
default:
CLIPPER2_THROW(Clipper2Exception("Unknown error"));
} }
#else #else
if(error_code) {}; // only to stop compiler 'parameter not used' warning if(error_code) {}; // only to stop compiler 'parameter not used' warning
@@ -109,6 +109,10 @@ namespace Clipper2Lib
//https://en.wikipedia.org/wiki/Nonzero-rule //https://en.wikipedia.org/wiki/Nonzero-rule
enum class FillRule { EvenOdd, NonZero, Positive, Negative }; enum class FillRule { EvenOdd, NonZero, Positive, Negative };
#ifdef USINGZ
using z_type = int64_t;
#endif
// Point ------------------------------------------------------------------------ // Point ------------------------------------------------------------------------
template <typename T> template <typename T>
@@ -116,10 +120,10 @@ namespace Clipper2Lib
T x; T x;
T y; T y;
#ifdef USINGZ #ifdef USINGZ
int64_t z; z_type z;
template <typename T2> template <typename T2>
inline void Init(const T2 x_ = 0, const T2 y_ = 0, const int64_t z_ = 0) inline void Init(const T2 x_ = 0, const T2 y_ = 0, const z_type z_ = 0)
{ {
if constexpr (std::is_integral_v<T> && if constexpr (std::is_integral_v<T> &&
is_round_invocable<T2>::value && !std::is_integral_v<T2>) is_round_invocable<T2>::value && !std::is_integral_v<T2>)
@@ -139,7 +143,7 @@ namespace Clipper2Lib
explicit Point() : x(0), y(0), z(0) {}; explicit Point() : x(0), y(0), z(0) {};
template <typename T2> template <typename T2>
Point(const T2 x_, const T2 y_, const int64_t z_ = 0) Point(const T2 x_, const T2 y_, const z_type z_ = 0)
{ {
Init(x_, y_); Init(x_, y_);
z = z_; z = z_;
@@ -152,7 +156,7 @@ namespace Clipper2Lib
} }
template <typename T2> template <typename T2>
explicit Point(const Point<T2>& p, int64_t z_) explicit Point(const Point<T2>& p, z_type z_)
{ {
Init(p.x, p.y, z_); Init(p.x, p.y, z_);
} }
@@ -162,7 +166,7 @@ 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; } void SetZ(const z_type 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)
{ {
@@ -326,10 +330,10 @@ namespace Clipper2Lib
{ {
Path<T> result; Path<T> result;
result.reserve(4); result.reserve(4);
result.push_back(Point<T>(left, top)); result.emplace_back(left, top);
result.push_back(Point<T>(right, top)); result.emplace_back(right, top);
result.push_back(Point<T>(right, bottom)); result.emplace_back(right, bottom);
result.push_back(Point<T>(left, bottom)); result.emplace_back(left, bottom);
return result; return result;
} }
@@ -364,6 +368,22 @@ namespace Clipper2Lib
top == other.top && bottom == other.bottom; top == other.top && bottom == other.bottom;
} }
Rect<T>& operator+=(const Rect<T>& other)
{
left = (std::min)(left, other.left);
top = (std::min)(top, other.top);
right = (std::max)(right, other.right);
bottom = (std::max)(bottom, other.bottom);
return *this;
}
Rect<T> operator+(const Rect<T>& other) const
{
Rect<T> result = *this;
result += other;
return result;
}
friend std::ostream& operator<<(std::ostream& os, const Rect<T>& rect) { friend std::ostream& operator<<(std::ostream& os, const Rect<T>& rect) {
os << "(" << rect.left << "," << rect.top << "," << rect.right << "," << rect.bottom << ") "; os << "(" << rect.left << "," << rect.top << "," << rect.right << "," << rect.bottom << ") ";
return os; return os;
@@ -597,13 +617,13 @@ namespace Clipper2Lib
result.reserve(path.size()); result.reserve(path.size());
typename Path<T>::const_iterator path_iter = path.cbegin(); typename Path<T>::const_iterator path_iter = path.cbegin();
Point<T> first_pt = *path_iter++, last_pt = first_pt; Point<T> first_pt = *path_iter++, last_pt = first_pt;
result.push_back(first_pt); result.emplace_back(first_pt);
for (; path_iter != path.cend(); ++path_iter) for (; path_iter != path.cend(); ++path_iter)
{ {
if (!NearEqual(*path_iter, last_pt, max_dist_sqrd)) if (!NearEqual(*path_iter, last_pt, max_dist_sqrd))
{ {
last_pt = *path_iter; last_pt = *path_iter;
result.push_back(last_pt); result.emplace_back(last_pt);
} }
} }
if (!is_closed_path) return result; if (!is_closed_path) return result;
@@ -621,7 +641,7 @@ namespace Clipper2Lib
for (typename Paths<T>::const_iterator paths_citer = paths.cbegin(); for (typename Paths<T>::const_iterator paths_citer = paths.cbegin();
paths_citer != paths.cend(); ++paths_citer) paths_citer != paths.cend(); ++paths_citer)
{ {
result.push_back(StripNearEqual(*paths_citer, max_dist_sqrd, is_closed_path)); result.emplace_back(std::move(StripNearEqual(*paths_citer, max_dist_sqrd, is_closed_path)));
} }
return result; return result;
} }
@@ -697,11 +717,11 @@ namespace Clipper2Lib
{ {
// Work around LLVM issue: https://github.com/llvm/llvm-project/issues/16778 // Work around LLVM issue: https://github.com/llvm/llvm-project/issues/16778
// Details: https://github.com/godotengine/godot/pull/95964#issuecomment-2306581804 // Details: https://github.com/godotengine/godot/pull/95964#issuecomment-2306581804
//#if (defined(__clang__) || defined(__GNUC__)) && UINTPTR_MAX >= UINT64_MAX // #if (defined(__clang__) || defined(__GNUC__)) && UINTPTR_MAX >= UINT64_MAX
// const auto ab = static_cast<__int128_t>(a) * static_cast<__int128_t>(b); // const auto ab = static_cast<__int128_t>(a) * static_cast<__int128_t>(b);
// const auto cd = static_cast<__int128_t>(c) * static_cast<__int128_t>(d); // const auto cd = static_cast<__int128_t>(c) * static_cast<__int128_t>(d);
// return ab == cd; // return ab == cd;
//#else // #else
// nb: unsigned values needed for calculating overflow carry // nb: unsigned values needed for calculating overflow carry
const auto abs_a = static_cast<uint64_t>(std::abs(a)); const auto abs_a = static_cast<uint64_t>(std::abs(a));
const auto abs_b = static_cast<uint64_t>(std::abs(b)); const auto abs_b = static_cast<uint64_t>(std::abs(b));
@@ -768,7 +788,7 @@ namespace Clipper2Lib
const Point<T>& line1, const Point<T>& line2) const Point<T>& line1, const Point<T>& line2)
{ {
//perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²) //perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²)
//see http://en.wikipedia.org/wiki/Perpendicular_distance //see https://en.wikipedia.org/wiki/Perpendicular_distance
double a = static_cast<double>(pt.x - line1.x); double a = static_cast<double>(pt.x - line1.x);
double b = static_cast<double>(pt.y - line1.y); double b = static_cast<double>(pt.y - line1.y);
double c = static_cast<double>(line2.x - line1.x); double c = static_cast<double>(line2.x - line1.x);

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

@@ -1,25 +1,19 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 5 July 2024 * * Date : 17 September 2024 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2024 *
* Purpose : This is the main polygon clipping module * * Purpose : This is the main polygon clipping module *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#ifndef CLIPPER_ENGINE_H #ifndef CLIPPER_ENGINE_H
#define CLIPPER_ENGINE_H #define CLIPPER_ENGINE_H
#include <cstdlib>
#include <stdint.h> //#541
#include <iostream>
#include <queue>
#include <vector>
#include <functional>
#include <numeric>
#include <memory>
#include "clipper2/clipper.core.h" #include "clipper2/clipper.core.h"
#include <queue>
#include <functional>
#include <memory>
namespace Clipper2Lib { namespace Clipper2Lib {
@@ -32,13 +26,13 @@ namespace Clipper2Lib {
struct HorzSegment; struct HorzSegment;
//Note: all clipping operations except for Difference are commutative. //Note: all clipping operations except for Difference are commutative.
enum class ClipType { None, Intersection, Union, Difference, Xor }; enum class ClipType { NoClip, Intersection, Union, Difference, Xor };
enum class PathType { Subject, Clip }; enum class PathType { Subject, Clip };
enum class JoinWith { None, Left, Right }; enum class JoinWith { NoJoin, Left, Right };
enum class VertexFlags : uint32_t { enum class VertexFlags : uint32_t {
None = 0, OpenStart = 1, OpenEnd = 2, LocalMax = 4, LocalMin = 8 Empty = 0, OpenStart = 1, OpenEnd = 2, LocalMax = 4, LocalMin = 8
}; };
constexpr enum VertexFlags operator &(enum VertexFlags a, enum VertexFlags b) constexpr enum VertexFlags operator &(enum VertexFlags a, enum VertexFlags b)
@@ -55,7 +49,7 @@ namespace Clipper2Lib {
Point64 pt; Point64 pt;
Vertex* next = nullptr; Vertex* next = nullptr;
Vertex* prev = nullptr; Vertex* prev = nullptr;
VertexFlags flags = VertexFlags::None; VertexFlags flags = VertexFlags::Empty;
}; };
struct OutPt { struct OutPt {
@@ -131,7 +125,7 @@ namespace Clipper2Lib {
Vertex* vertex_top = nullptr; Vertex* vertex_top = nullptr;
LocalMinima* local_min = nullptr; // the bottom of an edge 'bound' (also Vatti) LocalMinima* local_min = nullptr; // the bottom of an edge 'bound' (also Vatti)
bool is_left_bound = false; bool is_left_bound = false;
JoinWith join_with = JoinWith::None; JoinWith join_with = JoinWith::NoJoin;
}; };
struct LocalMinima { struct LocalMinima {
@@ -167,7 +161,7 @@ namespace Clipper2Lib {
}; };
#ifdef USINGZ #ifdef USINGZ
typedef std::function<void(const Point64& e1bot, const Point64& e1top, typedef std::function<void(const Point64& e1bot, const Point64& e1top,
const Point64& e2bot, const Point64& e2top, Point64& pt)> ZCallback64; const Point64& e2bot, const Point64& e2top, Point64& pt)> ZCallback64;
typedef std::function<void(const PointD& e1bot, const PointD& e1top, typedef std::function<void(const PointD& e1bot, const PointD& e1top,
@@ -197,7 +191,7 @@ namespace Clipper2Lib {
class ClipperBase { class ClipperBase {
private: private:
ClipType cliptype_ = ClipType::None; ClipType cliptype_ = ClipType::NoClip;
FillRule fillrule_ = FillRule::EvenOdd; FillRule fillrule_ = FillRule::EvenOdd;
FillRule fillpos = FillRule::Positive; FillRule fillpos = FillRule::Positive;
int64_t bot_y_ = 0; int64_t bot_y_ = 0;
@@ -210,7 +204,7 @@ namespace Clipper2Lib {
std::vector<Vertex*> vertex_lists_; std::vector<Vertex*> vertex_lists_;
std::priority_queue<int64_t> scanline_list_; std::priority_queue<int64_t> scanline_list_;
IntersectNodeList intersect_nodes_; IntersectNodeList intersect_nodes_;
HorzSegmentList horz_seg_list_; HorzSegmentList horz_seg_list_;
std::vector<HorzJoin> horz_join_list_; std::vector<HorzJoin> horz_join_list_;
void Reset(); void Reset();
inline void InsertScanline(int64_t y); inline void InsertScanline(int64_t y);

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

@@ -1,16 +1,16 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 14 May 2024 * * Date : 24 January 2025 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2025 *
* Purpose : This module exports the Clipper2 Library (ie DLL/so) * * Purpose : This module exports the Clipper2 Library (ie DLL/so) *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
/* /*
Boolean clipping: Boolean clipping:
cliptype: None=0, Intersection=1, Union=2, Difference=3, Xor=4 cliptype: NoClip=0, Intersection=1, Union=2, Difference=3, Xor=4
fillrule: EvenOdd=0, NonZero=1, Positive=2, Negative=3 fillrule: EvenOdd=0, NonZero=1, Positive=2, Negative=3
Polygon offsetting (inflate/deflate): Polygon offsetting (inflate/deflate):
@@ -19,73 +19,104 @@
The path structures used extensively in other parts of this library are all The path structures used extensively in other parts of this library are all
based on std::vector classes. Since C++ classes can't be accessed by other based on std::vector classes. Since C++ classes can't be accessed by other
languages, these paths are converted into very simple array data structures languages, these paths are exported here as very simple array structures
(of either int64_t for CPath64 or double for CPathD) that can be parsed by (either of int64_t or double) that can be parsed by just about any
just about any programming language. programming language.
These 2D paths are defined by series of x and y coordinates together with an
optional user-defined 'z' value (see Z-values below). Hence, a vertex refers
to a single x and y coordinate (+/- a user-defined value). Data structures
have names with suffixes that indicate the array type (either int64_t or
double). For example, the data structure CPath64 contains an array of int64_t
values, whereas the data structure CPathD contains an array of double.
Where documentation omits the type suffix (eg CPath), it is referring to an
array whose data type could be either int64_t or double.
For conciseness, the following letters are used in the diagrams below:
N: Number of vertices in a given path
C: Count (ie number) of paths (or PolyPaths) in the structure
A: Number of elements in an array
CPath64 and CPathD: CPath64 and CPathD:
These are arrays of consecutive x and y path coordinates preceeded by These are arrays of either int64_t or double values. Apart from
a pair of values containing the path's length (N) and a 0 value. the first two elements, these arrays are a series of vertices
__________________________________ that together define a path. The very first element contains the
|counter|coord1|coord2|...|coordN| number of vertices (N) in the path, while second element should
|N, 0 |x1, y1|x2, y2|...|xN, yN| contain a 0 value.
__________________________________ _______________________________________________________________
| counters | vertex1 | vertex2 | ... | vertexN |
| N, 0 | x1, y1, (z1) | x2, y2, (z2) | ... | xN, yN, (zN) |
---------------------------------------------------------------
CPaths64 and CPathsD: CPaths64 and CPathsD:
These are also arrays containing any number of consecutive CPath64 or These are also arrays of either int64_t or double values that
CPathD structures. But preceeding these consecutive paths, there is pair of contain any number of consecutive CPath structures. However,
values that contain the total length of the array structure (A) and the preceding the first path is a pair of values. The first value
number of CPath64 or CPathD it contains (C). The space these structures will contains the length of the entire array structure (A), and the
occupy in memory = A * sizeof(int64_t) or A * sizeof(double) respectively. second contains the number (ie count) of contained paths (C).
_______________________________ Memory allocation for CPaths64 = A * sizeof(int64_t)
|counter|path1|path2|...|pathC| Memory allocation for CPathsD = A * sizeof(double)
|A , C | | __________________________________________
_______________________________ | counters | path1 | path2 | ... | pathC |
| A, C | | | ... | |
------------------------------------------
CPolytree64 and CPolytreeD: CPolytree64 and CPolytreeD:
These are also arrays consisting of CPolyPath structures that represent The entire polytree structure is an array of int64_t or double. The
individual paths in a tree structure. However, the very first (ie top) first element in the array indicates the array's total length (A).
CPolyPath is just the tree container that doesn't have a path. And because The second element indicates the number (C) of CPolyPath structures
of that, its structure will be very slightly different from the remaining that are the TOP LEVEL CPolyPath in the polytree, and these top
CPolyPath. This difference will be discussed below. level CPolyPath immediately follow these first two array elements.
These top level CPolyPath structures may, in turn, contain nested
CPolyPath children, and these collectively make a tree structure.
_________________________________________________________
| counters | CPolyPath1 | CPolyPath2 | ... | CPolyPathC |
| A, C | | | ... | |
---------------------------------------------------------
CPolyPath64 and CPolyPathD: CPolyPath64 and CPolyPathD:
These are simple arrays consisting of a series of path coordinates followed These array structures consist of a pair of counter values followed by a
by any number of child (ie nested) CPolyPath. Preceeding these are two values series of polygon vertices and a series of nested CPolyPath children.
indicating the length of the path (N) and the number of child CPolyPath (C). The first counter values indicates the number of vertices in the
____________________________________________________________ polygon (N), and the second counter indicates the CPolyPath child count (C).
|counter|coord1|coord2|...|coordN| child1|child2|...|childC| _____________________________________________________________________________
|N , C |x1, y1|x2, y2|...|xN, yN| | |cntrs |vertex1 |vertex2 |...|vertexN |child1|child2|...|childC|
____________________________________________________________ |N, C |x1, y1, (z1)| x2, y2, (z2)|...|xN, yN, (zN)| | |...| |
-----------------------------------------------------------------------------
As mentioned above, the very first CPolyPath structure is just a container
that owns (both directly and indirectly) every other CPolyPath in the tree.
Since this first CPolyPath has no path, instead of a path length, its very
first value will contain the total length of the CPolytree array (not its
total bytes length).
Again, all theses exported structures (CPaths64, CPathsD, CPolyTree64 & DisposeArray64 & DisposeArrayD:
CPolyTreeD) are arrays of either type int64_t or double, and the first All array structures are allocated in heap memory which will eventually
value in these arrays will always be the length of that array. need to be released. However, since applications linking to these DLL
functions may use different memory managers, the only safe way to release
this memory is to use the exported DisposeArray functions.
(Optional) Z-Values:
Structures will only contain user-defined z-values when the USINGZ
pre-processor identifier is used. The library does not assign z-values
because this field is intended for users to assign custom values to vertices.
Z-values in input paths (subject and clip) will be copied to solution paths.
New vertices at path intersections will generate a callback event that allows
users to assign z-values at these new vertices. The user's callback function
must conform with the DLLZCallback definition and be registered with the
DLL via SetZCallback. To assist the user in assigning z-values, the library
passes in the callback function the new intersection point together with
the four vertices that define the two segments that are intersecting.
These array structures are allocated in heap memory which will eventually
need to be released. However, since applications dynamically linking to
these functions may use different memory managers, the only safe way to
free up this memory is to use the exported DisposeArray64 and
DisposeArrayD functions (see below).
*/ */
#ifndef CLIPPER2_EXPORT_H #ifndef CLIPPER2_EXPORT_H
#define CLIPPER2_EXPORT_H #define CLIPPER2_EXPORT_H
#include <cstdlib>
#include <vector>
#include "clipper2/clipper.core.h" #include "clipper2/clipper.core.h"
#include "clipper2/clipper.engine.h" #include "clipper2/clipper.engine.h"
#include "clipper2/clipper.offset.h" #include "clipper2/clipper.offset.h"
#include "clipper2/clipper.rectclip.h" #include "clipper2/clipper.rectclip.h"
#include <cstdlib>
namespace Clipper2Lib { namespace Clipper2Lib {
@@ -127,6 +158,12 @@ inline Rect<T> CRectToRect(const CRect<T>& rect)
return result; return result;
} }
template <typename T1, typename T2>
inline T1 Reinterpret(T2 value) {
return *reinterpret_cast<T1*>(&value);
}
#ifdef _WIN32 #ifdef _WIN32
#define EXTERN_DLL_EXPORT extern "C" __declspec(dllexport) #define EXTERN_DLL_EXPORT extern "C" __declspec(dllexport)
#else #else
@@ -178,11 +215,22 @@ EXTERN_DLL_EXPORT CPaths64 InflatePaths64(const CPaths64 paths,
double delta, uint8_t jointype, uint8_t endtype, double delta, uint8_t jointype, uint8_t endtype,
double miter_limit = 2.0, double arc_tolerance = 0.0, double miter_limit = 2.0, double arc_tolerance = 0.0,
bool reverse_solution = false); bool reverse_solution = false);
EXTERN_DLL_EXPORT CPathsD InflatePathsD(const CPathsD paths, EXTERN_DLL_EXPORT CPathsD InflatePathsD(const CPathsD paths,
double delta, uint8_t jointype, uint8_t endtype, double delta, uint8_t jointype, uint8_t endtype,
int precision = 2, double miter_limit = 2.0, int precision = 2, double miter_limit = 2.0,
double arc_tolerance = 0.0, bool reverse_solution = false); double arc_tolerance = 0.0, bool reverse_solution = false);
EXTERN_DLL_EXPORT CPaths64 InflatePath64(const CPath64 path,
double delta, uint8_t jointype, uint8_t endtype,
double miter_limit = 2.0, double arc_tolerance = 0.0,
bool reverse_solution = false);
EXTERN_DLL_EXPORT CPathsD InflatePathD(const CPathD path,
double delta, uint8_t jointype, uint8_t endtype,
int precision = 2, double miter_limit = 2.0,
double arc_tolerance = 0.0, bool reverse_solution = false);
// RectClip & RectClipLines: // RectClip & RectClipLines:
EXTERN_DLL_EXPORT CPaths64 RectClip64(const CRect64& rect, EXTERN_DLL_EXPORT CPaths64 RectClip64(const CRect64& rect,
const CPaths64 paths); const CPaths64 paths);
@@ -197,6 +245,15 @@ EXTERN_DLL_EXPORT CPathsD RectClipLinesD(const CRectD& rect,
// INTERNAL FUNCTIONS // INTERNAL FUNCTIONS
////////////////////////////////////////////////////// //////////////////////////////////////////////////////
#ifdef USINGZ
ZCallback64 dllCallback64 = nullptr;
ZCallbackD dllCallbackD = nullptr;
constexpr int EXPORT_VERTEX_DIMENSIONALITY = 3;
#else
constexpr int EXPORT_VERTEX_DIMENSIONALITY = 2;
#endif
template <typename T> template <typename T>
static void GetPathCountAndCPathsArrayLen(const Paths<T>& paths, static void GetPathCountAndCPathsArrayLen(const Paths<T>& paths,
size_t& cnt, size_t& array_len) size_t& cnt, size_t& array_len)
@@ -206,30 +263,47 @@ static void GetPathCountAndCPathsArrayLen(const Paths<T>& paths,
for (const Path<T>& path : paths) for (const Path<T>& path : paths)
if (path.size()) if (path.size())
{ {
array_len += path.size() * 2 + 2; array_len += path.size() * EXPORT_VERTEX_DIMENSIONALITY + 2;
++cnt; ++cnt;
} }
} }
static size_t GetPolyPath64ArrayLen(const PolyPath64& pp) static size_t GetPolyPathArrayLen64(const PolyPath64& pp)
{ {
size_t result = 2; // poly_length + child_count size_t result = 2; // poly_length + child_count
result += pp.Polygon().size() * 2; result += pp.Polygon().size() * EXPORT_VERTEX_DIMENSIONALITY;
//plus nested children :) //plus nested children :)
for (size_t i = 0; i < pp.Count(); ++i) for (size_t i = 0; i < pp.Count(); ++i)
result += GetPolyPath64ArrayLen(*pp[i]); result += GetPolyPathArrayLen64(*pp[i]);
return result; return result;
} }
static void GetPolytreeCountAndCStorageSize(const PolyTree64& tree, static size_t GetPolyPathArrayLenD(const PolyPathD& pp)
{
size_t result = 2; // poly_length + child_count
result += pp.Polygon().size() * EXPORT_VERTEX_DIMENSIONALITY;
//plus nested children :)
for (size_t i = 0; i < pp.Count(); ++i)
result += GetPolyPathArrayLenD(*pp[i]);
return result;
}
static void GetPolytreeCountAndCStorageSize64(const PolyTree64& tree,
size_t& cnt, size_t& array_len) size_t& cnt, size_t& array_len)
{ {
cnt = tree.Count(); // nb: top level count only cnt = tree.Count(); // nb: top level count only
array_len = GetPolyPath64ArrayLen(tree); array_len = GetPolyPathArrayLen64(tree);
}
static void GetPolytreeCountAndCStorageSizeD(const PolyTreeD& tree,
size_t& cnt, size_t& array_len)
{
cnt = tree.Count(); // nb: top level count only
array_len = GetPolyPathArrayLenD(tree);
} }
template <typename T> template <typename T>
static T* CreateCPaths(const Paths<T>& paths) static T* CreateCPathsFromPathsT(const Paths<T>& paths)
{ {
size_t cnt = 0, array_len = 0; size_t cnt = 0, array_len = 0;
GetPathCountAndCPathsArrayLen(paths, cnt, array_len); GetPathCountAndCPathsArrayLen(paths, cnt, array_len);
@@ -245,11 +319,38 @@ static T* CreateCPaths(const Paths<T>& paths)
{ {
*v++ = pt.x; *v++ = pt.x;
*v++ = pt.y; *v++ = pt.y;
#ifdef USINGZ
*v++ = Reinterpret<T>(pt.z);
#endif
} }
} }
return result; return result;
} }
CPathsD CreateCPathsDFromPathsD(const PathsD& paths)
{
if (!paths.size()) return nullptr;
size_t cnt, array_len;
GetPathCountAndCPathsArrayLen(paths, cnt, array_len);
CPathsD result = new double[array_len], v = result;
*v++ = (double)array_len;
*v++ = (double)cnt;
for (const PathD& path : paths)
{
if (!path.size()) continue;
*v = (double)path.size();
++v; *v++ = 0;
for (const PointD& pt : path)
{
*v++ = pt.x;
*v++ = pt.y;
#ifdef USINGZ
* v++ = Reinterpret<double>(pt.z);
#endif
}
}
return result;
}
CPathsD CreateCPathsDFromPaths64(const Paths64& paths, double scale) CPathsD CreateCPathsDFromPaths64(const Paths64& paths, double scale)
{ {
@@ -268,13 +369,16 @@ CPathsD CreateCPathsDFromPaths64(const Paths64& paths, double scale)
{ {
*v++ = pt.x * scale; *v++ = pt.x * scale;
*v++ = pt.y * scale; *v++ = pt.y * scale;
#ifdef USINGZ
*v++ = Reinterpret<double>(pt.z);
#endif
} }
} }
return result; return result;
} }
template <typename T> template <typename T>
static Path<T> ConvertCPath(T* path) static Path<T> ConvertCPathToPathT(T* path)
{ {
Path<T> result; Path<T> result;
if (!path) return result; if (!path) return result;
@@ -284,14 +388,19 @@ static Path<T> ConvertCPath(T* path)
result.reserve(cnt); result.reserve(cnt);
for (size_t j = 0; j < cnt; ++j) for (size_t j = 0; j < cnt; ++j)
{ {
T x = *v++, y = *v++; T x = *v++, y = *v++;
result.push_back(Point<T>(x, y)); #ifdef USINGZ
z_type z = Reinterpret<z_type>(*v++);
result.emplace_back(x, y, z);
#else
result.emplace_back(x, y);
#endif
} }
return result; return result;
} }
template <typename T> template <typename T>
static Paths<T> ConvertCPaths(T* paths) static Paths<T> ConvertCPathsToPathsT(T* paths)
{ {
Paths<T> result; Paths<T> result;
if (!paths) return result; if (!paths) return result;
@@ -301,19 +410,45 @@ static Paths<T> ConvertCPaths(T* paths)
for (size_t i = 0; i < cnt; ++i) for (size_t i = 0; i < cnt; ++i)
{ {
size_t cnt2 = static_cast<size_t>(*v); size_t cnt2 = static_cast<size_t>(*v);
v += 2; v += 2;
Path<T> path; Path<T> path;
path.reserve(cnt2); path.reserve(cnt2);
for (size_t j = 0; j < cnt2; ++j) for (size_t j = 0; j < cnt2; ++j)
{ {
T x = *v++, y = *v++; T x = *v++, y = *v++;
path.push_back(Point<T>(x, y)); #ifdef USINGZ
z_type z = Reinterpret<z_type>(*v++);
path.emplace_back(x, y, z);
#else
path.emplace_back(x, y);
#endif
} }
result.push_back(path); result.emplace_back(std::move(path));
} }
return result; return result;
} }
static Path64 ConvertCPathDToPath64WithScale(const CPathD path, double scale)
{
Path64 result;
if (!path) return result;
double* v = path;
size_t cnt = static_cast<size_t>(*v);
v += 2; // skip 0 value
result.reserve(cnt);
for (size_t j = 0; j < cnt; ++j)
{
double x = *v++ * scale;
double y = *v++ * scale;
#ifdef USINGZ
z_type z = Reinterpret<z_type>(*v++);
result.emplace_back(x, y, z);
#else
result.emplace_back(x, y);
#endif
}
return result;
}
static Paths64 ConvertCPathsDToPaths64(const CPathsD paths, double scale) static Paths64 ConvertCPathsDToPaths64(const CPathsD paths, double scale)
{ {
@@ -333,42 +468,78 @@ static Paths64 ConvertCPathsDToPaths64(const CPathsD paths, double scale)
{ {
double x = *v++ * scale; double x = *v++ * scale;
double y = *v++ * scale; double y = *v++ * scale;
path.push_back(Point64(x, y)); #ifdef USINGZ
z_type z = Reinterpret<z_type>(*v++);
path.emplace_back(x, y, z);
#else
path.emplace_back(x, y);
#endif
} }
result.push_back(path); result.emplace_back(std::move(path));
} }
return result; return result;
} }
template <typename T> static void CreateCPolyPath64(const PolyPath64* pp, int64_t*& v)
static void CreateCPolyPath(const PolyPath64* pp, T*& v, T scale)
{ {
*v++ = static_cast<T>(pp->Polygon().size()); *v++ = static_cast<int64_t>(pp->Polygon().size());
*v++ = static_cast<T>(pp->Count()); *v++ = static_cast<int64_t>(pp->Count());
for (const Point64& pt : pp->Polygon()) for (const Point64& pt : pp->Polygon())
{ {
*v++ = static_cast<T>(pt.x * scale); *v++ = pt.x;
*v++ = static_cast<T>(pt.y * scale); *v++ = pt.y;
#ifdef USINGZ
* v++ = Reinterpret<int64_t>(pt.z); // raw memory copy
#endif
} }
for (size_t i = 0; i < pp->Count(); ++i) for (size_t i = 0; i < pp->Count(); ++i)
CreateCPolyPath(pp->Child(i), v, scale); CreateCPolyPath64(pp->Child(i), v);
} }
template <typename T> static void CreateCPolyPathD(const PolyPathD* pp, double*& v)
static T* CreateCPolyTree(const PolyTree64& tree, T scale) {
*v++ = static_cast<double>(pp->Polygon().size());
*v++ = static_cast<double>(pp->Count());
for (const PointD& pt : pp->Polygon())
{
*v++ = pt.x;
*v++ = pt.y;
#ifdef USINGZ
* v++ = Reinterpret<double>(pt.z); // raw memory copy
#endif
}
for (size_t i = 0; i < pp->Count(); ++i)
CreateCPolyPathD(pp->Child(i), v);
}
static int64_t* CreateCPolyTree64(const PolyTree64& tree)
{ {
if (scale == 0) scale = 1;
size_t cnt, array_len; size_t cnt, array_len;
GetPolytreeCountAndCStorageSize(tree, cnt, array_len); GetPolytreeCountAndCStorageSize64(tree, cnt, array_len);
if (!cnt) return nullptr; if (!cnt) return nullptr;
// allocate storage // allocate storage
T* result = new T[array_len]; int64_t* result = new int64_t[array_len];
T* v = result; int64_t* v = result;
*v++ = static_cast<int64_t>(array_len);
*v++ = static_cast<T>(array_len); *v++ = static_cast<int64_t>(tree.Count());
*v++ = static_cast<T>(tree.Count());
for (size_t i = 0; i < tree.Count(); ++i) for (size_t i = 0; i < tree.Count(); ++i)
CreateCPolyPath(tree.Child(i), v, scale); CreateCPolyPath64(tree.Child(i), v);
return result;
}
static double* CreateCPolyTreeD(const PolyTreeD& tree)
{
double scale = std::log10(tree.Scale());
size_t cnt, array_len;
GetPolytreeCountAndCStorageSizeD(tree, cnt, array_len);
if (!cnt) return nullptr;
// allocate storage
double* result = new double[array_len];
double* v = result;
*v++ = static_cast<double>(array_len);
*v++ = static_cast<double>(tree.Count());
for (size_t i = 0; i < tree.Count(); ++i)
CreateCPolyPathD(tree.Child(i), v);
return result; return result;
} }
@@ -391,20 +562,24 @@ EXTERN_DLL_EXPORT int BooleanOp64(uint8_t cliptype,
if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3; if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3;
Paths64 sub, sub_open, clp, sol, sol_open; Paths64 sub, sub_open, clp, sol, sol_open;
sub = ConvertCPaths(subjects); sub = ConvertCPathsToPathsT(subjects);
sub_open = ConvertCPaths(subjects_open); sub_open = ConvertCPathsToPathsT(subjects_open);
clp = ConvertCPaths(clips); clp = ConvertCPathsToPathsT(clips);
Clipper64 clipper; Clipper64 clipper;
clipper.PreserveCollinear(preserve_collinear); clipper.PreserveCollinear(preserve_collinear);
clipper.ReverseSolution(reverse_solution); clipper.ReverseSolution(reverse_solution);
#ifdef USINGZ
if (dllCallback64)
clipper.SetZCallback(dllCallback64);
#endif
if (sub.size() > 0) clipper.AddSubject(sub); if (sub.size() > 0) clipper.AddSubject(sub);
if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open); if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open);
if (clp.size() > 0) clipper.AddClip(clp); if (clp.size() > 0) clipper.AddClip(clp);
if (!clipper.Execute(ClipType(cliptype), FillRule(fillrule), sol, sol_open)) if (!clipper.Execute(ClipType(cliptype), FillRule(fillrule), sol, sol_open))
return -1; // clipping bug - should never happen :) return -1; // clipping bug - should never happen :)
solution = CreateCPaths(sol); solution = CreateCPathsFromPathsT(sol);
solution_open = CreateCPaths(sol_open); solution_open = CreateCPathsFromPathsT(sol_open);
return 0; //success !! return 0; //success !!
} }
@@ -417,22 +592,26 @@ EXTERN_DLL_EXPORT int BooleanOp_PolyTree64(uint8_t cliptype,
if (cliptype > static_cast<uint8_t>(ClipType::Xor)) return -4; if (cliptype > static_cast<uint8_t>(ClipType::Xor)) return -4;
if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3; if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3;
Paths64 sub, sub_open, clp, sol_open; Paths64 sub, sub_open, clp, sol_open;
sub = ConvertCPaths(subjects); sub = ConvertCPathsToPathsT(subjects);
sub_open = ConvertCPaths(subjects_open); sub_open = ConvertCPathsToPathsT(subjects_open);
clp = ConvertCPaths(clips); clp = ConvertCPathsToPathsT(clips);
PolyTree64 tree; PolyTree64 tree;
Clipper64 clipper; Clipper64 clipper;
clipper.PreserveCollinear(preserve_collinear); clipper.PreserveCollinear(preserve_collinear);
clipper.ReverseSolution(reverse_solution); clipper.ReverseSolution(reverse_solution);
#ifdef USINGZ
if (dllCallback64)
clipper.SetZCallback(dllCallback64);
#endif
if (sub.size() > 0) clipper.AddSubject(sub); if (sub.size() > 0) clipper.AddSubject(sub);
if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open); if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open);
if (clp.size() > 0) clipper.AddClip(clp); if (clp.size() > 0) clipper.AddClip(clp);
if (!clipper.Execute(ClipType(cliptype), FillRule(fillrule), tree, sol_open)) if (!clipper.Execute(ClipType(cliptype), FillRule(fillrule), tree, sol_open))
return -1; // clipping bug - should never happen :) return -1; // clipping bug - should never happen :)
sol_tree = CreateCPolyTree(tree, (int64_t)1); sol_tree = CreateCPolyTree64(tree);
solution_open = CreateCPaths(sol_open); solution_open = CreateCPathsFromPathsT(sol_open);
return 0; //success !! return 0; //success !!
} }
@@ -445,23 +624,27 @@ EXTERN_DLL_EXPORT int BooleanOpD(uint8_t cliptype,
if (precision < -8 || precision > 8) return -5; if (precision < -8 || precision > 8) return -5;
if (cliptype > static_cast<uint8_t>(ClipType::Xor)) return -4; if (cliptype > static_cast<uint8_t>(ClipType::Xor)) return -4;
if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3; if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3;
const double scale = std::pow(10, precision); //const double scale = std::pow(10, precision);
Paths64 sub, sub_open, clp, sol, sol_open; PathsD sub, sub_open, clp, sol, sol_open;
sub = ConvertCPathsDToPaths64(subjects, scale); sub = ConvertCPathsToPathsT(subjects);
sub_open = ConvertCPathsDToPaths64(subjects_open, scale); sub_open = ConvertCPathsToPathsT(subjects_open);
clp = ConvertCPathsDToPaths64(clips, scale); clp = ConvertCPathsToPathsT(clips);
Clipper64 clipper; ClipperD clipper(precision);
clipper.PreserveCollinear(preserve_collinear); clipper.PreserveCollinear(preserve_collinear);
clipper.ReverseSolution(reverse_solution); clipper.ReverseSolution(reverse_solution);
#ifdef USINGZ
if (dllCallbackD)
clipper.SetZCallback(dllCallbackD);
#endif
if (sub.size() > 0) clipper.AddSubject(sub); if (sub.size() > 0) clipper.AddSubject(sub);
if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open); if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open);
if (clp.size() > 0) clipper.AddClip(clp); if (clp.size() > 0) clipper.AddClip(clp);
if (!clipper.Execute(ClipType(cliptype), if (!clipper.Execute(ClipType(cliptype),
FillRule(fillrule), sol, sol_open)) return -1; FillRule(fillrule), sol, sol_open)) return -1;
solution = CreateCPathsDFromPaths64(sol, 1 / scale); solution = CreateCPathsDFromPathsD(sol);
solution_open = CreateCPathsDFromPaths64(sol_open, 1 / scale); solution_open = CreateCPathsDFromPathsD(sol_open);
return 0; return 0;
} }
@@ -474,27 +657,30 @@ EXTERN_DLL_EXPORT int BooleanOp_PolyTreeD(uint8_t cliptype,
if (precision < -8 || precision > 8) return -5; if (precision < -8 || precision > 8) return -5;
if (cliptype > static_cast<uint8_t>(ClipType::Xor)) return -4; if (cliptype > static_cast<uint8_t>(ClipType::Xor)) return -4;
if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3; if (fillrule > static_cast<uint8_t>(FillRule::Negative)) return -3;
//double scale = std::pow(10, precision);
double scale = std::pow(10, precision);
int err = 0; int err = 0;
Paths64 sub, sub_open, clp, sol_open; PathsD sub, sub_open, clp, sol_open;
sub = ConvertCPathsDToPaths64(subjects, scale); sub = ConvertCPathsToPathsT(subjects);
sub_open = ConvertCPathsDToPaths64(subjects_open, scale); sub_open = ConvertCPathsToPathsT(subjects_open);
clp = ConvertCPathsDToPaths64(clips, scale); clp = ConvertCPathsToPathsT(clips);
PolyTree64 tree; PolyTreeD tree;
Clipper64 clipper; ClipperD clipper(precision);
clipper.PreserveCollinear(preserve_collinear); clipper.PreserveCollinear(preserve_collinear);
clipper.ReverseSolution(reverse_solution); clipper.ReverseSolution(reverse_solution);
#ifdef USINGZ
if (dllCallbackD)
clipper.SetZCallback(dllCallbackD);
#endif
if (sub.size() > 0) clipper.AddSubject(sub); if (sub.size() > 0) clipper.AddSubject(sub);
if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open); if (sub_open.size() > 0) clipper.AddOpenSubject(sub_open);
if (clp.size() > 0) clipper.AddClip(clp); if (clp.size() > 0) clipper.AddClip(clp);
if (!clipper.Execute(ClipType(cliptype), FillRule(fillrule), tree, sol_open)) if (!clipper.Execute(ClipType(cliptype), FillRule(fillrule), tree, sol_open))
return -1; // clipping bug - should never happen :) return -1; // clipping bug - should never happen :)
solution = CreateCPolyTree(tree, 1/scale); solution = CreateCPolyTreeD(tree);
solution_open = CreateCPathsDFromPaths64(sol_open, 1 / scale); solution_open = CreateCPathsDFromPathsD(sol_open);
return 0; //success !! return 0; //success !!
} }
@@ -503,13 +689,13 @@ EXTERN_DLL_EXPORT CPaths64 InflatePaths64(const CPaths64 paths,
double arc_tolerance, bool reverse_solution) double arc_tolerance, bool reverse_solution)
{ {
Paths64 pp; Paths64 pp;
pp = ConvertCPaths(paths); pp = ConvertCPathsToPathsT(paths);
ClipperOffset clip_offset( miter_limit, ClipperOffset clip_offset( miter_limit,
arc_tolerance, reverse_solution); arc_tolerance, reverse_solution);
clip_offset.AddPaths(pp, JoinType(jointype), EndType(endtype)); clip_offset.AddPaths(pp, JoinType(jointype), EndType(endtype));
Paths64 result; Paths64 result;
clip_offset.Execute(delta, result); clip_offset.Execute(delta, result);
return CreateCPaths(result); return CreateCPathsFromPathsT(result);
} }
EXTERN_DLL_EXPORT CPathsD InflatePathsD(const CPathsD paths, EXTERN_DLL_EXPORT CPathsD InflatePathsD(const CPathsD paths,
@@ -525,18 +711,49 @@ EXTERN_DLL_EXPORT CPathsD InflatePathsD(const CPathsD paths,
clip_offset.AddPaths(pp, JoinType(jointype), EndType(endtype)); clip_offset.AddPaths(pp, JoinType(jointype), EndType(endtype));
Paths64 result; Paths64 result;
clip_offset.Execute(delta * scale, result); clip_offset.Execute(delta * scale, result);
return CreateCPathsDFromPaths64(result, 1 / scale); return CreateCPathsDFromPaths64(result, 1 / scale);
} }
EXTERN_DLL_EXPORT CPaths64 InflatePath64(const CPath64 path,
double delta, uint8_t jointype, uint8_t endtype, double miter_limit,
double arc_tolerance, bool reverse_solution)
{
Path64 pp;
pp = ConvertCPathToPathT(path);
ClipperOffset clip_offset(miter_limit,
arc_tolerance, reverse_solution);
clip_offset.AddPath(pp, JoinType(jointype), EndType(endtype));
Paths64 result;
clip_offset.Execute(delta, result);
return CreateCPathsFromPathsT(result);
}
EXTERN_DLL_EXPORT CPathsD InflatePathD(const CPathD path,
double delta, uint8_t jointype, uint8_t endtype,
int precision, double miter_limit,
double arc_tolerance, bool reverse_solution)
{
if (precision < -8 || precision > 8 || !path) return nullptr;
const double scale = std::pow(10, precision);
ClipperOffset clip_offset(miter_limit, arc_tolerance, reverse_solution);
Path64 pp = ConvertCPathDToPath64WithScale(path, scale);
clip_offset.AddPath(pp, JoinType(jointype), EndType(endtype));
Paths64 result;
clip_offset.Execute(delta * scale, result);
return CreateCPathsDFromPaths64(result, 1 / scale);
}
EXTERN_DLL_EXPORT CPaths64 RectClip64(const CRect64& rect, const CPaths64 paths) EXTERN_DLL_EXPORT CPaths64 RectClip64(const CRect64& rect, const CPaths64 paths)
{ {
if (CRectIsEmpty(rect) || !paths) return nullptr; if (CRectIsEmpty(rect) || !paths) return nullptr;
Rect64 r64 = CRectToRect(rect); Rect64 r64 = CRectToRect(rect);
class RectClip64 rc(r64); class RectClip64 rc(r64);
Paths64 pp = ConvertCPaths(paths); Paths64 pp = ConvertCPathsToPathsT(paths);
Paths64 result = rc.Execute(pp); Paths64 result = rc.Execute(pp);
return CreateCPaths(result); return CreateCPathsFromPathsT(result);
} }
EXTERN_DLL_EXPORT CPathsD RectClipD(const CRectD& rect, const CPathsD paths, int precision) EXTERN_DLL_EXPORT CPathsD RectClipD(const CRectD& rect, const CPathsD paths, int precision)
@@ -560,9 +777,9 @@ EXTERN_DLL_EXPORT CPaths64 RectClipLines64(const CRect64& rect,
if (CRectIsEmpty(rect) || !paths) return nullptr; if (CRectIsEmpty(rect) || !paths) return nullptr;
Rect64 r = CRectToRect(rect); Rect64 r = CRectToRect(rect);
class RectClipLines64 rcl (r); class RectClipLines64 rcl (r);
Paths64 pp = ConvertCPaths(paths); Paths64 pp = ConvertCPathsToPathsT(paths);
Paths64 result = rcl.Execute(pp); Paths64 result = rcl.Execute(pp);
return CreateCPaths(result); return CreateCPathsFromPathsT(result);
} }
EXTERN_DLL_EXPORT CPathsD RectClipLinesD(const CRectD& rect, EXTERN_DLL_EXPORT CPathsD RectClipLinesD(const CRectD& rect,
@@ -581,20 +798,35 @@ EXTERN_DLL_EXPORT CPathsD RectClipLinesD(const CRectD& rect,
EXTERN_DLL_EXPORT CPaths64 MinkowskiSum64(const CPath64& cpattern, const CPath64& cpath, bool is_closed) EXTERN_DLL_EXPORT CPaths64 MinkowskiSum64(const CPath64& cpattern, const CPath64& cpath, bool is_closed)
{ {
Path64 path = ConvertCPath(cpath); Path64 path = ConvertCPathToPathT(cpath);
Path64 pattern = ConvertCPath(cpattern); Path64 pattern = ConvertCPathToPathT(cpattern);
Paths64 solution = MinkowskiSum(pattern, path, is_closed); Paths64 solution = MinkowskiSum(pattern, path, is_closed);
return CreateCPaths(solution); return CreateCPathsFromPathsT(solution);
} }
EXTERN_DLL_EXPORT CPaths64 MinkowskiDiff64(const CPath64& cpattern, const CPath64& cpath, bool is_closed) EXTERN_DLL_EXPORT CPaths64 MinkowskiDiff64(const CPath64& cpattern, const CPath64& cpath, bool is_closed)
{ {
Path64 path = ConvertCPath(cpath); Path64 path = ConvertCPathToPathT(cpath);
Path64 pattern = ConvertCPath(cpattern); Path64 pattern = ConvertCPathToPathT(cpattern);
Paths64 solution = MinkowskiDiff(pattern, path, is_closed); Paths64 solution = MinkowskiDiff(pattern, path, is_closed);
return CreateCPaths(solution); return CreateCPathsFromPathsT(solution);
} }
} // end Clipper2Lib namespace #ifdef USINGZ
typedef void (*DLLZCallback64)(const Point64& e1bot, const Point64& e1top, const Point64& e2bot, const Point64& e2top, Point64& pt);
typedef void (*DLLZCallbackD)(const PointD& e1bot, const PointD& e1top, const PointD& e2bot, const PointD& e2top, PointD& pt);
EXTERN_DLL_EXPORT void SetZCallback64(DLLZCallback64 callback)
{
dllCallback64 = callback;
}
EXTERN_DLL_EXPORT void SetZCallbackD(DLLZCallbackD callback)
{
dllCallbackD = callback;
}
#endif
}
#endif // CLIPPER2_EXPORT_H #endif // CLIPPER2_EXPORT_H

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

@@ -1,24 +1,21 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 27 April 2024 * * Date : 27 April 2024 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2024 *
* Purpose : This module provides a simple interface to the Clipper Library * * Purpose : This module provides a simple interface to the Clipper Library *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#ifndef CLIPPER_H #ifndef CLIPPER_H
#define CLIPPER_H #define CLIPPER_H
#include <cstdlib>
#include <type_traits>
#include <vector>
#include "clipper2/clipper.core.h" #include "clipper2/clipper.core.h"
#include "clipper2/clipper.engine.h" #include "clipper2/clipper.engine.h"
#include "clipper2/clipper.offset.h" #include "clipper2/clipper.offset.h"
#include "clipper2/clipper.minkowski.h" #include "clipper2/clipper.minkowski.h"
#include "clipper2/clipper.rectclip.h" #include "clipper2/clipper.rectclip.h"
#include <type_traits>
namespace Clipper2Lib { namespace Clipper2Lib {
@@ -272,14 +269,14 @@ namespace Clipper2Lib {
inline void PolyPathToPaths64(const PolyPath64& polypath, Paths64& paths) inline void PolyPathToPaths64(const PolyPath64& polypath, Paths64& paths)
{ {
paths.push_back(polypath.Polygon()); paths.emplace_back(polypath.Polygon());
for (const auto& child : polypath) for (const auto& child : polypath)
PolyPathToPaths64(*child, paths); PolyPathToPaths64(*child, paths);
} }
inline void PolyPathToPathsD(const PolyPathD& polypath, PathsD& paths) inline void PolyPathToPathsD(const PolyPathD& polypath, PathsD& paths)
{ {
paths.push_back(polypath.Polygon()); paths.emplace_back(polypath.Polygon());
for (const auto& child : polypath) for (const auto& child : polypath)
PolyPathToPathsD(*child, paths); PolyPathToPathsD(*child, paths);
} }
@@ -348,9 +345,9 @@ namespace Clipper2Lib {
result.reserve(array_size / 2); result.reserve(array_size / 2);
for (size_t i = 0; i < array_size; i +=2) for (size_t i = 0; i < array_size; i +=2)
#ifdef USINGZ #ifdef USINGZ
result.push_back( U{ an_array[i], an_array[i + 1], 0} ); result.emplace_back( an_array[i], an_array[i + 1], 0 );
#else #else
result.push_back( U{ an_array[i], an_array[i + 1]} ); result.emplace_back( an_array[i], an_array[i + 1] );
#endif #endif
} }
@@ -518,20 +515,20 @@ namespace Clipper2Lib {
} }
prevIt = srcIt++; prevIt = srcIt++;
dst.push_back(*prevIt); dst.emplace_back(*prevIt);
for (; srcIt != stop; ++srcIt) for (; srcIt != stop; ++srcIt)
{ {
if (!IsCollinear(*prevIt, *srcIt, *(srcIt + 1))) if (!IsCollinear(*prevIt, *srcIt, *(srcIt + 1)))
{ {
prevIt = srcIt; prevIt = srcIt;
dst.push_back(*prevIt); dst.emplace_back(*prevIt);
} }
} }
if (is_open_path) if (is_open_path)
dst.push_back(*srcIt); dst.emplace_back(*srcIt);
else if (!IsCollinear(*prevIt, *stop, dst[0])) else if (!IsCollinear(*prevIt, *stop, dst[0]))
dst.push_back(*stop); dst.emplace_back(*stop);
else else
{ {
while (dst.size() > 2 && while (dst.size() > 2 &&
@@ -603,10 +600,10 @@ namespace Clipper2Lib {
double dx = co, dy = si; double dx = co, dy = si;
Path<T> result; Path<T> result;
result.reserve(steps); result.reserve(steps);
result.push_back(Point<T>(center.x + radiusX, static_cast<double>(center.y))); result.emplace_back(center.x + radiusX, static_cast<double>(center.y));
for (size_t i = 1; i < steps; ++i) for (size_t i = 1; i < steps; ++i)
{ {
result.push_back(Point<T>(center.x + radiusX * dx, center.y + radiusY * dy)); result.emplace_back(center.x + radiusX * dx, center.y + radiusY * dy);
double x = dx * co - dy * si; double x = dx * co - dy * si;
dy = dy * co + dx * si; dy = dy * co + dx * si;
dx = x; dx = x;
@@ -700,7 +697,7 @@ namespace Clipper2Lib {
Path<T> result; Path<T> result;
result.reserve(len); result.reserve(len);
for (typename Path<T>::size_type i = 0; i < len; ++i) for (typename Path<T>::size_type i = 0; i < len; ++i)
if (!flags[i]) result.push_back(path[i]); if (!flags[i]) result.emplace_back(path[i]);
return result; return result;
} }
@@ -711,7 +708,7 @@ namespace Clipper2Lib {
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, isClosedPath)); result.emplace_back(std::move(SimplifyPath(path, epsilon, isClosedPath)));
return result; return result;
} }
@@ -749,7 +746,7 @@ namespace Clipper2Lib {
result.reserve(len); result.reserve(len);
for (typename Path<T>::size_type i = 0; i < len; ++i) for (typename Path<T>::size_type i = 0; i < len; ++i)
if (flags[i]) if (flags[i])
result.push_back(path[i]); result.emplace_back(path[i]);
return result; return result;
} }

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

@@ -1,18 +1,15 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 1 November 2023 * * Date : 1 November 2023 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2023 * * Copyright : Angus Johnson 2010-2023 *
* Purpose : Minkowski Sum and Difference * * Purpose : Minkowski Sum and Difference *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#ifndef CLIPPER_MINKOWSKI_H #ifndef CLIPPER_MINKOWSKI_H
#define CLIPPER_MINKOWSKI_H #define CLIPPER_MINKOWSKI_H
#include <cstdlib>
#include <vector>
#include <string>
#include "clipper2/clipper.core.h" #include "clipper2/clipper.core.h"
namespace Clipper2Lib namespace Clipper2Lib
@@ -35,7 +32,7 @@ namespace Clipper2Lib
Path64 path2(pattern.size()); Path64 path2(pattern.size());
std::transform(pattern.cbegin(), pattern.cend(), std::transform(pattern.cbegin(), pattern.cend(),
path2.begin(), [p](const Point64& pt2) {return p + pt2; }); path2.begin(), [p](const Point64& pt2) {return p + pt2; });
tmp.push_back(path2); tmp.emplace_back(std::move(path2));
} }
} }
else else
@@ -45,7 +42,7 @@ namespace Clipper2Lib
Path64 path2(pattern.size()); Path64 path2(pattern.size());
std::transform(pattern.cbegin(), pattern.cend(), std::transform(pattern.cbegin(), pattern.cend(),
path2.begin(), [p](const Point64& pt2) {return p - pt2; }); path2.begin(), [p](const Point64& pt2) {return p - pt2; });
tmp.push_back(path2); tmp.emplace_back(std::move(path2));
} }
} }
@@ -59,14 +56,14 @@ namespace Clipper2Lib
Path64 quad; Path64 quad;
quad.reserve(4); quad.reserve(4);
{ {
quad.push_back(tmp[g][h]); quad.emplace_back(tmp[g][h]);
quad.push_back(tmp[i][h]); quad.emplace_back(tmp[i][h]);
quad.push_back(tmp[i][j]); quad.emplace_back(tmp[i][j]);
quad.push_back(tmp[g][j]); quad.emplace_back(tmp[g][j]);
}; };
if (!IsPositive(quad)) if (!IsPositive(quad))
std::reverse(quad.begin(), quad.end()); std::reverse(quad.begin(), quad.end());
result.push_back(quad); result.emplace_back(std::move(quad));
h = j; h = j;
} }
g = i; g = i;

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

@@ -1,10 +1,10 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 24 March 2024 * * Date : 22 January 2025 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2025 *
* Purpose : Path Offset (Inflate/Shrink) * * Purpose : Path Offset (Inflate/Shrink) *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#ifndef CLIPPER_OFFSET_H_ #ifndef CLIPPER_OFFSET_H_
@@ -12,6 +12,7 @@
#include "clipper.core.h" #include "clipper.core.h"
#include "clipper.engine.h" #include "clipper.engine.h"
#include <optional>
namespace Clipper2Lib { namespace Clipper2Lib {
@@ -96,7 +97,7 @@ public:
void AddPaths(const Paths64& paths, JoinType jt_, EndType et_); void AddPaths(const Paths64& paths, JoinType jt_, EndType et_);
void Clear() { groups_.clear(); norms.clear(); }; void Clear() { groups_.clear(); norms.clear(); };
void Execute(double delta, Paths64& paths); void Execute(double delta, Paths64& sols_64);
void Execute(double delta, PolyTree64& polytree); void Execute(double delta, PolyTree64& polytree);
void Execute(DeltaCallback64 delta_cb, Paths64& paths); void Execute(DeltaCallback64 delta_cb, Paths64& paths);

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

@@ -1,19 +1,17 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 5 July 2024 * * Date : 5 July 2024 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2024 *
* Purpose : FAST rectangular clipping * * Purpose : FAST rectangular clipping *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#ifndef CLIPPER_RECTCLIP_H #ifndef CLIPPER_RECTCLIP_H
#define CLIPPER_RECTCLIP_H #define CLIPPER_RECTCLIP_H
#include <cstdlib>
#include <vector>
#include <queue>
#include "clipper2/clipper.core.h" #include "clipper2/clipper.core.h"
#include <queue>
namespace Clipper2Lib namespace Clipper2Lib
{ {

2
thirdparty/clipper2/include/clipper2/clipper.version.h vendored
View File

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

14
thirdparty/clipper2/patches/0001-disable-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 925c04685e..67dd731af6 100644 index ab71aeb072..110bee4c10 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
@@ -22,6 +22,8 @@ @@ -19,6 +19,8 @@
#include <optional> #include <numeric>
#include "clipper2/clipper.version.h" #include <cmath>
+#define CLIPPER2_THROW(exception) std::abort() +#define CLIPPER2_THROW(exception) std::abort()
+ +
namespace Clipper2Lib namespace Clipper2Lib
{ {
@@ -79,18 +81,18 @@ namespace Clipper2Lib @@ -76,21 +78,21 @@ namespace Clipper2Lib
switch (error_code) switch (error_code)
{ {
case precision_error_i: case precision_error_i:
@@ -29,6 +29,10 @@ index 925c04685e..67dd731af6 100644
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));
// Should never happen, but adding this to stop a compiler warning
default:
- throw Clipper2Exception("Unknown error");
+ CLIPPER2_THROW(Clipper2Exception("Unknown error"));
} }
#else #else
- ++error_code; // only to stop compiler warning - ++error_code; // only to stop compiler warning

16
thirdparty/clipper2/patches/0002-llvm-disable-int1280-math.patch → thirdparty/clipper2/patches/0002-llvm-disable-int128-math.patch vendored
View File

@@ -1,8 +1,8 @@
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 67dd731af6..dd1b873d5d 100644 index 110bee4c10..aa003bf032 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
@@ -695,11 +695,13 @@ namespace Clipper2Lib @@ -715,11 +715,13 @@ namespace Clipper2Lib
// returns true if (and only if) a * b == c * d // returns true if (and only if) a * b == c * d
inline bool ProductsAreEqual(int64_t a, int64_t b, int64_t c, int64_t d) inline bool ProductsAreEqual(int64_t a, int64_t b, int64_t c, int64_t d)
{ {
@@ -13,15 +13,15 @@ index 67dd731af6..dd1b873d5d 100644
-#else -#else
+// Work around LLVM issue: https://github.com/llvm/llvm-project/issues/16778 +// Work around LLVM issue: https://github.com/llvm/llvm-project/issues/16778
+// Details: https://github.com/godotengine/godot/pull/95964#issuecomment-2306581804 +// Details: https://github.com/godotengine/godot/pull/95964#issuecomment-2306581804
+//#if (defined(__clang__) || defined(__GNUC__)) && UINTPTR_MAX >= UINT64_MAX +// #if (defined(__clang__) || defined(__GNUC__)) && UINTPTR_MAX >= UINT64_MAX
+// const auto ab = static_cast<__int128_t>(a) * static_cast<__int128_t>(b); +// const auto ab = static_cast<__int128_t>(a) * static_cast<__int128_t>(b);
+// const auto cd = static_cast<__int128_t>(c) * static_cast<__int128_t>(d); +// const auto cd = static_cast<__int128_t>(c) * static_cast<__int128_t>(d);
+// return ab == cd; +// return ab == cd;
+//#else +// #else
// nb: unsigned values needed for calculating overflow carry // nb: unsigned values needed for calculating overflow carry
const auto abs_a = static_cast<uint64_t>(std::abs(a)); const auto abs_a = static_cast<uint64_t>(std::abs(a));
const auto abs_b = static_cast<uint64_t>(std::abs(b)); const auto abs_b = static_cast<uint64_t>(std::abs(b));
@@ -714,7 +716,7 @@ namespace Clipper2Lib @@ -734,7 +736,7 @@ namespace Clipper2Lib
const auto sign_cd = TriSign(c) * TriSign(d); const auto sign_cd = TriSign(c) * TriSign(d);
return abs_ab == abs_cd && sign_ab == sign_cd; return abs_ab == abs_cd && sign_ab == sign_cd;

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

@@ -1,21 +1,15 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 27 April 2024 * * Date : 17 September 2024 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2024 *
* Purpose : This is the main polygon clipping module * * Purpose : This is the main polygon clipping module *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#include <cstdlib>
#include <cmath>
#include <stdexcept>
#include <vector>
#include <numeric>
#include <algorithm>
#include "clipper2/clipper.engine.h" #include "clipper2/clipper.engine.h"
#include "clipper2/clipper.h" #include "clipper2/clipper.h"
#include <stdexcept>
// https://github.com/AngusJohnson/Clipper2/discussions/334 // https://github.com/AngusJohnson/Clipper2/discussions/334
// #discussioncomment-4248602 // #discussioncomment-4248602
@@ -85,7 +79,7 @@ namespace Clipper2Lib {
inline bool IsOpenEnd(const Vertex& v) inline bool IsOpenEnd(const Vertex& v)
{ {
return (v.flags & (VertexFlags::OpenStart | VertexFlags::OpenEnd)) != return (v.flags & (VertexFlags::OpenStart | VertexFlags::OpenEnd)) !=
VertexFlags::None; VertexFlags::Empty;
} }
@@ -220,7 +214,7 @@ namespace Clipper2Lib {
inline bool IsMaxima(const Vertex& v) inline bool IsMaxima(const Vertex& v)
{ {
return ((v.flags & VertexFlags::LocalMax) != VertexFlags::None); return ((v.flags & VertexFlags::LocalMax) != VertexFlags::Empty);
} }
@@ -235,12 +229,12 @@ namespace Clipper2Lib {
if (e.wind_dx > 0) if (e.wind_dx > 0)
while ((result->next->pt.y == result->pt.y) && while ((result->next->pt.y == result->pt.y) &&
((result->flags & (VertexFlags::OpenEnd | ((result->flags & (VertexFlags::OpenEnd |
VertexFlags::LocalMax)) == VertexFlags::None)) VertexFlags::LocalMax)) == VertexFlags::Empty))
result = result->next; result = result->next;
else else
while (result->prev->pt.y == result->pt.y && while (result->prev->pt.y == result->pt.y &&
((result->flags & (VertexFlags::OpenEnd | ((result->flags & (VertexFlags::OpenEnd |
VertexFlags::LocalMax)) == VertexFlags::None)) VertexFlags::LocalMax)) == VertexFlags::Empty))
result = result->prev; result = result->prev;
if (!IsMaxima(*result)) result = nullptr; // not a maxima if (!IsMaxima(*result)) result = nullptr; // not a maxima
return result; return result;
@@ -478,7 +472,7 @@ namespace Clipper2Lib {
inline bool IsJoined(const Active& e) inline bool IsJoined(const Active& e)
{ {
return e.join_with != JoinWith::None; return e.join_with != JoinWith::NoJoin;
} }
inline void SetOwner(OutRec* outrec, OutRec* new_owner) inline void SetOwner(OutRec* outrec, OutRec* new_owner)
@@ -517,7 +511,7 @@ namespace Clipper2Lib {
while (op2 != op && op2->pt.y > pt.y) op2 = op2->next; while (op2 != op && op2->pt.y > pt.y) op2 = op2->next;
if (op2 == op) break; if (op2 == op) break;
// must have touched or crossed the pt.Y horizonal // must have touched or crossed the pt.Y horizontal
// and this must happen an even number of times // and this must happen an even number of times
if (op2->pt.y == pt.y) // touching the horizontal if (op2->pt.y == pt.y) // touching the horizontal
@@ -564,7 +558,7 @@ namespace Clipper2Lib {
while (op2->next != op && while (op2->next != op &&
((op2->pt.x == op2->next->pt.x && op2->pt.x == op2->prev->pt.x) || ((op2->pt.x == op2->next->pt.x && op2->pt.x == op2->prev->pt.x) ||
(op2->pt.y == op2->next->pt.y && op2->pt.y == op2->prev->pt.y))) op2 = op2->next; (op2->pt.y == op2->next->pt.y && op2->pt.y == op2->prev->pt.y))) op2 = op2->next;
result.push_back(op2->pt); result.emplace_back(op2->pt);
OutPt* prevOp = op2; OutPt* prevOp = op2;
op2 = op2->next; op2 = op2->next;
while (op2 != op) while (op2 != op)
@@ -572,7 +566,7 @@ namespace Clipper2Lib {
if ((op2->pt.x != op2->next->pt.x || op2->pt.x != prevOp->pt.x) && if ((op2->pt.x != op2->next->pt.x || op2->pt.x != prevOp->pt.x) &&
(op2->pt.y != op2->next->pt.y || op2->pt.y != prevOp->pt.y)) (op2->pt.y != op2->next->pt.y || op2->pt.y != prevOp->pt.y))
{ {
result.push_back(op2->pt); result.emplace_back(op2->pt);
prevOp = op2; prevOp = op2;
} }
op2 = op2->next; op2 = op2->next;
@@ -608,10 +602,10 @@ namespace Clipper2Lib {
Vertex& vert, PathType polytype, bool is_open) Vertex& vert, PathType polytype, bool is_open)
{ {
//make sure the vertex is added only once ... //make sure the vertex is added only once ...
if ((VertexFlags::LocalMin & vert.flags) != VertexFlags::None) return; if ((VertexFlags::LocalMin & vert.flags) != VertexFlags::Empty) return;
vert.flags = (vert.flags | VertexFlags::LocalMin); vert.flags = (vert.flags | VertexFlags::LocalMin);
list.push_back(std::make_unique <LocalMinima>(&vert, polytype, is_open)); list.emplace_back(std::make_unique <LocalMinima>(&vert, polytype, is_open));
} }
void AddPaths_(const Paths64& paths, PathType polytype, bool is_open, void AddPaths_(const Paths64& paths, PathType polytype, bool is_open,
@@ -643,7 +637,7 @@ namespace Clipper2Lib {
} }
curr_v->prev = prev_v; curr_v->prev = prev_v;
curr_v->pt = pt; curr_v->pt = pt;
curr_v->flags = VertexFlags::None; curr_v->flags = VertexFlags::Empty;
prev_v = curr_v++; prev_v = curr_v++;
cnt++; cnt++;
} }
@@ -725,10 +719,10 @@ namespace Clipper2Lib {
void ReuseableDataContainer64::AddLocMin(Vertex& vert, PathType polytype, bool is_open) void ReuseableDataContainer64::AddLocMin(Vertex& vert, PathType polytype, bool is_open)
{ {
//make sure the vertex is added only once ... //make sure the vertex is added only once ...
if ((VertexFlags::LocalMin & vert.flags) != VertexFlags::None) return; if ((VertexFlags::LocalMin & vert.flags) != VertexFlags::Empty) return;
vert.flags = (vert.flags | VertexFlags::LocalMin); vert.flags = (vert.flags | VertexFlags::LocalMin);
minima_list_.push_back(std::make_unique <LocalMinima>(&vert, polytype, is_open)); minima_list_.emplace_back(std::make_unique <LocalMinima>(&vert, polytype, is_open));
} }
void ReuseableDataContainer64::AddPaths(const Paths64& paths, void ReuseableDataContainer64::AddPaths(const Paths64& paths,
@@ -836,9 +830,7 @@ namespace Clipper2Lib {
void ClipperBase::AddPath(const Path64& path, PathType polytype, bool is_open) void ClipperBase::AddPath(const Path64& path, PathType polytype, bool is_open)
{ {
Paths64 tmp; AddPaths(Paths64(1, path), polytype, is_open);
tmp.push_back(path);
AddPaths(tmp, polytype, is_open);
} }
void ClipperBase::AddPaths(const Paths64& paths, PathType polytype, bool is_open) void ClipperBase::AddPaths(const Paths64& paths, PathType polytype, bool is_open)
@@ -857,7 +849,7 @@ namespace Clipper2Lib {
LocalMinimaList::const_iterator i; LocalMinimaList::const_iterator i;
for (i = reuseable_data.minima_list_.cbegin(); i != reuseable_data.minima_list_.cend(); ++i) for (i = reuseable_data.minima_list_.cbegin(); i != reuseable_data.minima_list_.cend(); ++i)
{ {
minima_list_.push_back(std::make_unique <LocalMinima>((*i)->vertex, (*i)->polytype, (*i)->is_open)); minima_list_.emplace_back(std::make_unique <LocalMinima>((*i)->vertex, (*i)->polytype, (*i)->is_open));
if ((*i)->is_open) has_open_paths_ = true; if ((*i)->is_open) has_open_paths_ = true;
} }
} }
@@ -907,10 +899,10 @@ namespace Clipper2Lib {
void ClipperBase::AddLocMin(Vertex& vert, PathType polytype, bool is_open) void ClipperBase::AddLocMin(Vertex& vert, PathType polytype, bool is_open)
{ {
//make sure the vertex is added only once ... //make sure the vertex is added only once ...
if ((VertexFlags::LocalMin & vert.flags) != VertexFlags::None) return; if ((VertexFlags::LocalMin & vert.flags) != VertexFlags::Empty) return;
vert.flags = (vert.flags | VertexFlags::LocalMin); vert.flags = (vert.flags | VertexFlags::LocalMin);
minima_list_.push_back(std::make_unique <LocalMinima>(&vert, polytype, is_open)); minima_list_.emplace_back(std::make_unique <LocalMinima>(&vert, polytype, is_open));
} }
bool ClipperBase::IsContributingClosed(const Active& e) const bool ClipperBase::IsContributingClosed(const Active& e) const
@@ -928,11 +920,14 @@ namespace Clipper2Lib {
case FillRule::Negative: case FillRule::Negative:
if (e.wind_cnt != -1) return false; if (e.wind_cnt != -1) return false;
break; break;
// Should never happen, but adding this to stop a compiler warning
default:
break;
} }
switch (cliptype_) switch (cliptype_)
{ {
case ClipType::None: case ClipType::NoClip:
return false; return false;
case ClipType::Intersection: case ClipType::Intersection:
switch (fillrule_) switch (fillrule_)
@@ -978,6 +973,9 @@ namespace Clipper2Lib {
break; break;
case ClipType::Xor: return true; break; case ClipType::Xor: return true; break;
// Should never happen, but adding this to stop a compiler warning
default:
break;
} }
return false; // we should never get here return false; // we should never get here
} }
@@ -1208,7 +1206,7 @@ namespace Clipper2Lib {
while (PopLocalMinima(bot_y, local_minima)) while (PopLocalMinima(bot_y, local_minima))
{ {
if ((local_minima->vertex->flags & VertexFlags::OpenStart) != VertexFlags::None) if ((local_minima->vertex->flags & VertexFlags::OpenStart) != VertexFlags::Empty)
{ {
left_bound = nullptr; left_bound = nullptr;
} }
@@ -1224,7 +1222,7 @@ namespace Clipper2Lib {
SetDx(*left_bound); SetDx(*left_bound);
} }
if ((local_minima->vertex->flags & VertexFlags::OpenEnd) != VertexFlags::None) if ((local_minima->vertex->flags & VertexFlags::OpenEnd) != VertexFlags::Empty)
{ {
right_bound = nullptr; right_bound = nullptr;
} }
@@ -1488,7 +1486,7 @@ namespace Clipper2Lib {
{ {
OutRec* result = new OutRec(); OutRec* result = new OutRec();
result->idx = outrec_list_.size(); result->idx = outrec_list_.size();
outrec_list_.push_back(result); outrec_list_.emplace_back(result);
result->pts = nullptr; result->pts = nullptr;
result->owner = nullptr; result->owner = nullptr;
result->polypath = nullptr; result->polypath = nullptr;
@@ -1631,12 +1629,12 @@ namespace Clipper2Lib {
if (Path1InsidePath2(prevOp, newOp)) if (Path1InsidePath2(prevOp, newOp))
{ {
newOr->splits = new OutRecList(); newOr->splits = new OutRecList();
newOr->splits->push_back(outrec); newOr->splits->emplace_back(outrec);
} }
else else
{ {
if (!outrec->splits) outrec->splits = new OutRecList(); if (!outrec->splits) outrec->splits = new OutRecList();
outrec->splits->push_back(newOr); outrec->splits->emplace_back(newOr);
} }
} }
} }
@@ -1955,7 +1953,7 @@ namespace Clipper2Lib {
else if (IsFront(e1) || (e1.outrec == e2.outrec)) else if (IsFront(e1) || (e1.outrec == e2.outrec))
{ {
//this 'else if' condition isn't strictly needed but //this 'else if' condition isn't strictly needed but
//it's sensible to split polygons that ony touch at //it's sensible to split polygons that only touch at
//a common vertex (not at common edges). //a common vertex (not at common edges).
#ifdef USINGZ #ifdef USINGZ
@@ -2125,7 +2123,7 @@ namespace Clipper2Lib {
using_polytree_ = use_polytrees; using_polytree_ = use_polytrees;
Reset(); Reset();
int64_t y; int64_t y;
if (ct == ClipType::None || !PopScanline(y)) return true; if (ct == ClipType::NoClip || !PopScanline(y)) return true;
while (succeeded_) while (succeeded_)
{ {
@@ -2239,7 +2237,7 @@ namespace Clipper2Lib {
HorzJoin join = HorzJoin( HorzJoin join = HorzJoin(
DuplicateOp(hs1->left_op, true), DuplicateOp(hs1->left_op, true),
DuplicateOp(hs2->left_op, false)); DuplicateOp(hs2->left_op, false));
horz_join_list_.push_back(join); horz_join_list_.emplace_back(join);
} }
else else
{ {
@@ -2252,7 +2250,7 @@ namespace Clipper2Lib {
HorzJoin join = HorzJoin( HorzJoin join = HorzJoin(
DuplicateOp(hs2->left_op, true), DuplicateOp(hs2->left_op, true),
DuplicateOp(hs1->left_op, false)); DuplicateOp(hs1->left_op, false));
horz_join_list_.push_back(join); horz_join_list_.emplace_back(join);
} }
} }
} }
@@ -2264,7 +2262,7 @@ namespace Clipper2Lib {
if (!toOr->splits) toOr->splits = new OutRecList(); if (!toOr->splits) toOr->splits = new OutRecList();
OutRecList::iterator orIter = fromOr->splits->begin(); OutRecList::iterator orIter = fromOr->splits->begin();
for (; orIter != fromOr->splits->end(); ++orIter) for (; orIter != fromOr->splits->end(); ++orIter)
toOr->splits->push_back(*orIter); toOr->splits->emplace_back(*orIter);
fromOr->splits->clear(); fromOr->splits->clear();
} }
@@ -2317,7 +2315,7 @@ namespace Clipper2Lib {
or2->owner = or1->owner; or2->owner = or1->owner;
if (!or1->splits) or1->splits = new OutRecList(); if (!or1->splits) or1->splits = new OutRecList();
or1->splits->push_back(or2); or1->splits->emplace_back(or2);
} }
else else
or2->owner = or1; or2->owner = or1;
@@ -2376,7 +2374,7 @@ namespace Clipper2Lib {
else ip.x = TopX(e2, ip.y); else ip.x = TopX(e2, ip.y);
} }
} }
intersect_nodes_.push_back(IntersectNode(&e1, &e2, ip)); intersect_nodes_.emplace_back(&e1, &e2, ip);
} }
bool ClipperBase::BuildIntersectList(const int64_t top_y) bool ClipperBase::BuildIntersectList(const int64_t top_y)
@@ -2497,7 +2495,7 @@ namespace Clipper2Lib {
void ClipperBase::AddTrialHorzJoin(OutPt* op) void ClipperBase::AddTrialHorzJoin(OutPt* op)
{ {
if (op->outrec->is_open) return; if (op->outrec->is_open) return;
horz_seg_list_.push_back(HorzSegment(op)); horz_seg_list_.emplace_back(op);
} }
bool ClipperBase::ResetHorzDirection(const Active& horz, bool ClipperBase::ResetHorzDirection(const Active& horz,
@@ -2655,7 +2653,7 @@ namespace Clipper2Lib {
if (horz.outrec) if (horz.outrec)
{ {
//nb: The outrec containining the op returned by IntersectEdges //nb: The outrec containing the op returned by IntersectEdges
//above may no longer be associated with horzEdge. //above may no longer be associated with horzEdge.
AddTrialHorzJoin(GetLastOp(horz)); AddTrialHorzJoin(GetLastOp(horz));
} }
@@ -2789,14 +2787,14 @@ namespace Clipper2Lib {
{ {
if (e.join_with == JoinWith::Right) if (e.join_with == JoinWith::Right)
{ {
e.join_with = JoinWith::None; e.join_with = JoinWith::NoJoin;
e.next_in_ael->join_with = JoinWith::None; e.next_in_ael->join_with = JoinWith::NoJoin;
AddLocalMinPoly(e, *e.next_in_ael, pt, true); AddLocalMinPoly(e, *e.next_in_ael, pt, true);
} }
else else
{ {
e.join_with = JoinWith::None; e.join_with = JoinWith::NoJoin;
e.prev_in_ael->join_with = JoinWith::None; e.prev_in_ael->join_with = JoinWith::NoJoin;
AddLocalMinPoly(*e.prev_in_ael, e, pt, true); AddLocalMinPoly(*e.prev_in_ael, e, pt, true);
} }
} }
@@ -2899,14 +2897,14 @@ namespace Clipper2Lib {
lastPt = op->pt; lastPt = op->pt;
op2 = op->next; op2 = op->next;
} }
path.push_back(lastPt); path.emplace_back(lastPt);
while (op2 != op) while (op2 != op)
{ {
if (op2->pt != lastPt) if (op2->pt != lastPt)
{ {
lastPt = op2->pt; lastPt = op2->pt;
path.push_back(lastPt); path.emplace_back(lastPt);
} }
if (reverse) if (reverse)
op2 = op2->prev; op2 = op2->prev;
@@ -3031,7 +3029,7 @@ namespace Clipper2Lib {
{ {
Path64 path; Path64 path;
if (BuildPath64(outrec->pts, reverse_solution_, true, path)) if (BuildPath64(outrec->pts, reverse_solution_, true, path))
open_paths.push_back(path); open_paths.emplace_back(std::move(path));
continue; continue;
} }
@@ -3060,9 +3058,9 @@ namespace Clipper2Lib {
op2 = op->next; op2 = op->next;
} }
#ifdef USINGZ #ifdef USINGZ
path.push_back(PointD(lastPt.x * inv_scale, lastPt.y * inv_scale, lastPt.z)); path.emplace_back(lastPt.x * inv_scale, lastPt.y * inv_scale, lastPt.z);
#else #else
path.push_back(PointD(lastPt.x * inv_scale, lastPt.y * inv_scale)); path.emplace_back(lastPt.x * inv_scale, lastPt.y * inv_scale);
#endif #endif
while (op2 != op) while (op2 != op)
@@ -3071,9 +3069,9 @@ namespace Clipper2Lib {
{ {
lastPt = op2->pt; lastPt = op2->pt;
#ifdef USINGZ #ifdef USINGZ
path.push_back(PointD(lastPt.x * inv_scale, lastPt.y * inv_scale, lastPt.z)); path.emplace_back(lastPt.x * inv_scale, lastPt.y * inv_scale, lastPt.z);
#else #else
path.push_back(PointD(lastPt.x * inv_scale, lastPt.y * inv_scale)); path.emplace_back(lastPt.x * inv_scale, lastPt.y * inv_scale);
#endif #endif
} }
@@ -3137,7 +3135,7 @@ namespace Clipper2Lib {
{ {
PathD path; PathD path;
if (BuildPathD(outrec->pts, reverse_solution_, true, path, invScale_)) if (BuildPathD(outrec->pts, reverse_solution_, true, path, invScale_))
open_paths.push_back(path); open_paths.emplace_back(std::move(path));
continue; continue;
} }

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

@@ -1,21 +1,34 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 17 April 2024 * * Date : 22 January 2025 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2025 *
* Purpose : Path Offset (Inflate/Shrink) * * Purpose : Path Offset (Inflate/Shrink) *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#include <cmath>
#include "clipper2/clipper.h" #include "clipper2/clipper.h"
#include "clipper2/clipper.offset.h" #include "clipper2/clipper.offset.h"
namespace Clipper2Lib { namespace Clipper2Lib {
const double default_arc_tolerance = 0.25;
const double floating_point_tolerance = 1e-12; const double floating_point_tolerance = 1e-12;
// Clipper2 approximates arcs by using series of relatively short straight
//line segments. And logically, shorter line segments will produce better arc
// approximations. But very short segments can degrade performance, usually
// with little or no discernable improvement in curve quality. Very short
// segments can even detract from curve quality, due to the effects of integer
// rounding. Since there isn't an optimal number of line segments for any given
// arc radius (that perfectly balances curve approximation with performance),
// arc tolerance is user defined. Nevertheless, when the user doesn't define
// an arc tolerance (ie leaves alone the 0 default value), the calculated
// default arc tolerance (offset_radius / 500) generally produces good (smooth)
// arc approximations without producing excessively small segment lengths.
// See also: https://www.angusj.com/clipper2/Docs/Trigonometry.htm
const double arc_const = 0.002; // <-- 1/500
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Miscellaneous methods // Miscellaneous methods
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@@ -38,13 +51,22 @@ std::optional<size_t> GetLowestClosedPathIdx(const Paths64& paths)
return result; return result;
} }
PointD GetUnitNormal(const Point64& pt1, const Point64& pt2) inline double Hypot(double x, double y)
{
// given that this is an internal function, and given the x and y parameters
// will always be coordinate values (or the difference between coordinate values),
// x and y should always be within INT64_MIN to INT64_MAX. Consequently,
// there should be no risk that the following computation will overflow
// see https://stackoverflow.com/a/32436148/359538
return std::sqrt(x * x + y * y);
}
static PointD GetUnitNormal(const Point64& pt1, const Point64& pt2)
{ {
double dx, dy, inverse_hypot;
if (pt1 == pt2) return PointD(0.0, 0.0); if (pt1 == pt2) return PointD(0.0, 0.0);
dx = static_cast<double>(pt2.x - pt1.x); double dx = static_cast<double>(pt2.x - pt1.x);
dy = static_cast<double>(pt2.y - pt1.y); double dy = static_cast<double>(pt2.y - pt1.y);
inverse_hypot = 1.0 / hypot(dx, dy); double inverse_hypot = 1.0 / Hypot(dx, dy);
dx *= inverse_hypot; dx *= inverse_hypot;
dy *= inverse_hypot; dy *= inverse_hypot;
return PointD(dy, -dx); return PointD(dy, -dx);
@@ -55,12 +77,6 @@ inline bool AlmostZero(double value, double epsilon = 0.001)
return std::fabs(value) < epsilon; return std::fabs(value) < epsilon;
} }
inline double Hypot(double x, double y)
{
//see https://stackoverflow.com/a/32436148/359538
return std::sqrt(x * x + y * 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);
@@ -79,7 +95,7 @@ inline bool IsClosedPath(EndType et)
return et == EndType::Polygon || et == EndType::Joined; return et == EndType::Polygon || et == EndType::Joined;
} }
inline Point64 GetPerpendic(const Point64& pt, const PointD& norm, double delta) static inline Point64 GetPerpendic(const Point64& pt, const PointD& norm, double delta)
{ {
#ifdef USINGZ #ifdef USINGZ
return Point64(pt.x + norm.x * delta, pt.y + norm.y * delta, pt.z); return Point64(pt.x + norm.x * delta, pt.y + norm.y * delta, pt.z);
@@ -129,11 +145,11 @@ ClipperOffset::Group::Group(const Paths64& _paths, JoinType _join_type, EndType
// the lowermost path must be an outer path, so if its orientation is negative, // 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.) // then flag the whole group is 'reversed' (will negate delta etc.)
// as this is much more efficient than reversing every path. // as this is much more efficient than reversing every path.
is_reversed = (lowest_path_idx.has_value()) && Area(paths_in[lowest_path_idx.value()]) < 0; is_reversed = (lowest_path_idx.has_value()) && Area(paths_in[lowest_path_idx.value()]) < 0;
} }
else else
{ {
lowest_path_idx = std::nullopt; lowest_path_idx = std::nullopt;
is_reversed = false; is_reversed = false;
} }
} }
@@ -144,15 +160,13 @@ ClipperOffset::Group::Group(const Paths64& _paths, JoinType _join_type, EndType
void ClipperOffset::AddPath(const Path64& path, JoinType jt_, EndType et_) void ClipperOffset::AddPath(const Path64& path, JoinType jt_, EndType et_)
{ {
Paths64 paths; groups_.emplace_back(Paths64(1, path), jt_, et_);
paths.push_back(path);
AddPaths(paths, jt_, et_);
} }
void ClipperOffset::AddPaths(const Paths64 &paths, JoinType jt_, EndType et_) void ClipperOffset::AddPaths(const Paths64 &paths, JoinType jt_, EndType et_)
{ {
if (paths.size() == 0) return; if (paths.size() == 0) return;
groups_.push_back(Group(paths, jt_, et_)); groups_.emplace_back(paths, jt_, et_);
} }
void ClipperOffset::BuildNormals(const Path64& path) void ClipperOffset::BuildNormals(const Path64& path)
@@ -162,8 +176,8 @@ void ClipperOffset::BuildNormals(const Path64& path)
if (path.size() == 0) return; if (path.size() == 0) return;
Path64::const_iterator path_iter, path_stop_iter = --path.cend(); Path64::const_iterator path_iter, path_stop_iter = --path.cend();
for (path_iter = path.cbegin(); path_iter != path_stop_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.emplace_back(GetUnitNormal(*path_iter,*(path_iter +1)));
norms.push_back(GetUnitNormal(*path_stop_iter, *(path.cbegin()))); norms.emplace_back(GetUnitNormal(*path_stop_iter, *(path.cbegin())));
} }
void ClipperOffset::DoBevel(const Path64& path, size_t j, size_t k) void ClipperOffset::DoBevel(const Path64& path, size_t j, size_t k)
@@ -190,8 +204,8 @@ void ClipperOffset::DoBevel(const Path64& path, size_t j, size_t k)
pt2 = PointD(path[j].x + group_delta_ * norms[j].x, path[j].y + group_delta_ * norms[j].y); pt2 = PointD(path[j].x + group_delta_ * norms[j].x, path[j].y + group_delta_ * norms[j].y);
#endif #endif
} }
path_out.push_back(Point64(pt1)); path_out.emplace_back(pt1);
path_out.push_back(Point64(pt2)); path_out.emplace_back(pt2);
} }
void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k) void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
@@ -220,17 +234,17 @@ void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
PointD pt = ptQ; PointD pt = ptQ;
GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt); GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
//get the second intersect point through reflecion //get the second intersect point through reflecion
path_out.push_back(Point64(ReflectPoint(pt, ptQ))); path_out.emplace_back(ReflectPoint(pt, ptQ));
path_out.push_back(Point64(pt)); path_out.emplace_back(pt);
} }
else else
{ {
PointD pt4 = GetPerpendicD(path[j], norms[k], group_delta_); PointD pt4 = GetPerpendicD(path[j], norms[k], group_delta_);
PointD pt = ptQ; PointD pt = ptQ;
GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt); GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
path_out.push_back(Point64(pt)); path_out.emplace_back(pt);
//get the second intersect point through reflecion //get the second intersect point through reflecion
path_out.push_back(Point64(ReflectPoint(pt, ptQ))); path_out.emplace_back(ReflectPoint(pt, ptQ));
} }
} }
@@ -238,14 +252,14 @@ 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
path_out.push_back(Point64( path_out.emplace_back(
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
path_out.push_back(Point64( path_out.emplace_back(
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
} }
@@ -256,8 +270,7 @@ void ClipperOffset::DoRound(const Path64& path, size_t j, size_t k, double angle
// so we'll need to do the following calculations for *every* vertex. // so we'll need to do the following calculations for *every* vertex.
double abs_delta = std::fabs(group_delta_); double abs_delta = std::fabs(group_delta_);
double arcTol = (arc_tolerance_ > floating_point_tolerance ? double arcTol = (arc_tolerance_ > floating_point_tolerance ?
std::min(abs_delta, arc_tolerance_) : std::min(abs_delta, arc_tolerance_) : abs_delta * arc_const);
std::log10(2 + abs_delta) * default_arc_tolerance);
double steps_per_360 = std::min(PI / std::acos(1 - arcTol / abs_delta), abs_delta * PI); 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);
@@ -270,9 +283,9 @@ void ClipperOffset::DoRound(const Path64& path, size_t j, size_t k, double angle
if (j == k) offsetVec.Negate(); if (j == k) offsetVec.Negate();
#ifdef USINGZ #ifdef USINGZ
path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z)); path_out.emplace_back(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z);
#else #else
path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y)); path_out.emplace_back(pt.x + offsetVec.x, pt.y + offsetVec.y);
#endif #endif
int steps = static_cast<int>(std::ceil(steps_per_rad_ * std::abs(angle))); // #448, #456 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 for (int i = 1; i < steps; ++i) // ie 1 less than steps
@@ -280,12 +293,12 @@ void ClipperOffset::DoRound(const Path64& path, size_t j, size_t k, double angle
offsetVec = PointD(offsetVec.x * step_cos_ - step_sin_ * offsetVec.y, offsetVec = PointD(offsetVec.x * step_cos_ - step_sin_ * offsetVec.y,
offsetVec.x * step_sin_ + offsetVec.y * step_cos_); offsetVec.x * step_sin_ + offsetVec.y * step_cos_);
#ifdef USINGZ #ifdef USINGZ
path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z)); path_out.emplace_back(pt.x + offsetVec.x, pt.y + offsetVec.y, pt.z);
#else #else
path_out.push_back(Point64(pt.x + offsetVec.x, pt.y + offsetVec.y)); path_out.emplace_back(pt.x + offsetVec.x, pt.y + offsetVec.y);
#endif #endif
} }
path_out.push_back(GetPerpendic(path[j], norms[j], group_delta_)); path_out.emplace_back(GetPerpendic(path[j], norms[j], group_delta_));
} }
void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size_t k) void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size_t k)
@@ -309,28 +322,25 @@ void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size
} }
if (std::fabs(group_delta_) <= floating_point_tolerance) if (std::fabs(group_delta_) <= floating_point_tolerance)
{ {
path_out.push_back(path[j]); path_out.emplace_back(path[j]);
return; return;
} }
if (cos_a > -0.999 && (sin_a * group_delta_ < 0)) // test for concavity first (#593) if (cos_a > -0.999 && (sin_a * group_delta_ < 0)) // test for concavity first (#593)
{ {
// is concave (so insert 3 points that will create a negative region) // is concave
// by far the simplest way to construct concave joins, especially those joining very
// short segments, is to insert 3 points that produce negative regions. These regions
// will be removed later by the finishing union operation. This is also the best way
// to ensure that path reversals (ie over-shrunk paths) are removed.
#ifdef USINGZ #ifdef USINGZ
path_out.push_back(Point64(GetPerpendic(path[j], norms[k], group_delta_), path[j].z)); path_out.emplace_back(GetPerpendic(path[j], norms[k], group_delta_), path[j].z);
path_out.emplace_back(path[j]); // (#405, #873, #916)
path_out.emplace_back(GetPerpendic(path[j], norms[j], group_delta_), path[j].z);
#else #else
path_out.push_back(GetPerpendic(path[j], norms[k], group_delta_)); path_out.emplace_back(GetPerpendic(path[j], norms[k], group_delta_));
#endif path_out.emplace_back(path[j]); // (#405, #873, #916)
path_out.emplace_back(GetPerpendic(path[j], norms[j], group_delta_));
// this extra point is the only simple way to ensure that path reversals
// (ie over-shrunk paths) are fully cleaned out with the trailing union op.
// However it's probably safe to skip this whenever an angle is almost flat.
if (cos_a < 0.99) path_out.push_back(path[j]); // (#405)
#ifdef USINGZ
path_out.push_back(Point64(GetPerpendic(path[j], norms[j], group_delta_), path[j].z));
#else
path_out.push_back(GetPerpendic(path[j], norms[j], group_delta_));
#endif #endif
} }
else if (cos_a > 0.999 && join_type_ != JoinType::Round) else if (cos_a > 0.999 && join_type_ != JoinType::Round)
@@ -357,7 +367,7 @@ void ClipperOffset::OffsetPolygon(Group& group, const Path64& path)
path_out.clear(); path_out.clear();
for (Path64::size_type j = 0, k = path.size() - 1; j < path.size(); k = j, ++j) for (Path64::size_type j = 0, k = path.size() - 1; j < path.size(); k = j, ++j)
OffsetPoint(group, path, j, k); OffsetPoint(group, path, j, k);
solution->push_back(path_out); solution->emplace_back(path_out);
} }
void ClipperOffset::OffsetOpenJoined(Group& group, const Path64& path) void ClipperOffset::OffsetOpenJoined(Group& group, const Path64& path)
@@ -368,7 +378,7 @@ void ClipperOffset::OffsetOpenJoined(Group& group, const Path64& path)
//rebuild normals //rebuild normals
std::reverse(norms.begin(), norms.end()); std::reverse(norms.begin(), norms.end());
norms.push_back(norms[0]); norms.emplace_back(norms[0]);
norms.erase(norms.begin()); norms.erase(norms.begin());
NegatePath(norms); NegatePath(norms);
@@ -381,7 +391,7 @@ void ClipperOffset::OffsetOpenPath(Group& group, const Path64& path)
if (deltaCallback64_) group_delta_ = deltaCallback64_(path, norms, 0, 0); if (deltaCallback64_) group_delta_ = deltaCallback64_(path, norms, 0, 0);
if (std::fabs(group_delta_) <= floating_point_tolerance) if (std::fabs(group_delta_) <= floating_point_tolerance)
path_out.push_back(path[0]); path_out.emplace_back(path[0]);
else else
{ {
switch (end_type_) switch (end_type_)
@@ -413,7 +423,7 @@ void ClipperOffset::OffsetOpenPath(Group& group, const Path64& path)
group_delta_ = deltaCallback64_(path, norms, highI, highI); group_delta_ = deltaCallback64_(path, norms, highI, highI);
if (std::fabs(group_delta_) <= floating_point_tolerance) if (std::fabs(group_delta_) <= floating_point_tolerance)
path_out.push_back(path[highI]); path_out.emplace_back(path[highI]);
else else
{ {
switch (end_type_) switch (end_type_)
@@ -432,7 +442,7 @@ void ClipperOffset::OffsetOpenPath(Group& group, const Path64& path)
for (size_t j = highI -1, k = highI; j > 0; k = j, --j) for (size_t j = highI -1, k = highI; j > 0; k = j, --j)
OffsetPoint(group, path, j, k); OffsetPoint(group, path, j, k);
solution->push_back(path_out); solution->emplace_back(path_out);
} }
void ClipperOffset::DoGroupOffset(Group& group) void ClipperOffset::DoGroupOffset(Group& group)
@@ -454,13 +464,12 @@ void ClipperOffset::DoGroupOffset(Group& group)
if (group.join_type == JoinType::Round || group.end_type == EndType::Round) if (group.join_type == JoinType::Round || group.end_type == EndType::Round)
{ {
// calculate the number of steps required to approximate a circle // calculate the number of steps required to approximate a circle
// (see http://www.angusj.com/clipper2/Docs/Trigonometry.htm) // (see https://www.angusj.com/clipper2/Docs/Trigonometry.htm)
// arcTol - when arc_tolerance_ is undefined (0) then curve imprecision // arcTol - when arc_tolerance_ is undefined (0) then curve imprecision
// will be relative to the size of the offset (delta). Obviously very // will be relative to the size of the offset (delta). Obviously very
//large offsets will almost always require much less precision. //large offsets will almost always require much less precision.
double arcTol = (arc_tolerance_ > floating_point_tolerance ? double arcTol = (arc_tolerance_ > floating_point_tolerance) ?
std::min(abs_delta, arc_tolerance_) : std::min(abs_delta, arc_tolerance_) : abs_delta * arc_const;
std::log10(2 + abs_delta) * default_arc_tolerance);
double steps_per_360 = std::min(PI / std::acos(1 - arcTol / abs_delta), abs_delta * PI); 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);
@@ -507,7 +516,7 @@ void ClipperOffset::DoGroupOffset(Group& group)
#endif #endif
} }
solution->push_back(path_out); solution->emplace_back(path_out);
continue; continue;
} // end of offsetting a single point } // end of offsetting a single point
@@ -588,7 +597,7 @@ void ClipperOffset::ExecuteInternal(double delta)
if (!solution->size()) return; if (!solution->size()) return;
bool paths_reversed = CheckReverseOrientation(); bool paths_reversed = CheckReverseOrientation();
//clean up self-intersections ... //clean up self-intersections ...
Clipper64 c; Clipper64 c;
c.PreserveCollinear(false); c.PreserveCollinear(false);
@@ -617,10 +626,10 @@ void ClipperOffset::ExecuteInternal(double delta)
} }
} }
void ClipperOffset::Execute(double delta, Paths64& paths) void ClipperOffset::Execute(double delta, Paths64& paths64)
{ {
paths.clear(); paths64.clear();
solution = &paths; solution = &paths64;
solution_tree = nullptr; solution_tree = nullptr;
ExecuteInternal(delta); ExecuteInternal(delta);
} }

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

@@ -1,13 +1,12 @@
/******************************************************************************* /*******************************************************************************
* Author : Angus Johnson * * Author : Angus Johnson *
* Date : 5 July 2024 * * Date : 5 July 2024 *
* Website : http://www.angusj.com * * Website : https://www.angusj.com *
* Copyright : Angus Johnson 2010-2024 * * Copyright : Angus Johnson 2010-2024 *
* Purpose : FAST rectangular clipping * * Purpose : FAST rectangular clipping *
* License : http://www.boost.org/LICENSE_1_0.txt * * License : https://www.boost.org/LICENSE_1_0.txt *
*******************************************************************************/ *******************************************************************************/
#include <cmath>
#include "clipper2/clipper.h" #include "clipper2/clipper.h"
#include "clipper2/clipper.rectclip.h" #include "clipper2/clipper.rectclip.h"
@@ -282,7 +281,7 @@ namespace Clipper2Lib {
{ {
if (op->edge) return; if (op->edge) return;
op->edge = &edge; op->edge = &edge;
edge.push_back(op); edge.emplace_back(op);
} }
inline void UncoupleEdge(OutPt2* op) inline void UncoupleEdge(OutPt2* op)
@@ -328,7 +327,7 @@ namespace Clipper2Lib {
result->pt = pt; result->pt = pt;
result->next = result; result->next = result;
result->prev = result; result->prev = result;
results_.push_back(result); results_.emplace_back(result);
} }
else else
{ {
@@ -489,7 +488,7 @@ namespace Clipper2Lib {
{ {
bool isClockw = IsClockwise(prev, loc, prev_pt, path[i], rect_mp_); bool isClockw = IsClockwise(prev, loc, prev_pt, path[i], rect_mp_);
do { do {
start_locs_.push_back(prev); start_locs_.emplace_back(prev);
prev = GetAdjacentLocation(prev, isClockw); prev = GetAdjacentLocation(prev, isClockw);
} while (prev != loc); } while (prev != loc);
crossing_loc = crossing_prev; // still not crossed crossing_loc = crossing_prev; // still not crossed
@@ -514,7 +513,7 @@ namespace Clipper2Lib {
if (first_cross_ == Location::Inside) if (first_cross_ == Location::Inside)
{ {
first_cross_ = crossing_loc; first_cross_ = crossing_loc;
start_locs_.push_back(prev); start_locs_.emplace_back(prev);
} }
else if (prev != crossing_loc) else if (prev != crossing_loc)
{ {
@@ -536,7 +535,7 @@ namespace Clipper2Lib {
if (first_cross_ == Location::Inside) if (first_cross_ == Location::Inside)
{ {
first_cross_ = loc; first_cross_ = loc;
start_locs_.push_back(prev); start_locs_.emplace_back(prev);
} }
loc = crossing_loc; loc = crossing_loc;
@@ -750,7 +749,7 @@ namespace Clipper2Lib {
if (!isRejoining) if (!isRejoining)
{ {
size_t new_idx = results_.size(); size_t new_idx = results_.size();
results_.push_back(p1a); results_.emplace_back(p1a);
SetNewOwner(p1a, new_idx); SetNewOwner(p1a, new_idx);
} }
@@ -861,11 +860,11 @@ namespace Clipper2Lib {
if (!op2) return Path64(); if (!op2) return Path64();
Path64 result; Path64 result;
result.push_back(op->pt); result.emplace_back(op->pt);
op2 = op->next; op2 = op->next;
while (op2 != op) while (op2 != op)
{ {
result.push_back(op2->pt); result.emplace_back(op2->pt);
op2 = op2->next; op2 = op2->next;
} }
return result; return result;
@@ -885,7 +884,7 @@ namespace Clipper2Lib {
else if (rect_.Contains(path_bounds_)) else if (rect_.Contains(path_bounds_))
{ {
// the path must be completely inside rect_ // the path must be completely inside rect_
result.push_back(path); result.emplace_back(path);
continue; continue;
} }
@@ -898,7 +897,7 @@ namespace Clipper2Lib {
{ {
Path64 tmp = GetPath(op); Path64 tmp = GetPath(op);
if (!tmp.empty()) if (!tmp.empty())
result.emplace_back(tmp); result.emplace_back(std::move(tmp));
} }
//clean up after every loop //clean up after every loop
@@ -930,7 +929,7 @@ namespace Clipper2Lib {
{ {
Path64 tmp = GetPath(op); Path64 tmp = GetPath(op);
if (!tmp.empty()) if (!tmp.empty())
result.emplace_back(tmp); result.emplace_back(std::move(tmp));
} }
results_.clear(); results_.clear();
@@ -1015,11 +1014,11 @@ namespace Clipper2Lib {
Path64 result; Path64 result;
if (!op || op == op->next) return result; if (!op || op == op->next) return result;
op = op->next; // starting at path beginning op = op->next; // starting at path beginning
result.push_back(op->pt); result.emplace_back(op->pt);
OutPt2 *op2 = op->next; OutPt2 *op2 = op->next;
while (op2 != op) while (op2 != op)
{ {
result.push_back(op2->pt); result.emplace_back(op2->pt);
op2 = op2->next; op2 = op2->next;
} }
return result; return result;