ClipperLib Namespace Reference

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 cInt const	loRange = 0x3FFFFFFF
static cInt const	hiRange = 0x3FFFFFFFFFFFFFFFLL
static double const	pi = 3.141592653589793238
static double const	two_pi = pi *2
static double const	def_arc_tolerance = 0.25
static int const	Unassigned = -1
static int const	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 134 of file clipper.hpp.

PolyOutList

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

Definition at line 208 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.

{ ctIntersection, ctUnion, ctDifference, ctXor };

Direction

enum ClipperLib::Direction

Enumerator
dRightToLeft
dLeftToRight

Definition at line 57 of file clipper.cpp.

{ dRightToLeft, dLeftToRight };

EdgeSide

enum ClipperLib::EdgeSide

Enumerator
esLeft
esRight

Definition at line 198 of file clipper.hpp.

{ esLeft = 1, esRight = 2};

EndType

enum ClipperLib::EndType

Enumerator
etClosedPolygon
etClosedLine
etOpenButt
etOpenSquare
etOpenRound

Definition at line 131 of file clipper.hpp.

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

InitOptions

enum ClipperLib::InitOptions

Enumerator
ioReverseSolution
ioStrictlySimple
ioPreserveCollinear

Definition at line 129 of file clipper.hpp.

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

JoinType

enum ClipperLib::JoinType

Enumerator
jtSquare
jtRound
jtMiter

Definition at line 130 of file clipper.hpp.

{jtSquare, jtRound, jtMiter};

NodeType

enum ClipperLib::NodeType

Enumerator
ntAny
ntOpen
ntClosed

Definition at line 4553 of file clipper.cpp.

{ntAny, ntOpen, ntClosed};

PolyFillType

enum ClipperLib::PolyFillType

Enumerator
pftEvenOdd
pftNonZero
pftPositive
pftNegative

Definition at line 70 of file clipper.hpp.

{ pftEvenOdd, pftNonZero, pftPositive, pftNegative };

PolyType

enum ClipperLib::PolyType

Enumerator
ptSubject
ptClip

Definition at line 65 of file clipper.hpp.

{ ptSubject, ptClip };

Function Documentation

Abs()

cInt ClipperLib::Abs ( cInt  val )

inline

Definition at line 143 of file clipper.cpp.

{
  return val < 0 ? -val : val;
}

AddPolyNodeToPaths()

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

Definition at line 4555 of file clipper.cpp.

{
  bool match = true;
  if (nodetype == ntClosed) match = !polynode.IsOpen();
  else if (nodetype == ntOpen) return;
 
  if (!polynode.Contour.empty() && match)
    paths.push_back(polynode.Contour);
  for (int i = 0; i < polynode.ChildCount(); ++i)
    AddPolyNodeToPaths(*polynode.Childs[i], nodetype, paths);
}

Area() [1/3]

double ClipperLib::Area

(

const OutPt *

op

)

Definition at line 406 of file clipper.cpp.

{
  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);
  return a * 0.5;
}

Area() [2/3]

double ClipperLib::Area

(

const OutRec &

outRec

)

Definition at line 419 of file clipper.cpp.

{
  return Area(outRec.Pts);
}

Area() [3/3]

double ClipperLib::Area

(

const Path &

poly

)

Definition at line 391 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;
}

CleanPolygon() [1/2]

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

Definition at line 4383 of file clipper.cpp.

