Classes
class	Clipper

class	ClipperBase

class	clipperException

class	ClipperOffset

struct	DoublePoint

class	Int128

struct	IntersectNode

struct	IntPoint

struct	IntRect

struct	Join

struct	LocalMinimum

struct	LocMinSorter

struct	OutPt

struct	OutRec

class	PolyNode

class	PolyTree

struct	TEdge

Typedefs
typedef signed long long	cInt

typedef signed long long	long64

typedef unsigned long long	ulong64

typedef std::vector< IntPoint >	Path

typedef std::vector< Path >	Paths

typedef std::vector< PolyNode * >	PolyNodes

typedef std::vector< OutRec * >	PolyOutList

typedef std::vector< TEdge * >	EdgeList

typedef std::vector< Join * >	JoinList

typedef std::vector< IntersectNode * >	IntersectList

Enumerations
enum	ClipType { ctIntersection, ctUnion, ctDifference, ctXor }

enum	PolyType { ptSubject, ptClip }

enum	PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative }

enum	InitOptions { ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4 }

enum	JoinType { jtSquare, jtRound, jtMiter }

enum	EndType { etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound }

enum	EdgeSide { esLeft = 1, esRight = 2 }

enum	Direction { dRightToLeft, dLeftToRight }

enum	NodeType { ntAny, ntOpen, ntClosed }

Functions
Path &	operator<< (Path &poly, const IntPoint &p)

Paths &	operator<< (Paths &polys, const Path &p)

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)

bool	Orientation (const Path &poly)

double	Area (const Path &poly)

int	PointInPolygon (const IntPoint &pt, const Path &path)

void	SimplifyPolygon (const Path &in_poly, Paths &out_polys, PolyFillType fillType=pftEvenOdd)

void	SimplifyPolygons (const Paths &in_polys, Paths &out_polys, PolyFillType fillType=pftEvenOdd)

void	SimplifyPolygons (Paths &polys, PolyFillType fillType=pftEvenOdd)

void	CleanPolygon (const Path &in_poly, Path &out_poly, double distance=1.415)

void	CleanPolygon (Path &poly, double distance=1.415)

void	CleanPolygons (const Paths &in_polys, Paths &out_polys, double distance=1.415)

void	CleanPolygons (Paths &polys, double distance=1.415)

void	MinkowskiSum (const Path &pattern, const Path &path, Paths &solution, bool pathIsClosed)

void	MinkowskiSum (const Path &pattern, const Paths &paths, Paths &solution, bool pathIsClosed)

void	MinkowskiDiff (const Path &poly1, const Path &poly2, Paths &solution)

void	PolyTreeToPaths (const PolyTree &polytree, Paths &paths)

void	ClosedPathsFromPolyTree (const PolyTree &polytree, Paths &paths)

void	OpenPathsFromPolyTree (PolyTree &polytree, Paths &paths)

void	ReversePath (Path &p)

void	ReversePaths (Paths &p)

cInt	Round (double val)

cInt	Abs (cInt val)

Int128	Int128Mul (long64 lhs, long64 rhs)

double	Area (const OutPt *op)

double	Area (const OutRec &outRec)

bool	PointIsVertex (const IntPoint &Pt, OutPt *pp)

int	PointInPolygon (const IntPoint &pt, OutPt *op)

bool	Poly2ContainsPoly1 (OutPt OutPt1, OutPt OutPt2)

bool	SlopesEqual (const TEdge &e1, const TEdge &e2, bool UseFullInt64Range)

bool	SlopesEqual (const IntPoint pt1, const IntPoint pt2, const IntPoint pt3, bool UseFullInt64Range)

bool	SlopesEqual (const IntPoint pt1, const IntPoint pt2, const IntPoint pt3, const IntPoint pt4, bool UseFullInt64Range)

bool	IsHorizontal (TEdge &e)

double	GetDx (const IntPoint pt1, const IntPoint pt2)

void	SetDx (TEdge &e)

void	SwapSides (TEdge &Edge1, TEdge &Edge2)

void	SwapPolyIndexes (TEdge &Edge1, TEdge &Edge2)

cInt	TopX (TEdge &edge, const cInt currentY)

void	IntersectPoint (TEdge &Edge1, TEdge &Edge2, IntPoint &ip)

void	ReversePolyPtLinks (OutPt *pp)

void	DisposeOutPts (OutPt *&pp)

void	InitEdge (TEdge e, TEdge eNext, TEdge *ePrev, const IntPoint &Pt)

void	InitEdge2 (TEdge &e, PolyType Pt)

TEdge *	RemoveEdge (TEdge *e)

void	ReverseHorizontal (TEdge &e)

void	SwapPoints (IntPoint &pt1, IntPoint &pt2)

bool	GetOverlapSegment (IntPoint pt1a, IntPoint pt1b, IntPoint pt2a, IntPoint pt2b, IntPoint &pt1, IntPoint &pt2)

bool	FirstIsBottomPt (const OutPt btmPt1, const OutPt btmPt2)

OutPt *	GetBottomPt (OutPt *pp)

bool	Pt2IsBetweenPt1AndPt3 (const IntPoint pt1, const IntPoint pt2, const IntPoint pt3)

bool	HorzSegmentsOverlap (cInt seg1a, cInt seg1b, cInt seg2a, cInt seg2b)

void	RangeTest (const IntPoint &Pt, bool &useFullRange)

TEdge *	FindNextLocMin (TEdge *E)

OutRec *	GetLowermostRec (OutRec outRec1, OutRec outRec2)

bool	OutRec1RightOfOutRec2 (OutRec outRec1, OutRec outRec2)

bool	IsMinima (TEdge *e)

bool	IsMaxima (TEdge *e, const cInt Y)

bool	IsIntermediate (TEdge *e, const cInt Y)

TEdge *	GetMaximaPair (TEdge *e)

TEdge *	GetMaximaPairEx (TEdge *e)

TEdge *	GetNextInAEL (TEdge *e, Direction dir)

void	GetHorzDirection (TEdge &HorzEdge, Direction &Dir, cInt &Left, cInt &Right)

bool	IntersectListSort (IntersectNode node1, IntersectNode node2)

bool	EdgesAdjacent (const IntersectNode &inode)

int	PointCount (OutPt *Pts)

void	SwapIntersectNodes (IntersectNode &int1, IntersectNode &int2)

bool	E2InsertsBeforeE1 (TEdge &e1, TEdge &e2)

