ClipperLib Namespace Reference

Classes
class	Clipper
class	ClipperBase
class	clipperException
class	ClipperOffset
struct	IntersectNode
struct	IntRect
struct	Join
struct	LocalMinimum
struct	OutPt
struct	OutRec
class	PolyNode
class	PolyTree
struct	TEdge

Typedefs
using	cInt = int32_t
using	CrossProductType = int64_t
using	IntPoint = Eigen::Matrix< cInt, 2, 1, Eigen::DontAlign >
using	DoublePoint = Eigen::Matrix< double, 2, 1, Eigen::DontAlign >
template<typename BaseType >
using	Allocator = tbb::scalable_allocator< BaseType >
using	Path = std::vector< IntPoint, Allocator< IntPoint > >
using	Paths = std::vector< Path, Allocator< Path > >
typedef std::vector< PolyNode *, Allocator< PolyNode * > >	PolyNodes
using	OutPts = std::vector< OutPt, Allocator< OutPt > >

Enumerations
enum	Direction { dRightToLeft , dLeftToRight }
enum	NodeType { ntAny , ntOpen , ntClosed }
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 }

Functions
IntPoint	IntPoint2d (cInt x, cInt y)
cInt	Round (double val)
bool	operator== (const IntPoint &l, const IntPoint &r)
bool	operator!= (const IntPoint &l, const IntPoint &r)
double	Area (const Path &poly)
double	Area (const OutPt *op)
double	Area (const OutRec &outRec)
bool	PointIsVertex (const IntPoint &Pt, OutPt *pp)
int	PointInPolygon (const IntPoint &pt, const Path &path)
int	PointInPolygon (const IntPoint &pt, OutPt *op)
bool	Poly2ContainsPoly1 (OutPt *OutPt1, OutPt *OutPt2)
bool	SlopesEqual (const cInt dx1, const cInt dy1, const cInt dx2, const cInt dy2, bool)
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)
cInt	TopX (TEdge &edge, const cInt currentY)
void	IntersectPoint (TEdge &Edge1, TEdge &Edge2, IntPoint &ip)
void	ReversePolyPtLinks (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)
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)
static void	RangeTest (const IntPoint &pt)
TEdge *	FindNextLocMin (TEdge *E)
OutRec *	GetLowermostRec (OutRec *outRec1, OutRec *outRec2)
bool	Param1RightOfParam2 (OutRec *outRec1, OutRec *outRec2)
bool	IsMaxima (TEdge *e, const cInt Y)
bool	IsIntermediate (TEdge *e, const cInt Y)
TEdge *	GetMaximaPair (TEdge *e)
void	GetHorzDirection (TEdge &HorzEdge, Direction &Dir, cInt &Left, cInt &Right)
bool	EdgesAdjacent (const IntersectNode &inode)
int	PointCount (OutPt *Pts)
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)
DoublePoint	GetUnitNormal (const IntPoint &pt1, const IntPoint &pt2)
void	ReversePath (Path &p)
void	ReversePaths (Paths &p)
Paths	SimplifyPolygon (const Path &in_poly, PolyFillType fillType, bool strictly_simple)
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	CleanPolygon (const Path &in_poly, Path &out_poly, double distance)
void	CleanPolygon (Path &poly, double distance)
void	CleanPolygons (const Paths &in_polys, Paths &out_polys, double distance)
void	CleanPolygons (Paths &polys, double distance)
void	Minkowski (const Path &poly, const Path &path, Paths &solution, bool isSum, bool isClosed)
void	MinkowskiSum (const Path &pattern, const Path &path, Paths &solution, bool pathIsClosed)
void	TranslatePath (const Path &input, Path &output, const IntPoint &delta)
void	MinkowskiSum (const Path &pattern, const Paths &paths, Paths &solution, bool pathIsClosed)
void	MinkowskiDiff (const Path &poly1, const Path &poly2, Paths &solution)
void	AddPolyNodeToPaths (const PolyNode &polynode, NodeType nodetype, Paths &paths)
void	AddPolyNodeToPaths (PolyNode &&polynode, NodeType nodetype, Paths &paths)
void	PolyTreeToPaths (const PolyTree &polytree, Paths &paths)
void	PolyTreeToPaths (PolyTree &&polytree, Paths &paths)
void	ClosedPathsFromPolyTree (const PolyTree &polytree, Paths &paths)
void	OpenPathsFromPolyTree (PolyTree &polytree, Paths &paths)
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)
Path &	operator<< (Path &poly, const IntPoint &p)
Paths &	operator<< (Paths &polys, const Path &p)
bool	Orientation (const Path &poly)
template<typename PathsProvider >
Paths	SimplifyPolygons (PathsProvider &&in_polys, PolyFillType fillType=pftNonZero, bool strictly_simple=true)