{
  //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)
  {
    outPts[i].Pt = in_poly[i];
    outPts[i].Next = &outPts[(i + 1) % size];
    outPts[i].Next->Prev = &outPts[i];
    outPts[i].Idx = 0;
  }
 
  double distSqrd = distance * distance;
  OutPt* op = &outPts[0];
  while (op->Idx == 0 && op->Next != op->Prev) 
  {
    if (PointsAreClose(op->Pt, op->Prev->Pt, distSqrd))
    {
      op = ExcludeOp(op);
      size--;
    } 
    else if (PointsAreClose(op->Prev->Pt, op->Next->Pt, distSqrd))
    {
      ExcludeOp(op->Next);
      op = ExcludeOp(op);
      size -= 2;
    }
    else if (SlopesNearCollinear(op->Prev->Pt, op->Pt, op->Next->Pt, distSqrd))
    {
      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;
}

CleanPolygon() [2/2]

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

Definition at line 4443 of file clipper.cpp.

{
  CleanPolygon(poly, poly, distance);
}

CleanPolygons() [1/2]

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

Definition at line 4449 of file clipper.cpp.

{
  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);
}

CleanPolygons() [2/2]

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

Definition at line 4457 of file clipper.cpp.

{
  CleanPolygons(polys, polys, distance);
}

ClosedPathsFromPolyTree()

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

Definition at line 4576 of file clipper.cpp.

{
  paths.resize(0); 
  paths.reserve(polytree.Total());
  AddPolyNodeToPaths(polytree, ntClosed, paths);
}

DisposeOutPts()

void ClipperLib::DisposeOutPts

(

OutPt *&

pp

)

Definition at line 706 of file clipper.cpp.

{
  if (pp == 0) return;
    pp->Prev->Next = 0;
  while( pp )
  {
    OutPt *tmpPp = pp;
    pp = pp->Next;
    delete tmpPp;
  }
}

DistanceFromLineSqrd()

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

Definition at line 4321 of file clipper.cpp.

{
  //The equation of a line in general form (Ax + By + C = 0)
  //given 2 points (x¹,y¹) & (x²,y²) is ...
  //(y¹ - y²)x + (x² - x¹)y + (y² - y¹)x¹ - (x² - x¹)y¹ = 0
  //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;
  return (C * C) / (A * A + B * B);
}

DistanceSqrd()

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

inline

Definition at line 4313 of file clipper.cpp.

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

DupOutPt()

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

Definition at line 3341 of file clipper.cpp.

{
  OutPt* result = new OutPt;
  result->Pt = outPt->Pt;
  result->Idx = outPt->Idx;
  if (InsertAfter)
  {
    result->Next = outPt->Next;
    result->Prev = outPt;
    outPt->Next->Prev = result;
    outPt->Next = result;
  } 
  else
  {
    result->Prev = outPt->Prev;
    result->Next = outPt;
    outPt->Prev->Next = result;
    outPt->Prev = result;
  }
  return result;
}

E2InsertsBeforeE1()

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

inline

Definition at line 3271 of file clipper.cpp.

{
  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);
  } 
  else return e2.Curr.X < e1.Curr.X;
}

EdgesAdjacent()

bool ClipperLib::EdgesAdjacent ( const IntersectNode &  inode )

inline

Definition at line 2923 of file clipper.cpp.

{
  return (inode.Edge1->NextInSEL == inode.Edge2) ||
    (inode.Edge1->PrevInSEL == inode.Edge2);
}

ExcludeOp()

OutPt * ClipperLib::ExcludeOp

(

OutPt *

op

)

Definition at line 4373 of file clipper.cpp.

{
  OutPt* result = op->Prev;
  result->Next = op->Next;
  op->Next->Prev = result;
  result->Idx = 0;
  return result;
}

FindNextLocMin()

TEdge * ClipperLib::FindNextLocMin

(

TEdge *

E

)

Definition at line 911 of file clipper.cpp.

{
  for (;;)
  {
    while (E->Bot != E->Prev->Bot || E->Curr == E->Top) E = E->Next;
    if (!IsHorizontal(*E) && !IsHorizontal(*E->Prev)) break;
    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;
    break;
  }
  return E;
}

FirstIsBottomPt()

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

Definition at line 798 of file clipper.cpp.

