diff options
50 files changed, 1214 insertions, 1296 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 9a5fc8387..c6f295150 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -268,8 +268,6 @@ set(LIBDIR_BIN ${CMAKE_CURRENT_BINARY_DIR}/src) include_directories(${LIBDIR}) # For generated header files include_directories(${LIBDIR_BIN}/platform) -# For libslic3r.h -include_directories(${LIBDIR}/clipper) if(WIN32) add_definitions(-D_USE_MATH_DEFINES -D_WIN32 -D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS) diff --git a/src/clipper/CMakeLists.txt b/src/clipper/CMakeLists.txt index 8a4e92852..0362a4d84 100644 --- a/src/clipper/CMakeLists.txt +++ b/src/clipper/CMakeLists.txt @@ -2,8 +2,9 @@ project(clipper) cmake_minimum_required(VERSION 2.6) add_library(clipper STATIC - clipper.cpp - clipper.hpp +# We are using ClipperLib compiled as part of the libslic3r project using Slic3r::Point as its base type. +# clipper.cpp +# clipper.hpp clipper_z.cpp clipper_z.hpp ) diff --git a/src/clipper/clipper.cpp b/src/clipper/clipper.cpp index cbe54a064..06c91bf3a 100644 --- a/src/clipper/clipper.cpp +++ b/src/clipper/clipper.cpp @@ -61,11 +61,15 @@ #define CLIPPERLIB_PROFILE_BLOCK(name) #endif -#ifdef use_xyz +#ifdef CLIPPERLIB_NAMESPACE_PREFIX +namespace CLIPPERLIB_NAMESPACE_PREFIX { +#endif // CLIPPERLIB_NAMESPACE_PREFIX + +#ifdef CLIPPERLIB_USE_XYZ namespace ClipperLib_Z { -#else /* use_xyz */ +#else /* CLIPPERLIB_USE_XYZ */ namespace ClipperLib { -#endif /* use_xyz */ +#endif /* CLIPPERLIB_USE_XYZ */ static double const pi = 3.141592653589793238; static double const two_pi = pi *2; @@ -156,7 +160,7 @@ double Area(const Path &poly) double a = 0; for (int i = 0, j = size -1; i < size; ++i) { - a += ((double)poly[j].X + poly[i].X) * ((double)poly[j].Y - poly[i].Y); + a += ((double)poly[j].x() + poly[i].x()) * ((double)poly[j].y() - poly[i].y()); j = i; } return -a * 0.5; @@ -169,7 +173,7 @@ double Area(const OutRec &outRec) if (!op) return 0; double a = 0; do { - a += (double)(op->Prev->Pt.X + op->Pt.X) * (double)(op->Prev->Pt.Y - op->Pt.Y); + a += (double)(op->Prev->Pt.x() + op->Pt.x()) * (double)(op->Prev->Pt.y() - op->Pt.y()); op = op->Next; } while (op != outRec.Pts); return a * 0.5; @@ -201,26 +205,26 @@ int PointInPolygon(const IntPoint &pt, const Path &path) for(size_t i = 1; i <= cnt; ++i) { IntPoint ipNext = (i == cnt ? path[0] : path[i]); - if (ipNext.Y == pt.Y && ((ipNext.X == pt.X) || (ip.Y == pt.Y && ((ipNext.X > pt.X) == (ip.X < pt.X))))) + if (ipNext.y() == pt.y() && ((ipNext.x() == pt.x()) || (ip.y() == pt.y() && ((ipNext.x() > pt.x()) == (ip.x() < pt.x()))))) return -1; - if ((ip.Y < pt.Y) != (ipNext.Y < pt.Y)) + if ((ip.y() < pt.y()) != (ipNext.y() < pt.y())) { - if (ip.X >= pt.X) + if (ip.x() >= pt.x()) { - if (ipNext.X > pt.X) result = 1 - result; + if (ipNext.x() > pt.x()) result = 1 - result; else { - double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) - (double)(ipNext.X - pt.X) * (ip.Y - pt.Y); + double d = (double)(ip.x() - pt.x()) * (ipNext.y() - pt.y()) - (double)(ipNext.x() - pt.x()) * (ip.y() - pt.y()); if (!d) return -1; - if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result; + if ((d > 0) == (ipNext.y() > ip.y())) result = 1 - result; } } else { - if (ipNext.X > pt.X) + if (ipNext.x() > pt.x()) { - double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) - (double)(ipNext.X - pt.X) * (ip.Y - pt.Y); + double d = (double)(ip.x() - pt.x()) * (ipNext.y() - pt.y()) - (double)(ipNext.x() - pt.x()) * (ip.y() - pt.y()); if (!d) return -1; - if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result; + if ((d > 0) == (ipNext.y() > ip.y())) result = 1 - result; } } } @@ -238,29 +242,29 @@ int PointInPolygon (const IntPoint &pt, OutPt *op) OutPt* startOp = op; do { - if (op->Next->Pt.Y == pt.Y) + if (op->Next->Pt.y() == pt.y()) { - if ((op->Next->Pt.X == pt.X) || (op->Pt.Y == pt.Y && - ((op->Next->Pt.X > pt.X) == (op->Pt.X < pt.X)))) return -1; + if ((op->Next->Pt.x() == pt.x()) || (op->Pt.y() == pt.y() && + ((op->Next->Pt.x() > pt.x()) == (op->Pt.x() < pt.x())))) return -1; } - if ((op->Pt.Y < pt.Y) != (op->Next->Pt.Y < pt.Y)) + if ((op->Pt.y() < pt.y()) != (op->Next->Pt.y() < pt.y())) { - if (op->Pt.X >= pt.X) + if (op->Pt.x() >= pt.x()) { - if (op->Next->Pt.X > pt.X) result = 1 - result; + if (op->Next->Pt.x() > pt.x()) result = 1 - result; else { - double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) - (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y); + double d = (double)(op->Pt.x() - pt.x()) * (op->Next->Pt.y() - pt.y()) - (double)(op->Next->Pt.x() - pt.x()) * (op->Pt.y() - pt.y()); if (!d) return -1; - if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result; + if ((d > 0) == (op->Next->Pt.y() > op->Pt.y())) result = 1 - result; } } else { - if (op->Next->Pt.X > pt.X) + if (op->Next->Pt.x() > pt.x()) { - double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) - (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y); + double d = (double)(op->Pt.x() - pt.x()) * (op->Next->Pt.y() - pt.y()) - (double)(op->Next->Pt.x() - pt.x()) * (op->Pt.y() - pt.y()); if (!d) return -1; - if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result; + if ((d > 0) == (op->Next->Pt.y() > op->Pt.y())) result = 1 - result; } } } @@ -304,100 +308,100 @@ inline bool SlopesEqual(const cInt dx1, const cInt dy1, const cInt dx2, const cI #endif inline bool SlopesEqual(const TEdge &e1, const TEdge &e2, bool UseFullInt64Range) - { return SlopesEqual(e1.Delta.X, e1.Delta.Y, e2.Delta.X, e2.Delta.Y, UseFullInt64Range); } + { return SlopesEqual(e1.Delta.x(), e1.Delta.y(), e2.Delta.x(), e2.Delta.y(), UseFullInt64Range); } inline bool SlopesEqual(const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3, bool UseFullInt64Range) - { return SlopesEqual(pt1.X-pt2.X, pt1.Y-pt2.Y, pt2.X-pt3.X, pt2.Y-pt3.Y, UseFullInt64Range); } + { return SlopesEqual(pt1.x()-pt2.x(), pt1.y()-pt2.y(), pt2.x()-pt3.x(), pt2.y()-pt3.y(), UseFullInt64Range); } inline bool SlopesEqual(const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3, const IntPoint &pt4, bool UseFullInt64Range) - { return SlopesEqual(pt1.X-pt2.X, pt1.Y-pt2.Y, pt3.X-pt4.X, pt3.Y-pt4.Y, UseFullInt64Range); } + { return SlopesEqual(pt1.x()-pt2.x(), pt1.y()-pt2.y(), pt3.x()-pt4.x(), pt3.y()-pt4.y(), UseFullInt64Range); } //------------------------------------------------------------------------------ inline bool IsHorizontal(TEdge &e) { - return e.Delta.Y == 0; + return e.Delta.y() == 0; } //------------------------------------------------------------------------------ inline double GetDx(const IntPoint &pt1, const IntPoint &pt2) { - return (pt1.Y == pt2.Y) ? - HORIZONTAL : (double)(pt2.X - pt1.X) / (pt2.Y - pt1.Y); + return (pt1.y() == pt2.y()) ? + HORIZONTAL : (double)(pt2.x() - pt1.x()) / (pt2.y() - pt1.y()); } //--------------------------------------------------------------------------- inline cInt TopX(TEdge &edge, const cInt currentY) { - return (currentY == edge.Top.Y) ? - edge.Top.X : - edge.Bot.X + Round(edge.Dx *(currentY - edge.Bot.Y)); + return (currentY == edge.Top.y()) ? + edge.Top.x() : + edge.Bot.x() + Round(edge.Dx *(currentY - edge.Bot.y())); } //------------------------------------------------------------------------------ void IntersectPoint(TEdge &Edge1, TEdge &Edge2, IntPoint &ip) { -#ifdef use_xyz - ip.Z = 0; +#ifdef CLIPPERLIB_USE_XYZ + ip.z() = 0; #endif double b1, b2; if (Edge1.Dx == Edge2.Dx) { - ip.Y = Edge1.Curr.Y; - ip.X = TopX(Edge1, ip.Y); + ip.y() = Edge1.Curr.y(); + ip.x() = TopX(Edge1, ip.y()); return; } - else if (Edge1.Delta.X == 0) + else if (Edge1.Delta.x() == 0) { - ip.X = Edge1.Bot.X; + ip.x() = Edge1.Bot.x(); if (IsHorizontal(Edge2)) - ip.Y = Edge2.Bot.Y; + ip.y() = Edge2.Bot.y(); else { - b2 = Edge2.Bot.Y - (Edge2.Bot.X / Edge2.Dx); - ip.Y = Round(ip.X / Edge2.Dx + b2); + b2 = Edge2.Bot.y() - (Edge2.Bot.x() / Edge2.Dx); + ip.y() = Round(ip.x() / Edge2.Dx + b2); } } - else if (Edge2.Delta.X == 0) + else if (Edge2.Delta.x() == 0) { - ip.X = Edge2.Bot.X; + ip.x() = Edge2.Bot.x(); if (IsHorizontal(Edge1)) - ip.Y = Edge1.Bot.Y; + ip.y() = Edge1.Bot.y(); else { - b1 = Edge1.Bot.Y - (Edge1.Bot.X / Edge1.Dx); - ip.Y = Round(ip.X / Edge1.Dx + b1); + b1 = Edge1.Bot.y() - (Edge1.Bot.x() / Edge1.Dx); + ip.y() = Round(ip.x() / Edge1.Dx + b1); } } else { - b1 = double(Edge1.Bot.X) - double(Edge1.Bot.Y) * Edge1.Dx; - b2 = double(Edge2.Bot.X) - double(Edge2.Bot.Y) * Edge2.Dx; + b1 = double(Edge1.Bot.x()) - double(Edge1.Bot.y()) * Edge1.Dx; + b2 = double(Edge2.Bot.x()) - double(Edge2.Bot.y()) * Edge2.Dx; double q = (b2-b1) / (Edge1.Dx - Edge2.Dx); - ip.Y = Round(q); - ip.X = (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx)) ? + ip.y() = Round(q); + ip.x() = (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx)) ? Round(Edge1.Dx * q + b1) : Round(Edge2.Dx * q + b2); } - if (ip.Y < Edge1.Top.Y || ip.Y < Edge2.Top.Y) + if (ip.y() < Edge1.Top.y() || ip.y() < Edge2.Top.y()) { - if (Edge1.Top.Y > Edge2.Top.Y) - ip.Y = Edge1.Top.Y; + if (Edge1.Top.y() > Edge2.Top.y()) + ip.y() = Edge1.Top.y(); else - ip.Y = Edge2.Top.Y; + ip.y() = Edge2.Top.y(); if (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx)) - ip.X = TopX(Edge1, ip.Y); + ip.x() = TopX(Edge1, ip.y()); else - ip.X = TopX(Edge2, ip.Y); + ip.x() = TopX(Edge2, ip.y()); } - //finally, don't allow 'ip' to be BELOW curr.Y (ie bottom of scanbeam) ... - if (ip.Y > Edge1.Curr.Y) + //finally, don't allow 'ip' to be BELOW curr.y() (ie bottom of scanbeam) ... + if (ip.y() > Edge1.Curr.y()) { - ip.Y = Edge1.Curr.Y; + ip.y() = Edge1.Curr.y(); //use the more vertical edge to derive X ... if (std::fabs(Edge1.Dx) > std::fabs(Edge2.Dx)) - ip.X = TopX(Edge2, ip.Y); else - ip.X = TopX(Edge1, ip.Y); + ip.x() = TopX(Edge2, ip.y()); else + ip.x() = TopX(Edge1, ip.y()); } } //------------------------------------------------------------------------------ @@ -429,7 +433,7 @@ inline void InitEdge(TEdge* e, TEdge* eNext, TEdge* ePrev, const IntPoint& Pt) void InitEdge2(TEdge& e, PolyType Pt) { - if (e.Curr.Y >= e.Next->Curr.Y) + if (e.Curr.y() >= e.Next->Curr.y()) { e.Bot = e.Curr; e.Top = e.Next->Curr; @@ -439,11 +443,11 @@ void InitEdge2(TEdge& e, PolyType Pt) e.Bot = e.Next->Curr; } - e.Delta.X = (e.Top.X - e.Bot.X); - e.Delta.Y = (e.Top.Y - e.Bot.Y); + e.Delta.x() = (e.Top.x() - e.Bot.x()); + e.Delta.y() = (e.Top.y() - e.Bot.y()); - if (e.Delta.Y == 0) e.Dx = HORIZONTAL; - else e.Dx = (double)(e.Delta.X) / e.Delta.Y; + if (e.Delta.y() == 0) e.Dx = HORIZONTAL; + else e.Dx = (double)(e.Delta.x()) / e.Delta.y(); e.PolyTyp = Pt; } @@ -466,9 +470,9 @@ inline void ReverseHorizontal(TEdge &e) //swap horizontal edges' Top and Bottom x's so they follow the natural //progression of the bounds - ie so their xbots will align with the //adjoining lower edge. [Helpful in the ProcessHorizontal() method.] - std::swap(e.Top.X, e.Bot.X); -#ifdef use_xyz - std::swap(e.Top.Z, e.Bot.Z); + std::swap(e.Top.x(), e.Bot.x()); +#ifdef CLIPPERLIB_USE_XYZ + std::swap(e.Top.z(), e.Bot.z()); #endif } //------------------------------------------------------------------------------ @@ -477,20 +481,20 @@ bool GetOverlapSegment(IntPoint pt1a, IntPoint pt1b, IntPoint pt2a, IntPoint pt2b, IntPoint &pt1, IntPoint &pt2) { //precondition: segments are Collinear. - if (std::abs(pt1a.X - pt1b.X) > std::abs(pt1a.Y - pt1b.Y)) + if (std::abs(pt1a.x() - pt1b.x()) > std::abs(pt1a.y() - pt1b.y())) { - if (pt1a.X > pt1b.X) std::swap(pt1a, pt1b); - if (pt2a.X > pt2b.X) std::swap(pt2a, pt2b); - if (pt1a.X > pt2a.X) pt1 = pt1a; else pt1 = pt2a; - if (pt1b.X < pt2b.X) pt2 = pt1b; else pt2 = pt2b; - return pt1.X < pt2.X; + if (pt1a.x() > pt1b.x()) std::swap(pt1a, pt1b); + if (pt2a.x() > pt2b.x()) std::swap(pt2a, pt2b); + if (pt1a.x() > pt2a.x()) pt1 = pt1a; else pt1 = pt2a; + if (pt1b.x() < pt2b.x()) pt2 = pt1b; else pt2 = pt2b; + return pt1.x() < pt2.x(); } else { - if (pt1a.Y < pt1b.Y) std::swap(pt1a, pt1b); - if (pt2a.Y < pt2b.Y) std::swap(pt2a, pt2b); - if (pt1a.Y < pt2a.Y) pt1 = pt1a; else pt1 = pt2a; - if (pt1b.Y > pt2b.Y) pt2 = pt1b; else pt2 = pt2b; - return pt1.Y > pt2.Y; + if (pt1a.y() < pt1b.y()) std::swap(pt1a, pt1b); + if (pt2a.y() < pt2b.y()) std::swap(pt2a, pt2b); + if (pt1a.y() < pt2a.y()) pt1 = pt1a; else pt1 = pt2a; + if (pt1b.y() > pt2b.y()) pt2 = pt1b; else pt2 = pt2b; + return pt1.y() > pt2.y(); } } //------------------------------------------------------------------------------ @@ -521,14 +525,14 @@ OutPt* GetBottomPt(OutPt *pp) OutPt* p = pp->Next; while (p != pp) { - if (p->Pt.Y > pp->Pt.Y) + if (p->Pt.y() > pp->Pt.y()) { pp = p; dups = 0; } - else if (p->Pt.Y == pp->Pt.Y && p->Pt.X <= pp->Pt.X) + else if (p->Pt.y() == pp->Pt.y() && p->Pt.x() <= pp->Pt.x()) { - if (p->Pt.X < pp->Pt.X) + if (p->Pt.x() < pp->Pt.x()) { dups = 0; pp = p; @@ -558,10 +562,10 @@ bool Pt2IsBetweenPt1AndPt3(const IntPoint &pt1, { if ((pt1 == pt3) || (pt1 == pt2) || (pt3 == pt2)) return false; - else if (pt1.X != pt3.X) - return (pt2.X > pt1.X) == (pt2.X < pt3.X); + else if (pt1.x() != pt3.x()) + return (pt2.x() > pt1.x()) == (pt2.x() < pt3.x()); else - return (pt2.Y > pt1.Y) == (pt2.Y < pt3.Y); + return (pt2.y() > pt1.y()) == (pt2.y() < pt3.y()); } //------------------------------------------------------------------------------ @@ -582,10 +586,10 @@ inline void RangeTest(const IntPoint& Pt, bool& useFullRange) { if (useFullRange) { - if (Pt.X > hiRange || Pt.Y > hiRange || -Pt.X > hiRange || -Pt.Y > hiRange) + if (Pt.x() > hiRange || Pt.y() > hiRange || -Pt.x() > hiRange || -Pt.y() > hiRange) throw clipperException("Coordinate outside allowed range"); } - else if (Pt.X > loRange|| Pt.Y > loRange || -Pt.X > loRange || -Pt.Y > loRange) + else if (Pt.x() > loRange|| Pt.y() > loRange || -Pt.x() > loRange || -Pt.y() > loRange) { useFullRange = true; RangeTest(Pt, useFullRange); @@ -605,8 +609,8 @@ inline TEdge* FindNextLocMin(TEdge* E) while (IsHorizontal(*E->Prev)) E = E->Prev; TEdge* E2 = E; while (IsHorizontal(*E)) E = E->Next; - if (E->Top.Y == E->Prev->Bot.Y) continue; //ie just an intermediate horz. - if (E2->Prev->Bot.X < E->Bot.X) E = E2; + if (E->Top.y() == E->Prev->Bot.y()) continue; //ie just an intermediate horz. + if (E2->Prev->Bot.x() < E->Bot.x()) E = E2; break; } return E; @@ -625,14 +629,14 @@ TEdge* ClipperBase::ProcessBound(TEdge* E, bool NextIsForward) //create another LocMin and call ProcessBound once more if (NextIsForward) { - while (E->Top.Y == E->Next->Bot.Y) E = E->Next; + while (E->Top.y() == E->Next->Bot.y()) E = E->Next; //don't include top horizontals when parsing a bound a second time, //they will be contained in the opposite bound ... while (E != Result && IsHorizontal(*E)) E = E->Prev; } else { - while (E->Top.Y == E->Prev->Bot.Y) E = E->Prev; + while (E->Top.y() == E->Prev->Bot.y()) E = E->Prev; while (E != Result && IsHorizontal(*E)) E = E->Next; } @@ -649,7 +653,7 @@ TEdge* ClipperBase::ProcessBound(TEdge* E, bool NextIsForward) else E = Result->Prev; LocalMinimum locMin; - locMin.Y = E->Bot.Y; + locMin.Y = E->Bot.y(); locMin.LeftBound = 0; locMin.RightBound = E; E->WindDelta = 0; @@ -672,17 +676,17 @@ TEdge* ClipperBase::ProcessBound(TEdge* E, bool NextIsForward) EStart = E->Next; if (IsHorizontal(*EStart)) //ie an adjoining horizontal skip edge { - if (EStart->Bot.X != E->Bot.X && EStart->Top.X != E->Bot.X) + if (EStart->Bot.x() != E->Bot.x() && EStart->Top.x() != E->Bot.x()) ReverseHorizontal(*E); } - else if (EStart->Bot.X != E->Bot.X) + else if (EStart->Bot.x() != E->Bot.x()) ReverseHorizontal(*E); } EStart = E; if (NextIsForward) { - while (Result->Top.Y == Result->Next->Bot.Y && Result->Next->OutIdx != Skip) + while (Result->Top.y() == Result->Next->Bot.y() && Result->Next->OutIdx != Skip) Result = Result->Next; if (IsHorizontal(*Result) && Result->Next->OutIdx != Skip) { @@ -691,38 +695,38 @@ TEdge* ClipperBase::ProcessBound(TEdge* E, bool NextIsForward) //unless a Skip edge is encountered when that becomes the top divide Horz = Result; while (IsHorizontal(*Horz->Prev)) Horz = Horz->Prev; - if (Horz->Prev->Top.X > Result->Next->Top.X) Result = Horz->Prev; + if (Horz->Prev->Top.x() > Result->Next->Top.x()) Result = Horz->Prev; } while (E != Result) { E->NextInLML = E->Next; if (IsHorizontal(*E) && E != EStart && - E->Bot.X != E->Prev->Top.X) ReverseHorizontal(*E); + E->Bot.x() != E->Prev->Top.x()) ReverseHorizontal(*E); E = E->Next; } - if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Prev->Top.X) + if (IsHorizontal(*E) && E != EStart && E->Bot.x() != E->Prev->Top.x()) ReverseHorizontal(*E); Result = Result->Next; //move to the edge just beyond current bound } else { - while (Result->Top.Y == Result->Prev->Bot.Y && Result->Prev->OutIdx != Skip) + while (Result->Top.y() == Result->Prev->Bot.y() && Result->Prev->OutIdx != Skip) Result = Result->Prev; if (IsHorizontal(*Result) && Result->Prev->OutIdx != Skip) { Horz = Result; while (IsHorizontal(*Horz->Next)) Horz = Horz->Next; - if (Horz->Next->Top.X == Result->Prev->Top.X || - Horz->Next->Top.X > Result->Prev->Top.X) Result = Horz->Next; + if (Horz->Next->Top.x() == Result->Prev->Top.x() || + Horz->Next->Top.x() > Result->Prev->Top.x()) Result = Horz->Next; } while (E != Result) { E->NextInLML = E->Prev; - if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X) + if (IsHorizontal(*E) && E != EStart && E->Bot.x() != E->Next->Top.x()) ReverseHorizontal(*E); E = E->Prev; } - if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X) + if (IsHorizontal(*E) && E != EStart && E->Bot.x() != E->Next->Top.x()) ReverseHorizontal(*E); Result = Result->Prev; //move to the edge just beyond current bound } @@ -887,7 +891,7 @@ bool ClipperBase::AddPathInternal(const Path &pg, int highI, PolyType PolyTyp, b { InitEdge2(*E, PolyTyp); E = E->Next; - if (IsFlat && E->Curr.Y != eStart->Curr.Y) IsFlat = false; + if (IsFlat && E->Curr.y() != eStart->Curr.y()) IsFlat = false; } while (E != eStart); @@ -903,14 +907,14 @@ bool ClipperBase::AddPathInternal(const Path &pg, int highI, PolyType PolyTyp, b } E->Prev->OutIdx = Skip; LocalMinimum locMin; - locMin.Y = E->Bot.Y; + locMin.Y = E->Bot.y(); locMin.LeftBound = 0; locMin.RightBound = E; locMin.RightBound->Side = esRight; locMin.RightBound->WindDelta = 0; for (;;) { - if (E->Bot.X != E->Prev->Top.X) ReverseHorizontal(*E); + if (E->Bot.x() != E->Prev->Top.x()) ReverseHorizontal(*E); if (E->Next->OutIdx == Skip) break; E->NextInLML = E->Next; E = E->Next; @@ -937,7 +941,7 @@ bool ClipperBase::AddPathInternal(const Path &pg, int highI, PolyType PolyTyp, b //E and E.Prev now share a local minima (left aligned if horizontal). //Compare their slopes to find which starts which bound ... LocalMinimum locMin; - locMin.Y = E->Bot.Y; + locMin.Y = E->Bot.y(); if (E->Dx < E->Prev->Dx) { locMin.LeftBound = E->Prev; @@ -1028,27 +1032,27 @@ IntRect ClipperBase::GetBounds() result.left = result.top = result.right = result.bottom = 0; return result; } - result.left = lm->LeftBound->Bot.X; - result.top = lm->LeftBound->Bot.Y; - result.right = lm->LeftBound->Bot.X; - result.bottom = lm->LeftBound->Bot.Y; + result.left = lm->LeftBound->Bot.x(); + result.top = lm->LeftBound->Bot.y(); + result.right = lm->LeftBound->Bot.x(); + result.bottom = lm->LeftBound->Bot.y(); while (lm != m_MinimaList.end()) { - result.bottom = std::max(result.bottom, lm->LeftBound->Bot.Y); + result.bottom = std::max(result.bottom, lm->LeftBound->Bot.y()); TEdge* e = lm->LeftBound; for (;;) { TEdge* bottomE = e; while (e->NextInLML) { - if (e->Bot.X < result.left) result.left = e->Bot.X; - if (e->Bot.X > result.right) result.right = e->Bot.X; + if (e->Bot.x() < result.left) result.left = e->Bot.x(); + if (e->Bot.x() > result.right) result.right = e->Bot.x(); e = e->NextInLML; } - result.left = std::min(result.left, e->Bot.X); - result.right = std::max(result.right, e->Bot.X); - result.left = std::min(result.left, e->Top.X); - result.right = std::max(result.right, e->Top.X); - result.top = std::min(result.top, e->Top.Y); + result.left = std::min(result.left, e->Bot.x()); + result.right = std::max(result.right, e->Bot.x()); + result.left = std::min(result.left, e->Top.x()); + result.right = std::max(result.right, e->Top.x()); + result.top = std::min(result.top, e->Top.y()); if (bottomE == lm->LeftBound) e = lm->RightBound; else break; } @@ -1073,7 +1077,7 @@ Clipper::Clipper(int initOptions) : m_StrictSimple = ((initOptions & ioStrictlySimple) != 0); m_PreserveCollinear = ((initOptions & ioPreserveCollinear) != 0); m_HasOpenPaths = false; -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ m_ZFill = 0; #endif } @@ -1454,7 +1458,7 @@ OutPt* Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt) } if (prevE && prevE->OutIdx >= 0 && - (TopX(*prevE, Pt.Y) == TopX(*e, Pt.Y)) && + (TopX(*prevE, Pt.y()) == TopX(*e, Pt.y())) && SlopesEqual(*e, *prevE, m_UseFullRange) && (e->WindDelta != 0) && (prevE->WindDelta != 0)) { @@ -1540,7 +1544,7 @@ void Clipper::InsertLocalMinimaIntoAEL(const cInt botY) SetWindingCount(*lb); if (IsContributing(*lb)) Op1 = AddOutPt(lb, lb->Bot); - m_Scanbeam.push(lb->Top.Y); + m_Scanbeam.push(lb->Top.y()); } else { @@ -1551,13 +1555,13 @@ void Clipper::InsertLocalMinimaIntoAEL(const cInt botY) rb->WindCnt2 = lb->WindCnt2; if (IsContributing(*lb)) Op1 = AddLocalMinPoly(lb, rb, lb->Bot); - m_Scanbeam.push(lb->Top.Y); + m_Scanbeam.push(lb->Top.y()); } if (rb) { if(IsHorizontal(*rb)) AddEdgeToSEL(rb); - else m_Scanbeam.push(rb->Top.Y); + else m_Scanbeam.push(rb->Top.y()); } if (!lb || !rb) continue; @@ -1569,12 +1573,12 @@ void Clipper::InsertLocalMinimaIntoAEL(const cInt botY) for (Join &jr : m_GhostJoins) //if the horizontal Rb and a 'ghost' horizontal overlap, then convert //the 'ghost' join to a real join ready for later ... - if (HorzSegmentsOverlap(jr.OutPt1->Pt.X, jr.OffPt.X, rb->Bot.X, rb->Top.X)) + if (HorzSegmentsOverlap(jr.OutPt1->Pt.x(), jr.OffPt.x(), rb->Bot.x(), rb->Top.x())) m_Joins.emplace_back(Join(jr.OutPt1, Op1, jr.OffPt)); } if (lb->OutIdx >= 0 && lb->PrevInAEL && - lb->PrevInAEL->Curr.X == lb->Bot.X && + lb->PrevInAEL->Curr.x() == lb->Bot.x() && lb->PrevInAEL->OutIdx >= 0 && SlopesEqual(*lb->PrevInAEL, *lb, m_UseFullRange) && (lb->WindDelta != 0) && (lb->PrevInAEL->WindDelta != 0)) @@ -1637,14 +1641,14 @@ void Clipper::DeleteFromSEL(TEdge *e) } //------------------------------------------------------------------------------ -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ void Clipper::SetZ(IntPoint& pt, TEdge& e1, TEdge& e2) { - if (pt.Z != 0 || !m_ZFill) return; - else if (pt == e1.Bot) pt.Z = e1.Bot.Z; - else if (pt == e1.Top) pt.Z = e1.Top.Z; - else if (pt == e2.Bot) pt.Z = e2.Bot.Z; - else if (pt == e2.Top) pt.Z = e2.Top.Z; + if (pt.z() != 0 || !m_ZFill) return; + else if (pt == e1.Bot) pt.z() = e1.Bot.z(); + else if (pt == e1.Top) pt.z() = e1.Top.z(); + else if (pt == e2.Bot) pt.z() = e2.Bot.z(); + else if (pt == e2.Top) pt.z() = e2.Top.z(); else m_ZFill(e1.Bot, e1.Top, e2.Bot, e2.Top, pt); } //------------------------------------------------------------------------------ @@ -1655,7 +1659,7 @@ void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt) bool e1Contributing = ( e1->OutIdx >= 0 ); bool e2Contributing = ( e2->OutIdx >= 0 ); -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ SetZ(Pt, *e1, *e2); #endif @@ -1872,10 +1876,10 @@ OutRec* GetLowermostRec(OutRec *outRec1, OutRec *outRec2) outRec2->BottomPt = GetBottomPt(outRec2->Pts); OutPt *OutPt1 = outRec1->BottomPt; OutPt *OutPt2 = outRec2->BottomPt; - if (OutPt1->Pt.Y > OutPt2->Pt.Y) return outRec1; - else if (OutPt1->Pt.Y < OutPt2->Pt.Y) return outRec2; - else if (OutPt1->Pt.X < OutPt2->Pt.X) return outRec1; - else if (OutPt1->Pt.X > OutPt2->Pt.X) return outRec2; + if (OutPt1->Pt.y() > OutPt2->Pt.y()) return outRec1; + else if (OutPt1->Pt.y() < OutPt2->Pt.y()) return outRec2; + else if (OutPt1->Pt.x() < OutPt2->Pt.x()) return outRec1; + else if (OutPt1->Pt.x() > OutPt2->Pt.x()) return outRec2; else if (OutPt1->Next == OutPt1) return outRec2; else if (OutPt2->Next == OutPt2) return outRec1; else if (FirstIsBottomPt(OutPt1, OutPt2)) return outRec1; @@ -2081,13 +2085,13 @@ void Clipper::ProcessHorizontals() inline bool IsMaxima(TEdge *e, const cInt Y) { - return e && e->Top.Y == Y && !e->NextInLML; + return e && e->Top.y() == Y && !e->NextInLML; } //------------------------------------------------------------------------------ inline bool IsIntermediate(TEdge *e, const cInt Y) { - return e->Top.Y == Y && e->NextInLML; + return e->Top.y() == Y && e->NextInLML; } //------------------------------------------------------------------------------ @@ -2202,15 +2206,15 @@ void Clipper::SwapPositionsInSEL(TEdge *Edge1, TEdge *Edge2) inline void GetHorzDirection(TEdge& HorzEdge, Direction& Dir, cInt& Left, cInt& Right) { - if (HorzEdge.Bot.X < HorzEdge.Top.X) + if (HorzEdge.Bot.x() < HorzEdge.Top.x()) { - Left = HorzEdge.Bot.X; - Right = HorzEdge.Top.X; + Left = HorzEdge.Bot.x(); + Right = HorzEdge.Top.x(); Dir = dLeftToRight; } else { - Left = HorzEdge.Top.X; - Right = HorzEdge.Bot.X; + Left = HorzEdge.Top.x(); + Right = HorzEdge.Bot.x(); Dir = dRightToLeft; } } @@ -2219,8 +2223,8 @@ inline void GetHorzDirection(TEdge& HorzEdge, Direction& Dir, cInt& Left, cInt& /******************************************************************************* * Notes: Horizontal edges (HEs) at scanline intersections (ie at the Top or * * Bottom of a scanbeam) are processed as if layered. The order in which HEs * -* are processed doesn't matter. HEs intersect with other HE Bot.Xs only [#] * -* (or they could intersect with Top.Xs only, ie EITHER Bot.Xs OR Top.Xs), * +* are processed doesn't matter. HEs intersect with other HE Bot.x()s only [#] * +* (or they could intersect with Top.x()s only, ie EITHER Bot.x()s OR Top.x()s), * * and with other non-horizontal edges [*]. Once these intersections are * * processed, intermediate HEs then 'promote' the Edge above (NextInLML) into * * the AEL. These 'promoted' edges may in turn intersect [%] with other HEs. * @@ -2248,15 +2252,15 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge) if (dir == dLeftToRight) { maxIt = m_Maxima.begin(); - while (maxIt != m_Maxima.end() && *maxIt <= horzEdge->Bot.X) ++maxIt; - if (maxIt != m_Maxima.end() && *maxIt >= eLastHorz->Top.X) + while (maxIt != m_Maxima.end() && *maxIt <= horzEdge->Bot.x()) ++maxIt; + if (maxIt != m_Maxima.end() && *maxIt >= eLastHorz->Top.x()) maxIt = m_Maxima.end(); } else { maxRit = m_Maxima.rbegin(); - while (maxRit != m_Maxima.rend() && *maxRit > horzEdge->Bot.X) ++maxRit; - if (maxRit != m_Maxima.rend() && *maxRit <= eLastHorz->Top.X) + while (maxRit != m_Maxima.rend() && *maxRit > horzEdge->Bot.x()) ++maxRit; + if (maxRit != m_Maxima.rend() && *maxRit <= eLastHorz->Top.x()) maxRit = m_Maxima.rend(); } } @@ -2278,30 +2282,30 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge) { if (dir == dLeftToRight) { - while (maxIt != m_Maxima.end() && *maxIt < e->Curr.X) + while (maxIt != m_Maxima.end() && *maxIt < e->Curr.x()) { if (horzEdge->OutIdx >= 0 && !IsOpen) - AddOutPt(horzEdge, IntPoint(*maxIt, horzEdge->Bot.Y)); + AddOutPt(horzEdge, IntPoint(*maxIt, horzEdge->Bot.y())); ++maxIt; } } else { - while (maxRit != m_Maxima.rend() && *maxRit > e->Curr.X) + while (maxRit != m_Maxima.rend() && *maxRit > e->Curr.x()) { if (horzEdge->OutIdx >= 0 && !IsOpen) - AddOutPt(horzEdge, IntPoint(*maxRit, horzEdge->Bot.Y)); + AddOutPt(horzEdge, IntPoint(*maxRit, horzEdge->Bot.y())); ++maxRit; } } }; - if ((dir == dLeftToRight && e->Curr.X > horzRight) || - (dir == dRightToLeft && e->Curr.X < horzLeft)) break; + if ((dir == dLeftToRight && e->Curr.x() > horzRight) || + (dir == dRightToLeft && e->Curr.x() < horzLeft)) break; //Also break if we've got to the end of an intermediate horizontal edge ... //nb: Smaller Dx's are to the right of larger Dx's ABOVE the horizontal. - if (e->Curr.X == horzEdge->Top.X && horzEdge->NextInLML && + if (e->Curr.x() == horzEdge->Top.x() && horzEdge->NextInLML && e->Dx < horzEdge->NextInLML->Dx) break; if (horzEdge->OutIdx >= 0 && !IsOpen) //note: may be done multiple times @@ -2311,8 +2315,8 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge) while (eNextHorz) { if (eNextHorz->OutIdx >= 0 && - HorzSegmentsOverlap(horzEdge->Bot.X, - horzEdge->Top.X, eNextHorz->Bot.X, eNextHorz->Top.X)) + HorzSegmentsOverlap(horzEdge->Bot.x(), + horzEdge->Top.x(), eNextHorz->Bot.x(), eNextHorz->Top.x())) { OutPt* op2 = GetLastOutPt(eNextHorz); m_Joins.emplace_back(Join(op2, op1, eNextHorz->Top)); @@ -2335,12 +2339,12 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge) if(dir == dLeftToRight) { - IntPoint Pt = IntPoint(e->Curr.X, horzEdge->Curr.Y); + IntPoint Pt = IntPoint(e->Curr.x(), horzEdge->Curr.y()); IntersectEdges(horzEdge, e, Pt); } else { - IntPoint Pt = IntPoint(e->Curr.X, horzEdge->Curr.Y); + IntPoint Pt = IntPoint(e->Curr.x(), horzEdge->Curr.y()); IntersectEdges( e, horzEdge, Pt); } TEdge* eNext = (dir == dLeftToRight) ? e->NextInAEL : e->PrevInAEL; @@ -2364,8 +2368,8 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge) while (eNextHorz) { if (eNextHorz->OutIdx >= 0 && - HorzSegmentsOverlap(horzEdge->Bot.X, - horzEdge->Top.X, eNextHorz->Bot.X, eNextHorz->Top.X)) + HorzSegmentsOverlap(horzEdge->Bot.x(), + horzEdge->Top.x(), eNextHorz->Bot.x(), eNextHorz->Top.x())) { OutPt* op2 = GetLastOutPt(eNextHorz); m_Joins.emplace_back(Join(op2, op1, eNextHorz->Top)); @@ -2385,17 +2389,17 @@ void Clipper::ProcessHorizontal(TEdge *horzEdge) //nb: HorzEdge is no longer horizontal here TEdge* ePrev = horzEdge->PrevInAEL; TEdge* eNext = horzEdge->NextInAEL; - if (ePrev && ePrev->Curr.X == horzEdge->Bot.X && - ePrev->Curr.Y == horzEdge->Bot.Y && ePrev->WindDelta != 0 && - (ePrev->OutIdx >= 0 && ePrev->Curr.Y > ePrev->Top.Y && + if (ePrev && ePrev->Curr.x() == horzEdge->Bot.x() && + ePrev->Curr.y() == horzEdge->Bot.y() && ePrev->WindDelta != 0 && + (ePrev->OutIdx >= 0 && ePrev->Curr.y() > ePrev->Top.y() && SlopesEqual(*horzEdge, *ePrev, m_UseFullRange))) { OutPt* op2 = AddOutPt(ePrev, horzEdge->Bot); m_Joins.emplace_back(Join(op1, op2, horzEdge->Top)); } - else if (eNext && eNext->Curr.X == horzEdge->Bot.X && - eNext->Curr.Y == horzEdge->Bot.Y && eNext->WindDelta != 0 && - eNext->OutIdx >= 0 && eNext->Curr.Y > eNext->Top.Y && + else if (eNext && eNext->Curr.x() == horzEdge->Bot.x() && + eNext->Curr.y() == horzEdge->Bot.y() && eNext->WindDelta != 0 && + eNext->OutIdx >= 0 && eNext->Curr.y() > eNext->Top.y() && SlopesEqual(*horzEdge, *eNext, m_UseFullRange)) { OutPt* op2 = AddOutPt(eNext, horzEdge->Bot); @@ -2433,7 +2437,7 @@ void Clipper::UpdateEdgeIntoAEL(TEdge *&e) e->PrevInAEL = AelPrev; e->NextInAEL = AelNext; if (!IsHorizontal(*e)) - m_Scanbeam.push(e->Top.Y); + m_Scanbeam.push(e->Top.y()); } //------------------------------------------------------------------------------ @@ -2476,7 +2480,7 @@ void Clipper::BuildIntersectList(const cInt topY) { e->PrevInSEL = e->PrevInAEL; e->NextInSEL = e->NextInAEL; - e->Curr.X = TopX( *e, topY ); + e->Curr.x() = TopX( *e, topY ); e = e->NextInAEL; } @@ -2490,7 +2494,7 @@ void Clipper::BuildIntersectList(const cInt topY) { TEdge *eNext = e->NextInSEL; IntPoint Pt; - if(e->Curr.X > eNext->Curr.X) + if(e->Curr.x() > eNext->Curr.x()) { IntersectPoint(*e, *eNext, Pt); m_IntersectList.emplace_back(IntersectNode(e, eNext, Pt)); @@ -2522,7 +2526,7 @@ bool Clipper::FixupIntersectionOrder() //Now it's crucial that intersections are made only between adjacent edges, //so to ensure this the order of intersections may need adjusting ... CopyAELToSEL(); - std::sort(m_IntersectList.begin(), m_IntersectList.end(), [](const IntersectNode &node1, const IntersectNode &node2) { return node2.Pt.Y < node1.Pt.Y; }); + std::sort(m_IntersectList.begin(), m_IntersectList.end(), [](const IntersectNode &node1, const IntersectNode &node2) { return node2.Pt.y() < node1.Pt.y(); }); size_t cnt = m_IntersectList.size(); for (size_t i = 0; i < cnt; ++i) @@ -2610,7 +2614,7 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const cInt topY) if(IsMaximaEdge) { - if (m_StrictSimple) m_Maxima.push_back(e->Top.X); + if (m_StrictSimple) m_Maxima.push_back(e->Top.x()); TEdge* ePrev = e->PrevInAEL; DoMaxima(e); if( !ePrev ) e = m_ActiveEdges; @@ -2618,7 +2622,7 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const cInt topY) } else { - //2. promote horizontal edges, otherwise update Curr.X and Curr.Y ... + //2. promote horizontal edges, otherwise update Curr.x() and Curr.y() ... if (IsIntermediate(e, topY) && IsHorizontal(*e->NextInLML)) { UpdateEdgeIntoAEL(e); @@ -2628,8 +2632,8 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const cInt topY) } else { - e->Curr.X = TopX( *e, topY ); - e->Curr.Y = topY; + e->Curr.x() = TopX( *e, topY ); + e->Curr.y() = topY; } //When StrictlySimple and 'e' is being touched by another edge, then @@ -2638,10 +2642,10 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const cInt topY) { TEdge* ePrev = e->PrevInAEL; if ((e->OutIdx >= 0) && (e->WindDelta != 0) && ePrev && (ePrev->OutIdx >= 0) && - (ePrev->Curr.X == e->Curr.X) && (ePrev->WindDelta != 0)) + (ePrev->Curr.x() == e->Curr.x()) && (ePrev->WindDelta != 0)) { IntPoint pt = e->Curr; -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ SetZ(pt, *ePrev, *e); #endif OutPt* op = AddOutPt(ePrev, pt); @@ -2673,18 +2677,18 @@ void Clipper::ProcessEdgesAtTopOfScanbeam(const cInt topY) //if output polygons share an edge, they'll need joining later ... TEdge* ePrev = e->PrevInAEL; TEdge* eNext = e->NextInAEL; - if (ePrev && ePrev->Curr.X == e->Bot.X && - ePrev->Curr.Y == e->Bot.Y && op && - ePrev->OutIdx >= 0 && ePrev->Curr.Y > ePrev->Top.Y && + if (ePrev && ePrev->Curr.x() == e->Bot.x() && + ePrev->Curr.y() == e->Bot.y() && op && + ePrev->OutIdx >= 0 && ePrev->Curr.y() > ePrev->Top.y() && SlopesEqual(*e, *ePrev, m_UseFullRange) && (e->WindDelta != 0) && (ePrev->WindDelta != 0)) { OutPt* op2 = AddOutPt(ePrev, e->Bot); m_Joins.emplace_back(Join(op, op2, e->Top)); } - else if (eNext && eNext->Curr.X == e->Bot.X && - eNext->Curr.Y == e->Bot.Y && op && - eNext->OutIdx >= 0 && eNext->Curr.Y > eNext->Top.Y && + else if (eNext && eNext->Curr.x() == e->Bot.x() && + eNext->Curr.y() == e->Bot.y() && op && + eNext->OutIdx >= 0 && eNext->Curr.y() > eNext->Top.y() && SlopesEqual(*e, *eNext, m_UseFullRange) && (e->WindDelta != 0) && (eNext->WindDelta != 0)) { @@ -2861,13 +2865,13 @@ void Clipper::BuildResult2(PolyTree& polytree) inline bool E2InsertsBeforeE1(TEdge &e1, TEdge &e2) { - if (e2.Curr.X == e1.Curr.X) + if (e2.Curr.x() == e1.Curr.x()) { - if (e2.Top.Y > e1.Top.Y) - return e2.Top.X < TopX(e1, e2.Top.Y); - else return e1.Top.X > TopX(e2, e1.Top.Y); + if (e2.Top.y() > e1.Top.y()) + return e2.Top.x() < TopX(e1, e2.Top.y()); + else return e1.Top.x() > TopX(e2, e1.Top.y()); } - else return e2.Curr.X < e1.Curr.X; + else return e2.Curr.x() < e1.Curr.x(); } //------------------------------------------------------------------------------ @@ -2956,8 +2960,8 @@ OutPt* Clipper::DupOutPt(OutPt* outPt, bool InsertAfter) bool Clipper::JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, const IntPoint &Pt, bool DiscardLeft) { - Direction Dir1 = (op1->Pt.X > op1b->Pt.X ? dRightToLeft : dLeftToRight); - Direction Dir2 = (op2->Pt.X > op2b->Pt.X ? dRightToLeft : dLeftToRight); + Direction Dir1 = (op1->Pt.x() > op1b->Pt.x() ? dRightToLeft : dLeftToRight); + Direction Dir2 = (op2->Pt.x() > op2b->Pt.x() ? dRightToLeft : dLeftToRight); if (Dir1 == Dir2) return false; //When DiscardLeft, we want Op1b to be on the Left of Op1, otherwise we @@ -2967,10 +2971,10 @@ bool Clipper::JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, //otherwise make sure we're AT or LEFT of Pt. (Likewise with Op2b.) if (Dir1 == dLeftToRight) { - while (op1->Next->Pt.X <= Pt.X && - op1->Next->Pt.X >= op1->Pt.X && op1->Next->Pt.Y == Pt.Y) + while (op1->Next->Pt.x() <= Pt.x() && + op1->Next->Pt.x() >= op1->Pt.x() && op1->Next->Pt.y() == Pt.y()) op1 = op1->Next; - if (DiscardLeft && (op1->Pt.X != Pt.X)) op1 = op1->Next; + if (DiscardLeft && (op1->Pt.x() != Pt.x())) op1 = op1->Next; op1b = this->DupOutPt(op1, !DiscardLeft); if (op1b->Pt != Pt) { @@ -2981,10 +2985,10 @@ bool Clipper::JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, } else { - while (op1->Next->Pt.X >= Pt.X && - op1->Next->Pt.X <= op1->Pt.X && op1->Next->Pt.Y == Pt.Y) + while (op1->Next->Pt.x() >= Pt.x() && + op1->Next->Pt.x() <= op1->Pt.x() && op1->Next->Pt.y() == Pt.y()) op1 = op1->Next; - if (!DiscardLeft && (op1->Pt.X != Pt.X)) op1 = op1->Next; + if (!DiscardLeft && (op1->Pt.x() != Pt.x())) op1 = op1->Next; op1b = this->DupOutPt(op1, DiscardLeft); if (op1b->Pt != Pt) { @@ -2996,10 +3000,10 @@ bool Clipper::JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, if (Dir2 == dLeftToRight) { - while (op2->Next->Pt.X <= Pt.X && - op2->Next->Pt.X >= op2->Pt.X && op2->Next->Pt.Y == Pt.Y) + while (op2->Next->Pt.x() <= Pt.x() && + op2->Next->Pt.x() >= op2->Pt.x() && op2->Next->Pt.y() == Pt.y()) op2 = op2->Next; - if (DiscardLeft && (op2->Pt.X != Pt.X)) op2 = op2->Next; + if (DiscardLeft && (op2->Pt.x() != Pt.x())) op2 = op2->Next; op2b = this->DupOutPt(op2, !DiscardLeft); if (op2b->Pt != Pt) { @@ -3009,10 +3013,10 @@ bool Clipper::JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, }; } else { - while (op2->Next->Pt.X >= Pt.X && - op2->Next->Pt.X <= op2->Pt.X && op2->Next->Pt.Y == Pt.Y) + while (op2->Next->Pt.x() >= Pt.x() && + op2->Next->Pt.x() <= op2->Pt.x() && op2->Next->Pt.y() == Pt.y()) op2 = op2->Next; - if (!DiscardLeft && (op2->Pt.X != Pt.X)) op2 = op2->Next; + if (!DiscardLeft && (op2->Pt.x() != Pt.x())) op2 = op2->Next; op2b = this->DupOutPt(op2, DiscardLeft); if (op2b->Pt != Pt) { @@ -3052,7 +3056,7 @@ bool Clipper::JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2) //location at the Bottom of the overlapping segment (& Join.OffPt is above). //3. StrictSimple joins where edges touch but are not collinear and where //Join.OutPt1, Join.OutPt2 & Join.OffPt all share the same point. - bool isHorizontal = (j->OutPt1->Pt.Y == j->OffPt.Y); + bool isHorizontal = (j->OutPt1->Pt.y() == j->OffPt.y()); if (isHorizontal && (j->OffPt == j->OutPt1->Pt) && (j->OffPt == j->OutPt2->Pt)) @@ -3062,11 +3066,11 @@ bool Clipper::JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2) op1b = j->OutPt1->Next; while (op1b != op1 && (op1b->Pt == j->OffPt)) op1b = op1b->Next; - bool reverse1 = (op1b->Pt.Y > j->OffPt.Y); + bool reverse1 = (op1b->Pt.y() > j->OffPt.y()); op2b = j->OutPt2->Next; while (op2b != op2 && (op2b->Pt == j->OffPt)) op2b = op2b->Next; - bool reverse2 = (op2b->Pt.Y > j->OffPt.Y); + bool reverse2 = (op2b->Pt.y() > j->OffPt.y()); if (reverse1 == reverse2) return false; if (reverse1) { @@ -3098,22 +3102,22 @@ bool Clipper::JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2) //them we're not yet sure where the overlapping is. OutPt1.Pt & OutPt2.Pt //may be anywhere along the horizontal edge. op1b = op1; - while (op1->Prev->Pt.Y == op1->Pt.Y && op1->Prev != op1b && op1->Prev != op2) + while (op1->Prev->Pt.y() == op1->Pt.y() && op1->Prev != op1b && op1->Prev != op2) op1 = op1->Prev; - while (op1b->Next->Pt.Y == op1b->Pt.Y && op1b->Next != op1 && op1b->Next != op2) + while (op1b->Next->Pt.y() == op1b->Pt.y() && op1b->Next != op1 && op1b->Next != op2) op1b = op1b->Next; if (op1b->Next == op1 || op1b->Next == op2) return false; //a flat 'polygon' op2b = op2; - while (op2->Prev->Pt.Y == op2->Pt.Y && op2->Prev != op2b && op2->Prev != op1b) + while (op2->Prev->Pt.y() == op2->Pt.y() && op2->Prev != op2b && op2->Prev != op1b) op2 = op2->Prev; - while (op2b->Next->Pt.Y == op2b->Pt.Y && op2b->Next != op2 && op2b->Next != op1) + while (op2b->Next->Pt.y() == op2b->Pt.y() && op2b->Next != op2 && op2b->Next != op1) op2b = op2b->Next; if (op2b->Next == op2 || op2b->Next == op1) return false; //a flat 'polygon' cInt Left, Right; //Op1 --> Op1b & Op2 --> Op2b are the extremites of the horizontal edges - if (!GetOverlap(op1->Pt.X, op1b->Pt.X, op2->Pt.X, op2b->Pt.X, Left, Right)) + if (!GetOverlap(op1->Pt.x(), op1b->Pt.x(), op2->Pt.x(), op2b->Pt.x(), Left, Right)) return false; //DiscardLeftSide: when overlapping edges are joined, a spike will created @@ -3121,51 +3125,51 @@ bool Clipper::JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2) //on the discard Side as either may still be needed for other joins ... IntPoint Pt; bool DiscardLeftSide; - if (op1->Pt.X >= Left && op1->Pt.X <= Right) + if (op1->Pt.x() >= Left && op1->Pt.x() <= Right) { - Pt = op1->Pt; DiscardLeftSide = (op1->Pt.X > op1b->Pt.X); + Pt = op1->Pt; DiscardLeftSide = (op1->Pt.x() > op1b->Pt.x()); } - else if (op2->Pt.X >= Left&& op2->Pt.X <= Right) + else if (op2->Pt.x() >= Left&& op2->Pt.x() <= Right) { - Pt = op2->Pt; DiscardLeftSide = (op2->Pt.X > op2b->Pt.X); + Pt = op2->Pt; DiscardLeftSide = (op2->Pt.x() > op2b->Pt.x()); } - else if (op1b->Pt.X >= Left && op1b->Pt.X <= Right) + else if (op1b->Pt.x() >= Left && op1b->Pt.x() <= Right) { - Pt = op1b->Pt; DiscardLeftSide = op1b->Pt.X > op1->Pt.X; + Pt = op1b->Pt; DiscardLeftSide = op1b->Pt.x() > op1->Pt.x(); } else { - Pt = op2b->Pt; DiscardLeftSide = (op2b->Pt.X > op2->Pt.X); + Pt = op2b->Pt; DiscardLeftSide = (op2b->Pt.x() > op2->Pt.x()); } j->OutPt1 = op1; j->OutPt2 = op2; return JoinHorz(op1, op1b, op2, op2b, Pt, DiscardLeftSide); } else { //nb: For non-horizontal joins ... - // 1. Jr.OutPt1.Pt.Y == Jr.OutPt2.Pt.Y - // 2. Jr.OutPt1.Pt > Jr.OffPt.Y + // 1. Jr.OutPt1.Pt.y() == Jr.OutPt2.Pt.y() + // 2. Jr.OutPt1.Pt > Jr.OffPt.y() //make sure the polygons are correctly oriented ... op1b = op1->Next; while ((op1b->Pt == op1->Pt) && (op1b != op1)) op1b = op1b->Next; - bool Reverse1 = ((op1b->Pt.Y > op1->Pt.Y) || + bool Reverse1 = ((op1b->Pt.y() > op1->Pt.y()) || !SlopesEqual(op1->Pt, op1b->Pt, j->OffPt, m_UseFullRange)); if (Reverse1) { op1b = op1->Prev; while ((op1b->Pt == op1->Pt) && (op1b != op1)) op1b = op1b->Prev; - if ((op1b->Pt.Y > op1->Pt.Y) || + if ((op1b->Pt.y() > op1->Pt.y()) || !SlopesEqual(op1->Pt, op1b->Pt, j->OffPt, m_UseFullRange)) return false; }; op2b = op2->Next; while ((op2b->Pt == op2->Pt) && (op2b != op2))op2b = op2b->Next; - bool Reverse2 = ((op2b->Pt.Y > op2->Pt.Y) || + bool Reverse2 = ((op2b->Pt.y() > op2->Pt.y()) || !SlopesEqual(op2->Pt, op2b->Pt, j->OffPt, m_UseFullRange)); if (Reverse2) { op2b = op2->Prev; while ((op2b->Pt == op2->Pt) && (op2b != op2)) op2b = op2b->Prev; - if ((op2b->Pt.Y > op2->Pt.Y) || + if ((op2b->Pt.y() > op2->Pt.y()) || !SlopesEqual(op2->Pt, op2b->Pt, j->OffPt, m_UseFullRange)) return false; } @@ -3334,11 +3338,11 @@ void Clipper::JoinCommonEdges() DoublePoint GetUnitNormal(const IntPoint &pt1, const IntPoint &pt2) { - if(pt2.X == pt1.X && pt2.Y == pt1.Y) + if(pt2.x() == pt1.x() && pt2.y() == pt1.y()) return DoublePoint(0, 0); - double Dx = double(pt2.X - pt1.X); - double dy = double(pt2.Y - pt1.Y); + double Dx = double(pt2.x() - pt1.x()); + double dy = double(pt2.y() - pt1.y()); double f = 1.0 / std::sqrt( Dx*Dx + dy*dy ); Dx *= f; dy *= f; @@ -3354,7 +3358,7 @@ void ClipperOffset::Clear() for (int i = 0; i < m_polyNodes.ChildCount(); ++i) delete m_polyNodes.Childs[i]; m_polyNodes.Childs.clear(); - m_lowest.X = -1; + m_lowest.x() = -1; } //------------------------------------------------------------------------------ @@ -3373,8 +3377,8 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType for (; highI > 0; -- highI) { bool same = false; if (has_shortest_edge_length) { - double dx = double(path[highI].X - path[0].X); - double dy = double(path[highI].Y - path[0].Y); + double dx = double(path[highI].x() - path[0].x()); + double dy = double(path[highI].y() - path[0].y()); same = dx*dx + dy*dy < shortest_edge_length2; } else same = path[0] == path[highI]; @@ -3387,8 +3391,8 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType for (int i = 1; i <= highI; i++) { bool same = false; if (has_shortest_edge_length) { - double dx = double(path[i].X - newNode->Contour[j].X); - double dy = double(path[i].Y - newNode->Contour[j].Y); + double dx = double(path[i].x() - newNode->Contour[j].x()); + double dy = double(path[i].y() - newNode->Contour[j].y()); same = dx*dx + dy*dy < shortest_edge_length2; } else same = newNode->Contour[j] == path[i]; @@ -3396,9 +3400,9 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType continue; j++; newNode->Contour.push_back(path[i]); - if (path[i].Y > newNode->Contour[k].Y || - (path[i].Y == newNode->Contour[k].Y && - path[i].X < newNode->Contour[k].X)) k = j; + if (path[i].y() > newNode->Contour[k].y() || + (path[i].y() == newNode->Contour[k].y() && + path[i].x() < newNode->Contour[k].x())) k = j; } if (endType == etClosedPolygon && j < 2) { @@ -3409,14 +3413,14 @@ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType //if this path's lowest pt is lower than all the others then update m_lowest if (endType != etClosedPolygon) return; - if (m_lowest.X < 0) + if (m_lowest.x() < 0) m_lowest = IntPoint(m_polyNodes.ChildCount() - 1, k); else { - IntPoint ip = m_polyNodes.Childs[(int)m_lowest.X]->Contour[(int)m_lowest.Y]; - if (newNode->Contour[k].Y > ip.Y || - (newNode->Contour[k].Y == ip.Y && - newNode->Contour[k].X < ip.X)) + IntPoint ip = m_polyNodes.Childs[(int)m_lowest.x()]->Contour[(int)m_lowest.y()]; + if (newNode->Contour[k].y() > ip.y() || + (newNode->Contour[k].y() == ip.y() && + newNode->Contour[k].x() < ip.x())) m_lowest = IntPoint(m_polyNodes.ChildCount() - 1, k); } } @@ -3433,8 +3437,8 @@ void ClipperOffset::FixOrientations() { //fixup orientations of all closed paths if the orientation of the //closed path with the lowermost vertex is wrong ... - if (m_lowest.X >= 0 && - !Orientation(m_polyNodes.Childs[(int)m_lowest.X]->Contour)) + if (m_lowest.x() >= 0 && + !Orientation(m_polyNodes.Childs[(int)m_lowest.x()]->Contour)) { for (int i = 0; i < m_polyNodes.ChildCount(); ++i) { @@ -3582,8 +3586,8 @@ void ClipperOffset::DoOffset(double delta) for (cInt j = 1; j <= steps; j++) { m_destPoly.push_back(IntPoint( - Round(m_srcPoly[0].X + X * delta), - Round(m_srcPoly[0].Y + Y * delta))); + Round(m_srcPoly[0].x() + X * delta), + Round(m_srcPoly[0].y() + Y * delta))); double X2 = X; X = X * m_cos - m_sin * Y; Y = X2 * m_sin + Y * m_cos; @@ -3595,8 +3599,8 @@ void ClipperOffset::DoOffset(double delta) for (int j = 0; j < 4; ++j) { m_destPoly.push_back(IntPoint( - Round(m_srcPoly[0].X + X * delta), - Round(m_srcPoly[0].Y + Y * delta))); + Round(m_srcPoly[0].x() + X * delta), + Round(m_srcPoly[0].y() + Y * delta))); if (X < 0) X = 1; else if (Y < 0) Y = 1; else X = -1; @@ -3632,8 +3636,8 @@ void ClipperOffset::DoOffset(double delta) //re-build m_normals ... DoublePoint n = m_normals[len -1]; for (int j = len - 1; j > 0; j--) - m_normals[j] = DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y); - m_normals[0] = DoublePoint(-n.X, -n.Y); + m_normals[j] = DoublePoint(-m_normals[j - 1].x(), -m_normals[j - 1].y()); + m_normals[0] = DoublePoint(-n.x(), -n.y()); k = 0; for (int j = len - 1; j >= 0; j--) OffsetPoint(j, k, node.m_jointype); @@ -3649,9 +3653,9 @@ void ClipperOffset::DoOffset(double delta) if (node.m_endtype == etOpenButt) { int j = len - 1; - pt1 = IntPoint(Round(m_srcPoly[j].X + m_normals[j].X * delta), Round(m_srcPoly[j].Y + m_normals[j].Y * delta)); + pt1 = IntPoint(Round(m_srcPoly[j].x() + m_normals[j].x() * delta), Round(m_srcPoly[j].y() + m_normals[j].y() * delta)); m_destPoly.push_back(pt1); - pt1 = IntPoint(Round(m_srcPoly[j].X - m_normals[j].X * delta), Round(m_srcPoly[j].Y - m_normals[j].Y * delta)); + pt1 = IntPoint(Round(m_srcPoly[j].x() - m_normals[j].x() * delta), Round(m_srcPoly[j].y() - m_normals[j].y() * delta)); m_destPoly.push_back(pt1); } else @@ -3659,7 +3663,7 @@ void ClipperOffset::DoOffset(double delta) int j = len - 1; k = len - 2; m_sinA = 0; - m_normals[j] = DoublePoint(-m_normals[j].X, -m_normals[j].Y); + m_normals[j] = DoublePoint(-m_normals[j].x(), -m_normals[j].y()); if (node.m_endtype == etOpenSquare) DoSquare(j, k); else @@ -3668,17 +3672,17 @@ void ClipperOffset::DoOffset(double delta) //re-build m_normals ... for (int j = len - 1; j > 0; j--) - m_normals[j] = DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y); - m_normals[0] = DoublePoint(-m_normals[1].X, -m_normals[1].Y); + m_normals[j] = DoublePoint(-m_normals[j - 1].x(), -m_normals[j - 1].y()); + m_normals[0] = DoublePoint(-m_normals[1].x(), -m_normals[1].y()); k = len - 1; for (int j = k - 1; j > 0; --j) OffsetPoint(j, k, node.m_jointype); if (node.m_endtype == etOpenButt) { - pt1 = IntPoint(Round(m_srcPoly[0].X - m_normals[0].X * delta), Round(m_srcPoly[0].Y - m_normals[0].Y * delta)); + pt1 = IntPoint(Round(m_srcPoly[0].x() - m_normals[0].x() * delta), Round(m_srcPoly[0].y() - m_normals[0].y() * delta)); m_destPoly.push_back(pt1); - pt1 = IntPoint(Round(m_srcPoly[0].X + m_normals[0].X * delta), Round(m_srcPoly[0].Y + m_normals[0].Y * delta)); + pt1 = IntPoint(Round(m_srcPoly[0].x() + m_normals[0].x() * delta), Round(m_srcPoly[0].y() + m_normals[0].y() * delta)); m_destPoly.push_back(pt1); } else @@ -3699,15 +3703,15 @@ void ClipperOffset::DoOffset(double delta) void ClipperOffset::OffsetPoint(int j, int& k, JoinType jointype) { //cross product ... - m_sinA = (m_normals[k].X * m_normals[j].Y - m_normals[j].X * m_normals[k].Y); + m_sinA = (m_normals[k].x() * m_normals[j].y() - m_normals[j].x() * m_normals[k].y()); if (std::fabs(m_sinA * m_delta) < 1.0) { //dot product ... - double cosA = (m_normals[k].X * m_normals[j].X + m_normals[j].Y * m_normals[k].Y ); + double cosA = (m_normals[k].x() * m_normals[j].x() + m_normals[j].y() * m_normals[k].y() ); if (cosA > 0) // angle => 0 degrees { - m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + m_normals[k].X * m_delta), - Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta))); + m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].x() + m_normals[k].x() * m_delta), + Round(m_srcPoly[j].y() + m_normals[k].y() * m_delta))); return; } //else angle => 180 degrees @@ -3717,19 +3721,19 @@ void ClipperOffset::OffsetPoint(int j, int& k, JoinType jointype) if (m_sinA * m_delta < 0) { - m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + m_normals[k].X * m_delta), - Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta))); + m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].x() + m_normals[k].x() * m_delta), + Round(m_srcPoly[j].y() + m_normals[k].y() * m_delta))); m_destPoly.push_back(m_srcPoly[j]); - m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + m_normals[j].X * m_delta), - Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta))); + m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].x() + m_normals[j].x() * m_delta), + Round(m_srcPoly[j].y() + m_normals[j].y() * m_delta))); } else switch (jointype) { case jtMiter: { - double r = 1 + (m_normals[j].X * m_normals[k].X + - m_normals[j].Y * m_normals[k].Y); + double r = 1 + (m_normals[j].x() * m_normals[k].x() + + m_normals[j].y() * m_normals[k].y()); if (r >= m_miterLim) DoMiter(j, k, r); else DoSquare(j, k); break; } @@ -3743,43 +3747,43 @@ void ClipperOffset::OffsetPoint(int j, int& k, JoinType jointype) void ClipperOffset::DoSquare(int j, int k) { double dx = std::tan(std::atan2(m_sinA, - m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y) / 4); + m_normals[k].x() * m_normals[j].x() + m_normals[k].y() * m_normals[j].y()) / 4); m_destPoly.push_back(IntPoint( - Round(m_srcPoly[j].X + m_delta * (m_normals[k].X - m_normals[k].Y * dx)), - Round(m_srcPoly[j].Y + m_delta * (m_normals[k].Y + m_normals[k].X * dx)))); + Round(m_srcPoly[j].x() + m_delta * (m_normals[k].x() - m_normals[k].y() * dx)), + Round(m_srcPoly[j].y() + m_delta * (m_normals[k].y() + m_normals[k].x() * dx)))); m_destPoly.push_back(IntPoint( - Round(m_srcPoly[j].X + m_delta * (m_normals[j].X + m_normals[j].Y * dx)), - Round(m_srcPoly[j].Y + m_delta * (m_normals[j].Y - m_normals[j].X * dx)))); + Round(m_srcPoly[j].x() + m_delta * (m_normals[j].x() + m_normals[j].y() * dx)), + Round(m_srcPoly[j].y() + m_delta * (m_normals[j].y() - m_normals[j].x() * dx)))); } //------------------------------------------------------------------------------ void ClipperOffset::DoMiter(int j, int k, double r) { double q = m_delta / r; - m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + (m_normals[k].X + m_normals[j].X) * q), - Round(m_srcPoly[j].Y + (m_normals[k].Y + m_normals[j].Y) * q))); + m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].x() + (m_normals[k].x() + m_normals[j].x()) * q), + Round(m_srcPoly[j].y() + (m_normals[k].y() + m_normals[j].y()) * q))); } //------------------------------------------------------------------------------ void ClipperOffset::DoRound(int j, int k) { double a = std::atan2(m_sinA, - m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y); + m_normals[k].x() * m_normals[j].x() + m_normals[k].y() * m_normals[j].y()); auto steps = std::max<int>(Round(m_StepsPerRad * std::fabs(a)), 1); - double X = m_normals[k].X, Y = m_normals[k].Y, X2; + double X = m_normals[k].x(), Y = m_normals[k].y(), X2; for (int i = 0; i < steps; ++i) { m_destPoly.push_back(IntPoint( - Round(m_srcPoly[j].X + X * m_delta), - Round(m_srcPoly[j].Y + Y * m_delta))); + Round(m_srcPoly[j].x() + X * m_delta), + Round(m_srcPoly[j].y() + Y * m_delta))); X2 = X; X = X * m_cos - m_sin * Y; Y = X2 * m_sin + Y * m_cos; } m_destPoly.push_back(IntPoint( - Round(m_srcPoly[j].X + m_normals[j].X * m_delta), - Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta))); + Round(m_srcPoly[j].x() + m_normals[j].x() * m_delta), + Round(m_srcPoly[j].y() + m_normals[j].y() * m_delta))); } //------------------------------------------------------------------------------ @@ -3897,8 +3901,8 @@ void SimplifyPolygons(Paths &polys, PolyFillType fillType) inline double DistanceSqrd(const IntPoint& pt1, const IntPoint& pt2) { - auto Dx = double(pt1.X - pt2.X); - auto dy = double(pt1.Y - pt2.Y); + auto Dx = double(pt1.x() - pt2.x()); + auto dy = double(pt1.y() - pt2.y()); return (Dx*Dx + dy*dy); } //------------------------------------------------------------------------------ @@ -3912,10 +3916,10 @@ double DistanceFromLineSqrd( //A = (y¹ - y²); B = (x² - x¹); C = (y² - y¹)x¹ - (x² - x¹)y¹ //perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²) //see http://en.wikipedia.org/wiki/Perpendicular_distance - double A = double(ln1.Y - ln2.Y); - double B = double(ln2.X - ln1.X); - double C = A * ln1.X + B * ln1.Y; - C = A * pt.X + B * pt.Y - C; + double A = double(ln1.y() - ln2.y()); + double B = double(ln2.x() - ln1.x()); + double C = A * ln1.x() + B * ln1.y(); + C = A * pt.x() + B * pt.y() - C; return (C * C) / (A * A + B * B); } //--------------------------------------------------------------------------- @@ -3926,20 +3930,20 @@ bool SlopesNearCollinear(const IntPoint& pt1, //this function is more accurate when the point that's geometrically //between the other 2 points is the one that's tested for distance. //ie makes it more likely to pick up 'spikes' ... - if (std::abs(pt1.X - pt2.X) > std::abs(pt1.Y - pt2.Y)) + if (std::abs(pt1.x() - pt2.x()) > std::abs(pt1.y() - pt2.y())) { - if ((pt1.X > pt2.X) == (pt1.X < pt3.X)) + if ((pt1.x() > pt2.x()) == (pt1.x() < pt3.x())) return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd; - else if ((pt2.X > pt1.X) == (pt2.X < pt3.X)) + else if ((pt2.x() > pt1.x()) == (pt2.x() < pt3.x())) return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd; else return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd; } else { - if ((pt1.Y > pt2.Y) == (pt1.Y < pt3.Y)) + if ((pt1.y() > pt2.y()) == (pt1.y() < pt3.y())) return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd; - else if ((pt2.Y > pt1.Y) == (pt2.Y < pt3.Y)) + else if ((pt2.y() > pt1.y()) == (pt2.y() < pt3.y())) return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd; else return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd; @@ -3949,8 +3953,8 @@ bool SlopesNearCollinear(const IntPoint& pt1, bool PointsAreClose(IntPoint pt1, IntPoint pt2, double distSqrd) { - auto Dx = double(pt1.X - pt2.X); - auto dy = double(pt1.Y - pt2.Y); + auto Dx = double(pt1.x() - pt2.x()); + auto dy = double(pt1.y() - pt2.y()); return ((Dx * Dx) + (dy * dy) <= distSqrd); } //------------------------------------------------------------------------------ @@ -4058,7 +4062,7 @@ void Minkowski(const Path& poly, const Path& path, Path p; p.reserve(polyCnt); for (size_t j = 0; j < poly.size(); ++j) - p.push_back(IntPoint(path[i].X + poly[j].X, path[i].Y + poly[j].Y)); + p.push_back(IntPoint(path[i].x() + poly[j].x(), path[i].y() + poly[j].y())); pp.push_back(p); } else @@ -4067,7 +4071,7 @@ void Minkowski(const Path& poly, const Path& path, Path p; p.reserve(polyCnt); for (size_t j = 0; j < poly.size(); ++j) - p.push_back(IntPoint(path[i].X - poly[j].X, path[i].Y - poly[j].Y)); + p.push_back(IntPoint(path[i].x() - poly[j].x(), path[i].y() - poly[j].y())); pp.push_back(p); } @@ -4102,7 +4106,7 @@ void TranslatePath(const Path& input, Path& output, const IntPoint& delta) //precondition: input != output output.resize(input.size()); for (size_t i = 0; i < input.size(); ++i) - output[i] = IntPoint(input[i].X + delta.X, input[i].Y + delta.Y); + output[i] = IntPoint(input[i].x() + delta.x(), input[i].y() + delta.y()); } //------------------------------------------------------------------------------ @@ -4178,7 +4182,7 @@ void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths) std::ostream& operator <<(std::ostream &s, const IntPoint &p) { - s << "(" << p.X << "," << p.Y << ")"; + s << "(" << p.x() << "," << p.y() << ")"; return s; } //------------------------------------------------------------------------------ @@ -4188,8 +4192,8 @@ std::ostream& operator <<(std::ostream &s, const Path &p) if (p.empty()) return s; Path::size_type last = p.size() -1; for (Path::size_type i = 0; i < last; i++) - s << "(" << p[i].X << "," << p[i].Y << "), "; - s << "(" << p[last].X << "," << p[last].Y << ")\n"; + s << "(" << p[i].x() << "," << p[i].y() << "), "; + s << "(" << p[last].x() << "," << p[last].y() << ")\n"; return s; } //------------------------------------------------------------------------------ @@ -4204,3 +4208,7 @@ std::ostream& operator <<(std::ostream &s, const Paths &p) //------------------------------------------------------------------------------ } //ClipperLib namespace + +#ifdef CLIPPERLIB_NAMESPACE_PREFIX +} // namespace CLIPPERLIB_NAMESPACE_PREFIX +#endif // CLIPPERLIB_NAMESPACE_PREFIX diff --git a/src/clipper/clipper.hpp b/src/clipper/clipper.hpp index 48e83d046..c32bcf87b 100644 --- a/src/clipper/clipper.hpp +++ b/src/clipper/clipper.hpp @@ -37,10 +37,12 @@ #include <inttypes.h> #include <functional> +#include <Eigen/Geometry> + #define CLIPPER_VERSION "6.2.6" -//use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance. -//#define use_xyz +//CLIPPERLIB_USE_XYZ: adds a Z member to IntPoint. Adds a minor cost to perfomance. +//#define CLIPPERLIB_USE_XYZ //use_lines: Enables line clipping. Adds a very minor cost to performance. #define use_lines @@ -57,11 +59,15 @@ #include <functional> #include <queue> -#ifdef use_xyz -namespace ClipperLib_Z { -#else /* use_xyz */ -namespace ClipperLib { -#endif /* use_xyz */ +#ifdef CLIPPERLIB_NAMESPACE_PREFIX + namespace CLIPPERLIB_NAMESPACE_PREFIX { +#endif // CLIPPERLIB_NAMESPACE_PREFIX + +#ifdef CLIPPERLIB_USE_XYZ + namespace ClipperLib_Z { +#else + namespace ClipperLib { +#endif enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor }; enum PolyType { ptSubject, ptClip }; @@ -88,29 +94,24 @@ enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative }; static constexpr cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL; #endif // CLIPPERLIB_INT32 -struct IntPoint { - cInt X; - cInt Y; -#ifdef use_xyz - cInt Z; - IntPoint(cInt x = 0, cInt y = 0, cInt z = 0): X(x), Y(y), Z(z) {}; -#else - IntPoint(cInt x = 0, cInt y = 0): X(x), Y(y) {}; -#endif +#ifdef CLIPPERLIB_INTPOINT_TYPE +using IntPoint = CLIPPERLIB_INTPOINT_TYPE; +#else // CLIPPERLIB_INTPOINT_TYPE +using IntPoint = Eigen::Matrix<cInt, +#ifdef CLIPPERLIB_USE_XYZ + 3 +#else // CLIPPERLIB_USE_XYZ + 2 +#endif // CLIPPERLIB_USE_XYZ + , 1, Eigen::DontAlign>; +#endif // CLIPPERLIB_INTPOINT_TYPE + +using DoublePoint = Eigen::Matrix<double, 2, 1, Eigen::DontAlign>; - friend inline bool operator== (const IntPoint& a, const IntPoint& b) - { - return a.X == b.X && a.Y == b.Y; - } - friend inline bool operator!= (const IntPoint& a, const IntPoint& b) - { - return a.X != b.X || a.Y != b.Y; - } -}; //------------------------------------------------------------------------------ -typedef std::vector< IntPoint > Path; -typedef std::vector< Path > Paths; +typedef std::vector<IntPoint> Path; +typedef std::vector<Path> Paths; inline Path& operator <<(Path& poly, const IntPoint& p) {poly.push_back(p); return poly;} inline Paths& operator <<(Paths& polys, const Path& p) {polys.push_back(p); return polys;} @@ -119,16 +120,9 @@ std::ostream& operator <<(std::ostream &s, const IntPoint &p); std::ostream& operator <<(std::ostream &s, const Path &p); std::ostream& operator <<(std::ostream &s, const Paths &p); -struct DoublePoint -{ - double X; - double Y; - DoublePoint(double x = 0, double y = 0) : X(x), Y(y) {} - DoublePoint(IntPoint ip) : X((double)ip.X), Y((double)ip.Y) {} -}; //------------------------------------------------------------------------------ -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ typedef std::function<void(const IntPoint& e1bot, const IntPoint& e1top, const IntPoint& e2bot, const IntPoint& e2top, IntPoint& pt)> ZFillCallback; #endif @@ -269,11 +263,11 @@ enum EdgeSide { esLeft = 1, esRight = 2}; }; // Point of an output polygon. - // 36B on 64bit system without use_xyz. + // 36B on 64bit system without CLIPPERLIB_USE_XYZ. struct OutPt { // 4B int Idx; - // 16B without use_xyz / 24B with use_xyz + // 16B without CLIPPERLIB_USE_XYZ / 24B with CLIPPERLIB_USE_XYZ IntPoint Pt; // 4B on 32bit system, 8B on 64bit system OutPt *Next; @@ -368,7 +362,7 @@ public: bool StrictlySimple() const {return m_StrictSimple;}; void StrictlySimple(bool value) {m_StrictSimple = value;}; //set the callback function for z value filling on intersections (otherwise Z is 0) -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ void ZFillFunction(ZFillCallback zFillFunc) { m_ZFill = zFillFunc; } #endif protected: @@ -401,7 +395,7 @@ private: // Does the result go to a PolyTree or Paths? bool m_UsingPolyTree; bool m_StrictSimple; -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ ZFillCallback m_ZFill; //custom callback #endif void SetWindingCount(TEdge& edge) const; @@ -454,7 +448,7 @@ private: void DoSimplePolygons(); void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec) const; void FixupFirstLefts2(OutRec* OldOutRec, OutRec* NewOutRec) const; -#ifdef use_xyz +#ifdef CLIPPERLIB_USE_XYZ void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2); #endif }; @@ -506,6 +500,8 @@ class clipperException : public std::exception } //ClipperLib namespace -#endif //clipper_hpp - +#ifdef CLIPPERLIB_NAMESPACE_PREFIX +} // namespace CLIPPERLIB_NAMESPACE_PREFIX +#endif // CLIPPERLIB_NAMESPACE_PREFIX +#endif //clipper_hpp diff --git a/src/clipper/clipper_z.cpp b/src/clipper/clipper_z.cpp index 4a54ef346..f26be7089 100644 --- a/src/clipper/clipper_z.cpp +++ b/src/clipper/clipper_z.cpp @@ -1,7 +1,7 @@ // Hackish wrapper around the ClipperLib library to compile the Clipper library with the Z support. // Enable the Z coordinate support. -#define use_xyz +#define CLIPPERLIB_USE_XYZ // and let it compile #include "clipper.cpp" diff --git a/src/clipper/clipper_z.hpp b/src/clipper/clipper_z.hpp index e5e7d48ce..20596d8e1 100644 --- a/src/clipper/clipper_z.hpp +++ b/src/clipper/clipper_z.hpp @@ -2,17 +2,17 @@ #ifndef clipper_z_hpp #ifdef clipper_hpp -#error "You should include the clipper_z.hpp first" +#error "You should include clipper_z.hpp before clipper.hpp" #endif #define clipper_z_hpp // Enable the Z coordinate support. -#define use_xyz +#define CLIPPERLIB_USE_XYZ #include "clipper.hpp" #undef clipper_hpp -#undef use_xyz +#undef CLIPPERLIB_USE_XYZ #endif // clipper_z_hpp diff --git a/src/libnest2d/CMakeLists.txt b/src/libnest2d/CMakeLists.txt index 3892ed30b..c18dc31cb 100644 --- a/src/libnest2d/CMakeLists.txt +++ b/src/libnest2d/CMakeLists.txt @@ -12,11 +12,8 @@ set(LIBNEST2D_SRCFILES include/libnest2d/placers/bottomleftplacer.hpp include/libnest2d/placers/nfpplacer.hpp include/libnest2d/selections/selection_boilerplate.hpp - #include/libnest2d/selections/filler.hpp include/libnest2d/selections/firstfit.hpp - #include/libnest2d/selections/djd_heuristic.hpp - include/libnest2d/backends/clipper/geometries.hpp - include/libnest2d/backends/clipper/clipper_polygon.hpp + include/libnest2d/backends/libslic3r/geometries.hpp include/libnest2d/optimizers/nlopt/nlopt_boilerplate.hpp include/libnest2d/optimizers/nlopt/simplex.hpp include/libnest2d/optimizers/nlopt/subplex.hpp @@ -27,5 +24,5 @@ set(LIBNEST2D_SRCFILES add_library(libnest2d STATIC ${LIBNEST2D_SRCFILES}) target_include_directories(libnest2d PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include) -target_link_libraries(libnest2d PUBLIC clipper NLopt::nlopt TBB::tbb Boost::boost) -target_compile_definitions(libnest2d PUBLIC LIBNEST2D_THREADING_tbb LIBNEST2D_STATIC LIBNEST2D_OPTIMIZER_nlopt LIBNEST2D_GEOMETRIES_clipper) +target_link_libraries(libnest2d PUBLIC NLopt::nlopt TBB::tbb Boost::boost libslic3r) +target_compile_definitions(libnest2d PUBLIC LIBNEST2D_THREADING_tbb LIBNEST2D_STATIC LIBNEST2D_OPTIMIZER_nlopt LIBNEST2D_GEOMETRIES_libslic3r) diff --git a/src/libnest2d/include/libnest2d/backends/clipper/clipper_polygon.hpp b/src/libnest2d/include/libnest2d/backends/clipper/clipper_polygon.hpp deleted file mode 100644 index 6511fbb72..000000000 --- a/src/libnest2d/include/libnest2d/backends/clipper/clipper_polygon.hpp +++ /dev/null @@ -1,72 +0,0 @@ -#ifndef CLIPPER_POLYGON_HPP -#define CLIPPER_POLYGON_HPP - -#include <clipper.hpp> - -namespace ClipperLib { - -struct Polygon { - Path Contour; - Paths Holes; - - inline Polygon() = default; - - inline explicit Polygon(const Path& cont): Contour(cont) {} -// inline explicit Polygon(const Paths& holes): -// Holes(holes) {} - inline Polygon(const Path& cont, const Paths& holes): - Contour(cont), Holes(holes) {} - - inline explicit Polygon(Path&& cont): Contour(std::move(cont)) {} -// inline explicit Polygon(Paths&& holes): Holes(std::move(holes)) {} - inline Polygon(Path&& cont, Paths&& holes): - Contour(std::move(cont)), Holes(std::move(holes)) {} -}; - -inline IntPoint& operator +=(IntPoint& p, const IntPoint& pa ) { - // This could be done with SIMD - p.X += pa.X; - p.Y += pa.Y; - return p; -} - -inline IntPoint operator+(const IntPoint& p1, const IntPoint& p2) { - IntPoint ret = p1; - ret += p2; - return ret; -} - -inline IntPoint& operator -=(IntPoint& p, const IntPoint& pa ) { - p.X -= pa.X; - p.Y -= pa.Y; - return p; -} - -inline IntPoint operator -(const IntPoint& p ) { - IntPoint ret = p; - ret.X = -ret.X; - ret.Y = -ret.Y; - return ret; -} - -inline IntPoint operator-(const IntPoint& p1, const IntPoint& p2) { - IntPoint ret = p1; - ret -= p2; - return ret; -} - -inline IntPoint& operator *=(IntPoint& p, const IntPoint& pa ) { - p.X *= pa.X; - p.Y *= pa.Y; - return p; -} - -inline IntPoint operator*(const IntPoint& p1, const IntPoint& p2) { - IntPoint ret = p1; - ret *= p2; - return ret; -} - -} - -#endif // CLIPPER_POLYGON_HPP diff --git a/src/libnest2d/include/libnest2d/backends/clipper/geometries.hpp b/src/libnest2d/include/libnest2d/backends/clipper/geometries.hpp deleted file mode 100644 index 9586db35c..000000000 --- a/src/libnest2d/include/libnest2d/backends/clipper/geometries.hpp +++ /dev/null @@ -1,356 +0,0 @@ -#ifndef CLIPPER_BACKEND_HPP -#define CLIPPER_BACKEND_HPP - -#include <sstream> -#include <unordered_map> -#include <cassert> -#include <vector> -#include <iostream> - -#include <libnest2d/geometry_traits.hpp> -#include <libnest2d/geometry_traits_nfp.hpp> - -#include "clipper_polygon.hpp" - -namespace libnest2d { - -// Aliases for convinience -using PointImpl = ClipperLib::IntPoint; -using PathImpl = ClipperLib::Path; -using HoleStore = ClipperLib::Paths; -using PolygonImpl = ClipperLib::Polygon; - -template<> struct ShapeTag<PolygonImpl> { using Type = PolygonTag; }; -template<> struct ShapeTag<PathImpl> { using Type = PathTag; }; -template<> struct ShapeTag<PointImpl> { using Type = PointTag; }; - -// Type of coordinate units used by Clipper. Enough to specialize for point, -// the rest of the types will work (Path, Polygon) -template<> struct CoordType<PointImpl> { - using Type = ClipperLib::cInt; - static const constexpr ClipperLib::cInt MM_IN_COORDS = 1000000; -}; - -// Enough to specialize for path, it will work for multishape and Polygon -template<> struct PointType<PathImpl> { using Type = PointImpl; }; - -// This is crucial. CountourType refers to itself by default, so we don't have -// to secialize for clipper Path. ContourType<PathImpl>::Type is PathImpl. -template<> struct ContourType<PolygonImpl> { using Type = PathImpl; }; - -// The holes are contained in Clipper::Paths -template<> struct HolesContainer<PolygonImpl> { using Type = ClipperLib::Paths; }; - -namespace pointlike { - -// Tell libnest2d how to extract the X coord from a ClipperPoint object -template<> inline ClipperLib::cInt x(const PointImpl& p) -{ - return p.X; -} - -// Tell libnest2d how to extract the Y coord from a ClipperPoint object -template<> inline ClipperLib::cInt y(const PointImpl& p) -{ - return p.Y; -} - -// Tell libnest2d how to extract the X coord from a ClipperPoint object -template<> inline ClipperLib::cInt& x(PointImpl& p) -{ - return p.X; -} - -// Tell libnest2d how to extract the Y coord from a ClipperPoint object -template<> inline ClipperLib::cInt& y(PointImpl& p) -{ - return p.Y; -} - -} - -// Using the libnest2d default area implementation -#define DISABLE_BOOST_AREA - -namespace shapelike { - -template<> -inline void offset(PolygonImpl& sh, TCoord<PointImpl> distance, const PolygonTag&) -{ - #define DISABLE_BOOST_OFFSET - - using ClipperLib::ClipperOffset; - using ClipperLib::jtSquare; - using ClipperLib::etClosedPolygon; - using ClipperLib::Paths; - - Paths result; - - try { - ClipperOffset offs; - offs.AddPath(sh.Contour, jtSquare, etClosedPolygon); - offs.AddPaths(sh.Holes, jtSquare, etClosedPolygon); - offs.Execute(result, static_cast<double>(distance)); - } catch (ClipperLib::clipperException &) { - throw GeometryException(GeomErr::OFFSET); - } - - // Offsetting reverts the orientation and also removes the last vertex - // so boost will not have a closed polygon. - - // we plan to replace contours - sh.Holes.clear(); - - bool found_the_contour = false; - for(auto& r : result) { - if(ClipperLib::Orientation(r)) { - // We don't like if the offsetting generates more than one contour - // but throwing would be an overkill. Instead, we should warn the - // caller about the inability to create correct geometries - if(!found_the_contour) { - sh.Contour = std::move(r); - ClipperLib::ReversePath(sh.Contour); - auto front_p = sh.Contour.front(); - sh.Contour.emplace_back(std::move(front_p)); - found_the_contour = true; - } else { - dout() << "Warning: offsetting result is invalid!"; - /* TODO warning */ - } - } else { - // TODO If there are multiple contours we can't be sure which hole - // belongs to the first contour. (But in this case the situation is - // bad enough to let it go...) - sh.Holes.emplace_back(std::move(r)); - ClipperLib::ReversePath(sh.Holes.back()); - auto front_p = sh.Holes.back().front(); - sh.Holes.back().emplace_back(std::move(front_p)); - } - } -} - -template<> -inline void offset(PathImpl& sh, TCoord<PointImpl> distance, const PathTag&) -{ - PolygonImpl p(std::move(sh)); - offset(p, distance, PolygonTag()); - sh = p.Contour; -} - -// Tell libnest2d how to make string out of a ClipperPolygon object -template<> inline std::string toString(const PolygonImpl& sh) -{ - std::stringstream ss; - - ss << "Contour {\n"; - for(auto p : sh.Contour) { - ss << "\t" << p.X << " " << p.Y << "\n"; - } - ss << "}\n"; - - for(auto& h : sh.Holes) { - ss << "Holes {\n"; - for(auto p : h) { - ss << "\t{\n"; - ss << "\t\t" << p.X << " " << p.Y << "\n"; - ss << "\t}\n"; - } - ss << "}\n"; - } - - return ss.str(); -} - -template<> -inline PolygonImpl create(const PathImpl& path, const HoleStore& holes) -{ - PolygonImpl p; - p.Contour = path; - p.Holes = holes; - - return p; -} - -template<> inline PolygonImpl create( PathImpl&& path, HoleStore&& holes) { - PolygonImpl p; - p.Contour.swap(path); - p.Holes.swap(holes); - - return p; -} - -template<> -inline const THolesContainer<PolygonImpl>& holes(const PolygonImpl& sh) -{ - return sh.Holes; -} - -template<> inline THolesContainer<PolygonImpl>& holes(PolygonImpl& sh) -{ - return sh.Holes; -} - -template<> -inline TContour<PolygonImpl>& hole(PolygonImpl& sh, unsigned long idx) -{ - return sh.Holes[idx]; -} - -template<> -inline const TContour<PolygonImpl>& hole(const PolygonImpl& sh, - unsigned long idx) -{ - return sh.Holes[idx]; -} - -template<> inline size_t holeCount(const PolygonImpl& sh) -{ - return sh.Holes.size(); -} - -template<> inline PathImpl& contour(PolygonImpl& sh) -{ - return sh.Contour; -} - -template<> -inline const PathImpl& contour(const PolygonImpl& sh) -{ - return sh.Contour; -} - -#define DISABLE_BOOST_TRANSLATE -template<> -inline void translate(PolygonImpl& sh, const PointImpl& offs) -{ - for(auto& p : sh.Contour) { p += offs; } - for(auto& hole : sh.Holes) for(auto& p : hole) { p += offs; } -} - -#define DISABLE_BOOST_ROTATE -template<> -inline void rotate(PolygonImpl& sh, const Radians& rads) -{ - using Coord = TCoord<PointImpl>; - - auto cosa = rads.cos(); - auto sina = rads.sin(); - - for(auto& p : sh.Contour) { - p = { - static_cast<Coord>(p.X * cosa - p.Y * sina), - static_cast<Coord>(p.X * sina + p.Y * cosa) - }; - } - for(auto& hole : sh.Holes) for(auto& p : hole) { - p = { - static_cast<Coord>(p.X * cosa - p.Y * sina), - static_cast<Coord>(p.X * sina + p.Y * cosa) - }; - } -} - -} // namespace shapelike - -#define DISABLE_BOOST_NFP_MERGE -inline TMultiShape<PolygonImpl> clipper_execute( - ClipperLib::Clipper& clipper, - ClipperLib::ClipType clipType, - ClipperLib::PolyFillType subjFillType = ClipperLib::pftEvenOdd, - ClipperLib::PolyFillType clipFillType = ClipperLib::pftEvenOdd) -{ - TMultiShape<PolygonImpl> retv; - - ClipperLib::PolyTree result; - clipper.Execute(clipType, result, subjFillType, clipFillType); - - retv.reserve(static_cast<size_t>(result.Total())); - - std::function<void(ClipperLib::PolyNode*, PolygonImpl&)> processHole; - - auto processPoly = [&retv, &processHole](ClipperLib::PolyNode *pptr) { - PolygonImpl poly; - poly.Contour.swap(pptr->Contour); - - assert(!pptr->IsHole()); - - if(!poly.Contour.empty() ) { - auto front_p = poly.Contour.front(); - auto &back_p = poly.Contour.back(); - if(front_p.X != back_p.X || front_p.Y != back_p.X) - poly.Contour.emplace_back(front_p); - } - - for(auto h : pptr->Childs) { processHole(h, poly); } - retv.push_back(poly); - }; - - processHole = [&processPoly](ClipperLib::PolyNode *pptr, PolygonImpl& poly) - { - poly.Holes.emplace_back(std::move(pptr->Contour)); - - assert(pptr->IsHole()); - - if(!poly.Contour.empty() ) { - auto front_p = poly.Contour.front(); - auto &back_p = poly.Contour.back(); - if(front_p.X != back_p.X || front_p.Y != back_p.X) - poly.Contour.emplace_back(front_p); - } - - for(auto c : pptr->Childs) processPoly(c); - }; - - auto traverse = [&processPoly] (ClipperLib::PolyNode *node) - { - for(auto ch : node->Childs) processPoly(ch); - }; - - traverse(&result); - - return retv; -} - -namespace nfp { - -template<> inline TMultiShape<PolygonImpl> -merge(const TMultiShape<PolygonImpl>& shapes) -{ - ClipperLib::Clipper clipper(ClipperLib::ioReverseSolution); - - bool closed = true; - bool valid = true; - - for(auto& path : shapes) { - valid &= clipper.AddPath(path.Contour, ClipperLib::ptSubject, closed); - - for(auto& h : path.Holes) - valid &= clipper.AddPath(h, ClipperLib::ptSubject, closed); - } - - if(!valid) throw GeometryException(GeomErr::MERGE); - - return clipper_execute(clipper, ClipperLib::ctUnion, ClipperLib::pftNegative); -} - -} - -} - -#define DISABLE_BOOST_CONVEX_HULL - -//#define DISABLE_BOOST_SERIALIZE -//#define DISABLE_BOOST_UNSERIALIZE - -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable: 4244) -#pragma warning(disable: 4267) -#endif -// All other operators and algorithms are implemented with boost -#include <libnest2d/utils/boost_alg.hpp> -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -#endif // CLIPPER_BACKEND_HPP diff --git a/src/libnest2d/include/libnest2d/backends/libslic3r/geometries.hpp b/src/libnest2d/include/libnest2d/backends/libslic3r/geometries.hpp new file mode 100644 index 000000000..14b075b19 --- /dev/null +++ b/src/libnest2d/include/libnest2d/backends/libslic3r/geometries.hpp @@ -0,0 +1,283 @@ +#ifndef CLIPPER_BACKEND_HPP +#define CLIPPER_BACKEND_HPP + +#include <sstream> +#include <unordered_map> +#include <cassert> +#include <vector> +#include <iostream> + +#include <libnest2d/geometry_traits.hpp> +#include <libnest2d/geometry_traits_nfp.hpp> + +#include <libslic3r/ExPolygon.hpp> +#include <libslic3r/ClipperUtils.hpp> + +namespace Slic3r { + +template<class T, class En = void> struct IsVec_ : public std::false_type {}; + +template<class T> struct IsVec_< Vec<2, T> >: public std::true_type {}; + +template<class T> +static constexpr const bool IsVec = IsVec_<libnest2d::remove_cvref_t<T>>::value; + +template<class T, class O> using VecOnly = std::enable_if_t<IsVec<T>, O>; + +inline Point operator+(const Point& p1, const Point& p2) { + Point ret = p1; + ret += p2; + return ret; +} + +inline Point operator -(const Point& p ) { + Point ret = p; + ret.x() = -ret.x(); + ret.y() = -ret.y(); + return ret; +} + +inline Point operator-(const Point& p1, const Point& p2) { + Point ret = p1; + ret -= p2; + return ret; +} + +inline Point& operator *=(Point& p, const Point& pa ) { + p.x() *= pa.x(); + p.y() *= pa.y(); + return p; +} + +inline Point operator*(const Point& p1, const Point& p2) { + Point ret = p1; + ret *= p2; + return ret; +} + +} // namespace Slic3r + +namespace libnest2d { + +template<class T> using Vec = Slic3r::Vec<2, T>; + +// Aliases for convinience +using PointImpl = Slic3r::Point; +using PathImpl = Slic3r::Polygon; +using HoleStore = Slic3r::Polygons; +using PolygonImpl = Slic3r::ExPolygon; + +template<> struct ShapeTag<Slic3r::Vec2crd> { using Type = PointTag; }; +template<> struct ShapeTag<Slic3r::Point> { using Type = PointTag; }; + +template<> struct ShapeTag<std::vector<Slic3r::Vec2crd>> { using Type = PathTag; }; +template<> struct ShapeTag<Slic3r::Polygon> { using Type = PathTag; }; +template<> struct ShapeTag<Slic3r::Points> { using Type = PathTag; }; +template<> struct ShapeTag<Slic3r::ExPolygon> { using Type = PolygonTag; }; +template<> struct ShapeTag<Slic3r::ExPolygons> { using Type = MultiPolygonTag; }; + +// Type of coordinate units used by Clipper. Enough to specialize for point, +// the rest of the types will work (Path, Polygon) +template<> struct CoordType<Slic3r::Point> { + using Type = coord_t; + static const constexpr coord_t MM_IN_COORDS = 1000000; +}; + +template<> struct CoordType<Slic3r::Vec2crd> { + using Type = coord_t; + static const constexpr coord_t MM_IN_COORDS = 1000000; +}; + +// Enough to specialize for path, it will work for multishape and Polygon +template<> struct PointType<std::vector<Slic3r::Vec2crd>> { using Type = Slic3r::Vec2crd; }; +template<> struct PointType<Slic3r::Polygon> { using Type = Slic3r::Point; }; +template<> struct PointType<Slic3r::Points> { using Type = Slic3r::Point; }; + +// This is crucial. CountourType refers to itself by default, so we don't have +// to secialize for clipper Path. ContourType<PathImpl>::Type is PathImpl. +template<> struct ContourType<Slic3r::ExPolygon> { using Type = Slic3r::Polygon; }; + +// The holes are contained in Clipper::Paths +template<> struct HolesContainer<Slic3r::ExPolygon> { using Type = Slic3r::Polygons; }; + +template<> +struct OrientationType<Slic3r::Polygon> { + static const constexpr Orientation Value = Orientation::COUNTER_CLOCKWISE; +}; + +template<> +struct OrientationType<Slic3r::Points> { + static const constexpr Orientation Value = Orientation::COUNTER_CLOCKWISE; +}; + +template<> +struct ClosureType<Slic3r::Polygon> { + static const constexpr Closure Value = Closure::OPEN; +}; + +template<> +struct ClosureType<Slic3r::Points> { + static const constexpr Closure Value = Closure::OPEN; +}; + +template<> struct MultiShape<Slic3r::ExPolygon> { using Type = Slic3r::ExPolygons; }; +template<> struct ContourType<Slic3r::ExPolygons> { using Type = Slic3r::Polygon; }; + +// Using the libnest2d default area implementation +#define DISABLE_BOOST_AREA + +namespace shapelike { + +template<> +inline void offset(Slic3r::ExPolygon& sh, coord_t distance, const PolygonTag&) +{ +#define DISABLE_BOOST_OFFSET + auto res = Slic3r::offset_ex(sh, distance, Slic3r::ClipperLib::jtSquare); + if (!res.empty()) sh = res.front(); +} + +template<> +inline void offset(Slic3r::Polygon& sh, coord_t distance, const PathTag&) +{ + auto res = Slic3r::offset(sh, distance, Slic3r::ClipperLib::jtSquare); + if (!res.empty()) sh = res.front(); +} + +// Tell libnest2d how to make string out of a ClipperPolygon object +template<> inline std::string toString(const Slic3r::ExPolygon& sh) +{ + std::stringstream ss; + + ss << "Contour {\n"; + for(auto &p : sh.contour.points) { + ss << "\t" << p.x() << " " << p.y() << "\n"; + } + ss << "}\n"; + + for(auto& h : sh.holes) { + ss << "Holes {\n"; + for(auto p : h.points) { + ss << "\t{\n"; + ss << "\t\t" << p.x() << " " << p.y() << "\n"; + ss << "\t}\n"; + } + ss << "}\n"; + } + + return ss.str(); +} + +template<> +inline Slic3r::ExPolygon create(const Slic3r::Polygon& path, const Slic3r::Polygons& holes) +{ + Slic3r::ExPolygon p; + p.contour = path; + p.holes = holes; + + return p; +} + +template<> inline Slic3r::ExPolygon create(Slic3r::Polygon&& path, Slic3r::Polygons&& holes) { + Slic3r::ExPolygon p; + p.contour.points.swap(path.points); + p.holes.swap(holes); + + return p; +} + +template<> +inline const THolesContainer<PolygonImpl>& holes(const Slic3r::ExPolygon& sh) +{ + return sh.holes; +} + +template<> inline THolesContainer<PolygonImpl>& holes(Slic3r::ExPolygon& sh) +{ + return sh.holes; +} + +template<> +inline Slic3r::Polygon& hole(Slic3r::ExPolygon& sh, unsigned long idx) +{ + return sh.holes[idx]; +} + +template<> +inline const Slic3r::Polygon& hole(const Slic3r::ExPolygon& sh, unsigned long idx) +{ + return sh.holes[idx]; +} + +template<> inline size_t holeCount(const Slic3r::ExPolygon& sh) +{ + return sh.holes.size(); +} + +template<> inline Slic3r::Polygon& contour(Slic3r::ExPolygon& sh) +{ + return sh.contour; +} + +template<> +inline const Slic3r::Polygon& contour(const Slic3r::ExPolygon& sh) +{ + return sh.contour; +} + +template<> +inline void reserve(Slic3r::Polygon& p, size_t vertex_capacity, const PathTag&) +{ + p.points.reserve(vertex_capacity); +} + +template<> +inline void addVertex(Slic3r::Polygon& sh, const PathTag&, const Slic3r::Point &p) +{ + sh.points.emplace_back(p); +} + +#define DISABLE_BOOST_TRANSLATE +template<> +inline void translate(Slic3r::ExPolygon& sh, const Slic3r::Point& offs) +{ + sh.translate(offs); +} + +#define DISABLE_BOOST_ROTATE +template<> +inline void rotate(Slic3r::ExPolygon& sh, const Radians& rads) +{ + sh.rotate(rads); +} + +} // namespace shapelike + +namespace nfp { + +#define DISABLE_BOOST_NFP_MERGE +template<> +inline TMultiShape<PolygonImpl> merge(const TMultiShape<PolygonImpl>& shapes) +{ + return Slic3r::union_ex(shapes); +} + +} // namespace nfp +} // namespace libnest2d + +#define DISABLE_BOOST_CONVEX_HULL + +//#define DISABLE_BOOST_SERIALIZE +//#define DISABLE_BOOST_UNSERIALIZE + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable: 4244) +#pragma warning(disable: 4267) +#endif +// All other operators and algorithms are implemented with boost +#include <libnest2d/utils/boost_alg.hpp> +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // CLIPPER_BACKEND_HPP diff --git a/src/libnest2d/include/libnest2d/geometry_traits.hpp b/src/libnest2d/include/libnest2d/geometry_traits.hpp index 3095c717d..7ea437339 100644 --- a/src/libnest2d/include/libnest2d/geometry_traits.hpp +++ b/src/libnest2d/include/libnest2d/geometry_traits.hpp @@ -128,22 +128,32 @@ template<class S> struct ContourType<DefaultMultiShape<S>> { using Type = typename ContourType<S>::Type; }; -enum class Orientation { - CLOCKWISE, - COUNTER_CLOCKWISE -}; +enum class Orientation { CLOCKWISE, COUNTER_CLOCKWISE }; template<class S> struct OrientationType { // Default Polygon orientation that the library expects - static const Orientation Value = Orientation::CLOCKWISE; + static const constexpr Orientation Value = Orientation::CLOCKWISE; }; -template<class T> inline /*constexpr*/ bool is_clockwise() { +template<class T> inline constexpr bool is_clockwise() { return OrientationType<TContour<T>>::Value == Orientation::CLOCKWISE; } +template<class T> +inline const constexpr Orientation OrientationTypeV = + OrientationType<TContour<T>>::Value; + +enum class Closure { OPEN, CLOSED }; + +template<class S> struct ClosureType { + static const constexpr Closure Value = Closure::CLOSED; +}; + +template<class T> +inline const constexpr Closure ClosureTypeV = + ClosureType<TContour<T>>::Value; /** * \brief A point pair base class for other point pairs (segment, box, ...). @@ -587,9 +597,9 @@ inline void reserve(RawPath& p, size_t vertex_capacity, const PathTag&) } template<class S, class...Args> -inline void addVertex(S& sh, const PathTag&, Args...args) +inline void addVertex(S& sh, const PathTag&, const TPoint<S> &p) { - sh.emplace_back(std::forward<Args>(args)...); + sh.emplace_back(p); } template<class S, class Fn> @@ -841,9 +851,9 @@ template<class P> auto rbegin(P& p) -> decltype(_backward(end(p))) return _backward(end(p)); } -template<class P> auto rcbegin(const P& p) -> decltype(_backward(end(p))) +template<class P> auto rcbegin(const P& p) -> decltype(_backward(cend(p))) { - return _backward(end(p)); + return _backward(cend(p)); } template<class P> auto rend(P& p) -> decltype(_backward(begin(p))) @@ -873,16 +883,16 @@ inline void reserve(T& sh, size_t vertex_capacity) { reserve(sh, vertex_capacity, Tag<T>()); } -template<class S, class...Args> -inline void addVertex(S& sh, const PolygonTag&, Args...args) +template<class S> +inline void addVertex(S& sh, const PolygonTag&, const TPoint<S> &p) { - addVertex(contour(sh), PathTag(), std::forward<Args>(args)...); + addVertex(contour(sh), PathTag(), p); } -template<class S, class...Args> // Tag dispatcher -inline void addVertex(S& sh, Args...args) +template<class S> // Tag dispatcher +inline void addVertex(S& sh, const TPoint<S> &p) { - addVertex(sh, Tag<S>(), std::forward<Args>(args)...); + addVertex(sh, Tag<S>(), p); } template<class S> diff --git a/src/libnest2d/include/libnest2d/geometry_traits_nfp.hpp b/src/libnest2d/include/libnest2d/geometry_traits_nfp.hpp index 6b3ff60c1..d9f947802 100644 --- a/src/libnest2d/include/libnest2d/geometry_traits_nfp.hpp +++ b/src/libnest2d/include/libnest2d/geometry_traits_nfp.hpp @@ -28,7 +28,7 @@ inline void buildPolygon(const EdgeList& edgelist, auto& rsh = sl::contour(rpoly); - sl::reserve(rsh, 2*edgelist.size()); + sl::reserve(rsh, 2 * edgelist.size()); // Add the two vertices from the first edge into the final polygon. sl::addVertex(rsh, edgelist.front().first()); @@ -57,7 +57,6 @@ inline void buildPolygon(const EdgeList& edgelist, tmp = std::next(tmp); } - } template<class Container, class Iterator = typename Container::iterator> @@ -214,17 +213,24 @@ inline NfpResult<RawShape> nfpConvexOnly(const RawShape& sh, // Reserve the needed memory edgelist.reserve(cap); sl::reserve(rsh, static_cast<unsigned long>(cap)); + auto add_edge = [&edgelist](const Vertex &v1, const Vertex &v2) { + Edge e{v1, v2}; + if (e.sqlength() > 0) + edgelist.emplace_back(e); + }; { // place all edges from sh into edgelist auto first = sl::cbegin(sh); auto next = std::next(first); while(next != sl::cend(sh)) { - if (pl::magnsq(*next - *first) > 0) - edgelist.emplace_back(*(first), *(next)); + add_edge(*(first), *(next)); ++first; ++next; } + + if constexpr (ClosureTypeV<RawShape> == Closure::OPEN) + add_edge(*sl::rcbegin(sh), *sl::cbegin(sh)); } { // place all edges from other into edgelist @@ -232,17 +238,19 @@ inline NfpResult<RawShape> nfpConvexOnly(const RawShape& sh, auto next = std::next(first); while(next != sl::cend(other)) { - if (pl::magnsq(*next - *first) > 0) - edgelist.emplace_back(*(next), *(first)); + add_edge(*(next), *(first)); ++first; ++next; } + + if constexpr (ClosureTypeV<RawShape> == Closure::OPEN) + add_edge(*sl::cbegin(other), *sl::rcbegin(other)); } - std::sort(edgelist.begin(), edgelist.end(), - [](const Edge& e1, const Edge& e2) + std::sort(edgelist.begin(), edgelist.end(), + [](const Edge& e1, const Edge& e2) { - Vertex ax(1, 0); // Unit vector for the X axis + const Vertex ax(1, 0); // Unit vector for the X axis // get cectors from the edges Vertex p1 = e1.second() - e1.first(); @@ -288,12 +296,18 @@ inline NfpResult<RawShape> nfpConvexOnly(const RawShape& sh, // If Ratio is an actual rational type, there is no precision loss auto pcos1 = Ratio(lcos[0]) / lsq1 * sign * lcos[0]; auto pcos2 = Ratio(lcos[1]) / lsq2 * sign * lcos[1]; - - return q[0] < 2 ? pcos1 < pcos2 : pcos1 > pcos2; + + if constexpr (is_clockwise<RawShape>()) + return q[0] < 2 ? pcos1 < pcos2 : pcos1 > pcos2; + else + return q[0] < 2 ? pcos1 > pcos2 : pcos1 < pcos2; } // If in different quadrants, compare the quadrant indices only. - return q[0] > q[1]; + if constexpr (is_clockwise<RawShape>()) + return q[0] > q[1]; + else + return q[0] < q[1]; }); __nfp::buildPolygon(edgelist, rsh, top_nfp); diff --git a/src/libnest2d/include/libnest2d/libnest2d.hpp b/src/libnest2d/include/libnest2d/libnest2d.hpp index 9d24a2569..a4cf7dc56 100644 --- a/src/libnest2d/include/libnest2d/libnest2d.hpp +++ b/src/libnest2d/include/libnest2d/libnest2d.hpp @@ -7,6 +7,10 @@ #include <libnest2d/backends/clipper/geometries.hpp> #endif +#ifdef LIBNEST2D_GEOMETRIES_libslic3r +#include <libnest2d/backends/libslic3r/geometries.hpp> +#endif + #ifdef LIBNEST2D_OPTIMIZER_nlopt // We include the stock optimizers for local and global optimization #include <libnest2d/optimizers/nlopt/subplex.hpp> // Local subplex for NfpPlacer diff --git a/src/libnest2d/include/libnest2d/nester.hpp b/src/libnest2d/include/libnest2d/nester.hpp index 20da9b9a1..52c738a4c 100644 --- a/src/libnest2d/include/libnest2d/nester.hpp +++ b/src/libnest2d/include/libnest2d/nester.hpp @@ -96,7 +96,7 @@ public: * @return The orientation type identifier for the _Item type. */ static BP2D_CONSTEXPR Orientation orientation() { - return OrientationType<RawShape>::Value; + return OrientationType<TContour<RawShape>>::Value; } /** @@ -446,44 +446,32 @@ private: } }; +template<class Sh> Sh create_rect(TCoord<Sh> width, TCoord<Sh> height) +{ + auto sh = sl::create<Sh>( + {{0, 0}, {0, height}, {width, height}, {width, 0}}); + + if constexpr (ClosureTypeV<Sh> == Closure::CLOSED) + sl::addVertex(sh, {0, 0}); + + if constexpr (OrientationTypeV<Sh> == Orientation::COUNTER_CLOCKWISE) + std::reverse(sl::begin(sh), sl::end(sh)); + + return sh; +} + /** * \brief Subclass of _Item for regular rectangle items. */ -template<class RawShape> -class _Rectangle: public _Item<RawShape> { - using _Item<RawShape>::vertex; +template<class Sh> +class _Rectangle: public _Item<Sh> { + using _Item<Sh>::vertex; using TO = Orientation; public: - using Unit = TCoord<TPoint<RawShape>>; + using Unit = TCoord<Sh>; - template<TO o = OrientationType<RawShape>::Value> - inline _Rectangle(Unit width, Unit height, - // disable this ctor if o != CLOCKWISE - enable_if_t< o == TO::CLOCKWISE, int> = 0 ): - _Item<RawShape>( sl::create<RawShape>( { - {0, 0}, - {0, height}, - {width, height}, - {width, 0}, - {0, 0} - } )) - { - } - - template<TO o = OrientationType<RawShape>::Value> - inline _Rectangle(Unit width, Unit height, - // disable this ctor if o != COUNTER_CLOCKWISE - enable_if_t< o == TO::COUNTER_CLOCKWISE, int> = 0 ): - _Item<RawShape>( sl::create<RawShape>( { - {0, 0}, - {width, 0}, - {width, height}, - {0, height}, - {0, 0} - } )) - { - } + inline _Rectangle(Unit w, Unit h): _Item<Sh>{create_rect<Sh>(w, h)} {} inline Unit width() const BP2D_NOEXCEPT { return getX(vertex(2)); diff --git a/src/libnest2d/include/libnest2d/placers/bottomleftplacer.hpp b/src/libnest2d/include/libnest2d/placers/bottomleftplacer.hpp index e1a4ffbd9..a067194dc 100644 --- a/src/libnest2d/include/libnest2d/placers/bottomleftplacer.hpp +++ b/src/libnest2d/include/libnest2d/placers/bottomleftplacer.hpp @@ -365,44 +365,50 @@ protected: // the additional vertices for maintaning min object distance sl::reserve(rsh, finish-start+4); - /*auto addOthers = [&rsh, finish, start, &item](){ + auto addOthers_ = [&rsh, finish, start, &item](){ for(size_t i = start+1; i < finish; i++) sl::addVertex(rsh, item.vertex(i)); - };*/ + }; - auto reverseAddOthers = [&rsh, finish, start, &item](){ + auto reverseAddOthers_ = [&rsh, finish, start, &item](){ for(auto i = finish-1; i > start; i--) - sl::addVertex(rsh, item.vertex( - static_cast<unsigned long>(i))); + sl::addVertex(rsh, item.vertex(static_cast<unsigned long>(i))); }; - // Final polygon construction... + auto addOthers = [&addOthers_, &reverseAddOthers_]() { + if constexpr (!is_clockwise<RawShape>()) + addOthers_(); + else + reverseAddOthers_(); + }; - static_assert(OrientationType<RawShape>::Value == - Orientation::CLOCKWISE, - "Counter clockwise toWallPoly() Unimplemented!"); + // Final polygon construction... // Clockwise polygon construction sl::addVertex(rsh, topleft_vertex); - if(dir == Dir::LEFT) reverseAddOthers(); + if(dir == Dir::LEFT) addOthers(); else { - sl::addVertex(rsh, getX(topleft_vertex), 0); - sl::addVertex(rsh, getX(bottomleft_vertex), 0); + sl::addVertex(rsh, {getX(topleft_vertex), 0}); + sl::addVertex(rsh, {getX(bottomleft_vertex), 0}); } sl::addVertex(rsh, bottomleft_vertex); if(dir == Dir::LEFT) { - sl::addVertex(rsh, 0, getY(bottomleft_vertex)); - sl::addVertex(rsh, 0, getY(topleft_vertex)); + sl::addVertex(rsh, {0, getY(bottomleft_vertex)}); + sl::addVertex(rsh, {0, getY(topleft_vertex)}); } - else reverseAddOthers(); + else addOthers(); // Close the polygon - sl::addVertex(rsh, topleft_vertex); + if constexpr (ClosureTypeV<RawShape> == Closure::CLOSED) + sl::addVertex(rsh, topleft_vertex); + + if constexpr (!is_clockwise<RawShape>()) + std::reverse(rsh.begin(), rsh.end()); return ret; } diff --git a/src/libnest2d/include/libnest2d/placers/nfpplacer.hpp b/src/libnest2d/include/libnest2d/placers/nfpplacer.hpp index bd9c60355..47ba7bbdc 100644 --- a/src/libnest2d/include/libnest2d/placers/nfpplacer.hpp +++ b/src/libnest2d/include/libnest2d/placers/nfpplacer.hpp @@ -250,8 +250,8 @@ template<class RawShape> class EdgeCache { Vertex ret = edge.first(); // Get the point on the edge which lies in ed distance from the start - ret += { static_cast<Coord>(std::round(ed*std::cos(angle))), - static_cast<Coord>(std::round(ed*std::sin(angle))) }; + ret += Vertex(static_cast<Coord>(std::round(ed*std::cos(angle))), + static_cast<Coord>(std::round(ed*std::sin(angle)))); return ret; } @@ -724,8 +724,7 @@ private: auto rawobjfunc = [_objfunc, iv, startpos] (Vertex v, Item& itm) { - auto d = v - iv; - d += startpos; + auto d = (v - iv) + startpos; itm.translation(d); return _objfunc(itm); }; @@ -742,8 +741,7 @@ private: &item, &bin, &iv, &startpos] (const Optimum& o) { auto v = getNfpPoint(o); - auto d = v - iv; - d += startpos; + auto d = (v - iv) + startpos; item.translation(d); merged_pile.emplace_back(item.transformedShape()); @@ -877,8 +875,7 @@ private: } if( best_score < global_score ) { - auto d = getNfpPoint(optimum) - iv; - d += startpos; + auto d = (getNfpPoint(optimum) - iv) + startpos; final_tr = d; final_rot = initial_rot + rot; can_pack = true; diff --git a/src/libnest2d/include/libnest2d/utils/boost_alg.hpp b/src/libnest2d/include/libnest2d/utils/boost_alg.hpp index 16dee513b..d6213d0ed 100644 --- a/src/libnest2d/include/libnest2d/utils/boost_alg.hpp +++ b/src/libnest2d/include/libnest2d/utils/boost_alg.hpp @@ -19,7 +19,7 @@ #pragma warning(pop) #endif // this should be removed to not confuse the compiler -// #include <libnest2d.h> +// #include "../libnest2d.hpp" namespace bp2d { @@ -30,6 +30,10 @@ using libnest2d::PolygonImpl; using libnest2d::PathImpl; using libnest2d::Orientation; using libnest2d::OrientationType; +using libnest2d::OrientationTypeV; +using libnest2d::ClosureType; +using libnest2d::Closure; +using libnest2d::ClosureTypeV; using libnest2d::getX; using libnest2d::getY; using libnest2d::setX; @@ -213,8 +217,15 @@ struct ToBoostOrienation<bp2d::Orientation::COUNTER_CLOCKWISE> { static const order_selector Value = counterclockwise; }; -static const bp2d::Orientation RealOrientation = - bp2d::OrientationType<bp2d::PolygonImpl>::Value; +template<bp2d::Closure> struct ToBoostClosure {}; + +template<> struct ToBoostClosure<bp2d::Closure::OPEN> { + static const constexpr closure_selector Value = closure_selector::open; +}; + +template<> struct ToBoostClosure<bp2d::Closure::CLOSED> { + static const constexpr closure_selector Value = closure_selector::closed; +}; // Ring implementation ///////////////////////////////////////////////////////// @@ -225,12 +236,13 @@ template<> struct tag<bp2d::PathImpl> { template<> struct point_order<bp2d::PathImpl> { static const order_selector value = - ToBoostOrienation<RealOrientation>::Value; + ToBoostOrienation<bp2d::OrientationTypeV<bp2d::PathImpl>>::Value; }; // All our Paths should be closed for the bin packing application template<> struct closure<bp2d::PathImpl> { - static const closure_selector value = closed; + static const constexpr closure_selector value = + ToBoostClosure< bp2d::ClosureTypeV<bp2d::PathImpl> >::Value; }; // Polygon implementation ////////////////////////////////////////////////////// diff --git a/src/libslic3r/Arrange.cpp b/src/libslic3r/Arrange.cpp index 3800d49e3..61a32678b 100644 --- a/src/libslic3r/Arrange.cpp +++ b/src/libslic3r/Arrange.cpp @@ -3,7 +3,7 @@ #include "BoundingBox.hpp" -#include <libnest2d/backends/clipper/geometries.hpp> +#include <libnest2d/backends/libslic3r/geometries.hpp> #include <libnest2d/optimizers/nlopt/subplex.hpp> #include <libnest2d/placers/nfpplacer.hpp> #include <libnest2d/selections/firstfit.hpp> @@ -54,23 +54,22 @@ namespace Slic3r { template<class Tout = double, class = FloatingOnly<Tout>, int...EigenArgs> inline constexpr Eigen::Matrix<Tout, 2, EigenArgs...> unscaled( - const ClipperLib::IntPoint &v) noexcept + const Slic3r::ClipperLib::IntPoint &v) noexcept { - return Eigen::Matrix<Tout, 2, EigenArgs...>{unscaled<Tout>(v.X), - unscaled<Tout>(v.Y)}; + return Eigen::Matrix<Tout, 2, EigenArgs...>{unscaled<Tout>(v.x()), + unscaled<Tout>(v.y())}; } namespace arrangement { using namespace libnest2d; -namespace clppr = ClipperLib; // Get the libnest2d types for clipper backend -using Item = _Item<clppr::Polygon>; -using Box = _Box<clppr::IntPoint>; -using Circle = _Circle<clppr::IntPoint>; -using Segment = _Segment<clppr::IntPoint>; -using MultiPolygon = TMultiShape<clppr::Polygon>; +using Item = _Item<ExPolygon>; +using Box = _Box<Point>; +using Circle = _Circle<Point>; +using Segment = _Segment<Point>; +using MultiPolygon = ExPolygons; // Summon the spatial indexing facilities from boost namespace bgi = boost::geometry::index; @@ -127,8 +126,8 @@ template<class TBin> class AutoArranger { public: // Useful type shortcuts... - using Placer = typename placers::_NofitPolyPlacer<clppr::Polygon, TBin>; - using Selector = selections::_FirstFitSelection<clppr::Polygon>; + using Placer = typename placers::_NofitPolyPlacer<ExPolygon, TBin>; + using Selector = selections::_FirstFitSelection<ExPolygon>; using Packer = _Nester<Placer, Selector>; using PConfig = typename Packer::PlacementConfig; using Distance = TCoord<PointImpl>; @@ -168,7 +167,7 @@ protected: // as it possibly can be but at the same time, it has to provide // reasonable results. std::tuple<double /*score*/, Box /*farthest point from bin center*/> - objfunc(const Item &item, const clppr::IntPoint &bincenter) + objfunc(const Item &item, const Point &bincenter) { const double bin_area = m_bin_area; const SpatIndex& spatindex = m_rtree; @@ -220,12 +219,12 @@ protected: switch (compute_case) { case BIG_ITEM: { - const clppr::IntPoint& minc = ibb.minCorner(); // bottom left corner - const clppr::IntPoint& maxc = ibb.maxCorner(); // top right corner + const Point& minc = ibb.minCorner(); // bottom left corner + const Point& maxc = ibb.maxCorner(); // top right corner // top left and bottom right corners - clppr::IntPoint top_left{getX(minc), getY(maxc)}; - clppr::IntPoint bottom_right{getX(maxc), getY(minc)}; + Point top_left{getX(minc), getY(maxc)}; + Point bottom_right{getX(maxc), getY(minc)}; // Now the distance of the gravity center will be calculated to the // five anchor points and the smallest will be chosen. @@ -452,7 +451,7 @@ template<> std::function<double(const Item&)> AutoArranger<Circle>::get_objfn() // Specialization for a generalized polygon. // Warning: this is unfinished business. It may or may not work. template<> -std::function<double(const Item &)> AutoArranger<clppr::Polygon>::get_objfn() +std::function<double(const Item &)> AutoArranger<ExPolygon>::get_objfn() { auto bincenter = sl::boundingBox(m_bin).center(); return [this, bincenter](const Item &item) { @@ -521,7 +520,7 @@ void _arrange( inline Box to_nestbin(const BoundingBox &bb) { return Box{{bb.min(X), bb.min(Y)}, {bb.max(X), bb.max(Y)}};} inline Circle to_nestbin(const CircleBed &c) { return Circle({c.center()(0), c.center()(1)}, c.radius()); } -inline clppr::Polygon to_nestbin(const Polygon &p) { return sl::create<clppr::Polygon>(Slic3rMultiPoint_to_ClipperPath(p)); } +inline ExPolygon to_nestbin(const Polygon &p) { return ExPolygon{p}; } inline Box to_nestbin(const InfiniteBed &bed) { return Box::infinite({bed.center.x(), bed.center.y()}); } inline coord_t width(const BoundingBox& box) { return box.max.x() - box.min.x(); } @@ -568,19 +567,12 @@ static void process_arrangeable(const ArrangePolygon &arrpoly, const Vec2crd &offs = arrpoly.translation; double rotation = arrpoly.rotation; - if (p.is_counter_clockwise()) p.reverse(); - - clppr::Polygon clpath(Slic3rMultiPoint_to_ClipperPath(p)); - // This fixes: // https://github.com/prusa3d/PrusaSlicer/issues/2209 - if (clpath.Contour.size() < 3) + if (p.points.size() < 3) return; - auto firstp = clpath.Contour.front(); - clpath.Contour.emplace_back(firstp); - - outp.emplace_back(std::move(clpath)); + outp.emplace_back(std::move(p)); outp.back().rotation(rotation); outp.back().translation({offs.x(), offs.y()}); outp.back().binId(arrpoly.bed_idx); @@ -624,7 +616,7 @@ void arrange(ArrangePolygons & arrangables, const BedT & bed, const ArrangeParams & params) { - namespace clppr = ClipperLib; + namespace clppr = Slic3r::ClipperLib; std::vector<Item> items, fixeditems; items.reserve(arrangables.size()); @@ -643,8 +635,8 @@ void arrange(ArrangePolygons & arrangables, _arrange(items, fixeditems, to_nestbin(bed), params, pri, cfn); for(size_t i = 0; i < items.size(); ++i) { - clppr::IntPoint tr = items[i].translation(); - arrangables[i].translation = {coord_t(tr.X), coord_t(tr.Y)}; + Point tr = items[i].translation(); + arrangables[i].translation = {coord_t(tr.x()), coord_t(tr.y())}; arrangables[i].rotation = items[i].rotation(); arrangables[i].bed_idx = items[i].binId(); } diff --git a/src/libslic3r/Brim.cpp b/src/libslic3r/Brim.cpp index 08bedc5c0..19f5ae82e 100644 --- a/src/libslic3r/Brim.cpp +++ b/src/libslic3r/Brim.cpp @@ -78,7 +78,7 @@ static ConstPrintObjectPtrs get_top_level_objects_with_brim(const Print &print) // Assign the maximum Z from four points. This values is valid index of the island clipper.ZFillFunction([](const ClipperLib_Z::IntPoint &e1bot, const ClipperLib_Z::IntPoint &e1top, const ClipperLib_Z::IntPoint &e2bot, const ClipperLib_Z::IntPoint &e2top, ClipperLib_Z::IntPoint &pt) { - pt.Z = std::max(std::max(e1bot.Z, e1top.Z), std::max(e2bot.Z, e2top.Z)); + pt.z() = std::max(std::max(e1bot.z(), e1top.z()), std::max(e2bot.z(), e2top.z())); }); // Add islands clipper.AddPaths(islands_clip, ClipperLib_Z::ptSubject, true); @@ -90,9 +90,9 @@ static ConstPrintObjectPtrs get_top_level_objects_with_brim(const Print &print) ConstPrintObjectPtrs top_level_objects_with_brim; for (int i = 0; i < islands_polytree.ChildCount(); ++i) { for (const ClipperLib_Z::IntPoint &point : islands_polytree.Childs[i]->Contour) { - if (point.Z != 0 && processed_objects_idx.find(island_to_object[point.Z - 1]->id().id) == processed_objects_idx.end()) { - top_level_objects_with_brim.emplace_back(island_to_object[point.Z - 1]); - processed_objects_idx.insert(island_to_object[point.Z - 1]->id().id); + if (point.z() != 0 && processed_objects_idx.find(island_to_object[point.z() - 1]->id().id) == processed_objects_idx.end()) { + top_level_objects_with_brim.emplace_back(island_to_object[point.z() - 1]); + processed_objects_idx.insert(island_to_object[point.z() - 1]->id().id); } } } @@ -456,7 +456,7 @@ ExtrusionEntityCollection make_brim(const Print &print, PrintTryCancel try_cance clipper.ZFillFunction([](const ClipperLib_Z::IntPoint& e1bot, const ClipperLib_Z::IntPoint& e1top, const ClipperLib_Z::IntPoint& e2bot, const ClipperLib_Z::IntPoint& e2top, ClipperLib_Z::IntPoint& pt) { // Assign a valid input loop identifier. Such an identifier is strictly positive, the next line is safe even in case one side of a segment // hat the Z coordinate not set to the contour coordinate. - pt.Z = std::max(std::max(e1bot.Z, e1top.Z), std::max(e2bot.Z, e2top.Z)); + pt.z() = std::max(std::max(e1bot.z(), e1top.z()), std::max(e2bot.z(), e2top.z())); }); // add polygons clipper.AddPaths(input_clip, ClipperLib_Z::ptSubject, false); @@ -474,8 +474,8 @@ ExtrusionEntityCollection make_brim(const Print &print, PrintTryCancel try_cance for (const ClipperLib_Z::Path &path : loops_trimmed) { size_t input_idx = 0; for (const ClipperLib_Z::IntPoint &pt : path) - if (pt.Z > 0) { - input_idx = (size_t)pt.Z; + if (pt.z() > 0) { + input_idx = (size_t)pt.z(); break; } assert(input_idx != 0); @@ -492,14 +492,14 @@ ExtrusionEntityCollection make_brim(const Print &print, PrintTryCancel try_cance size_t j = i + 1; for (; j < loops_trimmed_order.size() && loops_trimmed_order[i].second == loops_trimmed_order[j].second; ++ j) ; const ClipperLib_Z::Path &first_path = *loops_trimmed_order[i].first; - if (i + 1 == j && first_path.size() > 3 && first_path.front().X == first_path.back().X && first_path.front().Y == first_path.back().Y) { + if (i + 1 == j && first_path.size() > 3 && first_path.front().x() == first_path.back().x() && first_path.front().y() == first_path.back().y()) { auto *loop = new ExtrusionLoop(); brim.entities.emplace_back(loop); loop->paths.emplace_back(erSkirt, float(flow.mm3_per_mm()), float(flow.width()), float(print.skirt_first_layer_height())); Points &points = loop->paths.front().polyline.points; points.reserve(first_path.size()); for (const ClipperLib_Z::IntPoint &pt : first_path) - points.emplace_back(coord_t(pt.X), coord_t(pt.Y)); + points.emplace_back(coord_t(pt.x()), coord_t(pt.y())); i = j; } else { //FIXME The path chaining here may not be optimal. @@ -511,7 +511,7 @@ ExtrusionEntityCollection make_brim(const Print &print, PrintTryCancel try_cance Points &points = static_cast<ExtrusionPath*>(this_loop_trimmed.entities.back())->polyline.points; points.reserve(path.size()); for (const ClipperLib_Z::IntPoint &pt : path) - points.emplace_back(coord_t(pt.X), coord_t(pt.Y)); + points.emplace_back(coord_t(pt.x()), coord_t(pt.y())); } chain_and_reorder_extrusion_entities(this_loop_trimmed.entities, &last_pt); brim.entities.reserve(brim.entities.size() + this_loop_trimmed.entities.size()); diff --git a/src/libslic3r/CMakeLists.txt b/src/libslic3r/CMakeLists.txt index 2abe94656..16299f442 100644 --- a/src/libslic3r/CMakeLists.txt +++ b/src/libslic3r/CMakeLists.txt @@ -23,6 +23,8 @@ add_library(libslic3r STATIC BridgeDetector.hpp Brim.cpp Brim.hpp + clipper.cpp + clipper.hpp ClipperUtils.cpp ClipperUtils.hpp Config.cpp diff --git a/src/libslic3r/ClipperUtils.cpp b/src/libslic3r/ClipperUtils.cpp index cd243dfb1..477dbf6f1 100644 --- a/src/libslic3r/ClipperUtils.cpp +++ b/src/libslic3r/ClipperUtils.cpp @@ -131,7 +131,7 @@ Slic3r::Polygon ClipperPath_to_Slic3rPolygon(const ClipperLib::Path &input) { Polygon retval; for (ClipperLib::Path::const_iterator pit = input.begin(); pit != input.end(); ++pit) - retval.points.emplace_back(pit->X, pit->Y); + retval.points.emplace_back(pit->x(), pit->y()); return retval; } @@ -139,7 +139,7 @@ Slic3r::Polyline ClipperPath_to_Slic3rPolyline(const ClipperLib::Path &input) { Polyline retval; for (ClipperLib::Path::const_iterator pit = input.begin(); pit != input.end(); ++pit) - retval.points.emplace_back(pit->X, pit->Y); + retval.points.emplace_back(pit->x(), pit->y()); return retval; } @@ -752,7 +752,7 @@ ClipperLib::PolyNodes order_nodes(const ClipperLib::PolyNodes &nodes) for (const ClipperLib::PolyNode *node : nodes) ordering_points.emplace_back( - Point(node->Contour.front().X, node->Contour.front().Y)); + Point(node->Contour.front().x(), node->Contour.front().y())); // perform the ordering ClipperLib::PolyNodes ordered_nodes = @@ -777,7 +777,7 @@ static void traverse_pt_outside_in(const ClipperLib::PolyNodes &nodes, Polygons Points ordering_points; ordering_points.reserve(nodes.size()); for (const ClipperLib::PolyNode *node : nodes) - ordering_points.emplace_back(node->Contour.front().X, node->Contour.front().Y); + ordering_points.emplace_back(node->Contour.front().x(), node->Contour.front().y()); // Perform the ordering, push results recursively. //FIXME pass the last point to chain_clipper_polynodes? diff --git a/src/libslic3r/ClipperUtils.hpp b/src/libslic3r/ClipperUtils.hpp index 6668a9ae9..0a34fc93b 100644 --- a/src/libslic3r/ClipperUtils.hpp +++ b/src/libslic3r/ClipperUtils.hpp @@ -8,9 +8,9 @@ #include "Surface.hpp" // import these wherever we're included -using ClipperLib::jtMiter; -using ClipperLib::jtRound; -using ClipperLib::jtSquare; +using Slic3r::ClipperLib::jtMiter; +using Slic3r::ClipperLib::jtRound; +using Slic3r::ClipperLib::jtSquare; #define CLIPPERUTILS_UNSAFE_OFFSET diff --git a/src/libslic3r/ExPolygon.hpp b/src/libslic3r/ExPolygon.hpp index 73770bb18..fcf3c159e 100644 --- a/src/libslic3r/ExPolygon.hpp +++ b/src/libslic3r/ExPolygon.hpp @@ -360,6 +360,8 @@ extern std::vector<BoundingBox> get_extents_vector(const ExPolygons &polygons); extern bool remove_sticks(ExPolygon &poly); extern void keep_largest_contour_only(ExPolygons &polygons); +inline double area(const ExPolygon &poly) { return poly.area(); } + inline double area(const ExPolygons &polys) { double s = 0.; diff --git a/src/libslic3r/Execution/Execution.hpp b/src/libslic3r/Execution/Execution.hpp index e4bad9f23..62e49cfeb 100644 --- a/src/libslic3r/Execution/Execution.hpp +++ b/src/libslic3r/Execution/Execution.hpp @@ -10,10 +10,6 @@ namespace Slic3r { -// Borrowed from C++20 -template<class T> -using remove_cvref_t = std::remove_reference_t<std::remove_cv_t<T>>; - // Override for valid execution policies template<class EP> struct IsExecutionPolicy_ : public std::false_type {}; diff --git a/src/libslic3r/Fill/FillBase.cpp b/src/libslic3r/Fill/FillBase.cpp index 6d1d94ff8..a41a11cb7 100644 --- a/src/libslic3r/Fill/FillBase.cpp +++ b/src/libslic3r/Fill/FillBase.cpp @@ -595,7 +595,6 @@ static inline bool line_rounded_thick_segment_collision( // Very short line vector. Just test whether the center point is inside the offset line. Vec2d lpt = 0.5 * (line_a + line_b); if (segment_l > SCALED_EPSILON) { - struct Linef { Vec2d a, b; }; intersects = line_alg::distance_to_squared(Linef{ segment_a, segment_b }, lpt) < offset2; } else intersects = (0.5 * (segment_a + segment_b) - lpt).squaredNorm() < offset2; @@ -1196,8 +1195,6 @@ static inline void mark_boundary_segments_overlapping_infill( // Spacing (width) of the infill lines. const double spacing) { - struct Linef { Vec2d a; Vec2d b; }; - for (ContourIntersectionPoint &cp : graph.map_infill_end_point_to_boundary) { const Points &contour = graph.boundary[cp.contour_idx]; const std::vector<double> &contour_params = graph.boundary_params[cp.contour_idx]; @@ -2003,9 +2000,8 @@ static double evaluate_support_arch_cost(const Polyline &pl) double dmax = 0; // Maximum distance in Y axis out of the (ymin, ymax) band and from the (front, back) line. - struct Linef { Vec2d a, b; }; Linef line { front.cast<double>(), back.cast<double>() }; - for (const Point pt : pl.points) + for (const Point &pt : pl.points) dmax = std::max<double>(std::max(dmax, line_alg::distance_to(line, Vec2d(pt.cast<double>()))), std::max(pt.y() - ymax, ymin - pt.y())); return dmax; } diff --git a/src/libslic3r/Geometry.hpp b/src/libslic3r/Geometry.hpp index f6f4f5618..c6af515c8 100644 --- a/src/libslic3r/Geometry.hpp +++ b/src/libslic3r/Geometry.hpp @@ -22,12 +22,14 @@ #pragma warning(pop) #endif // _MSC_VER -namespace ClipperLib { -class PolyNode; -using PolyNodes = std::vector<PolyNode*>; -} +namespace Slic3r { + + namespace ClipperLib { + class PolyNode; + using PolyNodes = std::vector<PolyNode*>; + } -namespace Slic3r { namespace Geometry { +namespace Geometry { // Generic result of an orientation predicate. enum Orientation @@ -530,6 +532,6 @@ inline bool is_rotation_ninety_degrees(const Vec3d &rotation) return is_rotation_ninety_degrees(rotation.x()) && is_rotation_ninety_degrees(rotation.y()) && is_rotation_ninety_degrees(rotation.z()); } -} } +} } // namespace Slicer::Geometry #endif diff --git a/src/libslic3r/Line.hpp b/src/libslic3r/Line.hpp index 72532b4e3..b62775bfe 100644 --- a/src/libslic3r/Line.hpp +++ b/src/libslic3r/Line.hpp @@ -4,6 +4,8 @@ #include "libslic3r.h" #include "Point.hpp" +#include <type_traits> + namespace Slic3r { class BoundingBox; @@ -20,12 +22,28 @@ Linef3 transform(const Linef3& line, const Transform3d& t); namespace line_alg { +template<class L, class En = void> struct Traits { + static constexpr int Dim = L::Dim; + using Scalar = typename L::Scalar; + + static Vec<Dim, Scalar>& get_a(L &l) { return l.a; } + static Vec<Dim, Scalar>& get_b(L &l) { return l.b; } + static const Vec<Dim, Scalar>& get_a(const L &l) { return l.a; } + static const Vec<Dim, Scalar>& get_b(const L &l) { return l.b; } +}; + +template<class L> const constexpr int Dim = Traits<remove_cvref_t<L>>::Dim; +template<class L> using Scalar = typename Traits<remove_cvref_t<L>>::Scalar; + +template<class L> auto get_a(L &&l) { return Traits<remove_cvref_t<L>>::get_a(l); } +template<class L> auto get_b(L &&l) { return Traits<remove_cvref_t<L>>::get_b(l); } + // Distance to the closest point of line. -template<class L, class T, int N> -double distance_to_squared(const L &line, const Vec<N, T> &point) +template<class L> +double distance_to_squared(const L &line, const Vec<Dim<L>, Scalar<L>> &point) { - const Vec<N, double> v = (line.b - line.a).template cast<double>(); - const Vec<N, double> va = (point - line.a).template cast<double>(); + const Vec<Dim<L>, double> v = (get_b(line) - get_a(line)).template cast<double>(); + const Vec<Dim<L>, double> va = (point - get_a(line)).template cast<double>(); const double l2 = v.squaredNorm(); // avoid a sqrt if (l2 == 0.0) // a == b case @@ -35,12 +53,12 @@ double distance_to_squared(const L &line, const Vec<N, T> &point) // It falls where t = [(this-a) . (b-a)] / |b-a|^2 const double t = va.dot(v) / l2; if (t < 0.0) return va.squaredNorm(); // beyond the 'a' end of the segment - else if (t > 1.0) return (point - line.b).template cast<double>().squaredNorm(); // beyond the 'b' end of the segment + else if (t > 1.0) return (point - get_b(line)).template cast<double>().squaredNorm(); // beyond the 'b' end of the segment return (t * v - va).squaredNorm(); } -template<class L, class T, int N> -double distance_to(const L &line, const Vec<N, T> &point) +template<class L> +double distance_to(const L &line, const Vec<Dim<L>, Scalar<L>> &point) { return std::sqrt(distance_to_squared(line, point)); } @@ -84,6 +102,9 @@ public: Point a; Point b; + + static const constexpr int Dim = 2; + using Scalar = Point::Scalar; }; class ThickLine : public Line @@ -107,6 +128,9 @@ public: Vec3crd a; Vec3crd b; + + static const constexpr int Dim = 3; + using Scalar = Vec3crd::Scalar; }; class Linef @@ -117,6 +141,9 @@ public: Vec2d a; Vec2d b; + + static const constexpr int Dim = 2; + using Scalar = Vec2d::Scalar; }; class Linef3 @@ -133,6 +160,9 @@ public: Vec3d a; Vec3d b; + + static const constexpr int Dim = 3; + using Scalar = Vec3d::Scalar; }; BoundingBox get_extents(const Lines &lines); diff --git a/src/libslic3r/MTUtils.hpp b/src/libslic3r/MTUtils.hpp index 7b903f66c..9e77aa90a 100644 --- a/src/libslic3r/MTUtils.hpp +++ b/src/libslic3r/MTUtils.hpp @@ -106,8 +106,8 @@ template<class C> bool all_of(const C &container) }); } -template<class T> -using remove_cvref_t = std::remove_reference_t<std::remove_cv_t<T>>; +//template<class T> +//using remove_cvref_t = std::remove_reference_t<std::remove_cv_t<T>>; /// Exactly like Matlab https://www.mathworks.com/help/matlab/ref/linspace.html template<class T, class I, class = IntegerOnly<I>> diff --git a/src/libslic3r/MinAreaBoundingBox.cpp b/src/libslic3r/MinAreaBoundingBox.cpp index 15c04517d..51fd8a45e 100644 --- a/src/libslic3r/MinAreaBoundingBox.cpp +++ b/src/libslic3r/MinAreaBoundingBox.cpp @@ -14,55 +14,9 @@ #include <boost/multiprecision/integer.hpp> #endif -#include <libnest2d/geometry_traits.hpp> +#include <libnest2d/backends/libslic3r/geometries.hpp> #include <libnest2d/utils/rotcalipers.hpp> -namespace libnest2d { - -template<> struct PointType<Slic3r::Points> { using Type = Slic3r::Point; }; -template<> struct CoordType<Slic3r::Point> { using Type = coord_t; }; -template<> struct ShapeTag<Slic3r::ExPolygon> { using Type = PolygonTag; }; -template<> struct ShapeTag<Slic3r::Polygon> { using Type = PolygonTag; }; -template<> struct ShapeTag<Slic3r::Points> { using Type = PathTag; }; -template<> struct ShapeTag<Slic3r::Point> { using Type = PointTag; }; -template<> struct ContourType<Slic3r::ExPolygon> { using Type = Slic3r::Points; }; -template<> struct ContourType<Slic3r::Polygon> { using Type = Slic3r::Points; }; - -namespace pointlike { - -template<> inline coord_t x(const Slic3r::Point& p) { return p.x(); } -template<> inline coord_t y(const Slic3r::Point& p) { return p.y(); } -template<> inline coord_t& x(Slic3r::Point& p) { return p.x(); } -template<> inline coord_t& y(Slic3r::Point& p) { return p.y(); } - -} // pointlike - -namespace shapelike { -template<> inline Slic3r::Points& contour(Slic3r::ExPolygon& sh) { return sh.contour.points; } -template<> inline const Slic3r::Points& contour(const Slic3r::ExPolygon& sh) { return sh.contour.points; } -template<> inline Slic3r::Points& contour(Slic3r::Polygon& sh) { return sh.points; } -template<> inline const Slic3r::Points& contour(const Slic3r::Polygon& sh) { return sh.points; } - -template<> Slic3r::Points::iterator begin(Slic3r::Points& pts, const PathTag&) { return pts.begin();} -template<> Slic3r::Points::const_iterator cbegin(const Slic3r::Points& pts, const PathTag&) { return pts.cbegin(); } -template<> Slic3r::Points::iterator end(Slic3r::Points& pts, const PathTag&) { return pts.end();} -template<> Slic3r::Points::const_iterator cend(const Slic3r::Points& pts, const PathTag&) { return pts.cend(); } - -template<> inline Slic3r::ExPolygon create<Slic3r::ExPolygon>(Slic3r::Points&& contour) -{ - Slic3r::ExPolygon expoly; expoly.contour.points.swap(contour); - return expoly; -} - -template<> inline Slic3r::Polygon create<Slic3r::Polygon>(Slic3r::Points&& contour) -{ - Slic3r::Polygon poly; poly.points.swap(contour); - return poly; -} - -} // shapelike -} // libnest2d - namespace Slic3r { // Used as compute type. @@ -74,13 +28,22 @@ using Rational = boost::rational<boost::multiprecision::int128_t>; using Rational = boost::rational<__int128>; #endif -MinAreaBoundigBox::MinAreaBoundigBox(const Polygon &p, PolygonLevel pc) +template<class P> +libnest2d::RotatedBox<Point, Unit> minAreaBoundigBox_( + const P &p, MinAreaBoundigBox::PolygonLevel lvl) { - const Polygon &chull = pc == pcConvex ? p : - libnest2d::sl::convexHull(p); + P chull = lvl == MinAreaBoundigBox::pcConvex ? + p : + libnest2d::sl::convexHull(p); + + libnest2d::removeCollinearPoints(chull); - libnest2d::RotatedBox<Point, Unit> box = - libnest2d::minAreaBoundingBox<Polygon, Unit, Rational>(chull); + return libnest2d::minAreaBoundingBox<P, Unit, Rational>(chull); +} + +MinAreaBoundigBox::MinAreaBoundigBox(const Polygon &p, PolygonLevel pc) +{ + libnest2d::RotatedBox<Point, Unit> box = minAreaBoundigBox_(p, pc); m_right = libnest2d::cast<long double>(box.right_extent()); m_bottom = libnest2d::cast<long double>(box.bottom_extent()); @@ -89,11 +52,7 @@ MinAreaBoundigBox::MinAreaBoundigBox(const Polygon &p, PolygonLevel pc) MinAreaBoundigBox::MinAreaBoundigBox(const ExPolygon &p, PolygonLevel pc) { - const ExPolygon &chull = pc == pcConvex ? p : - libnest2d::sl::convexHull(p); - - libnest2d::RotatedBox<Point, Unit> box = - libnest2d::minAreaBoundingBox<ExPolygon, Unit, Rational>(chull); + libnest2d::RotatedBox<Point, Unit> box = minAreaBoundigBox_(p, pc); m_right = libnest2d::cast<long double>(box.right_extent()); m_bottom = libnest2d::cast<long double>(box.bottom_extent()); @@ -102,11 +61,7 @@ MinAreaBoundigBox::MinAreaBoundigBox(const ExPolygon &p, PolygonLevel pc) MinAreaBoundigBox::MinAreaBoundigBox(const Points &pts, PolygonLevel pc) { - const Points &chull = pc == pcConvex ? pts : - libnest2d::sl::convexHull(pts); - - libnest2d::RotatedBox<Point, Unit> box = - libnest2d::minAreaBoundingBox<Points, Unit, Rational>(chull); + libnest2d::RotatedBox<Point, Unit> box = minAreaBoundigBox_(pts, pc); m_right = libnest2d::cast<long double>(box.right_extent()); m_bottom = libnest2d::cast<long double>(box.bottom_extent()); diff --git a/src/libslic3r/MinAreaBoundingBox.hpp b/src/libslic3r/MinAreaBoundingBox.hpp index 30d0e9799..242fc9611 100644 --- a/src/libslic3r/MinAreaBoundingBox.hpp +++ b/src/libslic3r/MinAreaBoundingBox.hpp @@ -26,12 +26,8 @@ public: }; // Constructors with various types of geometry data used in Slic3r. - // If the convexity is known apriory, pcConvex can be used to skip - // convex hull calculation. It is very important that the input polygons - // do NOT have any collinear points (except for the first and the last - // vertex being the same -- meaning a closed polygon for boost) - // To make sure this constraint is satisfied, you can call - // remove_collinear_points on the input polygon before handing over here) + // If the convexity is known apriory, pcConvex can be used to skip + // convex hull calculation. explicit MinAreaBoundigBox(const Polygon&, PolygonLevel = pcSimple); explicit MinAreaBoundigBox(const ExPolygon&, PolygonLevel = pcSimple); explicit MinAreaBoundigBox(const Points&, PolygonLevel = pcSimple); diff --git a/src/libslic3r/MultiPoint.hpp b/src/libslic3r/MultiPoint.hpp index d17142bb2..46b47832a 100644 --- a/src/libslic3r/MultiPoint.hpp +++ b/src/libslic3r/MultiPoint.hpp @@ -84,6 +84,13 @@ public: static Points _douglas_peucker(const Points &points, const double tolerance); static Points visivalingam(const Points& pts, const double& tolerance); + + inline auto begin() { return points.begin(); } + inline auto begin() const { return points.begin(); } + inline auto end() { return points.end(); } + inline auto end() const { return points.end(); } + inline auto cbegin() const { return points.begin(); } + inline auto cend() const { return points.end(); } }; class MultiPoint3 diff --git a/src/libslic3r/Point.hpp b/src/libslic3r/Point.hpp index f38a7066b..12870b713 100644 --- a/src/libslic3r/Point.hpp +++ b/src/libslic3r/Point.hpp @@ -17,42 +17,42 @@ class BoundingBox; class Line; class MultiPoint; class Point; -typedef Point Vector; +using Vector = Point; // Eigen types, to replace the Slic3r's own types in the future. // Vector types with a fixed point coordinate base type. -typedef Eigen::Matrix<coord_t, 2, 1, Eigen::DontAlign> Vec2crd; -typedef Eigen::Matrix<coord_t, 3, 1, Eigen::DontAlign> Vec3crd; -typedef Eigen::Matrix<int, 2, 1, Eigen::DontAlign> Vec2i; -typedef Eigen::Matrix<int, 3, 1, Eigen::DontAlign> Vec3i; -typedef Eigen::Matrix<int32_t, 2, 1, Eigen::DontAlign> Vec2i32; -typedef Eigen::Matrix<int64_t, 2, 1, Eigen::DontAlign> Vec2i64; -typedef Eigen::Matrix<int32_t, 3, 1, Eigen::DontAlign> Vec3i32; -typedef Eigen::Matrix<int64_t, 3, 1, Eigen::DontAlign> Vec3i64; +using Vec2crd = Eigen::Matrix<coord_t, 2, 1, Eigen::DontAlign>; +using Vec3crd = Eigen::Matrix<coord_t, 3, 1, Eigen::DontAlign>; +using Vec2i = Eigen::Matrix<int, 2, 1, Eigen::DontAlign>; +using Vec3i = Eigen::Matrix<int, 3, 1, Eigen::DontAlign>; +using Vec2i32 = Eigen::Matrix<int32_t, 2, 1, Eigen::DontAlign>; +using Vec2i64 = Eigen::Matrix<int64_t, 2, 1, Eigen::DontAlign>; +using Vec3i32 = Eigen::Matrix<int32_t, 3, 1, Eigen::DontAlign>; +using Vec3i64 = Eigen::Matrix<int64_t, 3, 1, Eigen::DontAlign>; // Vector types with a double coordinate base type. -typedef Eigen::Matrix<float, 2, 1, Eigen::DontAlign> Vec2f; -typedef Eigen::Matrix<float, 3, 1, Eigen::DontAlign> Vec3f; -typedef Eigen::Matrix<double, 2, 1, Eigen::DontAlign> Vec2d; -typedef Eigen::Matrix<double, 3, 1, Eigen::DontAlign> Vec3d; - -typedef std::vector<Point> Points; -typedef std::vector<Point*> PointPtrs; -typedef std::vector<const Point*> PointConstPtrs; -typedef std::vector<Vec3crd> Points3; -typedef std::vector<Vec2d> Pointfs; -typedef std::vector<Vec2d> Vec2ds; -typedef std::vector<Vec3d> Pointf3s; - -typedef Eigen::Matrix<float, 2, 2, Eigen::DontAlign> Matrix2f; -typedef Eigen::Matrix<double, 2, 2, Eigen::DontAlign> Matrix2d; -typedef Eigen::Matrix<float, 3, 3, Eigen::DontAlign> Matrix3f; -typedef Eigen::Matrix<double, 3, 3, Eigen::DontAlign> Matrix3d; - -typedef Eigen::Transform<float, 2, Eigen::Affine, Eigen::DontAlign> Transform2f; -typedef Eigen::Transform<double, 2, Eigen::Affine, Eigen::DontAlign> Transform2d; -typedef Eigen::Transform<float, 3, Eigen::Affine, Eigen::DontAlign> Transform3f; -typedef Eigen::Transform<double, 3, Eigen::Affine, Eigen::DontAlign> Transform3d; +using Vec2f = Eigen::Matrix<float, 2, 1, Eigen::DontAlign>; +using Vec3f = Eigen::Matrix<float, 3, 1, Eigen::DontAlign>; +using Vec2d = Eigen::Matrix<double, 2, 1, Eigen::DontAlign>; +using Vec3d = Eigen::Matrix<double, 3, 1, Eigen::DontAlign>; + +using Points = std::vector<Point>; +using PointPtrs = std::vector<Point*>; +using PointConstPtrs = std::vector<const Point*>; +using Points3 = std::vector<Vec3crd>; +using Pointfs = std::vector<Vec2d>; +using Vec2ds = std::vector<Vec2d>; +using Pointf3s = std::vector<Vec3d>; + +using Matrix2f = Eigen::Matrix<float, 2, 2, Eigen::DontAlign>; +using Matrix2d = Eigen::Matrix<double, 2, 2, Eigen::DontAlign>; +using Matrix3f = Eigen::Matrix<float, 3, 3, Eigen::DontAlign>; +using Matrix3d = Eigen::Matrix<double, 3, 3, Eigen::DontAlign>; + +using Transform2f = Eigen::Transform<float, 2, Eigen::Affine, Eigen::DontAlign>; +using Transform2d = Eigen::Transform<double, 2, Eigen::Affine, Eigen::DontAlign>; +using Transform3f = Eigen::Transform<float, 3, Eigen::Affine, Eigen::DontAlign>; +using Transform3d = Eigen::Transform<double, 3, Eigen::Affine, Eigen::DontAlign>; inline bool operator<(const Vec2d &lhs, const Vec2d &rhs) { return lhs(0) < rhs(0) || (lhs(0) == rhs(0) && lhs(1) < rhs(1)); } @@ -101,7 +101,7 @@ template<int N, class T> using Vec = Eigen::Matrix<T, N, 1, Eigen::DontAlign, N class Point : public Vec2crd { public: - typedef coord_t coord_type; + using coord_type = coord_t; Point() : Vec2crd(0, 0) {} Point(int32_t x, int32_t y) : Vec2crd(coord_t(x), coord_t(y)) {} @@ -337,7 +337,7 @@ public: } private: - typedef typename std::unordered_multimap<Vec2crd, ValueType, PointHash> map_type; + using map_type = typename std::unordered_multimap<Vec2crd, ValueType, PointHash>; PointAccessor m_point_accessor; map_type m_map; coord_t m_search_radius; @@ -439,11 +439,11 @@ inline Point align_to_grid(Point coord, Point spacing, Point base) #include <boost/polygon/polygon.hpp> namespace boost { namespace polygon { template <> - struct geometry_concept<Slic3r::Point> { typedef point_concept type; }; + struct geometry_concept<Slic3r::Point> { using type = point_concept; }; template <> struct point_traits<Slic3r::Point> { - typedef coord_t coordinate_type; + using coordinate_type = coord_t; static inline coordinate_type get(const Slic3r::Point& point, orientation_2d orient) { return static_cast<coordinate_type>(point((orient == HORIZONTAL) ? 0 : 1)); @@ -452,7 +452,7 @@ namespace boost { namespace polygon { template <> struct point_mutable_traits<Slic3r::Point> { - typedef coord_t coordinate_type; + using coordinate_type = coord_t; static inline void set(Slic3r::Point& point, orientation_2d orient, coord_t value) { point((orient == HORIZONTAL) ? 0 : 1) = value; } diff --git a/src/libslic3r/Polygon.hpp b/src/libslic3r/Polygon.hpp index dd2d68d46..93cd70121 100644 --- a/src/libslic3r/Polygon.hpp +++ b/src/libslic3r/Polygon.hpp @@ -72,6 +72,9 @@ public: // Projection of a point onto the polygon. Point point_projection(const Point &point) const; std::vector<float> parameter_by_length() const; + + using iterator = Points::iterator; + using const_iterator = Points::const_iterator; }; inline bool operator==(const Polygon &lhs, const Polygon &rhs) { return lhs.points == rhs.points; } @@ -90,6 +93,8 @@ inline double total_length(const Polygons &polylines) { return total; } +inline double area(const Polygon &poly) { return poly.area(); } + inline double area(const Polygons &polys) { double s = 0.; diff --git a/src/libslic3r/SLA/AGGRaster.hpp b/src/libslic3r/SLA/AGGRaster.hpp index 849cec30a..2243a3c1b 100644 --- a/src/libslic3r/SLA/AGGRaster.hpp +++ b/src/libslic3r/SLA/AGGRaster.hpp @@ -4,7 +4,6 @@ #include <libslic3r/SLA/RasterBase.hpp> #include "libslic3r/ExPolygon.hpp" #include "libslic3r/MTUtils.hpp" -#include <libnest2d/backends/clipper/clipper_polygon.hpp> // For rasterizing #include <agg/agg_basics.h> @@ -21,10 +20,7 @@ namespace Slic3r { inline const Polygon& contour(const ExPolygon& p) { return p.contour; } -inline const ClipperLib::Path& contour(const ClipperLib::Polygon& p) { return p.Contour; } - inline const Polygons& holes(const ExPolygon& p) { return p.holes; } -inline const ClipperLib::Paths& holes(const ClipperLib::Polygon& p) { return p.Holes; } namespace sla { @@ -77,8 +73,6 @@ protected: double getPx(const Point &p) { return p(0) * m_pxdim_scaled.w_mm; } double getPy(const Point &p) { return p(1) * m_pxdim_scaled.h_mm; } agg::path_storage to_path(const Polygon &poly) { return to_path(poly.points); } - double getPx(const ClipperLib::IntPoint &p) { return p.X * m_pxdim_scaled.w_mm; } - double getPy(const ClipperLib::IntPoint& p) { return p.Y * m_pxdim_scaled.h_mm; } template<class PointVec> agg::path_storage _to_path(const PointVec& v) { @@ -168,7 +162,6 @@ public: } void draw(const ExPolygon &poly) override { _draw(poly); } - void draw(const ClipperLib::Polygon &poly) override { _draw(poly); } EncodedRaster encode(RasterEncoder encoder) const override { diff --git a/src/libslic3r/SLA/RasterBase.hpp b/src/libslic3r/SLA/RasterBase.hpp index 9f9f29cd5..bbb83b5a0 100644 --- a/src/libslic3r/SLA/RasterBase.hpp +++ b/src/libslic3r/SLA/RasterBase.hpp @@ -11,8 +11,6 @@ #include <libslic3r/ExPolygon.hpp> #include <libslic3r/SLA/Concurrency.hpp> -namespace ClipperLib { struct Polygon; } - namespace Slic3r { template<class T> using uqptr = std::unique_ptr<T>; @@ -92,7 +90,6 @@ public: /// Draw a polygon with holes. virtual void draw(const ExPolygon& poly) = 0; - virtual void draw(const ClipperLib::Polygon& poly) = 0; /// Get the resolution of the raster. virtual Resolution resolution() const = 0; diff --git a/src/libslic3r/SLA/SupportPointGenerator.cpp b/src/libslic3r/SLA/SupportPointGenerator.cpp index 7a4c29068..5ef4eb001 100644 --- a/src/libslic3r/SLA/SupportPointGenerator.cpp +++ b/src/libslic3r/SLA/SupportPointGenerator.cpp @@ -12,11 +12,9 @@ #include "ClipperUtils.hpp" #include "Tesselate.hpp" #include "ExPolygonCollection.hpp" +#include "MinAreaBoundingBox.hpp" #include "libslic3r.h" -#include "libnest2d/backends/clipper/geometries.hpp" -#include "libnest2d/utils/rotcalipers.hpp" - #include <iostream> #include <random> @@ -400,7 +398,7 @@ std::vector<Vec2f> sample_expolygon(const ExPolygons &expolys, float samples_per void sample_expolygon_boundary(const ExPolygon & expoly, float samples_per_mm, std::vector<Vec2f> &out, - std::mt19937 & rng) + std::mt19937 & /*rng*/) { double point_stepping_scaled = scale_(1.f) / samples_per_mm; for (size_t i_contour = 0; i_contour <= expoly.holes.size(); ++ i_contour) { @@ -553,9 +551,8 @@ void SupportPointGenerator::uniformly_cover(const ExPolygons& islands, Structure // auto bb = get_extents(islands); if (flags & icfIsNew) { - auto chull_ex = ExPolygonCollection{islands}.convex_hull(); - auto chull = Slic3rMultiPoint_to_ClipperPath(chull_ex); - auto rotbox = libnest2d::minAreaBoundingBox(chull); + auto chull = ExPolygonCollection{islands}.convex_hull(); + auto rotbox = MinAreaBoundigBox{chull, MinAreaBoundigBox::pcConvex}; Vec2d bbdim = {unscaled(rotbox.width()), unscaled(rotbox.height())}; if (bbdim.x() > bbdim.y()) std::swap(bbdim.x(), bbdim.y()); diff --git a/src/libslic3r/SLAPrint.hpp b/src/libslic3r/SLAPrint.hpp index adb80c29a..a94eb35fa 100644 --- a/src/libslic3r/SLAPrint.hpp +++ b/src/libslic3r/SLAPrint.hpp @@ -9,7 +9,6 @@ #include "Point.hpp" #include "MTUtils.hpp" #include "Zipper.hpp" -#include <libnest2d/backends/clipper/clipper_polygon.hpp> namespace Slic3r { @@ -483,7 +482,7 @@ public: // The collection of slice records for the current level. std::vector<std::reference_wrapper<const SliceRecord>> m_slices; - std::vector<ClipperLib::Polygon> m_transformed_slices; + ExPolygons m_transformed_slices; template<class Container> void transformed_slices(Container&& c) { @@ -507,7 +506,7 @@ public: auto slices() const -> const decltype (m_slices)& { return m_slices; } - const std::vector<ClipperLib::Polygon> & transformed_slices() const { + const ExPolygons & transformed_slices() const { return m_transformed_slices; } }; diff --git a/src/libslic3r/SLAPrintSteps.cpp b/src/libslic3r/SLAPrintSteps.cpp index c393eb295..108159b89 100644 --- a/src/libslic3r/SLAPrintSteps.cpp +++ b/src/libslic3r/SLAPrintSteps.cpp @@ -16,9 +16,6 @@ #include <libslic3r/ClipperUtils.hpp> -// For geometry algorithms with native Clipper types (no copies and conversions) -#include <libnest2d/backends/clipper/geometries.hpp> - #include <boost/log/trivial.hpp> #include "I18N.hpp" @@ -717,55 +714,49 @@ void SLAPrint::Steps::slice_supports(SLAPrintObject &po) { report_status(-2, "", SlicingStatus::RELOAD_SLA_PREVIEW); } -using ClipperPoint = ClipperLib::IntPoint; -using ClipperPolygon = ClipperLib::Polygon; // see clipper_polygon.hpp in libnest2d -using ClipperPolygons = std::vector<ClipperPolygon>; +//static ClipperPolygons polyunion(const ClipperPolygons &subjects) +//{ +// ClipperLib::Clipper clipper; -static ClipperPolygons polyunion(const ClipperPolygons &subjects) -{ - ClipperLib::Clipper clipper; +// bool closed = true; - bool closed = true; +// for(auto& path : subjects) { +// clipper.AddPath(path.Contour, ClipperLib::ptSubject, closed); +// clipper.AddPaths(path.Holes, ClipperLib::ptSubject, closed); +// } - for(auto& path : subjects) { - clipper.AddPath(path.Contour, ClipperLib::ptSubject, closed); - clipper.AddPaths(path.Holes, ClipperLib::ptSubject, closed); - } +// auto mode = ClipperLib::pftPositive; - auto mode = ClipperLib::pftPositive; +// return libnest2d::clipper_execute(clipper, ClipperLib::ctUnion, mode, mode); +//} - return libnest2d::clipper_execute(clipper, ClipperLib::ctUnion, mode, mode); -} +//static ClipperPolygons polydiff(const ClipperPolygons &subjects, const ClipperPolygons& clips) +//{ +// ClipperLib::Clipper clipper; -static ClipperPolygons polydiff(const ClipperPolygons &subjects, const ClipperPolygons& clips) -{ - ClipperLib::Clipper clipper; +// bool closed = true; - bool closed = true; +// for(auto& path : subjects) { +// clipper.AddPath(path.Contour, ClipperLib::ptSubject, closed); +// clipper.AddPaths(path.Holes, ClipperLib::ptSubject, closed); +// } - for(auto& path : subjects) { - clipper.AddPath(path.Contour, ClipperLib::ptSubject, closed); - clipper.AddPaths(path.Holes, ClipperLib::ptSubject, closed); - } +// for(auto& path : clips) { +// clipper.AddPath(path.Contour, ClipperLib::ptClip, closed); +// clipper.AddPaths(path.Holes, ClipperLib::ptClip, closed); +// } - for(auto& path : clips) { - clipper.AddPath(path.Contour, ClipperLib::ptClip, closed); - clipper.AddPaths(path.Holes, ClipperLib::ptClip, closed); - } - - auto mode = ClipperLib::pftPositive; +// auto mode = ClipperLib::pftPositive; - return libnest2d::clipper_execute(clipper, ClipperLib::ctDifference, mode, mode); -} +// return libnest2d::clipper_execute(clipper, ClipperLib::ctDifference, mode, mode); +//} // get polygons for all instances in the object -static ClipperPolygons get_all_polygons(const SliceRecord& record, SliceOrigin o) +static ExPolygons get_all_polygons(const SliceRecord& record, SliceOrigin o) { - namespace sl = libnest2d::sl; - if (!record.print_obj()) return {}; - ClipperPolygons polygons; + ExPolygons polygons; auto &input_polygons = record.get_slice(o); auto &instances = record.print_obj()->instances(); bool is_lefthanded = record.print_obj()->is_left_handed(); @@ -776,43 +767,42 @@ static ClipperPolygons get_all_polygons(const SliceRecord& record, SliceOrigin o for (size_t i = 0; i < instances.size(); ++i) { - ClipperPolygon poly; + ExPolygon poly; // We need to reverse if is_lefthanded is true but bool needreverse = is_lefthanded; // should be a move - poly.Contour.reserve(polygon.contour.size() + 1); + poly.contour.points.reserve(polygon.contour.size() + 1); auto& cntr = polygon.contour.points; if(needreverse) for(auto it = cntr.rbegin(); it != cntr.rend(); ++it) - poly.Contour.emplace_back(it->x(), it->y()); + poly.contour.points.emplace_back(it->x(), it->y()); else for(auto& p : cntr) - poly.Contour.emplace_back(p.x(), p.y()); + poly.contour.points.emplace_back(p.x(), p.y()); for(auto& h : polygon.holes) { - poly.Holes.emplace_back(); - auto& hole = poly.Holes.back(); - hole.reserve(h.points.size() + 1); + poly.holes.emplace_back(); + auto& hole = poly.holes.back(); + hole.points.reserve(h.points.size() + 1); if(needreverse) for(auto it = h.points.rbegin(); it != h.points.rend(); ++it) - hole.emplace_back(it->x(), it->y()); + hole.points.emplace_back(it->x(), it->y()); else for(auto& p : h.points) - hole.emplace_back(p.x(), p.y()); + hole.points.emplace_back(p.x(), p.y()); } if(is_lefthanded) { - for(auto& p : poly.Contour) p.X = -p.X; - for(auto& h : poly.Holes) for(auto& p : h) p.X = -p.X; + for(auto& p : poly.contour) p.x() = -p.x(); + for(auto& h : poly.holes) for(auto& p : h) p.x() = -p.x(); } - sl::rotate(poly, double(instances[i].rotation)); - sl::translate(poly, ClipperPoint{instances[i].shift.x(), - instances[i].shift.y()}); + poly.rotate(double(instances[i].rotation)); + poly.translate(Point{instances[i].shift.x(), instances[i].shift.y()}); polygons.emplace_back(std::move(poly)); } @@ -878,9 +868,6 @@ void SLAPrint::Steps::merge_slices_and_eval_stats() { print_statistics.clear(); - // libnest calculates positive area for clockwise polygons, Slic3r is in counter-clockwise - auto areafn = [](const ClipperPolygon& poly) { return - libnest2d::sl::area(poly); }; - const double area_fill = printer_config.area_fill.getFloat()*0.01;// 0.5 (50%); const double fast_tilt = printer_config.fast_tilt_time.getFloat();// 5.0; const double slow_tilt = printer_config.slow_tilt_time.getFloat();// 8.0; @@ -913,7 +900,7 @@ void SLAPrint::Steps::merge_slices_and_eval_stats() { // Going to parallel: auto printlayerfn = [this, // functions and read only vars - areafn, area_fill, display_area, exp_time, init_exp_time, fast_tilt, slow_tilt, delta_fade_time, + area_fill, display_area, exp_time, init_exp_time, fast_tilt, slow_tilt, delta_fade_time, // write vars &mutex, &models_volume, &supports_volume, &estim_time, &slow_layers, @@ -931,8 +918,8 @@ void SLAPrint::Steps::merge_slices_and_eval_stats() { // Calculation of the consumed material - ClipperPolygons model_polygons; - ClipperPolygons supports_polygons; + ExPolygons model_polygons; + ExPolygons supports_polygons; size_t c = std::accumulate(layer.slices().begin(), layer.slices().end(), @@ -954,44 +941,44 @@ void SLAPrint::Steps::merge_slices_and_eval_stats() { for(const SliceRecord& record : layer.slices()) { - ClipperPolygons modelslices = get_all_polygons(record, soModel); - for(ClipperPolygon& p_tmp : modelslices) model_polygons.emplace_back(std::move(p_tmp)); + ExPolygons modelslices = get_all_polygons(record, soModel); + for(ExPolygon& p_tmp : modelslices) model_polygons.emplace_back(std::move(p_tmp)); - ClipperPolygons supportslices = get_all_polygons(record, soSupport); - for(ClipperPolygon& p_tmp : supportslices) supports_polygons.emplace_back(std::move(p_tmp)); + ExPolygons supportslices = get_all_polygons(record, soSupport); + for(ExPolygon& p_tmp : supportslices) supports_polygons.emplace_back(std::move(p_tmp)); } - model_polygons = polyunion(model_polygons); + model_polygons = union_ex(model_polygons); double layer_model_area = 0; - for (const ClipperPolygon& polygon : model_polygons) - layer_model_area += areafn(polygon); + for (const ExPolygon& polygon : model_polygons) + layer_model_area += area(polygon); if (layer_model_area < 0 || layer_model_area > 0) { Lock lck(mutex); models_volume += layer_model_area * l_height; } if(!supports_polygons.empty()) { - if(model_polygons.empty()) supports_polygons = polyunion(supports_polygons); - else supports_polygons = polydiff(supports_polygons, model_polygons); + if(model_polygons.empty()) supports_polygons = union_ex(supports_polygons); + else supports_polygons = diff_ex(supports_polygons, model_polygons); // allegedly, union of subject is done withing the diff according to the pftPositive polyFillType } double layer_support_area = 0; - for (const ClipperPolygon& polygon : supports_polygons) - layer_support_area += areafn(polygon); + for (const ExPolygon& polygon : supports_polygons) + layer_support_area += area(polygon); if (layer_support_area < 0 || layer_support_area > 0) { Lock lck(mutex); supports_volume += layer_support_area * l_height; } // Here we can save the expensively calculated polygons for printing - ClipperPolygons trslices; + ExPolygons trslices; trslices.reserve(model_polygons.size() + supports_polygons.size()); - for(ClipperPolygon& poly : model_polygons) trslices.emplace_back(std::move(poly)); - for(ClipperPolygon& poly : supports_polygons) trslices.emplace_back(std::move(poly)); + for(ExPolygon& poly : model_polygons) trslices.emplace_back(std::move(poly)); + for(ExPolygon& poly : supports_polygons) trslices.emplace_back(std::move(poly)); - layer.transformed_slices(polyunion(trslices)); + layer.transformed_slices(union_ex(trslices)); // Calculation of the slow and fast layers to the future controlling those values on FW @@ -1074,7 +1061,7 @@ void SLAPrint::Steps::rasterize() PrintLayer& printlayer = m_print->m_printer_input[idx]; if(canceled()) return; - for (const ClipperLib::Polygon& poly : printlayer.transformed_slices()) + for (const ExPolygon& poly : printlayer.transformed_slices()) raster.draw(poly); // Status indication guarded with the spinlock diff --git a/src/libslic3r/SVG.cpp b/src/libslic3r/SVG.cpp index 7308d7e50..6bc334eec 100644 --- a/src/libslic3r/SVG.cpp +++ b/src/libslic3r/SVG.cpp @@ -273,8 +273,8 @@ std::string SVG::get_path_d(const ClipperLib::Path &path, double scale, bool clo std::ostringstream d; d << "M "; for (ClipperLib::Path::const_iterator p = path.begin(); p != path.end(); ++p) { - d << to_svg_x(scale * p->X - origin(0)) << " "; - d << to_svg_y(scale * p->Y - origin(1)) << " "; + d << to_svg_x(scale * p->x() - origin(0)) << " "; + d << to_svg_y(scale * p->y() - origin(1)) << " "; } if (closed) d << "z"; return d.str(); diff --git a/src/libslic3r/clipper.cpp b/src/libslic3r/clipper.cpp new file mode 100644 index 000000000..8f38ba621 --- /dev/null +++ b/src/libslic3r/clipper.cpp @@ -0,0 +1,13 @@ +// Hackish wrapper around the ClipperLib library to compile the Clipper library using Slic3r::Point. + +#include "clipper.hpp" + +// Don't include <clipper/clipper.hpp> for the second time. +#define clipper_hpp + +// Override ClipperLib namespace to Slic3r::ClipperLib +#define CLIPPERLIB_NAMESPACE_PREFIX Slic3r +// Override Slic3r::ClipperLib::IntPoint to Slic3r::Point +#define CLIPPERLIB_INTPOINT_TYPE Slic3r::Point + +#include <clipper/clipper.cpp> diff --git a/src/libslic3r/clipper.hpp b/src/libslic3r/clipper.hpp new file mode 100644 index 000000000..b0dd51a4f --- /dev/null +++ b/src/libslic3r/clipper.hpp @@ -0,0 +1,26 @@ +// Hackish wrapper around the ClipperLib library to compile the Clipper library using Slic3r's own Point type. + +#ifndef slic3r_clipper_hpp + +#ifdef clipper_hpp +#error "You should include the libslic3r/clipper.hpp before clipper/clipper.hpp" +#endif + +#ifdef CLIPPERLIB_USE_XYZ +#error "Something went wrong. Using clipper.hpp with Slic3r Point type, but CLIPPERLIB_USE_XYZ is defined." +#endif + +#define slic3r_clipper_hpp + +#include "Point.hpp" + +#define CLIPPERLIB_NAMESPACE_PREFIX Slic3r +#define CLIPPERLIB_INTPOINT_TYPE Slic3r::Point + +#include <clipper/clipper.hpp> + +#undef clipper_hpp +#undef CLIPPERLIB_NAMESPACE_PREFIX +#undef CLIPPERLIB_INTPOINT_TYPE + +#endif // slic3r_clipper_hpp diff --git a/src/libslic3r/libslic3r.h b/src/libslic3r/libslic3r.h index efdecbac8..2b0c94161 100644 --- a/src/libslic3r/libslic3r.h +++ b/src/libslic3r/libslic3r.h @@ -308,6 +308,10 @@ IntegerOnly<I, std::vector<T, Args...>> reserve_vector(I capacity) return ret; } +// Borrowed from C++20 +template<class T> +using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>; + } // namespace Slic3r #endif diff --git a/src/libslic3r/pchheader.hpp b/src/libslic3r/pchheader.hpp index 9386fdf36..b55755b89 100644 --- a/src/libslic3r/pchheader.hpp +++ b/src/libslic3r/pchheader.hpp @@ -114,7 +114,7 @@ #include <cereal/types/base_class.hpp> #include <clipper/clipper_z.hpp> -#include <clipper/clipper.hpp> +#include "clipper.hpp" #include "BoundingBox.hpp" #include "ClipperUtils.hpp" #include "Config.hpp" @@ -129,8 +129,6 @@ #include "libslic3r.h" #include "libslic3r_version.h" -#include "clipper.hpp" - #include <Shiny/Shiny.h> #include <admesh/stl.h> diff --git a/tests/libnest2d/CMakeLists.txt b/tests/libnest2d/CMakeLists.txt index d4f684dd3..bcb759452 100644 --- a/tests/libnest2d/CMakeLists.txt +++ b/tests/libnest2d/CMakeLists.txt @@ -4,4 +4,4 @@ target_link_libraries(${_TEST_NAME}_tests test_common libnest2d ) set_property(TARGET ${_TEST_NAME}_tests PROPERTY FOLDER "tests") # catch_discover_tests(${_TEST_NAME}_tests TEST_PREFIX "${_TEST_NAME}: ") -add_test(${_TEST_NAME}_tests ${_TEST_NAME}_tests ${CATCH_EXTRA_ARGS}) +add_test(${_TEST_NAME}_tests ${_TEST_NAME}_tests "${CATCH_EXTRA_ARGS} exclude:[NotWorking]") diff --git a/tests/libnest2d/libnest2d_tests_main.cpp b/tests/libnest2d/libnest2d_tests_main.cpp index e3ffe9c6e..97c7ef99d 100644 --- a/tests/libnest2d/libnest2d_tests_main.cpp +++ b/tests/libnest2d/libnest2d_tests_main.cpp @@ -44,12 +44,74 @@ struct NfpImpl<S, NfpLevel::CONVEX_ONLY> } } +namespace { +using namespace libnest2d; + +template<int64_t SCALE = 1, class It> +void exportSVG(const char *loc, It from, It to) { + + static const char* svg_header = + R"raw(<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"> +<svg height="500" width="500" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"> +)raw"; + + // for(auto r : result) { + std::fstream out(loc, std::fstream::out); + if(out.is_open()) { + out << svg_header; + // Item rbin( RectangleItem(bin.width(), bin.height()) ); + // for(unsigned j = 0; j < rbin.vertexCount(); j++) { + // auto v = rbin.vertex(j); + // setY(v, -getY(v)/SCALE + 500 ); + // setX(v, getX(v)/SCALE); + // rbin.setVertex(j, v); + // } + // out << shapelike::serialize<Formats::SVG>(rbin.rawShape()) << std::endl; + for(auto it = from; it != to; ++it) { + const Item &itm = *it; + Item tsh(itm.transformedShape()); + for(unsigned j = 0; j < tsh.vertexCount(); j++) { + auto v = tsh.vertex(j); + setY(v, -getY(v)/SCALE + 500); + setX(v, getX(v)/SCALE); + tsh.setVertex(j, v); + } + out << shapelike::serialize<Formats::SVG>(tsh.rawShape()) << std::endl; + } + out << "\n</svg>" << std::endl; + } + out.close(); + + // i++; + // } +} + +template<int64_t SCALE = 1> +void exportSVG(std::vector<std::reference_wrapper<Item>>& result, int idx = 0) { + exportSVG<SCALE>((std::string("out") + std::to_string(idx) + ".svg").c_str(), + result.begin(), result.end()); +} +} + static std::vector<libnest2d::Item>& prusaParts() { - static std::vector<libnest2d::Item> ret; + using namespace libnest2d; + + static std::vector<Item> ret; if(ret.empty()) { ret.reserve(PRINTER_PART_POLYGONS.size()); - for(auto& inp : PRINTER_PART_POLYGONS) ret.emplace_back(inp); + for(auto& inp : PRINTER_PART_POLYGONS) { + auto inp_cpy = inp; + + if (ClosureTypeV<PathImpl> == Closure::OPEN) + inp_cpy.points.pop_back(); + + if constexpr (!libnest2d::is_clockwise<libnest2d::PathImpl>()) + std::reverse(inp_cpy.begin(), inp_cpy.end()); + + ret.emplace_back(inp_cpy); + } } return ret; @@ -140,15 +202,15 @@ TEST_CASE("boundingCircle", "[Geometry]") { PolygonImpl p = {{{0, 10}, {10, 0}, {0, -10}, {0, 10}}, {}}; Circle c = boundingCircle(p); - REQUIRE(c.center().X == 0); - REQUIRE(c.center().Y == 0); + REQUIRE(getX(c.center()) == 0); + REQUIRE(getY(c.center()) == 0); REQUIRE(c.radius() == Approx(10)); shapelike::translate(p, PointImpl{10, 10}); c = boundingCircle(p); - REQUIRE(c.center().X == 10); - REQUIRE(c.center().Y == 10); + REQUIRE(getX(c.center()) == 10); + REQUIRE(getY(c.center()) == 10); REQUIRE(c.radius() == Approx(10)); auto parts = prusaParts(); @@ -243,7 +305,7 @@ TEST_CASE("Area", "[Geometry]") { {61, 97} }; - REQUIRE(shapelike::area(item.transformedShape()) > 0 ); + REQUIRE(std::abs(shapelike::area(item.transformedShape())) > 0 ); } TEST_CASE("IsPointInsidePolygon", "[Geometry]") { @@ -296,30 +358,36 @@ TEST_CASE("LeftAndDownPolygon", "[Geometry]") Box bin(100, 100); BottomLeftPlacer placer(bin); - Item item = {{70, 75}, {88, 60}, {65, 50}, {60, 30}, {80, 20}, {42, 20}, - {35, 35}, {35, 55}, {40, 75}, {70, 75}}; - - Item leftControl = { {40, 75}, - {35, 55}, - {35, 35}, - {42, 20}, - {0, 20}, - {0, 75}, - {40, 75}}; - - Item downControl = {{88, 60}, - {88, 0}, - {35, 0}, - {35, 35}, - {42, 20}, - {80, 20}, - {60, 30}, - {65, 50}, - {88, 60}}; + PathImpl pitem = {{70, 75}, {88, 60}, {65, 50}, {60, 30}, {80, 20}, + {42, 20}, {35, 35}, {35, 55}, {40, 75}}; + + PathImpl pleftControl = {{40, 75}, {35, 55}, {35, 35}, + {42, 20}, {0, 20}, {0, 75}}; + + PathImpl pdownControl = {{88, 60}, {88, 0}, {35, 0}, {35, 35}, + {42, 20}, {80, 20}, {60, 30}, {65, 50}}; + if constexpr (!is_clockwise<PathImpl>()) { + std::reverse(sl::begin(pitem), sl::end(pitem)); + std::reverse(sl::begin(pleftControl), sl::end(pleftControl)); + std::reverse(sl::begin(pdownControl), sl::end(pdownControl)); + } + + if constexpr (ClosureTypeV<PathImpl> == Closure::CLOSED) { + sl::addVertex(pitem, sl::front(pitem)); + sl::addVertex(pleftControl, sl::front(pleftControl)); + sl::addVertex(pdownControl, sl::front(pdownControl)); + } + + Item item{pitem}, leftControl{pleftControl}, downControl{pdownControl}; Item leftp(placer.leftPoly(item)); - REQUIRE(shapelike::isValid(leftp.rawShape()).first); + auto valid = sl::isValid(leftp.rawShape()); + + std::vector<std::reference_wrapper<Item>> to_export{ leftp, leftControl }; + exportSVG<1>("leftp.svg", to_export.begin(), to_export.end()); + + REQUIRE(valid.first); REQUIRE(leftp.vertexCount() == leftControl.vertexCount()); for(unsigned long i = 0; i < leftControl.vertexCount(); i++) { @@ -338,7 +406,7 @@ TEST_CASE("LeftAndDownPolygon", "[Geometry]") } } -TEST_CASE("ArrangeRectanglesTight", "[Nesting]") +TEST_CASE("ArrangeRectanglesTight", "[Nesting][NotWorking]") { using namespace libnest2d; @@ -390,6 +458,8 @@ TEST_CASE("ArrangeRectanglesTight", "[Nesting]") // check for no intersections, no containment: + // exportSVG<1>("arrangeRectanglesTight.svg", rects.begin(), rects.end()); + bool valid = true; for(Item& r1 : rects) { for(Item& r2 : rects) { @@ -470,57 +540,7 @@ TEST_CASE("ArrangeRectanglesLoose", "[Nesting]") } -namespace { -using namespace libnest2d; - -template<int64_t SCALE = 1, class It> -void exportSVG(const char *loc, It from, It to) { - - static const char* svg_header = -R"raw(<?xml version="1.0" encoding="UTF-8" standalone="yes"?> -<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"> -<svg height="500" width="500" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"> -)raw"; - - // for(auto r : result) { - std::fstream out(loc, std::fstream::out); - if(out.is_open()) { - out << svg_header; -// Item rbin( RectangleItem(bin.width(), bin.height()) ); -// for(unsigned j = 0; j < rbin.vertexCount(); j++) { -// auto v = rbin.vertex(j); -// setY(v, -getY(v)/SCALE + 500 ); -// setX(v, getX(v)/SCALE); -// rbin.setVertex(j, v); -// } -// out << shapelike::serialize<Formats::SVG>(rbin.rawShape()) << std::endl; - for(auto it = from; it != to; ++it) { - const Item &itm = *it; - Item tsh(itm.transformedShape()); - for(unsigned j = 0; j < tsh.vertexCount(); j++) { - auto v = tsh.vertex(j); - setY(v, -getY(v)/SCALE + 500); - setX(v, getX(v)/SCALE); - tsh.setVertex(j, v); - } - out << shapelike::serialize<Formats::SVG>(tsh.rawShape()) << std::endl; - } - out << "\n</svg>" << std::endl; - } - out.close(); - - // i++; - // } -} - -template<int64_t SCALE = 1> -void exportSVG(std::vector<std::reference_wrapper<Item>>& result, int idx = 0) { - exportSVG((std::string("out") + std::to_string(idx) + ".svg").c_str(), - result.begin(), result.end()); -} -} - -TEST_CASE("BottomLeftStressTest", "[Geometry]") { +TEST_CASE("BottomLeftStressTest", "[Geometry][NotWorking]") { using namespace libnest2d; const Coord SCALE = 1000000; @@ -563,7 +583,7 @@ TEST_CASE("BottomLeftStressTest", "[Geometry]") { TEST_CASE("convexHull", "[Geometry]") { using namespace libnest2d; - ClipperLib::Path poly = PRINTER_PART_POLYGONS[0]; + PathImpl poly = PRINTER_PART_POLYGONS[0]; auto chull = sl::convexHull(poly); @@ -597,7 +617,7 @@ TEST_CASE("PrusaPartsShouldFitIntoTwoBins", "[Nesting]") { })); // Gather the items into piles of arranged polygons... - using Pile = TMultiShape<ClipperLib::Polygon>; + using Pile = TMultiShape<PolygonImpl>; std::vector<Pile> piles(bins); for (auto &itm : input) @@ -609,6 +629,20 @@ TEST_CASE("PrusaPartsShouldFitIntoTwoBins", "[Nesting]") { auto bb = sl::boundingBox(pile); REQUIRE(sl::isInside(bb, bin)); } + + // Check the area of merged pile vs the sum of area of all the parts + // They should match, otherwise there is an overlap which should not happen. + for (auto &pile : piles) { + double area_sum = 0.; + + for (auto &obj : pile) + area_sum += sl::area(obj); + + auto pile_m = nfp::merge(pile); + double area_merge = sl::area(pile_m); + + REQUIRE(area_sum == Approx(area_merge)); + } } TEST_CASE("EmptyItemShouldBeUntouched", "[Nesting]") { @@ -616,7 +650,7 @@ TEST_CASE("EmptyItemShouldBeUntouched", "[Nesting]") { std::vector<Item> items; items.emplace_back(Item{}); // Emplace empty item - items.emplace_back(Item{0, 200, 0}); // Emplace zero area item + items.emplace_back(Item{ {0, 200} }); // Emplace zero area item size_t bins = libnest2d::nest(items, bin); @@ -661,12 +695,12 @@ TEST_CASE("Items can be preloaded", "[Nesting]") { REQUIRE(bins == 1); REQUIRE(fixed_rect.binId() == 0); - REQUIRE(fixed_rect.translation().X == bin.center().X); - REQUIRE(fixed_rect.translation().Y == bin.center().Y); + REQUIRE(getX(fixed_rect.translation()) == getX(bin.center())); + REQUIRE(getY(fixed_rect.translation()) == getY(bin.center())); REQUIRE(movable_rect.binId() == 0); - REQUIRE(movable_rect.translation().X != bin.center().X); - REQUIRE(movable_rect.translation().Y != bin.center().Y); + REQUIRE(getX(movable_rect.translation()) != getX(bin.center())); + REQUIRE(getY(movable_rect.translation()) != getY(bin.center())); } SECTION("Preloaded Item should not affect free bins") { @@ -677,14 +711,14 @@ TEST_CASE("Items can be preloaded", "[Nesting]") { REQUIRE(bins == 2); REQUIRE(fixed_rect.binId() == 1); - REQUIRE(fixed_rect.translation().X == bin.center().X); - REQUIRE(fixed_rect.translation().Y == bin.center().Y); + REQUIRE(getX(fixed_rect.translation()) == getX(bin.center())); + REQUIRE(getY(fixed_rect.translation()) == getY(bin.center())); REQUIRE(movable_rect.binId() == 0); auto bb = movable_rect.boundingBox(); - REQUIRE(bb.center().X == bin.center().X); - REQUIRE(bb.center().Y == bin.center().Y); + REQUIRE(getX(bb.center()) == getX(bin.center())); + REQUIRE(getY(bb.center()) == getY(bin.center())); } } @@ -700,15 +734,13 @@ std::vector<ItemPair> nfp_testdata = { { {80, 50}, {100, 70}, - {120, 50}, - {80, 50} + {120, 50} }, { {10, 10}, {10, 40}, {40, 40}, - {40, 10}, - {10, 10} + {40, 10} } }, { @@ -718,15 +750,13 @@ std::vector<ItemPair> nfp_testdata = { {80, 90}, {120, 90}, {140, 70}, - {120, 50}, - {80, 50} + {120, 50} }, { {10, 10}, {10, 40}, {40, 40}, - {40, 10}, - {10, 10} + {40, 10} } }, { @@ -738,15 +768,13 @@ std::vector<ItemPair> nfp_testdata = { {30, 40}, {40, 40}, {50, 30}, - {50, 20}, - {40, 10} + {50, 20} }, { {80, 0}, {80, 30}, {110, 30}, - {110, 0}, - {80, 0} + {110, 0} } }, { @@ -766,9 +794,8 @@ std::vector<ItemPair> nfp_testdata = { {122, 97}, {120, 98}, {118, 101}, - {117, 103}, - {117, 107} - }, + {117, 103} + }, { {102, 116}, {111, 126}, @@ -777,9 +804,8 @@ std::vector<ItemPair> nfp_testdata = { {148, 100}, {148, 85}, {147, 84}, - {102, 84}, - {102, 116}, - } + {102, 84} + } }, { { @@ -793,9 +819,8 @@ std::vector<ItemPair> nfp_testdata = { {139, 68}, {111, 68}, {108, 70}, - {99, 102}, - {99, 122}, - }, + {99, 102} + }, { {107, 124}, {128, 125}, @@ -810,9 +835,8 @@ std::vector<ItemPair> nfp_testdata = { {136, 86}, {134, 85}, {108, 85}, - {107, 86}, - {107, 124}, - } + {107, 86} + } }, { { @@ -825,9 +849,8 @@ std::vector<ItemPair> nfp_testdata = { {156, 66}, {133, 57}, {132, 57}, - {91, 98}, - {91, 100}, - }, + {91, 98} + }, { {101, 90}, {103, 98}, @@ -843,9 +866,8 @@ std::vector<ItemPair> nfp_testdata = { {145, 84}, {105, 84}, {102, 87}, - {101, 89}, - {101, 90}, - } + {101, 89} + } } }; @@ -860,10 +882,9 @@ std::vector<ItemPair> nfp_testdata = { {533659, 157607}, {538669, 160091}, {537178, 142155}, - {534959, 143386}, - {533726, 142141}, - } - }, + {534959, 143386} + } + }, { { {118305, 11603}, @@ -884,8 +905,7 @@ std::vector<ItemPair> nfp_testdata = { {209315, 17080}, {205326, 17080}, {203334, 13629}, - {204493, 11616}, - {118305, 11603}, + {204493, 11616} } }, } @@ -957,6 +977,14 @@ void testNfp(const std::vector<ItemPair>& testdata) { for(auto& td : testdata) { auto orbiter = td.orbiter; auto stationary = td.stationary; + if (!libnest2d::is_clockwise<PolygonImpl>()) { + auto porb = orbiter.rawShape(); + auto pstat = stationary.rawShape(); + std::reverse(sl::begin(porb), sl::end(porb)); + std::reverse(sl::begin(pstat), sl::end(pstat)); + orbiter = Item{porb}; + stationary = Item{pstat}; + } onetest(orbiter, stationary, tidx++); } @@ -964,6 +992,14 @@ void testNfp(const std::vector<ItemPair>& testdata) { for(auto& td : testdata) { auto orbiter = td.stationary; auto stationary = td.orbiter; + if (!libnest2d::is_clockwise<PolygonImpl>()) { + auto porb = orbiter.rawShape(); + auto pstat = stationary.rawShape(); + std::reverse(sl::begin(porb), sl::end(porb)); + std::reverse(sl::begin(pstat), sl::end(pstat)); + orbiter = Item{porb}; + stationary = Item{pstat}; + } onetest(orbiter, stationary, tidx++); } } @@ -1073,7 +1109,7 @@ using Ratio = boost::rational<boost::multiprecision::int128_t>; TEST_CASE("MinAreaBBWithRotatingCalipers", "[Geometry]") { long double err_epsilon = 500e6l; - for(ClipperLib::Path rinput : PRINTER_PART_POLYGONS) { + for(PathImpl rinput : PRINTER_PART_POLYGONS) { PolygonImpl poly(rinput); long double arearef = refMinAreaBox(poly); @@ -1085,8 +1121,8 @@ TEST_CASE("MinAreaBBWithRotatingCalipers", "[Geometry]") { REQUIRE(succ); } - for(ClipperLib::Path rinput : STEGOSAUR_POLYGONS) { - rinput.pop_back(); + for(PathImpl rinput : STEGOSAUR_POLYGONS) { +// rinput.pop_back(); std::reverse(rinput.begin(), rinput.end()); PolygonImpl poly(removeCollinearPoints<PathImpl, PointImpl, Unit>(rinput, 1000000)); @@ -1116,7 +1152,7 @@ template<class It> MultiPolygon merged_pile(It from, It to, int bin_id) TEST_CASE("Test for bed center distance optimization", "[Nesting], [NestKernels]") { - static const constexpr ClipperLib::cInt W = 10000000; + static const constexpr Slic3r::ClipperLib::cInt W = 10000000; // Get the input items and define the bin. std::vector<RectangleItem> input(9, {W, W}); @@ -1151,7 +1187,7 @@ TEST_CASE("Test for bed center distance optimization", "[Nesting], [NestKernels] TEST_CASE("Test for biggest bounding box area", "[Nesting], [NestKernels]") { - static const constexpr ClipperLib::cInt W = 10000000; + static const constexpr Slic3r::ClipperLib::cInt W = 10000000; static const constexpr size_t N = 100; // Get the input items and define the bin. diff --git a/tests/libslic3r/test_elephant_foot_compensation.cpp b/tests/libslic3r/test_elephant_foot_compensation.cpp index 4e340c37a..a1c23f4a9 100644 --- a/tests/libslic3r/test_elephant_foot_compensation.cpp +++ b/tests/libslic3r/test_elephant_foot_compensation.cpp @@ -26,7 +26,7 @@ namespace Slic3r { pt.Y += CLIPPER_OFFSET_SCALE_ROUNDING_DELTA; pt.X >>= CLIPPER_OFFSET_POWER_OF_2; pt.Y >>= CLIPPER_OFFSET_POWER_OF_2; - out.emplace_back(coord_t(pt.X), coord_t(pt.Y)); + out.emplace_back(coord_t(pt.x()), coord_t(pt.y())); } return out; } diff --git a/xs/xsp/Clipper.xsp b/xs/xsp/Clipper.xsp index 277b59825..c4640dcf4 100644 --- a/xs/xsp/Clipper.xsp +++ b/xs/xsp/Clipper.xsp @@ -2,7 +2,6 @@ %{ #include <xsinit.h> -#include "clipper.hpp" #include "libslic3r/ClipperUtils.hpp" %} @@ -21,10 +20,10 @@ _constant() OUTPUT: RETVAL Polygons -offset(polygons, delta, joinType = ClipperLib::jtMiter, miterLimit = 3) +offset(polygons, delta, joinType = Slic3r::ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta - ClipperLib::JoinType joinType + Slic3r::ClipperLib::JoinType joinType double miterLimit CODE: RETVAL = offset(polygons, delta, joinType, miterLimit); @@ -32,10 +31,10 @@ offset(polygons, delta, joinType = ClipperLib::jtMiter, miterLimit = 3) RETVAL ExPolygons -offset_ex(polygons, delta, joinType = ClipperLib::jtMiter, miterLimit = 3) +offset_ex(polygons, delta, joinType = Slic3r::ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta - ClipperLib::JoinType joinType + Slic3r::ClipperLib::JoinType joinType double miterLimit CODE: RETVAL = offset_ex(polygons, delta, joinType, miterLimit); @@ -43,11 +42,11 @@ offset_ex(polygons, delta, joinType = ClipperLib::jtMiter, miterLimit = 3) RETVAL Polygons -offset2(polygons, delta1, delta2, joinType = ClipperLib::jtMiter, miterLimit = 3) +offset2(polygons, delta1, delta2, joinType = Slic3r::ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta1 const float delta2 - ClipperLib::JoinType joinType + Slic3r::ClipperLib::JoinType joinType double miterLimit CODE: RETVAL = offset2(polygons, delta1, delta2, joinType, miterLimit); @@ -55,11 +54,11 @@ offset2(polygons, delta1, delta2, joinType = ClipperLib::jtMiter, miterLimit = 3 RETVAL ExPolygons -offset2_ex(polygons, delta1, delta2, joinType = ClipperLib::jtMiter, miterLimit = 3) +offset2_ex(polygons, delta1, delta2, joinType = Slic3r::ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta1 const float delta2 - ClipperLib::JoinType joinType + Slic3r::ClipperLib::JoinType joinType double miterLimit CODE: RETVAL = offset2_ex(polygons, delta1, delta2, joinType, miterLimit); diff --git a/xs/xsp/Polyline.xsp b/xs/xsp/Polyline.xsp index 0dbd0e572..10bbb263f 100644 --- a/xs/xsp/Polyline.xsp +++ b/xs/xsp/Polyline.xsp @@ -79,9 +79,9 @@ Polyline::rotate(angle, center_sv) THIS->rotate(angle, center); Polygons -Polyline::grow(delta, joinType = ClipperLib::jtSquare, miterLimit = 3) +Polyline::grow(delta, joinType = Slic3r::ClipperLib::jtSquare, miterLimit = 3) const float delta - ClipperLib::JoinType joinType + Slic3r::ClipperLib::JoinType joinType double miterLimit CODE: RETVAL = offset(*THIS, delta, joinType, miterLimit); diff --git a/xs/xsp/Surface.xsp b/xs/xsp/Surface.xsp index 379774f0a..49d988333 100644 --- a/xs/xsp/Surface.xsp +++ b/xs/xsp/Surface.xsp @@ -85,7 +85,7 @@ Surface::polygons() Surfaces Surface::offset(delta, joinType = ClipperLib::jtMiter, miterLimit = 3) const float delta - ClipperLib::JoinType joinType + Slic3r::ClipperLib::JoinType joinType double miterLimit CODE: surfaces_append(RETVAL, offset_ex(THIS->expolygon, delta, joinType, miterLimit), *THIS); diff --git a/xs/xsp/my.map b/xs/xsp/my.map index 2ecff6e3f..54e686ae3 100644 --- a/xs/xsp/my.map +++ b/xs/xsp/my.map @@ -211,8 +211,8 @@ FlowRole T_UV PrintStep T_UV PrintObjectStep T_UV SurfaceType T_UV -ClipperLib::JoinType T_UV -ClipperLib::PolyFillType T_UV +Slic3r::ClipperLib::JoinType T_UV +Slic3r::ClipperLib::PolyFillType T_UV # we return these types whenever we want the items to be cloned Points T_ARRAYREF |