Variables
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

---

Class Documentation

ClipperLib::IntRect

struct ClipperLib::IntRect

Class Members
cInt	bottom
cInt	left
cInt	right
cInt	top

ClipperLib::LocalMinimum

struct ClipperLib::LocalMinimum

Collaboration diagram for ClipperLib::LocalMinimum:

Class Members
TEdge *	LeftBound
TEdge *	RightBound
cInt	Y

ClipperLib::OutPt

struct ClipperLib::OutPt

Collaboration diagram for ClipperLib::OutPt:

Class Members
int	Idx
OutPt *	Next
OutPt *	Prev
IntPoint	Pt

ClipperLib::OutRec

struct ClipperLib::OutRec

Collaboration diagram for ClipperLib::OutRec:

Class Members
OutPt *	BottomPt
OutRec *	FirstLeft
int	Idx
bool	IsHole
bool	IsOpen
PolyNode *	PolyNd
OutPt *	Pts

ClipperLib::TEdge

struct ClipperLib::TEdge

Collaboration diagram for ClipperLib::TEdge:

Class Members
IntPoint	Bot
IntPoint	Curr
IntPoint	Delta
double	Dx
TEdge *	Next
TEdge *	NextInAEL
TEdge *	NextInLML
TEdge *	NextInSEL
int	OutIdx
PolyType	PolyTyp
TEdge *	Prev
TEdge *	PrevInAEL
TEdge *	PrevInSEL
EdgeSide	Side
IntPoint	Top
int	WindCnt
int	WindCnt2
int	WindDelta

Typedef Documentation

Allocator

template<typename BaseType >

using ClipperLib::Allocator = typedef tbb::scalable_allocator<BaseType>

cInt

using ClipperLib::cInt = typedef int32_t

CrossProductType

using ClipperLib::CrossProductType = typedef int64_t

DoublePoint

using ClipperLib::DoublePoint = typedef Eigen::Matrix<double, 2, 1, Eigen::DontAlign>

IntPoint

using ClipperLib::IntPoint = typedef Eigen::Matrix<cInt, 2 , 1, Eigen::DontAlign>

OutPts

using ClipperLib::OutPts = typedef std::vector<OutPt, Allocator<OutPt> >

Path

using ClipperLib::Path = typedef std::vector<IntPoint, Allocator<IntPoint> >

Paths

using ClipperLib::Paths = typedef std::vector<Path, Allocator<Path> >

PolyNodes

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

Enumeration Type Documentation

ClipType

enum ClipperLib::ClipType

Enumerator
ctIntersection
ctUnion
ctDifference
ctXor

{ ctIntersection, ctUnion, ctDifference, ctXor };

Direction

enum ClipperLib::Direction

Enumerator
dRightToLeft
dLeftToRight

{ dRightToLeft, dLeftToRight };

EdgeSide

enum ClipperLib::EdgeSide

Enumerator
esLeft
esRight

{ esLeft = 1, esRight = 2};

EndType

enum ClipperLib::EndType

Enumerator
etClosedPolygon
etClosedLine
etOpenButt
etOpenSquare
etOpenRound

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

InitOptions

enum ClipperLib::InitOptions

Enumerator
ioReverseSolution
ioStrictlySimple
ioPreserveCollinear

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

JoinType

enum ClipperLib::JoinType

Enumerator
jtSquare
jtRound
jtMiter

{jtSquare, jtRound, jtMiter};

NodeType

enum ClipperLib::NodeType

Enumerator
ntAny
ntOpen
ntClosed

{ntAny, ntOpen, ntClosed};

PolyFillType

enum ClipperLib::PolyFillType

Enumerator
pftEvenOdd
pftNonZero
pftPositive
pftNegative

{ pftEvenOdd, pftNonZero, pftPositive, pftNegative };

PolyType

enum ClipperLib::PolyType

Enumerator
ptSubject
ptClip

{ ptSubject, ptClip };

Function Documentation

AddPolyNodeToPaths() [1/2]

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

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

References AddPolyNodeToPaths(), ClipperLib::PolyNode::ChildCount(), ClipperLib::PolyNode::Childs, ClipperLib::PolyNode::Contour, ClipperLib::PolyNode::IsOpen(), ntClosed, and ntOpen.

Referenced by AddPolyNodeToPaths(), AddPolyNodeToPaths(), ClosedPathsFromPolyTree(), PolyTreeToPaths(), and PolyTreeToPaths().

Here is the call graph for this function:

Here is the caller graph for this function:

AddPolyNodeToPaths() [2/2]

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

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