{
  OutPt *p = btmPt1->Prev;
  while ((p->Pt == btmPt1->Pt) && (p != btmPt1)) p = p->Prev;
  double dx1p = std::fabs(GetDx(btmPt1->Pt, p->Pt));
  p = btmPt1->Next;
  while ((p->Pt == btmPt1->Pt) && (p != btmPt1)) p = p->Next;
  double dx1n = std::fabs(GetDx(btmPt1->Pt, p->Pt));
 
  p = btmPt2->Prev;
  while ((p->Pt == btmPt2->Pt) && (p != btmPt2)) p = p->Prev;
  double dx2p = std::fabs(GetDx(btmPt2->Pt, p->Pt));
  p = btmPt2->Next;
  while ((p->Pt == btmPt2->Pt) && (p != btmPt2)) p = p->Next;
  double dx2n = std::fabs(GetDx(btmPt2->Pt, p->Pt));
 
  if (std::max(dx1p, dx1n) == std::max(dx2p, dx2n) &&
    std::min(dx1p, dx1n) == std::min(dx2p, dx2n))
      return Area(btmPt1) > 0; //if otherwise identical use orientation
  else
    return (dx1p >= dx2p && dx1p >= dx2n) || (dx1n >= dx2p && dx1n >= dx2n);
}

GetBottomPt()

OutPt * ClipperLib::GetBottomPt

(

OutPt *

pp

)

Definition at line 822 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;
    }
    else if (p->Pt.Y == pp->Pt.Y && p->Pt.X <= pp->Pt.X)
    {
      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;
    }
  }
  return pp;
}

GetDx()

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

inline

Definition at line 584 of file clipper.cpp.

{
  return (pt1.Y == pt2.Y) ?
    HORIZONTAL : (double)(pt2.X - pt1.X) / (pt2.Y - pt1.Y);
}

GetHorzDirection()

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

Definition at line 2610 of file clipper.cpp.

{
  if (HorzEdge.Bot.X < HorzEdge.Top.X)
  {
    Left = HorzEdge.Bot.X;
    Right = HorzEdge.Top.X;
    Dir = dLeftToRight;
  } else
  {
    Left = HorzEdge.Top.X;
    Right = HorzEdge.Bot.X;
    Dir = dRightToLeft;
  }
}

GetLowermostRec()

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

Definition at line 2327 of file clipper.cpp.

{
  //work out which polygon fragment has the correct hole state ...
  if (!outRec1->BottomPt) 
    outRec1->BottomPt = GetBottomPt(outRec1->Pts);
  if (!outRec2->BottomPt) 
    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;
  else if (OutPt1->Next == OutPt1) return outRec2;
  else if (OutPt2->Next == OutPt2) return outRec1;
  else if (FirstIsBottomPt(OutPt1, OutPt2)) return outRec1;
  else return outRec2;
}

GetMaximaPair()

TEdge * ClipperLib::GetMaximaPair

(

TEdge *

e

)

Definition at line 2538 of file clipper.cpp.

{
  if ((e->Next->Top == e->Top) && !e->Next->NextInLML)
    return e->Next;
  else if ((e->Prev->Top == e->Top) && !e->Prev->NextInLML)
    return e->Prev;
  else return 0;
}

GetMaximaPairEx()

TEdge * ClipperLib::GetMaximaPairEx

(

TEdge *

e

)

Definition at line 2548 of file clipper.cpp.

{
  //as GetMaximaPair() but returns 0 if MaxPair isn't in AEL (unless it's horizontal)
  TEdge* result = GetMaximaPair(e);
  if (result && (result->OutIdx == Skip ||
    (result->NextInAEL == result->PrevInAEL && !IsHorizontal(*result)))) return 0;
  return result;
}

GetNextInAEL()

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

Definition at line 2604 of file clipper.cpp.

{
  return dir == dLeftToRight ? e->NextInAEL : e->PrevInAEL;
}

GetOverlap()

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

Definition at line 3283 of file clipper.cpp.