bool	GetOverlap (const cInt a1, const cInt a2, const cInt b1, const cInt b2, cInt &Left, cInt &Right)

void	UpdateOutPtIdxs (OutRec &outrec)

OutPt *	DupOutPt (OutPt *outPt, bool InsertAfter)

bool	JoinHorz (OutPt op1, OutPt op1b, OutPt op2, OutPt op2b, const IntPoint Pt, bool DiscardLeft)

static OutRec *	ParseFirstLeft (OutRec *FirstLeft)

DoublePoint	GetUnitNormal (const IntPoint &pt1, const IntPoint &pt2)

double	DistanceSqrd (const IntPoint &pt1, const IntPoint &pt2)

double	DistanceFromLineSqrd (const IntPoint &pt, const IntPoint &ln1, const IntPoint &ln2)

bool	SlopesNearCollinear (const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3, double distSqrd)

bool	PointsAreClose (IntPoint pt1, IntPoint pt2, double distSqrd)

OutPt *	ExcludeOp (OutPt *op)

void	Minkowski (const Path &poly, const Path &path, Paths &solution, bool isSum, bool isClosed)

void	TranslatePath (const Path &input, Path &output, const IntPoint delta)

void	AddPolyNodeToPaths (const PolyNode &polynode, NodeType nodetype, Paths &paths)

Variables
static const cInt	loRange = 0x3FFFFFFF

static const cInt	hiRange = 0x3FFFFFFFFFFFFFFFLL

static const double	pi = 3.141592653589793238

static const double	two_pi = pi *2

static const double	def_arc_tolerance = 0.25

static const int	Unassigned = -1

static const int	Skip = -2

Typedef Documentation

◆ cInt

typedef signed long long ClipperLib::cInt

Definition at line 77 of file clipper.hpp.

◆ EdgeList

typedef std::vector< TEdge* > ClipperLib::EdgeList

Definition at line 209 of file clipper.hpp.

◆ IntersectList

typedef std::vector< IntersectNode* > ClipperLib::IntersectList

Definition at line 211 of file clipper.hpp.

◆ JoinList

typedef std::vector< Join* > ClipperLib::JoinList

Definition at line 210 of file clipper.hpp.

◆ long64

typedef signed long long ClipperLib::long64

Definition at line 80 of file clipper.hpp.

◆ Path

typedef std::vector< IntPoint > ClipperLib::Path

Definition at line 106 of file clipper.hpp.

◆ Paths

typedef std::vector< Path > ClipperLib::Paths

Definition at line 107 of file clipper.hpp.

◆ PolyNodes

typedef std::vector< PolyNode* > ClipperLib::PolyNodes

Definition at line 133 of file clipper.hpp.

◆ PolyOutList

typedef std::vector< OutRec* > ClipperLib::PolyOutList

Definition at line 206 of file clipper.hpp.

◆ ulong64

typedef unsigned long long ClipperLib::ulong64

Definition at line 81 of file clipper.hpp.

Enumeration Type Documentation

◆ ClipType

enum ClipperLib::ClipType

Enumerator
ctIntersection
ctUnion
ctDifference
ctXor

Definition at line 64 of file clipper.hpp.

64 { ctIntersection, ctUnion, ctDifference, ctXor };

◆ Direction

enum ClipperLib::Direction

Enumerator
dRightToLeft
dLeftToRight

Definition at line 93 of file clipper.cpp.