References AddPolyNodeToPaths(), ntClosed, and ntOpen.

Here is the call graph for this function:

Area() [1/3]

double ClipperLib::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);
  return a * 0.5;
}

References Area(), ClipperLib::OutPt::Next, ClipperLib::OutPt::Prev, and ClipperLib::OutPt::Pt.

Here is the call graph for this function:

Area() [2/3]

double ClipperLib::Area

(

const OutRec &

outRec

)

{
  return Area(outRec.Pts);
}

References Area(), and ClipperLib::OutRec::Pts.

Here is the call graph for this function:

Area() [3/3]

double ClipperLib::Area

(

const Path &

poly

)

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

References Area().

Referenced by Area(), Area(), Area(), ClipperLib::Clipper::ExecuteInternal(), Slic3r::expolygons_to_zpaths_shrunk(), FirstIsBottomPt(), ClipperLib::Clipper::JoinCommonEdges(), Orientation(), Slic3r::Arachne::removeSmallAreas(), Slic3r::simplify_polygon_impl(), Slic3r::variable_offset_inner_raw(), Slic3r::variable_offset_outer_ex(), and Slic3r::variable_offset_outer_raw().

Here is the call graph for this function:

Here is the caller graph for this function:

CleanPolygon() [1/2]

void ClipperLib::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;
  }
 
  OutPts outPts(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;
  }
}

References ExcludeOp(), ClipperLib::OutPt::Idx, ClipperLib::OutPt::Next, PointsAreClose(), ClipperLib::OutPt::Prev, ClipperLib::OutPt::Pt, and SlopesNearCollinear().

Referenced by CleanPolygon(), and CleanPolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

CleanPolygon() [2/2]

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

{
  CleanPolygon(poly, poly, distance);
}

References CleanPolygon().

Here is the call graph for this function:

CleanPolygons() [1/2]

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

{
  for (Paths::size_type i = 0; i < in_polys.size(); ++i)
    CleanPolygon(in_polys[i], out_polys[i], distance);
}

References CleanPolygon().

Referenced by CleanPolygons(), and Slic3r::Emboss::heal_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

CleanPolygons() [2/2]

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

{
  CleanPolygons(polys, polys, distance);
}

References CleanPolygons().

Here is the call graph for this function:

ClosedPathsFromPolyTree()

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

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

References AddPolyNodeToPaths(), ntClosed, and ClipperLib::PolyTree::Total().

Here is the call graph for this function:

DistanceFromLineSqrd()

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

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

Referenced by SlopesNearCollinear().

Here is the caller graph for this function:

DistanceSqrd()

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

inline

{
  auto Dx = double(pt1.x() - pt2.x());
  auto dy = double(pt1.y() - pt2.y());
  return (Dx*Dx + dy*dy);
}

E2InsertsBeforeE1()

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

inline

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

References ClipperLib::TEdge::Curr, ClipperLib::TEdge::Top, and TopX().

Referenced by ClipperLib::Clipper::InsertEdgeIntoAEL().

Here is the call graph for this function:

Here is the caller graph for this function:

EdgesAdjacent()

bool ClipperLib::EdgesAdjacent ( const IntersectNode &  inode )

inline

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

References ClipperLib::IntersectNode::Edge1, ClipperLib::IntersectNode::Edge2, ClipperLib::TEdge::NextInSEL, and ClipperLib::TEdge::PrevInSEL.

Referenced by ClipperLib::Clipper::FixupIntersectionOrder().

Here is the caller graph for this function:

ExcludeOp()

OutPt * ClipperLib::ExcludeOp

(

OutPt *

op

)

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

References ClipperLib::OutPt::Idx, ClipperLib::OutPt::Next, and ClipperLib::OutPt::Prev.

Referenced by CleanPolygon().

Here is the caller graph for this function:

FindNextLocMin()

TEdge * ClipperLib::FindNextLocMin ( TEdge *  E )

inline

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

References ClipperLib::TEdge::Bot, FindNextLocMin(), IsHorizontal(), and ClipperLib::TEdge::Prev.

Referenced by ClipperLib::ClipperBase::AddPathInternal(), and FindNextLocMin().

Here is the call graph for this function:

Here is the caller graph for this function:

FirstIsBottomPt()

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

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

References Area(), FirstIsBottomPt(), GetDx(), ClipperLib::OutPt::Next, ClipperLib::OutPt::Prev, and ClipperLib::OutPt::Pt.

Referenced by FirstIsBottomPt(), GetBottomPt(), and GetLowermostRec().

Here is the call graph for this function:

Here is the caller graph for this function:

GetBottomPt()

OutPt * ClipperLib::GetBottomPt