{
  if (a1 < a2)
  {
    if (b1 < b2) {Left = std::max(a1,b1); Right = std::min(a2,b2);}
    else {Left = std::max(a1,b2); Right = std::min(a2,b1);}
  } 
  else
  {
    if (b1 < b2) {Left = std::max(a2,b1); Right = std::min(a1,b2);}
    else {Left = std::max(a2,b2); Right = std::min(a1,b1);}
  }
  return Left < Right;
}

GetOverlapSegment()

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

Definition at line 776 of file clipper.cpp.

{
  //precondition: segments are Collinear.
  if (Abs(pt1a.X - pt1b.X) > Abs(pt1a.Y - pt1b.Y))
  {
    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);
    if (pt2a.Y < pt2b.Y) SwapPoints(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;
  }
}

GetUnitNormal()

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

Definition at line 3762 of file clipper.cpp.

{
  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 f = 1 *1.0/ std::sqrt( Dx*Dx + dy*dy );
  Dx *= f;
  dy *= f;
  return DoublePoint(dy, -Dx);
}

HorzSegmentsOverlap()

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

Definition at line 872 of file clipper.cpp.

{
  if (seg1a > seg1b) std::swap(seg1a, seg1b);
  if (seg2a > seg2b) std::swap(seg2a, seg2b);
  return (seg1a < seg2b) && (seg2a < seg1b);
}

InitEdge()

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

inline

Definition at line 719 of file clipper.cpp.

{
  std::memset(e, 0, sizeof(TEdge));
  e->Next = eNext;
  e->Prev = ePrev;
  e->Curr = Pt;
  e->OutIdx = Unassigned;
}

InitEdge2()

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

Definition at line 729 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;
  }
  SetDx(e);
  e.PolyTyp = Pt;
}

Int128Mul()

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

Definition at line 354 of file clipper.cpp.

{
  bool negate = (lhs < 0) != (rhs < 0);
 
  if (lhs < 0) lhs = -lhs;
  ulong64 int1Hi = ulong64(lhs) >> 32;
  ulong64 int1Lo = ulong64(lhs & 0xFFFFFFFF);
 
  if (rhs < 0) rhs = -rhs;
  ulong64 int2Hi = ulong64(rhs) >> 32;
  ulong64 int2Lo = ulong64(rhs & 0xFFFFFFFF);
 
  //nb: see comments in clipper.pas
  ulong64 a = int1Hi * int2Hi;
  ulong64 b = int1Lo * int2Lo;
  ulong64 c = int1Hi * int2Lo + int1Lo * int2Hi;
 
  Int128 tmp;
  tmp.hi = long64(a + (c >> 32));
  tmp.lo = long64(c << 32);
  tmp.lo += long64(b);
  if (tmp.lo < b) tmp.hi++;
  if (negate) tmp = -tmp;
  return tmp;
};

IntersectListSort()

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

Definition at line 2917 of file clipper.cpp.

{
  return node2->Pt.Y < node1->Pt.Y;
}

IntersectPoint()

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

Definition at line 622 of file clipper.cpp.

{
#ifdef 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);
    return;
  }
  else if (Edge1.Dx == 0)
  {
    ip.X = Edge1.Bot.X;
    if (IsHorizontal(Edge2))
      ip.Y = Edge2.Bot.Y;
    else
    {
      b2 = Edge2.Bot.Y - (Edge2.Bot.X / Edge2.Dx);
      ip.Y = Round(ip.X / Edge2.Dx + b2);
    }
  }
  else if (Edge2.Dx == 0)
  {
    ip.X = Edge2.Bot.X;
    if (IsHorizontal(Edge1))
      ip.Y = Edge1.Bot.Y;
    else
    {
      b1 = Edge1.Bot.Y - (Edge1.Bot.X / Edge1.Dx);
      ip.Y = Round(ip.X / Edge1.Dx + b1);
    }
  } 
  else 
  {
    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);
  }
}