102 {

◆ EdgeSide

enum ClipperLib::EdgeSide

Enumerator
esLeft
esRight

Definition at line 198 of file clipper.hpp.

198 { esLeft = 1, esRight = 2};

◆ EndType

enum ClipperLib::EndType

Enumerator
etClosedPolygon
etClosedLine
etOpenButt
etOpenSquare
etOpenRound

Definition at line 131 of file clipper.hpp.

131 {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};

◆ InitOptions

enum ClipperLib::InitOptions

Enumerator
ioReverseSolution
ioStrictlySimple
ioPreserveCollinear

Definition at line 129 of file clipper.hpp.

129 {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};

◆ JoinType

enum ClipperLib::JoinType

Enumerator
jtSquare
jtRound
jtMiter

Definition at line 130 of file clipper.hpp.

130 {jtSquare, jtRound, jtMiter};

◆ NodeType

enum ClipperLib::NodeType

Enumerator
ntAny
ntOpen
ntClosed

Definition at line 4589 of file clipper.cpp.

◆ PolyFillType

enum ClipperLib::PolyFillType

Enumerator
pftEvenOdd
pftNonZero
pftPositive
pftNegative

Definition at line 70 of file clipper.hpp.

70 { pftEvenOdd, pftNonZero, pftPositive, pftNegative };

◆ PolyType

enum ClipperLib::PolyType

Enumerator
ptSubject
ptClip

Definition at line 65 of file clipper.hpp.

65 { ptSubject, ptClip };

Function Documentation

◆ Abs()

cInt ClipperLib::Abs ( cInt val )

inline

Definition at line 179 of file clipper.cpp.

182 : Childs(), Parent(0), Index(0), m_IsOpen(false)

◆ AddPolyNodeToPaths()

void ClipperLib::AddPolyNodeToPaths	(	const PolyNode &	polynode,
		NodeType	nodetype,
		Paths &	paths
	)

Definition at line 4591 of file clipper.cpp.

 {
   s << "(" << p.X << "," << p.Y << ")";
   return s;
 }
 //------------------------------------------------------------------------------
  

◆ Area() [1/3]

double ClipperLib::Area ( const OutPt * op )

Definition at line 442 of file clipper.cpp.

   {
     IntPoint ipNext = (i == cnt ? path[0] : path[i]);
     if (ipNext.Y == pt.Y)
     {
         if ((ipNext.X == pt.X) || (ip.Y == pt.Y && 

◆ Area() [2/3]

double ClipperLib::Area ( const OutRec & outRec )

Definition at line 455 of file clipper.cpp.

     {
       if (ip.X >= pt.X)
       {

◆ Area() [3/3]

double ClipperLib::Area ( const Path & poly )

Definition at line 427 of file clipper.cpp.

   {
     if (pp2->Pt == Pt) return true;
     pp2 = pp2->Next;
   }
   while (pp2 != pp);
   return false;
 }
 //------------------------------------------------------------------------------
  
 //See "The Point in Polygon Problem for Arbitrary Polygons" by Hormann & Agathos
 //http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf

◆ CleanPolygon() [1/2]

void ClipperLib::CleanPolygon	(	const Path &	in_poly,
		Path &	out_poly,
		double	distance = `1.415`
	)

Definition at line 4419 of file clipper.cpp.

     {
       op = ExcludeOp(op);
       size--;
     }
     else
     {
       op->Idx = 1;
       op = op->Next;
     }
   }
  
   if (size < 3) size = 0;
   out_poly.resize(size);
   for (size_t i = 0; i < size; ++i)
   {
     out_poly[i] = op->Pt;
     op = op->Next;
   }
   delete [] outPts;
 }
 //------------------------------------------------------------------------------
  
 void CleanPolygon(Path& poly, double distance)
 {
   CleanPolygon(poly, poly, distance);
 }
 //------------------------------------------------------------------------------
  
 void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance)
 {
   out_polys.resize(in_polys.size());
   for (Paths::size_type i = 0; i < in_polys.size(); ++i)
     CleanPolygon(in_polys[i], out_polys[i], distance);
 }
 //------------------------------------------------------------------------------
  
 void CleanPolygons(Paths& polys, double distance)
 {
   CleanPolygons(polys, polys, distance);
 }
 //------------------------------------------------------------------------------
  
 void Minkowski(const Path& poly, const Path& path, 
   Paths& solution, bool isSum, bool isClosed)
 {
   int delta = (isClosed ? 1 : 0);
   size_t polyCnt = poly.size();
   size_t pathCnt = path.size();
   Paths pp;
   pp.reserve(pathCnt);
   if (isSum)
     for (size_t i = 0; i < pathCnt; ++i)
     {
       Path p;
       p.reserve(polyCnt);
       for (size_t j = 0; j < poly.size(); ++j)

◆ CleanPolygon() [2/2]

void ClipperLib::CleanPolygon	(	Path &	poly,
		double	distance = `1.415`
	)

Definition at line 4479 of file clipper.cpp.

4482 {

◆ CleanPolygons() [1/2]

void ClipperLib::CleanPolygons	(	const Paths &	in_polys,
		Paths &	out_polys,
		double	distance = `1.415`
	)

Definition at line 4485 of file clipper.cpp.

4494 {

◆ CleanPolygons() [2/2]

void ClipperLib::CleanPolygons	(	Paths &	polys,
		double	distance = `1.415`
	)

Definition at line 4493 of file clipper.cpp.

     {
       Path quad;
       quad.reserve(4);

◆ ClosedPathsFromPolyTree()

void ClipperLib::ClosedPathsFromPolyTree	(	const PolyTree &	polytree,
		Paths &	paths
	)

Definition at line 4612 of file clipper.cpp.

 {
   for (Paths::size_type i = 0; i < p.size(); i++)
     s << p[i];
   s << "\n";

◆ DisposeOutPts()

void ClipperLib::DisposeOutPts ( OutPt *& pp )

Definition at line 742 of file clipper.cpp.

 {
   //removes e from double_linked_list (but without removing from memory)
   e->Prev->Next = e->Next;
   e->Next->Prev = e->Prev;
   TEdge* result = e->Next;
   e->Prev = 0; //flag as removed (see ClipperBase.Clear)
   return result;

◆ DistanceFromLineSqrd()

double ClipperLib::DistanceFromLineSqrd	(	const IntPoint &	pt,
		const IntPoint &	ln1,
		const IntPoint &	ln2
	)

Definition at line 4357 of file clipper.cpp.

 {
     double Dx = (double)pt1.X - pt2.X;
     double dy = (double)pt1.Y - pt2.Y;
     return ((Dx * Dx) + (dy * dy) <= distSqrd);
 }
 //------------------------------------------------------------------------------

◆ DistanceSqrd()

double ClipperLib::DistanceSqrd	(	const IntPoint &	pt1,
		const IntPoint &	pt2
	)

inline

Definition at line 4349 of file clipper.cpp.

4354 {

◆ DupOutPt()

OutPt* ClipperLib::DupOutPt	(	OutPt *	outPt,
		bool	InsertAfter
	)

Definition at line 3377 of file clipper.cpp.

   {
     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;
     op1b = DupOutPt(op1, !DiscardLeft);
     if (op1b->Pt != Pt) 
     {
       op1 = op1b;
       op1->Pt = Pt;
       op1b = DupOutPt(op1, !DiscardLeft);
     }
   } 
   else
   {
     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;
     op1b = DupOutPt(op1, DiscardLeft);
     if (op1b->Pt != Pt)

◆ E2InsertsBeforeE1()

bool ClipperLib::E2InsertsBeforeE1	(	TEdge &	e1,
		TEdge &	e2
	)

inline

Definition at line 3307 of file clipper.cpp.

 {
   if(!m_ActiveEdges)
   {
     edge->PrevInAEL = 0;

◆ EdgesAdjacent()

bool ClipperLib::EdgesAdjacent ( const IntersectNode & inode )

inline

Definition at line 2959 of file clipper.cpp.

2966 {

◆ ExcludeOp()

OutPt* ClipperLib::ExcludeOp ( OutPt * op )

Definition at line 4409 of file clipper.cpp.

     {
       op = ExcludeOp(op);
       size--;
     } 
     else if (PointsAreClose(op->Prev->Pt, op->Next->Pt, distSqrd))
     {
       ExcludeOp(op->Next);

◆ FindNextLocMin()

TEdge* ClipperLib::FindNextLocMin ( TEdge * E )

Definition at line 947 of file clipper.cpp.

     {
       if (NextIsForward) Result = E->Next;
       else Result = E->Prev;
     }
     else
     {
       //there are more edges in the bound beyond result starting with E
       if (NextIsForward)
         E = Result->Next;
       else
         E = Result->Prev;

◆ FirstIsBottomPt()

bool ClipperLib::FirstIsBottomPt	(	const OutPt *	btmPt1,
		const OutPt *	btmPt2
	)

Definition at line 834 of file clipper.cpp.

     {
       if (p->Pt.X < pp->Pt.X)
       {
         dups = 0;
         pp = p;
       } else
       {
         if (p->Next != pp && p->Prev != pp) dups = p;
       }
     }
     p = p->Next;
   }
   if (dups)
   {
     //there appears to be at least 2 vertices at BottomPt so ...
     while (dups != p)
     {
       if (!FirstIsBottomPt(p, dups)) pp = dups;
       dups = dups->Next;
       while (dups->Pt != pp->Pt) dups = dups->Next;
     }
   }

◆ GetBottomPt()

OutPt* ClipperLib::GetBottomPt ( OutPt * pp )

Definition at line 858 of file clipper.cpp.

 {
   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
     return (pt2.Y > pt1.Y) == (pt2.Y < pt3.Y);
 }
 //------------------------------------------------------------------------------
  
 bool HorzSegmentsOverlap(cInt seg1a, cInt seg1b, cInt seg2a, cInt seg2b)
 {
   if (seg1a > seg1b) std::swap(seg1a, seg1b);
   if (seg2a > seg2b) std::swap(seg2a, seg2b);
   return (seg1a < seg2b) && (seg2a < seg1b);
 }
  
 //------------------------------------------------------------------------------
 // ClipperBase class methods ...
 //------------------------------------------------------------------------------
  
 ClipperBase::ClipperBase() //constructor
 {
   m_CurrentLM = m_MinimaList.begin(); //begin() == end() here
   m_UseFullRange = false;
 }
 //------------------------------------------------------------------------------
  
 ClipperBase::~ClipperBase() //destructor
 {
   Clear();
 }

◆ GetDx()

double ClipperLib::GetDx	(	const IntPoint	pt1,
		const IntPoint	pt2
	)

inline

Definition at line 620 of file clipper.cpp.

623 {

624 #ifdef use_xyz

◆ GetHorzDirection()

void ClipperLib::GetHorzDirection	(	TEdge &	HorzEdge,
		Direction &	Dir,
		cInt &	Left,
		cInt &	Right
	)

Definition at line 2646 of file clipper.cpp.

   {
       //get the first maxima in range (X) ...
       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)

◆ GetLowermostRec()

OutRec* ClipperLib::GetLowermostRec	(	OutRec *	outRec1,
		OutRec *	outRec2
	)

Definition at line 2363 of file clipper.cpp.

 {
   //get the start and ends of both output polygons ...
   OutRec *outRec1 = m_PolyOuts[e1->OutIdx];
   OutRec *outRec2 = m_PolyOuts[e2->OutIdx];
  
   OutRec *holeStateRec;
   if (OutRec1RightOfOutRec2(outRec1, outRec2))
     holeStateRec = outRec2;
   else if (OutRec1RightOfOutRec2(outRec2, outRec1))
     holeStateRec = outRec1;
   else 
     holeStateRec = GetLowermostRec(outRec1, outRec2);
  

◆ GetMaximaPair()

TEdge* ClipperLib::GetMaximaPair ( TEdge * e )

Definition at line 2574 of file clipper.cpp.

   {
     TEdge* Next = Edge1->NextInSEL;
     if( Next ) Next->PrevInSEL = Edge2;
     TEdge* Prev = Edge2->PrevInSEL;
     if( Prev ) Prev->NextInSEL = Edge1;
     Edge1->PrevInSEL = Prev;
     Edge1->NextInSEL = Edge2;

◆ GetMaximaPairEx()

TEdge* ClipperLib::GetMaximaPairEx ( TEdge * e )

Definition at line 2584 of file clipper.cpp.

   {
     TEdge* Next = Edge1->NextInSEL;
     TEdge* Prev = Edge1->PrevInSEL;
     Edge1->NextInSEL = Edge2->NextInSEL;
     if( Edge1->NextInSEL ) Edge1->NextInSEL->PrevInSEL = Edge1;
     Edge1->PrevInSEL = Edge2->PrevInSEL;

◆ GetNextInAEL()

TEdge* ClipperLib::GetNextInAEL	(	TEdge *	e,
		Direction	dir
	)

Definition at line 2640 of file clipper.cpp.

◆ GetOverlap()

bool ClipperLib::GetOverlap	(	const cInt	a1,
		const cInt	a2,
		const cInt	b1,
		const cInt	b2,
		cInt &	Left,
		cInt &	Right
	)

Definition at line 3319 of file clipper.cpp.

   {
       edge->PrevInAEL = 0;
       edge->NextInAEL = m_ActiveEdges;
       m_ActiveEdges->PrevInAEL = edge;
       m_ActiveEdges = edge;
   } 
   else
   {
     if(!startEdge) startEdge = m_ActiveEdges;
     while(startEdge->NextInAEL  && 
       !E2InsertsBeforeE1(*startEdge->NextInAEL , *edge))
         startEdge = startEdge->NextInAEL;
     edge->NextInAEL = startEdge->NextInAEL;

◆ GetOverlapSegment()

bool ClipperLib::GetOverlapSegment	(	IntPoint	pt1a,
		IntPoint	pt1b,
		IntPoint	pt2a,
		IntPoint	pt2b,
		IntPoint &	pt1,
		IntPoint &	pt2
	)

Definition at line 812 of file clipper.cpp.

 {
   OutPt* dups = 0;
   OutPt* p = pp->Next;
   while (p != pp)
   {
     if (p->Pt.Y > pp->Pt.Y)
     {
       pp = p;
       dups = 0;

◆ GetUnitNormal()

DoublePoint ClipperLib::GetUnitNormal	(	const IntPoint &	pt1,
		const IntPoint &	pt2
	)

Definition at line 3798 of file clipper.cpp.

 {
   int highI = (int)path.size() - 1;
   if (highI < 0) return;
   PolyNode* newNode = new PolyNode();
   newNode->m_jointype = joinType;
   newNode->m_endtype = endType;
  

◆ HorzSegmentsOverlap()

bool ClipperLib::HorzSegmentsOverlap	(	cInt	seg1a,
		cInt	seg1b,
		cInt	seg2a,
		cInt	seg2b
	)

Definition at line 908 of file clipper.cpp.

912 {

913 for (;;)

◆ InitEdge()

void ClipperLib::InitEdge	(	TEdge *	e,
		TEdge *	eNext,
		TEdge *	ePrev,
		const IntPoint &	Pt
	)

inline

Definition at line 755 of file clipper.cpp.

 {
   //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  

◆ InitEdge2()

void ClipperLib::InitEdge2	(	TEdge &	e,
		PolyType	Pt
	)

Definition at line 765 of file clipper.cpp.

 {
   IntPoint tmp = pt1;
   pt1 = pt2;
   pt2 = tmp;
 }
 //------------------------------------------------------------------------------
  
 bool GetOverlapSegment(IntPoint pt1a, IntPoint pt1b, IntPoint pt2a,
   IntPoint pt2b, IntPoint &pt1, IntPoint &pt2)
 {

◆ Int128Mul()

Int128 ClipperLib::Int128Mul	(	long64	lhs,
		long64	rhs
	)

Definition at line 390 of file clipper.cpp.

 {
   int size = (int)poly.size();
   if (size < 3) return 0;
  
   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);
     j = i;
   }
   return -a * 0.5;
 }
 //------------------------------------------------------------------------------
  
 double Area(const OutPt *op)
 {
   const OutPt *startOp = op;
   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);
     op = op->Next;
   } while (op != startOp);

◆ IntersectListSort()

bool ClipperLib::IntersectListSort	(	IntersectNode *	node1,
		IntersectNode *	node2
	)

Definition at line 2953 of file clipper.cpp.

 {
   TEdge* eMaxPair = GetMaximaPairEx(e);
   if (!eMaxPair)

◆ IntersectPoint()

void ClipperLib::IntersectPoint	(	TEdge &	Edge1,
		TEdge &	Edge2,
		IntPoint &	ip
	)

Definition at line 658 of file clipper.cpp.

   {
     b1 = Edge1.Bot.X - Edge1.Bot.Y * Edge1.Dx;
     b2 = Edge2.Bot.X - Edge2.Bot.Y * Edge2.Dx;
     double q = (b2-b1) / (Edge1.Dx - Edge2.Dx);
     ip.Y = Round(q);
     if (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx))
       ip.X = Round(Edge1.Dx * q + b1);
     else 
       ip.X = Round(Edge2.Dx * q + b2);
   }
  
   if (ip.Y < Edge1.Top.Y || ip.Y < Edge2.Top.Y) 
   {
     if (Edge1.Top.Y > Edge2.Top.Y)
       ip.Y = Edge1.Top.Y;
     else
       ip.Y = Edge2.Top.Y;
     if (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx))
       ip.X = TopX(Edge1, ip.Y);
     else
       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)
   {
     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);
   }
 }
 //------------------------------------------------------------------------------
  
 void ReversePolyPtLinks(OutPt *pp)
 {
   if (!pp) return;
   OutPt *pp1, *pp2;
   pp1 = pp;
   do {
   pp2 = pp1->Next;
   pp1->Next = pp1->Prev;
   pp1->Prev = pp2;
   pp1 = pp2;
   } while( pp1 != pp );
 }
 //------------------------------------------------------------------------------
  
 void DisposeOutPts(OutPt*& pp)
 {
   if (pp == 0) return;
     pp->Prev->Next = 0;
   while( pp )
   {
     OutPt *tmpPp = pp;
     pp = pp->Next;
     delete tmpPp;
   }
 }
 //------------------------------------------------------------------------------
  
 inline void InitEdge(TEdge* e, TEdge* eNext, TEdge* ePrev, const IntPoint& Pt)
 {
   std::memset(e, 0, sizeof(TEdge));
   e->Next = eNext;
   e->Prev = ePrev;
   e->Curr = Pt;
   e->OutIdx = Unassigned;

◆ IsHorizontal()

bool ClipperLib::IsHorizontal ( TEdge & e )

inline

Definition at line 614 of file clipper.cpp.

616 {

617 return ( currentY == edge.Top.Y ) ?

◆ IsIntermediate()

bool ClipperLib::IsIntermediate	(	TEdge *	e,
		const cInt	Y
	)

inline

Definition at line 2568 of file clipper.cpp.

2575 {

◆ IsMaxima()

bool ClipperLib::IsMaxima	(	TEdge *	e,
		const cInt	Y
	)

inline

Definition at line 2562 of file clipper.cpp.

2564 {

2565 TEdge* Next = Edge2->NextInSEL;

◆ IsMinima()

bool ClipperLib::IsMinima ( TEdge * e )

inline

Definition at line 2556 of file clipper.cpp.

2559 {

◆ JoinHorz()

bool ClipperLib::JoinHorz	(	OutPt *	op1,
		OutPt *	op1b,
		OutPt *	op2,
		OutPt *	op2b,
		const IntPoint	Pt,
		bool	DiscardLeft
	)

Definition at line 3400 of file clipper.cpp.

   {
     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;
     op2b = DupOutPt(op2, !DiscardLeft);
     if (op2b->Pt != Pt)
     {
       op2 = op2b;
       op2->Pt = Pt;
       op2b = DupOutPt(op2, !DiscardLeft);
     };
   } else
   {
     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;
     op2b = DupOutPt(op2, DiscardLeft);
     if (op2b->Pt != Pt)
     {
       op2 = op2b;
       op2->Pt = Pt;
       op2b = DupOutPt(op2, DiscardLeft);
     };
   };
  
   if ((Dir1 == dLeftToRight) == DiscardLeft)
   {
     op1->Prev = op2;
     op2->Next = op1;
     op1b->Next = op2b;
     op2b->Prev = op1b;
   }
   else
   {
     op1->Next = op2;
     op2->Prev = op1;
     op1b->Prev = op2b;
     op2b->Next = op1b;
   }
   return true;
 }
 //------------------------------------------------------------------------------
  
 bool Clipper::JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2)
 {
   OutPt *op1 = j->OutPt1, *op1b;
   OutPt *op2 = j->OutPt2, *op2b;
  
   //There are 3 kinds of joins for output polygons ...
   //1. Horizontal joins where Join.OutPt1 & Join.OutPt2 are vertices anywhere
   //along (horizontal) collinear edges (& Join.OffPt is on the same horizontal).
   //2. Non-horizontal joins where Join.OutPt1 & Join.OutPt2 are at the same
   //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);
  
   if (isHorizontal  && (j->OffPt == j->OutPt1->Pt) &&
   (j->OffPt == j->OutPt2->Pt))
   {
     //Strictly Simple join ...
     if (outRec1 != outRec2) return false;
     op1b = j->OutPt1->Next;
     while (op1b != op1 && (op1b->Pt == j->OffPt)) 
       op1b = op1b->Next;
     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);
     if (reverse1 == reverse2) return false;
     if (reverse1)
     {
       op1b = DupOutPt(op1, false);
       op2b = DupOutPt(op2, true);
       op1->Prev = op2;
       op2->Next = op1;

◆ Minkowski()

void ClipperLib::Minkowski	(	const Path &	poly,
		const Path &	path,
		Paths &	solution,
		bool	isSum,
		bool	isClosed
	)

Definition at line 4499 of file clipper.cpp.

 {
   Minkowski(pattern, path, solution, true, pathIsClosed);
   Clipper c;
   c.AddPaths(solution, ptSubject, true);
   c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
 }
 //------------------------------------------------------------------------------
  
 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);
 }
 //------------------------------------------------------------------------------
  
 void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed)
 {
   Clipper c;
   for (size_t i = 0; i < paths.size(); ++i)
   {
     Paths tmp;
     Minkowski(pattern, paths[i], tmp, true, pathIsClosed);
     c.AddPaths(tmp, ptSubject, true);
     if (pathIsClosed)
     {
       Path tmp2;
       TranslatePath(paths[i], tmp2, pattern[0]);
       c.AddPath(tmp2, ptClip, true);
     }
   }
     c.Execute(ctUnion, solution, pftNonZero, pftNonZero);

◆ MinkowskiDiff()

void ClipperLib::MinkowskiDiff	(	const Path &	poly1,
		const Path &	poly2,
		Paths &	solution
	)

Definition at line 4580 of file clipper.cpp.

4585 {

4586 paths.resize(0);

◆ MinkowskiSum() [1/2]

void ClipperLib::MinkowskiSum	(	const Path &	pattern,
		const Path &	path,
		Paths &	solution,
		bool	pathIsClosed
	)

Definition at line 4543 of file clipper.cpp.

 {
   Minkowski(poly1, poly2, solution, false, true);
   Clipper c;
   c.AddPaths(solution, ptSubject, true);
   c.Execute(ctUnion, solution, pftNonZero, pftNonZero);

◆ MinkowskiSum() [2/2]

void ClipperLib::MinkowskiSum	(	const Path &	pattern,
		const Paths &	paths,
		Paths &	solution,
		bool	pathIsClosed
	)

Definition at line 4561 of file clipper.cpp.

 {
   paths.resize(0); 
   paths.reserve(polytree.Total());
   AddPolyNodeToPaths(polytree, ntAny, paths);
 }
 //------------------------------------------------------------------------------
  
 void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths)
 {

◆ OpenPathsFromPolyTree()

void ClipperLib::OpenPathsFromPolyTree	(	PolyTree &	polytree,
		Paths &	paths
	)

Definition at line 4620 of file clipper.cpp.

◆ operator<<() [1/5]

Path& ClipperLib::operator<<	(	Path &	poly,
		const IntPoint &	p
	)

inline

Definition at line 109 of file clipper.hpp.

109 {poly.push_back(p); return poly;}

◆ operator<<() [2/5]

Paths& ClipperLib::operator<<	(	Paths &	polys,
		const Path &	p
	)

inline

Definition at line 110 of file clipper.hpp.

110 {polys.push_back(p); return polys;}

◆ operator<<() [3/5]

std::ostream & ClipperLib::operator<<	(	std::ostream &	s,
		const IntPoint &	p
	)

Definition at line 4631 of file clipper.cpp.

◆ operator<<() [4/5]

std::ostream & ClipperLib::operator<<	(	std::ostream &	s,
		const Path &	p
	)

Definition at line 4638 of file clipper.cpp.

◆ operator<<() [5/5]

std::ostream & ClipperLib::operator<<	(	std::ostream &	s,
		const Paths &	p
	)

Definition at line 4649 of file clipper.cpp.

◆ Orientation()

bool ClipperLib::Orientation ( const Path & poly )

Definition at line 421 of file clipper.cpp.

426 {

◆ OutRec1RightOfOutRec2()

bool ClipperLib::OutRec1RightOfOutRec2	(	OutRec *	outRec1,
		OutRec *	outRec2
	)

Definition at line 2383 of file clipper.cpp.

2391 {

◆ ParseFirstLeft()

static OutRec* ClipperLib::ParseFirstLeft ( OutRec * FirstLeft )

static

Definition at line 3646 of file clipper.cpp.

◆ PointCount()

int ClipperLib::PointCount ( OutPt * Pts )

Definition at line 3213 of file clipper.cpp.

 {
     polytree.Clear();
     polytree.AllNodes.reserve(m_PolyOuts.size());
     //add each output polygon/contour to polytree ...
     for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); i++)
     {
         OutRec* outRec = m_PolyOuts[i];
         int cnt = PointCount(outRec->Pts);
         if ((outRec->IsOpen && cnt < 2) || (!outRec->IsOpen && cnt < 3)) continue;
         FixHoleLinkage(*outRec);
         PolyNode* pn = new PolyNode();
         //nb: polytree takes ownership of all the PolyNodes

◆ PointInPolygon() [1/2]

int ClipperLib::PointInPolygon	(	const IntPoint &	pt,
		const Path &	path
	)

Definition at line 476 of file clipper.cpp.

 {
   //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
   int result = 0;
   OutPt* startOp = op;
   for(;;)
   {
     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->Pt.Y < pt.Y) != (op->Next->Pt.Y < pt.Y))
     {
       if (op->Pt.X >= pt.X)
       {
         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);
           if (!d) return -1;
           if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result;
         }
       } else
       {
         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);
           if (!d) return -1;
           if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result;
         }
       }

◆ PointInPolygon() [2/2]

int ClipperLib::PointInPolygon	(	const IntPoint &	pt,
		OutPt *	op
	)

Definition at line 520 of file clipper.cpp.

 {
   OutPt* op = OutPt1;
   do
   {
     //nb: PointInPolygon returns 0 if false, +1 if true, -1 if pt on polygon
     int res = PointInPolygon(op->Pt, OutPt2);
     if (res >= 0) return res > 0;
     op = op->Next; 
   }
   while (op != OutPt1);
   return true; 
 }
 //----------------------------------------------------------------------
  
 bool SlopesEqual(const TEdge &e1, const TEdge &e2, bool UseFullInt64Range)
 {
 #ifndef use_int32
   if (UseFullInt64Range)
     return Int128Mul(e1.Top.Y - e1.Bot.Y, e2.Top.X - e2.Bot.X) == 
     Int128Mul(e1.Top.X - e1.Bot.X, e2.Top.Y - e2.Bot.Y);
   else 
 #endif
     return (e1.Top.Y - e1.Bot.Y) * (e2.Top.X - e2.Bot.X) == 
     (e1.Top.X - e1.Bot.X) * (e2.Top.Y - e2.Bot.Y);
 }
 //------------------------------------------------------------------------------
  
 bool SlopesEqual(const IntPoint pt1, const IntPoint pt2,
   const IntPoint pt3, bool UseFullInt64Range)
 {
 #ifndef use_int32
   if (UseFullInt64Range)
     return Int128Mul(pt1.Y-pt2.Y, pt2.X-pt3.X) == Int128Mul(pt1.X-pt2.X, pt2.Y-pt3.Y);

◆ PointIsVertex()

bool ClipperLib::PointIsVertex	(	const IntPoint &	Pt,
		OutPt *	pp
	)

Definition at line 461 of file clipper.cpp.

         {
           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;
         }
       } else
       {
         if (ipNext.X > pt.X)
         {
           double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) - 

◆ PointsAreClose()

bool ClipperLib::PointsAreClose	(	IntPoint	pt1,
		IntPoint	pt2,
		double	distSqrd
	)

Definition at line 4401 of file clipper.cpp.

4408 {

◆ Poly2ContainsPoly1()

bool ClipperLib::Poly2ContainsPoly1	(	OutPt *	OutPt1,
		OutPt *	OutPt2
	)

Definition at line 562 of file clipper.cpp.

 {
 #ifndef use_int32
   if (UseFullInt64Range)
     return Int128Mul(pt1.Y-pt2.Y, pt3.X-pt4.X) == Int128Mul(pt1.X-pt2.X, pt3.Y-pt4.Y);
   else 
 #endif
     return (pt1.Y-pt2.Y)*(pt3.X-pt4.X) == (pt1.X-pt2.X)*(pt3.Y-pt4.Y);

◆ PolyTreeToPaths()

void ClipperLib::PolyTreeToPaths	(	const PolyTree &	polytree,
		Paths &	paths
	)

Definition at line 4604 of file clipper.cpp.

◆ Pt2IsBetweenPt1AndPt3()

bool ClipperLib::Pt2IsBetweenPt1AndPt3	(	const IntPoint	pt1,
		const IntPoint	pt2,
		const IntPoint	pt3
	)

Definition at line 896 of file clipper.cpp.

 {
   if (useFullRange)
   {
     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) 
   {
     useFullRange = true;

◆ RangeTest()

void ClipperLib::RangeTest	(	const IntPoint &	Pt,
		bool &	useFullRange
	)

Definition at line 932 of file clipper.cpp.

   {
     //if edges still remain in the current bound beyond the skip edge then
     //create another LocMin and call ProcessBound once more
     if (NextIsForward)
     {
       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

◆ RemoveEdge()

TEdge* ClipperLib::RemoveEdge ( TEdge * e )

Definition at line 781 of file clipper.cpp.

   {
     if (pt1a.X > pt1b.X) SwapPoints(pt1a, pt1b);
     if (pt2a.X > pt2b.X) SwapPoints(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) SwapPoints(pt1a, pt1b);

◆ ReverseHorizontal()

void ClipperLib::ReverseHorizontal ( TEdge & e )

inline

Definition at line 792 of file clipper.cpp.

 {
   OutPt *p = btmPt1->Prev;
   while ((p->Pt == btmPt1->Pt) && (p != btmPt1)) p = p->Prev;

◆ ReversePath()

void ClipperLib::ReversePath ( Path & p )

Definition at line 4312 of file clipper.cpp.

4314 {

4315 double Dx = ((double)pt1.X - pt2.X);

◆ ReversePaths()

void ClipperLib::ReversePaths ( Paths & p )

Definition at line 4318 of file clipper.cpp.

4323 {

◆ ReversePolyPtLinks()

void ClipperLib::ReversePolyPtLinks ( OutPt * pp )

Definition at line 728 of file clipper.cpp.

 {
   if (e.Curr.Y >= e.Next->Curr.Y)
   {
     e.Bot = e.Curr;
     e.Top = e.Next->Curr;
   } else
   {
     e.Top = e.Curr;
     e.Bot = e.Next->Curr;
   }

◆ Round()

cInt ClipperLib::Round ( double val )

inline

Definition at line 172 of file clipper.cpp.

◆ SetDx()

void ClipperLib::SetDx ( TEdge & e )

inline

Definition at line 627 of file clipper.cpp.

   {
     ip.Y = Edge1.Curr.Y;
     ip.X = TopX(Edge1, ip.Y);

◆ SimplifyPolygon()

void ClipperLib::SimplifyPolygon	(	const Path &	in_poly,
		Paths &	out_polys,
		PolyFillType	fillType = `pftEvenOdd`
	)

Definition at line 4325 of file clipper.cpp.

4340 {

◆ SimplifyPolygons() [1/2]

void ClipperLib::SimplifyPolygons	(	const Paths &	in_polys,
		Paths &	out_polys,
		PolyFillType	fillType = `pftEvenOdd`
	)

Definition at line 4334 of file clipper.cpp.

4340 {

◆ SimplifyPolygons() [2/2]

void ClipperLib::SimplifyPolygons	(	Paths &	polys,
		PolyFillType	fillType = `pftEvenOdd`
	)

Definition at line 4343 of file clipper.cpp.

4345 {

4346 if ((pt1.X > pt2.X) == (pt1.X < pt3.X))

◆ SlopesEqual() [1/3]

bool ClipperLib::SlopesEqual	(	const IntPoint	pt1,
		const IntPoint	pt2,
		const IntPoint	pt3,
		bool	UseFullInt64Range
	)

Definition at line 590 of file clipper.cpp.

 {
   cInt dy  = (e.Top.Y - e.Bot.Y);
   if (dy == 0) e.Dx = HORIZONTAL;
   else e.Dx = (double)(e.Top.X - e.Bot.X) / dy;
 }
 //---------------------------------------------------------------------------
  
 inline void SwapSides(TEdge &Edge1, TEdge &Edge2)

◆ SlopesEqual() [2/3]

bool ClipperLib::SlopesEqual	(	const IntPoint	pt1,
		const IntPoint	pt2,
		const IntPoint	pt3,
		const IntPoint	pt4,
		bool	UseFullInt64Range
	)

Definition at line 602 of file clipper.cpp.

 {
   int OutIdx =  Edge1.OutIdx;
   Edge1.OutIdx = Edge2.OutIdx;
   Edge2.OutIdx = OutIdx;

◆ SlopesEqual() [3/3]

bool ClipperLib::SlopesEqual	(	const TEdge &	e1,
		const TEdge &	e2,
		bool	UseFullInt64Range
	)

Definition at line 577 of file clipper.cpp.

 {
   return e.Dx == HORIZONTAL;
 }
 //------------------------------------------------------------------------------
  
 inline double GetDx(const IntPoint pt1, const IntPoint pt2)
 {
   return (pt1.Y == pt2.Y) ?
     HORIZONTAL : (double)(pt2.X - pt1.X) / (pt2.Y - pt1.Y);

◆ SlopesNearCollinear()

bool ClipperLib::SlopesNearCollinear	(	const IntPoint &	pt1,
		const IntPoint &	pt2,
		const IntPoint &	pt3,
		double	distSqrd
	)

Definition at line 4374 of file clipper.cpp.

 {
   OutPt* result = op->Prev;
   result->Next = op->Next;
   op->Next->Prev = result;
   result->Idx = 0;
   return result;
 }
 //------------------------------------------------------------------------------
  
 void CleanPolygon(const Path& in_poly, Path& out_poly, double distance)
 {
   //distance = proximity in units/pixels below which vertices
   //will be stripped. Default ~= sqrt(2).
   
   size_t size = in_poly.size();
   
   if (size == 0) 
   {
     out_poly.clear();
     return;
   }
  
   OutPt* outPts = new OutPt[size];
   for (size_t i = 0; i < size; ++i)
   {

◆ SwapIntersectNodes()

void ClipperLib::SwapIntersectNodes	(	IntersectNode &	int1,
		IntersectNode &	int2
	)

Definition at line 3294 of file clipper.cpp.

          {Left = std::max(a2,b2); Right = std::min(a1,b1);}
   }
   return Left < Right;
 }
 //------------------------------------------------------------------------------
  
 inline void UpdateOutPtIdxs(OutRec& outrec)
 {  
   OutPt* op = outrec.Pts;
   do
   {

◆ SwapPoints()

void ClipperLib::SwapPoints	(	IntPoint &	pt1,
		IntPoint &	pt2
	)

Definition at line 804 of file clipper.cpp.

◆ SwapPolyIndexes()

void ClipperLib::SwapPolyIndexes	(	TEdge &	Edge1,
		TEdge &	Edge2
	)

inline

Definition at line 643 of file clipper.cpp.

647 {

648 ip.X = Edge2.Bot.X;

◆ SwapSides()

void ClipperLib::SwapSides	(	TEdge &	Edge1,
		TEdge &	Edge2
	)

inline

Definition at line 635 of file clipper.cpp.

   {
     ip.X = Edge1.Bot.X;
     if (IsHorizontal(Edge2))
       ip.Y = Edge2.Bot.Y;
     else

◆ TopX()

cInt ClipperLib::TopX	(	TEdge &	edge,
		const cInt	currentY
	)

inline

Definition at line 651 of file clipper.cpp.

     {
       b1 = Edge1.Bot.Y - (Edge1.Bot.X / Edge1.Dx);
       ip.Y = Round(ip.X / Edge1.Dx + b1);
     }

◆ TranslatePath()

void ClipperLib::TranslatePath	(	const Path &	input,
		Path &	output,
		const IntPoint	delta
	)

Definition at line 4552 of file clipper.cpp.

               {ntAny, ntOpen, ntClosed};
  
 void AddPolyNodeToPaths(const PolyNode& polynode, NodeType nodetype, Paths& paths)
 {
   bool match = true;
   if (nodetype == ntClosed) match = !polynode.IsOpen();

◆ UpdateOutPtIdxs()

void ClipperLib::UpdateOutPtIdxs ( OutRec & outrec )

inline

Definition at line 3336 of file clipper.cpp.

 {
   OutPt* result = new OutPt;
   result->Pt = outPt->Pt;
   result->Idx = outPt->Idx;

Variable Documentation

◆ def_arc_tolerance

const double ClipperLib::def_arc_tolerance = 0.25

static

Definition at line 91 of file clipper.cpp.

◆ hiRange

const cInt ClipperLib::hiRange = 0x3FFFFFFFFFFFFFFFLL

static

Definition at line 79 of file clipper.hpp.

◆ loRange

const cInt ClipperLib::loRange = 0x3FFFFFFF

static

Definition at line 78 of file clipper.hpp.

◆ pi

const double ClipperLib::pi = 3.141592653589793238

static

Examples: elasticity.cpp.

Definition at line 89 of file clipper.cpp.

◆ Skip

const int ClipperLib::Skip = -2

static

Definition at line 96 of file clipper.cpp.

◆ two_pi

const double ClipperLib::two_pi = pi *2

static

Definition at line 90 of file clipper.cpp.

◆ Unassigned

const int ClipperLib::Unassigned = -1

static

Definition at line 95 of file clipper.cpp.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ cInt

◆ EdgeList

◆ IntersectList

◆ JoinList

◆ long64

◆ Path

◆ Paths

◆ PolyNodes

◆ PolyOutList

◆ ulong64

Enumeration Type Documentation

◆ ClipType

◆ Direction

◆ EdgeSide

◆ EndType

◆ InitOptions

◆ JoinType

◆ NodeType

◆ PolyFillType

◆ PolyType

Function Documentation

◆ Abs()

◆ AddPolyNodeToPaths()

◆ Area() [1/3]

◆ Area() [2/3]

◆ Area() [3/3]

◆ CleanPolygon() [1/2]

◆ CleanPolygon() [2/2]

◆ CleanPolygons() [1/2]

◆ CleanPolygons() [2/2]

◆ ClosedPathsFromPolyTree()

◆ DisposeOutPts()

◆ DistanceFromLineSqrd()

◆ DistanceSqrd()

◆ DupOutPt()

◆ E2InsertsBeforeE1()

◆ EdgesAdjacent()

◆ ExcludeOp()

◆ FindNextLocMin()

◆ FirstIsBottomPt()

◆ GetBottomPt()

◆ GetDx()

◆ GetHorzDirection()

◆ GetLowermostRec()

◆ GetMaximaPair()

◆ GetMaximaPairEx()

◆ GetNextInAEL()

◆ GetOverlap()

◆ GetOverlapSegment()

◆ GetUnitNormal()

◆ HorzSegmentsOverlap()

◆ InitEdge()

◆ InitEdge2()

◆ Int128Mul()

◆ IntersectListSort()

◆ IntersectPoint()

◆ IsHorizontal()

◆ IsIntermediate()

◆ IsMaxima()

◆ IsMinima()

◆ JoinHorz()

◆ Minkowski()

◆ MinkowskiDiff()

◆ MinkowskiSum() [1/2]

◆ MinkowskiSum() [2/2]

◆ OpenPathsFromPolyTree()

◆ operator<<() [1/5]

◆ operator<<() [2/5]

◆ operator<<() [3/5]

◆ operator<<() [4/5]

◆ operator<<() [5/5]

◆ Orientation()

◆ OutRec1RightOfOutRec2()

◆ ParseFirstLeft()