(

OutPt *

pp

)

{
  OutPt* dups = nullptr;
  OutPt* p = pp->Next;
  while (p != pp)
  {
    if (p->Pt.y() > pp->Pt.y())
    {
      pp = p;
      dups = nullptr;
    }
    else if (p->Pt.y() == pp->Pt.y() && p->Pt.x() <= pp->Pt.x())
    {
      if (p->Pt.x() < pp->Pt.x())
      {
        dups = nullptr;
        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;
}

References FirstIsBottomPt(), GetBottomPt(), ClipperLib::OutPt::Next, ClipperLib::OutPt::Prev, and ClipperLib::OutPt::Pt.

Referenced by GetBottomPt(), and GetLowermostRec().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDx()

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

inline

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

References GetDx(), and HORIZONTAL.

Referenced by FirstIsBottomPt(), and GetDx().

Here is the call graph for this function:

Here is the caller graph for this function:

GetHorzDirection()

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

inline

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

References ClipperLib::TEdge::Bot, dLeftToRight, dRightToLeft, and ClipperLib::TEdge::Top.

Referenced by ClipperLib::Clipper::ProcessHorizontal().

Here is the caller graph for this function:

GetLowermostRec()

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

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

References ClipperLib::OutRec::BottomPt, FirstIsBottomPt(), GetBottomPt(), ClipperLib::OutPt::Next, ClipperLib::OutPt::Pt, and ClipperLib::OutRec::Pts.

Referenced by ClipperLib::Clipper::AppendPolygon(), and ClipperLib::Clipper::JoinCommonEdges().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMaximaPair()

TEdge * ClipperLib::GetMaximaPair ( TEdge *  e )

inline

{
  TEdge* result = 0;
  if ((e->Next->Top == e->Top) && !e->Next->NextInLML)
    result = e->Next;
  else if ((e->Prev->Top == e->Top) && !e->Prev->NextInLML)
    result = e->Prev;
 
  if (result && (result->OutIdx == Skip ||
    //result is false if both NextInAEL & PrevInAEL are nil & not horizontal ...
    (result->NextInAEL == result->PrevInAEL && !IsHorizontal(*result))))
      return 0;
  return result;
}

References IsHorizontal(), ClipperLib::TEdge::Next, ClipperLib::TEdge::NextInAEL, ClipperLib::TEdge::NextInLML, ClipperLib::TEdge::OutIdx, ClipperLib::TEdge::Prev, ClipperLib::TEdge::PrevInAEL, Skip, and ClipperLib::TEdge::Top.

Referenced by ClipperLib::Clipper::DoMaxima(), ClipperLib::Clipper::ProcessEdgesAtTopOfScanbeam(), and ClipperLib::Clipper::ProcessHorizontal().

Here is the call graph for this function:

Here is the caller graph for this function:

GetOverlap()

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

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

Referenced by ClipperLib::Clipper::JoinPoints().

Here is the caller graph for this function:

GetOverlapSegment()

bool ClipperLib::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 (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();
  }
}

References GetOverlapSegment().

Referenced by GetOverlapSegment().

Here is the call graph for this function:

Here is the caller graph for this function:

GetUnitNormal()

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

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

Referenced by ClipperLib::ClipperOffset::DoOffset().

Here is the caller graph for this function:

HorzSegmentsOverlap()

bool ClipperLib::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);
}

References HorzSegmentsOverlap().

Referenced by HorzSegmentsOverlap(), ClipperLib::Clipper::InsertLocalMinimaIntoAEL(), and ClipperLib::Clipper::ProcessHorizontal().

Here is the call graph for this function:

Here is the caller graph for this function:

InitEdge()

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

inline

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

References ClipperLib::TEdge::Curr, InitEdge(), ClipperLib::TEdge::Next, ClipperLib::TEdge::OutIdx, ClipperLib::TEdge::Prev, and Unassigned.

Referenced by ClipperLib::ClipperBase::AddPathInternal(), and InitEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

InitEdge2()

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

{
  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;
  }
 
  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();
 
  e.PolyTyp = Pt;
}

References ClipperLib::TEdge::Bot, ClipperLib::TEdge::Curr, ClipperLib::TEdge::Delta, ClipperLib::TEdge::Dx, HORIZONTAL, InitEdge2(), ClipperLib::TEdge::Next, ClipperLib::TEdge::PolyTyp, and ClipperLib::TEdge::Top.

Referenced by ClipperLib::ClipperBase::AddPathInternal(), and InitEdge2().

Here is the call graph for this function:

Here is the caller graph for this function:

IntersectPoint()

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