IsHorizontal()

bool ClipperLib::IsHorizontal ( TEdge &  e )

inline

Definition at line 578 of file clipper.cpp.

{
  return e.Dx == HORIZONTAL;
}

IsIntermediate()

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

inline

Definition at line 2532 of file clipper.cpp.

{
  return e->Top.Y == Y && e->NextInLML;
}

IsMaxima()

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

inline

Definition at line 2526 of file clipper.cpp.

{
  return e && e->Top.Y == Y && !e->NextInLML;
}

IsMinima()

bool ClipperLib::IsMinima ( TEdge *  e )

inline

Definition at line 2520 of file clipper.cpp.

{
  return e  && (e->Prev->NextInLML != e) && (e->Next->NextInLML != e);
}

JoinHorz()

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

Definition at line 3364 of file clipper.cpp.

{
  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
  //want Op1b to be on the Right. (And likewise with Op2 and Op2b.)
  //So, to facilitate this while inserting Op1b and Op2b ...
  //when DiscardLeft, make sure we're AT or RIGHT of Pt before adding Op1b,
  //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)  
        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)
    {
      op1 = op1b;
      op1->Pt = Pt;
      op1b = DupOutPt(op1, DiscardLeft);
    }
  }
 
  if (Dir2 == dLeftToRight)
  {
    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;
}

Minkowski()

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

Definition at line 4463 of file clipper.cpp.

{
  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)
        p.push_back(IntPoint(path[i].X + poly[j].X, path[i].Y + poly[j].Y));
      pp.push_back(p);
    }
  else
    for (size_t i = 0; i < pathCnt; ++i)
    {
      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));
      pp.push_back(p);
    }
 
  solution.clear();
  solution.reserve((pathCnt + delta) * (polyCnt + 1));
  for (size_t i = 0; i < pathCnt - 1 + delta; ++i)
    for (size_t j = 0; j < polyCnt; ++j)
    {
      Path quad;
      quad.reserve(4);
      quad.push_back(pp[i % pathCnt][j % polyCnt]);
      quad.push_back(pp[(i + 1) % pathCnt][j % polyCnt]);
      quad.push_back(pp[(i + 1) % pathCnt][(j + 1) % polyCnt]);
      quad.push_back(pp[i % pathCnt][(j + 1) % polyCnt]);
      if (!Orientation(quad)) ReversePath(quad);
      solution.push_back(quad);
    }
}

MinkowskiDiff()

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

Definition at line 4544 of file clipper.cpp.

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

MinkowskiSum() [1/2]

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

Definition at line 4507 of file clipper.cpp.

{
  Minkowski(pattern, path, solution, true, pathIsClosed);
  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 4525 of file clipper.cpp.

{
  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);
}

OpenPathsFromPolyTree()

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

Definition at line 4584 of file clipper.cpp.

{
  paths.resize(0); 
  paths.reserve(polytree.Total());
  //Open paths are top level only, so ...
  for (int i = 0; i < polytree.ChildCount(); ++i)
    if (polytree.Childs[i]->IsOpen())
      paths.push_back(polytree.Childs[i]->Contour);
}

operator<<() [1/5]

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

inline

Definition at line 109 of file clipper.hpp.

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

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

operator<<() [3/5]

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

Definition at line 4595 of file clipper.cpp.

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

operator<<() [4/5]

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

Definition at line 4602 of file clipper.cpp.

{
  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";
  return s;
}

operator<<() [5/5]

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

Definition at line 4613 of file clipper.cpp.

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

Orientation()

bool ClipperLib::Orientation

(

const Path &

poly

)

Definition at line 385 of file clipper.cpp.

{
    return Area(poly) >= 0;
}

OutRec1RightOfOutRec2()

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

Definition at line 2347 of file clipper.cpp.

{
  do
  {
    outRec1 = outRec1->FirstLeft;
    if (outRec1 == outRec2) return true;
  } while (outRec1);
  return false;
}