{
#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());
    return;
  }
  else if (Edge1.Delta.x() == 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.Delta.x() == 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 = 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)) ? 
      Round(Edge1.Dx * q + b1) :
      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());
  }
}

References ClipperLib::TEdge::Bot, ClipperLib::TEdge::Curr, ClipperLib::TEdge::Delta, ClipperLib::TEdge::Dx, IntersectPoint(), IsHorizontal(), Round(), ClipperLib::TEdge::Top, and TopX().

Referenced by ClipperLib::Clipper::BuildIntersectList(), and IntersectPoint().

Here is the call graph for this function:

Here is the caller graph for this function:

IntPoint2d()

IntPoint ClipperLib::IntPoint2d ( cInt  x, cInt  y  )

inline

{
  return IntPoint(x, y
#ifdef CLIPPERLIB_USE_XYZ
    , 0
#endif // CLIPPERLIB_USE_XYZ
    );
}

References CLIPPERLIB_USE_XYZ, and IntPoint2d().

Referenced by ClipperLib::ClipperOffset::AddPath(), ClipperLib::ClipperOffset::DoMiter(), ClipperLib::ClipperOffset::DoOffset(), ClipperLib::ClipperOffset::DoRound(), ClipperLib::ClipperOffset::DoSquare(), ClipperLib::ClipperOffset::Execute(), ClipperLib::ClipperOffset::Execute(), IntPoint2d(), Minkowski(), ClipperLib::ClipperOffset::OffsetPoint(), ClipperLib::Clipper::ProcessHorizontal(), and TranslatePath().

Here is the call graph for this function:

Here is the caller graph for this function:

IsHorizontal()

bool ClipperLib::IsHorizontal ( TEdge &  e )

inline

{
  return e.Delta.y() == 0;
}

References ClipperLib::TEdge::Delta, and IsHorizontal().

Referenced by ClipperLib::Clipper::AddLocalMinPoly(), FindNextLocMin(), GetMaximaPair(), ClipperLib::Clipper::InsertLocalMinimaIntoAEL(), IntersectPoint(), IsHorizontal(), ClipperLib::ClipperBase::ProcessBound(), ClipperLib::Clipper::ProcessEdgesAtTopOfScanbeam(), ClipperLib::Clipper::ProcessHorizontal(), and ClipperLib::Clipper::UpdateEdgeIntoAEL().

Here is the call graph for this function:

Here is the caller graph for this function:

IsIntermediate()

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

inline

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

References ClipperLib::TEdge::NextInLML, and ClipperLib::TEdge::Top.

Referenced by ClipperLib::Clipper::ProcessEdgesAtTopOfScanbeam().

Here is the caller graph for this function:

IsMaxima()

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

inline

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

References ClipperLib::TEdge::NextInLML, and ClipperLib::TEdge::Top.

Referenced by ClipperLib::Clipper::ProcessEdgesAtTopOfScanbeam().

Here is the caller graph for this function:

Minkowski()

void ClipperLib::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)
        p.emplace_back(IntPoint2d(path[i].x() + poly[j].x(), path[i].y() + poly[j].y()));
      pp.emplace_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.emplace_back(IntPoint2d(path[i].x() - poly[j].x(), path[i].y() - poly[j].y()));
      pp.emplace_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.emplace_back(pp[i % pathCnt][j % polyCnt]);
      quad.emplace_back(pp[(i + 1) % pathCnt][j % polyCnt]);
      quad.emplace_back(pp[(i + 1) % pathCnt][(j + 1) % polyCnt]);
      quad.emplace_back(pp[i % pathCnt][(j + 1) % polyCnt]);
      if (!Orientation(quad)) ReversePath(quad);
      solution.emplace_back(quad);
    }
}

References IntPoint2d(), and ReversePath().

Referenced by MinkowskiDiff(), MinkowskiSum(), and MinkowskiSum().

Here is the call graph for this function:

Here is the caller graph for this function:

MinkowskiDiff()

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

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

References ctUnion, Minkowski(), pftNonZero, and ptSubject.

Here is the call graph for this function:

MinkowskiSum() [1/2]

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

{
  Minkowski(pattern, path, solution, true, pathIsClosed);
  Clipper c;
  c.AddPaths(solution, ptSubject, true);
  c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
}

References ctUnion, Minkowski(), pftNonZero, and ptSubject.

Here is the call graph for this function:

MinkowskiSum() [2/2]

void ClipperLib::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);
}

References ctUnion, Minkowski(), pftNonZero, ptClip, ptSubject, and TranslatePath().

Here is the call graph for this function:

OpenPathsFromPolyTree()

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

{
  paths.clear();
  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.emplace_back(polytree.Childs[i]->Contour);
}

References ClipperLib::PolyNode::ChildCount(), ClipperLib::PolyNode::Childs, and ClipperLib::PolyTree::Total().

Here is the call graph for this function:

operator!=()

bool ClipperLib::operator!= ( const IntPoint &  l, const IntPoint &  r  )

inline

{ return l.x() != r.x() || l.y() != r.y(); }

References operator!=().

Referenced by operator!=().

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [1/5]

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

inline

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

operator<<() [2/5]

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

inline

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

operator<<() [3/5]

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

{
  s << "(" << p.x() << "," << p.y() << ")";
  return s;
}

operator<<() [4/5]

std::ostream & ClipperLib::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";
  return s;
}

operator<<() [5/5]

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

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

operator==()

bool ClipperLib::operator== ( const IntPoint &  l, const IntPoint &  r  )

inline

{ return l.x() == r.x() && l.y() == r.y(); }

References operator==().

Referenced by operator==().

Here is the call graph for this function:

Here is the caller graph for this function:

Orientation()

bool ClipperLib::Orientation ( const Path &  poly )

inline

{ return Area(poly) >= 0; }

References Area().

Referenced by Slic3r::Polygon::is_counter_clockwise(), Slic3r::raw_offset(), and Slic3r::Algorithm::wavefront_step().

Here is the call graph for this function:

Here is the caller graph for this function:

Param1RightOfParam2()

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

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

References ClipperLib::OutRec::FirstLeft.

Referenced by ClipperLib::Clipper::AppendPolygon(), and ClipperLib::Clipper::JoinCommonEdges().

Here is the caller graph for this function:

PointCount()

int ClipperLib::PointCount

(

OutPt *

Pts

)

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

References ClipperLib::OutPt::Next.

Referenced by ClipperLib::Clipper::BuildResult(), and ClipperLib::Clipper::BuildResult2().

Here is the caller graph for this function:

PointInPolygon() [1/2]

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

{
  //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() && ((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
        {
          auto d = CrossProductType(ip.x() - pt.x()) * CrossProductType(ipNext.y() - pt.y()) - CrossProductType(ipNext.x() - pt.x()) * CrossProductType(ip.y() - pt.y());
          if (!d) return -1;
          if ((d > 0) == (ipNext.y() > ip.y())) result = 1 - result;
        }
      } else
      {
        if (ipNext.x() > pt.x())
        {
          auto d = CrossProductType(ip.x() - pt.x()) * CrossProductType(ipNext.y() - pt.y()) - CrossProductType(ipNext.x() - pt.x()) * CrossProductType(ip.y() - pt.y());
          if (!d) return -1;
          if ((d > 0) == (ipNext.y() > ip.y())) result = 1 - result;
        }
      }
    }
    ip = ipNext;
  } 
  return result;
}

References PointInPolygon().

Referenced by Slic3r::contains(), Slic3r::contains(), PointInPolygon(), PointInPolygon(), and Poly2ContainsPoly1().

Here is the call graph for this function:

Here is the caller graph for this function:

PointInPolygon() [2/2]

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