ParseFirstLeft()

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

static

Definition at line 3610 of file clipper.cpp.

{
  while (FirstLeft && !FirstLeft->Pts)
    FirstLeft = FirstLeft->FirstLeft;
  return FirstLeft;
}

PointCount()

int ClipperLib::PointCount

(

OutPt *

Pts

)

Definition at line 3177 of file clipper.cpp.

{
    if (!Pts) return 0;
    int result = 0;
    OutPt* p = Pts;
    do
    {
        result++;
        p = p->Next;
    }
    while (p != Pts);
    return result;
}

PointInPolygon() [1/2]

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

Definition at line 440 of file clipper.cpp.

{
  //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
  int result = 0;
  size_t cnt = path.size();
  if (cnt < 3) return 0;
  IntPoint ip = path[0];
  for(size_t i = 1; i <= cnt; ++i)
  {
    IntPoint ipNext = (i == cnt ? path[0] : path[i]);
    if (ipNext.Y == pt.Y)
    {
        if ((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.X >= pt.X)
      {
        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);
          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) - 
            (double)(ipNext.X - pt.X) * (ip.Y - pt.Y);
          if (!d) return -1;
          if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result;
        }
      }
    }
    ip = ipNext;
  } 
  return result;
}

PointInPolygon() [2/2]

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

Definition at line 484 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;
        }
      }
    } 
    op = op->Next;
    if (startOp == op) break;
  } 
  return result;
}

PointIsVertex()

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

Definition at line 425 of file clipper.cpp.

{
  OutPt *pp2 = pp;
  do
  {
    if (pp2->Pt == Pt) return true;
    pp2 = pp2->Next;
  }
  while (pp2 != pp);
  return false;
}

PointsAreClose()

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

Definition at line 4365 of file clipper.cpp.

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

Poly2ContainsPoly1()

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

Definition at line 526 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; 
}

PolyTreeToPaths()

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

Definition at line 4568 of file clipper.cpp.

{
  paths.resize(0); 
  paths.reserve(polytree.Total());
  AddPolyNodeToPaths(polytree, ntAny, paths);
}

Pt2IsBetweenPt1AndPt3()

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

Definition at line 860 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);
}

RangeTest()

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

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(Pt, useFullRange);
  }
}

RemoveEdge()

TEdge * ClipperLib::RemoveEdge

(

TEdge *

e

)

Definition at line 745 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;
}

ReverseHorizontal()

void ClipperLib::ReverseHorizontal ( TEdge &  e )

inline

Definition at line 756 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  
  std::swap(e.Top.Z, e.Bot.Z);
#endif
}

ReversePath()

void ClipperLib::ReversePath

(

Path &

p

)

Definition at line 4276 of file clipper.cpp.

{
  std::reverse(p.begin(), p.end());
}

ReversePaths()

void ClipperLib::ReversePaths

(

Paths &

p

)

Definition at line 4282 of file clipper.cpp.

{
  for (Paths::size_type i = 0; i < p.size(); ++i)
    ReversePath(p[i]);
}

ReversePolyPtLinks()

void ClipperLib::ReversePolyPtLinks

(

OutPt *

pp

)

Definition at line 692 of file clipper.cpp.

{
  if (!pp) return;
  OutPt *pp1, *pp2;
  pp1 = pp;
  do {
  pp2 = pp1->Next;
  pp1->Next = pp1->Prev;
  pp1->Prev = pp2;
  pp1 = pp2;
  } while( pp1 != pp );
}

Round()

cInt ClipperLib::Round ( double  val )

inline

Definition at line 136 of file clipper.cpp.

{
  if ((val < 0)) return static_cast<cInt>(val - 0.5); 
  else return static_cast<cInt>(val + 0.5);
}

SetDx()

void ClipperLib::SetDx ( TEdge &  e )

inline

Definition at line 591 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;
}

SimplifyPolygon()

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

Definition at line 4289 of file clipper.cpp.

{
  Clipper c;
  c.StrictlySimple(true);
  c.AddPath(in_poly, ptSubject, true);
  c.Execute(ctUnion, out_polys, fillType, fillType);
}

SimplifyPolygons() [1/2]

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

Definition at line 4298 of file clipper.cpp.

{
  Clipper c;
  c.StrictlySimple(true);
  c.AddPaths(in_polys, ptSubject, true);
  c.Execute(ctUnion, out_polys, fillType, fillType);
}

SimplifyPolygons() [2/2]

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

Definition at line 4307 of file clipper.cpp.

{
  SimplifyPolygons(polys, polys, fillType);
}

SlopesEqual() [1/3]

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

Definition at line 554 of file clipper.cpp.

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

SlopesEqual() [2/3]

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

Definition at line 566 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);
}

SlopesEqual() [3/3]

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

Definition at line 541 of file clipper.cpp.

{
#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);
}

SlopesNearCollinear()

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

Definition at line 4338 of file clipper.cpp.

{
  //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 (Abs(pt1.X - pt2.X) > Abs(pt1.Y - pt2.Y))
    {
    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))
      return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
        else
        return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
    }
    else
    {
    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))
      return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
        else
      return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
    }
}

SwapIntersectNodes()

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

Definition at line 3258 of file clipper.cpp.

{
  //just swap the contents (because fIntersectNodes is a single-linked-list)
  IntersectNode inode = int1; //gets a copy of Int1
  int1.Edge1 = int2.Edge1;
  int1.Edge2 = int2.Edge2;
  int1.Pt = int2.Pt;
  int2.Edge1 = inode.Edge1;
  int2.Edge2 = inode.Edge2;
  int2.Pt = inode.Pt;
}

SwapPoints()

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

Definition at line 768 of file clipper.cpp.

{
  IntPoint tmp = pt1;
  pt1 = pt2;
  pt2 = tmp;
}

SwapPolyIndexes()

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

inline

Definition at line 607 of file clipper.cpp.

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

SwapSides()

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

inline

Definition at line 599 of file clipper.cpp.

{
  EdgeSide Side =  Edge1.Side;
  Edge1.Side = Edge2.Side;
  Edge2.Side = Side;
}

TopX()

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

inline

Definition at line 615 of file clipper.cpp.

{
  return ( currentY == edge.Top.Y ) ?
    edge.Top.X : edge.Bot.X + Round(edge.Dx *(currentY - edge.Bot.Y));
}

TranslatePath()

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

Definition at line 4516 of file clipper.cpp.

{
  //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);
}

UpdateOutPtIdxs()

void ClipperLib::UpdateOutPtIdxs ( OutRec &  outrec )

inline

Definition at line 3300 of file clipper.cpp.

{  
  OutPt* op = outrec.Pts;
  do
  {
    op->Idx = outrec.Idx;
    op = op->Prev;
  }
  while(op != outrec.Pts);
}

Variable Documentation

def_arc_tolerance

double const ClipperLib::def_arc_tolerance = 0.25

static

Definition at line 55 of file clipper.cpp.

hiRange

cInt const ClipperLib::hiRange = 0x3FFFFFFFFFFFFFFFLL

static

Definition at line 79 of file clipper.hpp.

loRange

cInt const ClipperLib::loRange = 0x3FFFFFFF

static

Definition at line 78 of file clipper.hpp.

pi

double const ClipperLib::pi = 3.141592653589793238

static

Definition at line 53 of file clipper.cpp.

Skip

int const ClipperLib::Skip = -2

static

Definition at line 60 of file clipper.cpp.

two_pi

double const ClipperLib::two_pi = pi *2

static

Definition at line 54 of file clipper.cpp.

Unassigned

int const ClipperLib::Unassigned = -1

static

Definition at line 59 of file clipper.cpp.