{
  //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
  int result = 0;
  OutPt* startOp = op;
  do
  {
    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
        {
          auto d = CrossProductType(op->Pt.x() - pt.x()) * CrossProductType(op->Next->Pt.y() - pt.y()) - CrossProductType(op->Next->Pt.x() - pt.x()) * CrossProductType(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())
        {
          auto d = CrossProductType(op->Pt.x() - pt.x()) * CrossProductType(op->Next->Pt.y() - pt.y()) - CrossProductType(op->Next->Pt.x() - pt.x()) * CrossProductType(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;
  } while (startOp != op);
  return result;
}

References ClipperLib::OutPt::Next, PointInPolygon(), and ClipperLib::OutPt::Pt.

Here is the call graph for this function:

PointIsVertex()

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

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

References ClipperLib::OutPt::Next, PointIsVertex(), and ClipperLib::OutPt::Pt.

Referenced by PointIsVertex().

Here is the call graph for this function:

Here is the caller graph for this function:

PointsAreClose()

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

{
    auto Dx = double(pt1.x() - pt2.x());
    auto dy = double(pt1.y() - pt2.y());
    return ((Dx * Dx) + (dy * dy) <= distSqrd);
}

Referenced by CleanPolygon().

Here is the caller graph for this function:

Poly2ContainsPoly1()

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

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

References ClipperLib::OutPt::Next, PointInPolygon(), Poly2ContainsPoly1(), and ClipperLib::OutPt::Pt.

Referenced by ClipperLib::Clipper::DoSimplePolygons(), ClipperLib::Clipper::FixupFirstLefts1(), ClipperLib::Clipper::JoinCommonEdges(), and Poly2ContainsPoly1().

Here is the call graph for this function:

Here is the caller graph for this function:

PolyTreeToPaths() [1/2]

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

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

References AddPolyNodeToPaths(), ntAny, and ClipperLib::PolyTree::Total().

Here is the call graph for this function:

PolyTreeToPaths() [2/2]

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

{
  paths.clear();
  paths.reserve(polytree.Total());
  AddPolyNodeToPaths(std::move(polytree), ntAny, paths);
}

References AddPolyNodeToPaths(), and ntAny.

Here is the call graph for this function:

Pt2IsBetweenPt1AndPt3()

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

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

References Pt2IsBetweenPt1AndPt3().

Referenced by ClipperLib::ClipperBase::AddPathInternal(), ClipperLib::Clipper::FixupOutPolygon(), and Pt2IsBetweenPt1AndPt3().

Here is the call graph for this function:

Here is the caller graph for this function:

RangeTest()

static void ClipperLib::RangeTest ( const IntPoint &  pt )

inlinestatic

{
#ifndef NDEBUG
    static constexpr const int32_t hi = 65536 * 16383;
    if (pt.x() > hi || pt.y() > hi || -pt.x() > hi || -pt.y() > hi) 
      throw clipperException("Coordinate outside allowed range");
#endif // NDEBUG
}

References RangeTest().

Referenced by ClipperLib::ClipperBase::AddPathInternal(), and RangeTest().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveEdge()

TEdge * ClipperLib::RemoveEdge ( TEdge *  e )

inline

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

References ClipperLib::TEdge::Next, ClipperLib::TEdge::Prev, and RemoveEdge().

Referenced by ClipperLib::ClipperBase::AddPathInternal(), and RemoveEdge().

Here is the call graph for this function:

Here is the caller graph for this function:

ReverseHorizontal()

void ClipperLib::ReverseHorizontal ( TEdge &  e )

inline

{
  //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 CLIPPERLIB_USE_XYZ  
  std::swap(e.Top.z(), e.Bot.z());
#endif
}

References ClipperLib::TEdge::Bot, ReverseHorizontal(), and ClipperLib::TEdge::Top.

Referenced by ClipperLib::ClipperBase::AddPathInternal(), ClipperLib::ClipperBase::ProcessBound(), and ReverseHorizontal().

Here is the call graph for this function:

Here is the caller graph for this function:

ReversePath()

void ClipperLib::ReversePath

(

Path &

p

)

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

Referenced by ClipperLib::ClipperOffset::FixOrientations(), Minkowski(), and ReversePaths().

Here is the caller graph for this function:

ReversePaths()

void ClipperLib::ReversePaths

(

Paths &

p

)

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

References ReversePath().

Here is the call graph for this function:

ReversePolyPtLinks()

void ClipperLib::ReversePolyPtLinks

(

OutPt *

pp

)

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

References ClipperLib::OutPt::Next, ClipperLib::OutPt::Prev, and ReversePolyPtLinks().

Referenced by ClipperLib::Clipper::AppendPolygon(), ClipperLib::Clipper::ExecuteInternal(), ClipperLib::Clipper::JoinCommonEdges(), and ReversePolyPtLinks().

Here is the call graph for this function:

Here is the caller graph for this function:

Round()

cInt ClipperLib::Round ( double  val )

inline

{
  return static_cast<cInt>((val < 0) ? (val - 0.5) : (val + 0.5));
}

References Round().

Referenced by ClipperLib::ClipperOffset::DoMiter(), ClipperLib::ClipperOffset::DoOffset(), ClipperLib::ClipperOffset::DoRound(), ClipperLib::ClipperOffset::DoSquare(), IntersectPoint(), ClipperLib::ClipperOffset::OffsetPoint(), Round(), and TopX().

Here is the call graph for this function:

Here is the caller graph for this function:

SimplifyPolygon()

Paths ClipperLib::SimplifyPolygon	(	const Path &	in_poly,
		PolyFillType	fillType,
		bool	strictly_simple
	)

{
  Clipper c;
  c.StrictlySimple(strictly_simple);
  c.AddPath(in_poly, ptSubject, true);
  Paths out; 
  c.Execute(ctUnion, out, fillType, fillType);
  return out;
}

References ctUnion, and ptSubject.

SimplifyPolygons()

template<typename PathsProvider >

Paths ClipperLib::SimplifyPolygons ( PathsProvider &&  in_polys, PolyFillType  fillType = pftNonZero, bool  strictly_simple = true  )

inline

                                                                                                                         {
    Clipper c;
    c.StrictlySimple(strictly_simple);
    c.AddPaths(std::forward<PathsProvider>(in_polys), ptSubject, true);
    Paths out;
    c.Execute(ctUnion, out, fillType, fillType);
    return out;
}

References ctUnion, ptSubject, and SimplifyPolygons().

Referenced by Slic3r::Arachne::fixSelfIntersections(), Slic3r::Emboss::heal_shape(), Slic3r::simplify_polygon_impl(), and SimplifyPolygons().

Here is the call graph for this function:

Here is the caller graph for this function:

SlopesEqual() [1/4]

bool ClipperLib::SlopesEqual ( const cInt  dx1, const cInt  dy1, const cInt  dx2, const cInt  dy2, bool    )

inline

                                                                                                {
  return int64_t(dy1) * int64_t(dx2) == int64_t(dx1) * int64_t(dy2);
}

References SlopesEqual().

Referenced by ClipperLib::Clipper::AddLocalMinPoly(), ClipperLib::ClipperBase::AddPathInternal(), ClipperLib::Clipper::FixupOutPolygon(), ClipperLib::Clipper::InsertLocalMinimaIntoAEL(), ClipperLib::Clipper::JoinPoints(), ClipperLib::Clipper::ProcessEdgesAtTopOfScanbeam(), ClipperLib::Clipper::ProcessHorizontal(), SlopesEqual(), SlopesEqual(), SlopesEqual(), and SlopesEqual().

Here is the call graph for this function:

Here is the caller graph for this function:

SlopesEqual() [2/4]

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

inline

  { return SlopesEqual(pt1.x()-pt2.x(), pt1.y()-pt2.y(), pt2.x()-pt3.x(), pt2.y()-pt3.y(), UseFullInt64Range); }

References SlopesEqual().

Here is the call graph for this function:

SlopesEqual() [3/4]

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

inline

  { return SlopesEqual(pt1.x()-pt2.x(), pt1.y()-pt2.y(), pt3.x()-pt4.x(), pt3.y()-pt4.y(), UseFullInt64Range); }

References SlopesEqual().

Here is the call graph for this function:

SlopesEqual() [4/4]

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

inline

  { return SlopesEqual(e1.Delta.x(), e1.Delta.y(), e2.Delta.x(), e2.Delta.y(), UseFullInt64Range); }

References ClipperLib::TEdge::Delta, and SlopesEqual().

Here is the call graph for this function:

SlopesNearCollinear()

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

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

References DistanceFromLineSqrd().

Referenced by CleanPolygon().

Here is the call graph for this function:

Here is the caller graph for this function:

TopX()

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

inline

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

References ClipperLib::TEdge::Bot, ClipperLib::TEdge::Dx, Round(), ClipperLib::TEdge::Top, and TopX().

Referenced by ClipperLib::Clipper::AddLocalMinPoly(), ClipperLib::Clipper::BuildIntersectList(), E2InsertsBeforeE1(), IntersectPoint(), ClipperLib::Clipper::ProcessEdgesAtTopOfScanbeam(), and TopX().

Here is the call graph for this function:

Here is the caller graph for this function:

TranslatePath()

void ClipperLib::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] = IntPoint2d(input[i].x() + delta.x(), input[i].y() + delta.y());
}

References input(), and IntPoint2d().

Referenced by MinkowskiSum().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateOutPtIdxs()

void ClipperLib::UpdateOutPtIdxs ( OutRec &  outrec )

inline

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

References ClipperLib::OutPt::Idx, ClipperLib::OutRec::Idx, ClipperLib::OutPt::Prev, and ClipperLib::OutRec::Pts.

Referenced by ClipperLib::Clipper::DoSimplePolygons(), and ClipperLib::Clipper::JoinCommonEdges().

Here is the caller graph for this function:

Variable Documentation

def_arc_tolerance

double const ClipperLib::def_arc_tolerance = 0.25

static

Referenced by ClipperLib::ClipperOffset::DoOffset().

pi

double const ClipperLib::pi = 3.141592653589793238

static

Referenced by ClipperLib::ClipperOffset::DoOffset().

Skip

int const ClipperLib::Skip = -2

static

Referenced by ClipperLib::ClipperBase::AddPathInternal(), GetMaximaPair(), and ClipperLib::ClipperBase::ProcessBound().

two_pi

double const ClipperLib::two_pi = pi *2

static

Referenced by ClipperLib::ClipperOffset::DoOffset().

Unassigned

int const ClipperLib::Unassigned = -1

static

Referenced by ClipperLib::Clipper::AddLocalMaxPoly(), ClipperLib::Clipper::AppendPolygon(), ClipperLib::Clipper::DoMaxima(), InitEdge(), ClipperLib::Clipper::IntersectEdges(), and ClipperLib::ClipperBase::Reset().