Represent a set of closed polygons. More...

#include <shape_poly_set.h>

Inheritance diagram for SHAPE_POLY_SET:

Classes
class	ITERATOR_TEMPLATE
	Base class for iterating over all vertices in a given SHAPE_POLY_SET. More...

class	SEGMENT_ITERATOR_TEMPLATE
	Base class for iterating over all segments in a given SHAPE_POLY_SET. More...

class	TRIANGULATED_POLYGON

struct	VERTEX_INDEX
	Structure to hold the necessary information in order to index a vertex on a SHAPE_POLY_SET object: the polygon index, the contour index relative to the polygon and the vertex index relative the contour. More...

Public Types
enum	POLYGON_MODE { PM_FAST = true , PM_STRICTLY_SIMPLE = false }
	Operations on polygons use a aFastMode param if aFastMode is PM_FAST (true) the result can be a weak polygon if aFastMode is PM_STRICTLY_SIMPLE (false) (default) the result is (theoretically) a strictly simple polygon, but calculations can be really significantly time consuming Most of time PM_FAST is preferable. More...

enum	CORNER_STRATEGY { ALLOW_ACUTE_CORNERS , CHAMFER_ACUTE_CORNERS , ROUND_ACUTE_CORNERS , CHAMFER_ALL_CORNERS , ROUND_ALL_CORNERS }
	< define how inflate transform build inflated polygon More...

typedef std::vector< SHAPE_LINE_CHAIN >	POLYGON
	< represents a single polygon outline with holes. More...

typedef ITERATOR_TEMPLATE< VECTOR2I >	ITERATOR

typedef ITERATOR_TEMPLATE< const VECTOR2I >	CONST_ITERATOR

typedef SEGMENT_ITERATOR_TEMPLATE< SEG >	SEGMENT_ITERATOR

typedef SEGMENT_ITERATOR_TEMPLATE< const SEG >	CONST_SEGMENT_ITERATOR

Public Member Functions
	SHAPE_POLY_SET ()

	SHAPE_POLY_SET (const BOX2D &aRect)

	SHAPE_POLY_SET (const SHAPE_LINE_CHAIN &aOutline)
	Construct a SHAPE_POLY_SET with the first outline given by aOutline. More...

	SHAPE_POLY_SET (const SHAPE_POLY_SET &aOther)
	Copy constructor SHAPE_POLY_SET Performs a deep copy of `aOther` into `this`. More...

	~SHAPE_POLY_SET ()

SHAPE_POLY_SET &	operator= (const SHAPE_POLY_SET &aOther)

void	CacheTriangulation (bool aPartition=true, bool aSimplify=false)
	Build a polygon triangulation, needed to draw a polygon on OpenGL and in some other calculations. More...

bool	IsTriangulationUpToDate () const

MD5_HASH	GetHash () const

virtual bool	HasIndexableSubshapes () const override

virtual size_t	GetIndexableSubshapeCount () const override

virtual void	GetIndexableSubshapes (std::vector< const SHAPE * > &aSubshapes) const override

bool	GetRelativeIndices (int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
	Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated list of all vertices in all contours— and get the index of the vertex relative to the contour relative to the polygon in which it is. More...

bool	GetGlobalIndex (VERTEX_INDEX aRelativeIndices, int &aGlobalIdx) const
	Compute the global index of a vertex from the relative indices of polygon, contour and vertex. More...

SHAPE *	Clone () const override
	Return a dynamically allocated copy of the shape. More...

SHAPE_POLY_SET	CloneDropTriangulation () const
	Creates a new empty polygon in the set and returns its index. More...

int	NewOutline ()
	Creates a new hole in a given outline. More...

int	NewHole (int aOutline=-1)
	Adds a new outline to the set and returns its index. More...

int	AddOutline (const SHAPE_LINE_CHAIN &aOutline)
	Adds a new hole to the given outline (default: last) and returns its index. More...

int	AddHole (const SHAPE_LINE_CHAIN &aHole, int aOutline=-1)
	Return the area of this poly set. More...

double	Area ()
	Count the number of arc shapes present. More...

int	ArcCount () const
	Appends all the arcs in this polyset to aArcBuffer. More...

void	GetArcs (std::vector< SHAPE_ARC > &aArcBuffer) const
	Removes all arc references from all the outlines and holes in the polyset. More...

void	ClearArcs ()
	Appends a vertex at the end of the given outline/hole (default: the last outline) More...

int	Append (int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
	Add a new vertex to the contour indexed by `aOutline` and `aHole` (defaults to the outline of the last polygon). More...

void	Append (const SHAPE_POLY_SET &aSet)
	Append a vertex at the end of the given outline/hole (default: the last outline) More...

void	Append (const VECTOR2I &aP, int aOutline=-1, int aHole=-1)

int	Append (SHAPE_ARC &aArc, int aOutline=-1, int aHole=-1, double aAccuracy=SHAPE_ARC::DefaultAccuracyForPCB())
	Append a new arc to the contour indexed by `aOutline` and `aHole` (defaults to the outline of the last polygon). More...

void	InsertVertex (int aGlobalIndex, const VECTOR2I &aNewVertex)
	Adds a vertex in the globally indexed position aGlobalIndex. More...

const VECTOR2I &	CVertex (int aIndex, int aOutline, int aHole) const
	Return the aGlobalIndex-th vertex in the poly set. More...

const VECTOR2I &	CVertex (int aGlobalIndex) const
	Return the index-th vertex in a given hole outline within a given outline. More...

const VECTOR2I &	CVertex (VERTEX_INDEX aIndex) const

bool	GetNeighbourIndexes (int aGlobalIndex, int aPrevious, int aNext)
	Return the global indexes of the previous and the next corner of the aGlobalIndex-th corner of a contour in the polygon set. More...

bool	IsPolygonSelfIntersecting (int aPolygonIndex) const
	Check whether the aPolygonIndex-th polygon in the set is self intersecting. More...

bool	IsSelfIntersecting () const
	Check whether any of the polygons in the set is self intersecting. More...

unsigned int	TriangulatedPolyCount () const
	Return the number of outlines in the set. More...

int	OutlineCount () const
	Return the number of vertices in a given outline/hole. More...

int	VertexCount (int aOutline=-1, int aHole=-1) const
	Return the number of points in the shape poly set. More...

int	FullPointCount () const
	Returns the number of holes in a given outline. More...

int	HoleCount (int aOutline) const
	Return the reference to aIndex-th outline in the set. More...

SHAPE_LINE_CHAIN &	Outline (int aIndex)

const SHAPE_LINE_CHAIN &	Outline (int aIndex) const

SHAPE_POLY_SET	Subset (int aFirstPolygon, int aLastPolygon)
	Return a subset of the polygons in this set, the ones between aFirstPolygon and aLastPolygon. More...

SHAPE_POLY_SET	UnitSet (int aPolygonIndex)
	Return the reference to aHole-th hole in the aIndex-th outline. More...

SHAPE_LINE_CHAIN &	Hole (int aOutline, int aHole)
	Return the aIndex-th subpolygon in the set. More...

POLYGON &	Polygon (int aIndex)

const POLYGON &	Polygon (int aIndex) const

const TRIANGULATED_POLYGON *	TriangulatedPolygon (int aIndex) const

const SHAPE_LINE_CHAIN &	COutline (int aIndex) const

const SHAPE_LINE_CHAIN &	CHole (int aOutline, int aHole) const

const POLYGON &	CPolygon (int aIndex) const

ITERATOR	Iterate (int aFirst, int aLast, bool aIterateHoles=false)
	Return an object to iterate through the points of the polygons between `aFirst` and `aLast`. More...

ITERATOR	Iterate (int aOutline)

ITERATOR	IterateWithHoles (int aOutline)

ITERATOR	Iterate ()

ITERATOR	IterateWithHoles ()

CONST_ITERATOR	CIterate (int aFirst, int aLast, bool aIterateHoles=false) const

CONST_ITERATOR	CIterate (int aOutline) const

CONST_ITERATOR	CIterateWithHoles (int aOutline) const

CONST_ITERATOR	CIterate () const

CONST_ITERATOR	CIterateWithHoles () const

ITERATOR	IterateFromVertexWithHoles (int aGlobalIdx)
	Return an iterator object, for iterating between aFirst and aLast outline, with or without holes (default: without) More...

SEGMENT_ITERATOR	IterateSegments (int aFirst, int aLast, bool aIterateHoles=false)
	Return an iterator object, for iterating between aFirst and aLast outline, with or without holes (default: without) More...

CONST_SEGMENT_ITERATOR	CIterateSegments (int aFirst, int aLast, bool aIterateHoles=false) const
	Return an iterator object, for iterating aPolygonIdx-th polygon edges. More...

SEGMENT_ITERATOR	IterateSegments (int aPolygonIdx)
	Return an iterator object, for iterating aPolygonIdx-th polygon edges. More...

CONST_SEGMENT_ITERATOR	CIterateSegments (int aPolygonIdx) const
	Return an iterator object, for all outlines in the set (no holes). More...

SEGMENT_ITERATOR	IterateSegments ()
	Returns an iterator object, for all outlines in the set (no holes) More...

CONST_SEGMENT_ITERATOR	CIterateSegments () const
	Returns an iterator object, for all outlines in the set (with holes) More...

SEGMENT_ITERATOR	IterateSegmentsWithHoles ()
	Return an iterator object, for the aOutline-th outline in the set (with holes). More...

SEGMENT_ITERATOR	IterateSegmentsWithHoles (int aOutline)
	Return an iterator object, for the aOutline-th outline in the set (with holes). More...

CONST_SEGMENT_ITERATOR	CIterateSegmentsWithHoles () const
	Return an iterator object, for the aOutline-th outline in the set (with holes). More...

CONST_SEGMENT_ITERATOR	CIterateSegmentsWithHoles (int aOutline) const

void	BooleanAdd (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Perform boolean polyset difference For aFastMode meaning, see function booleanOp. More...

void	BooleanSubtract (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Perform boolean polyset intersection For aFastMode meaning, see function booleanOp. More...

void	BooleanIntersection (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Perform boolean polyset union between a and b, store the result in it self For aFastMode meaning, see function booleanOp. More...

void	BooleanAdd (const SHAPE_POLY_SET &a, const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Perform boolean polyset difference between a and b, store the result in it self For aFastMode meaning, see function booleanOp. More...

void	BooleanSubtract (const SHAPE_POLY_SET &a, const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Perform boolean polyset intersection between a and b, store the result in it self For aFastMode meaning, see function booleanOp. More...

void	BooleanIntersection (const SHAPE_POLY_SET &a, const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)

void	Inflate (int aAmount, int aCircleSegCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
	Perform outline inflation/deflation. More...

void	Deflate (int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)

void	InflateWithLinkedHoles (int aFactor, int aCircleSegmentsCount, POLYGON_MODE aFastMode)
	Perform outline inflation/deflation, using round corners. More...

void	Fracture (POLYGON_MODE aFastMode)
	Convert a single outline slitted ("fractured") polygon into a set ouf outlines with holes. More...

void	Unfracture (POLYGON_MODE aFastMode)
	Return true if the polygon set has any holes. More...

bool	HasHoles () const
	Return true if the polygon set has any holes that share a vertex. More...

bool	HasTouchingHoles () const
	Simplify the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFastMode meaning, see function booleanOp. More...

void	Simplify (POLYGON_MODE aFastMode)

int	NormalizeAreaOutlines ()
	Convert a self-intersecting polygon to one (or more) non self-intersecting polygon(s). More...

const std::string	Format (bool aCplusPlus=true) const override

bool	Parse (std::stringstream &aStream) override

void	Move (const VECTOR2I &aVector) override

void	Mirror (bool aX=true, bool aY=false, const VECTOR2I &aRef={ 0, 0 })
	Mirror the line points about y or x (or both) More...

void	Rotate (const EDA_ANGLE &aAngle, const VECTOR2I &aCenter={ 0, 0 }) override
	Rotate all vertices by a given angle. More...

bool	IsSolid () const override

const BOX2I	BBox (int aClearance=0) const override
	Compute a bounding box of the shape, with a margin of aClearance a collision. More...

bool	PointOnEdge (const VECTOR2I &aP) const
	Check if point aP lies on an edge or vertex of some of the outlines or holes. More...

bool	Collide (const SHAPE aShape, int aClearance=0, int aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
	Check if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating a collision. More...

bool	Collide (const VECTOR2I &aP, int aClearance=0, int aActual=nullptr, VECTOR2I aLocation=nullptr) const override
	Check whether the point aP is either inside or on the edge of the polygon set. More...

bool	Collide (const SEG &aSeg, int aClearance=0, int aActual=nullptr, VECTOR2I aLocation=nullptr) const override
	Check whether the segment aSeg collides with the polygon set (or its edge). More...

bool	CollideVertex (const VECTOR2I &aPoint, VERTEX_INDEX *aClosestVertex=nullptr, int aClearance=0) const
	Check whether aPoint collides with any vertex of any of the contours of the polygon. More...

bool	CollideEdge (const VECTOR2I &aPoint, VERTEX_INDEX *aClosestVertex=nullptr, int aClearance=0) const
	Check whether aPoint collides with any edge of any of the contours of the polygon. More...

void	BuildBBoxCaches () const
	Construct BBoxCaches for Contains(), below. More...

const BOX2I	BBoxFromCaches () const

bool	Contains (const VECTOR2I &aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=false) const
	Return true if a given subpolygon contains the point aP. More...

bool	IsEmpty () const

void	RemoveVertex (int aGlobalIndex)
	Delete the aGlobalIndex-th vertex. More...

void	RemoveVertex (VERTEX_INDEX aRelativeIndices)
	Delete the vertex indexed by aRelativeIndex (index of polygon, contour and vertex). More...

void	RemoveAllContours ()

void	RemoveContour (int aContourIdx, int aPolygonIdx=-1)
	Delete the aContourIdx-th contour of the aPolygonIdx-th polygon in the set. More...

int	RemoveNullSegments ()
	Look for null segments; ie, segments whose ends are exactly the same and deletes them. More...

void	SetVertex (const VERTEX_INDEX &aIndex, const VECTOR2I &aPos)
	Accessor function to set the position of a specific point. More...

void	SetVertex (int aGlobalIndex, const VECTOR2I &aPos)
	Set the vertex based on the global index. More...

int	TotalVertices () const
	Delete aIdx-th polygon from the set. More...

void	DeletePolygon (int aIdx)
	Delete aIdx-th polygon and its triangulation data from the set. More...

void	DeletePolygonAndTriangulationData (int aIdx, bool aUpdateHash=true)

void	UpdateTriangulationDataHash ()

POLYGON	ChamferPolygon (unsigned int aDistance, int aIndex)
	Return a chamfered version of the aIndex-th polygon. More...

POLYGON	FilletPolygon (unsigned int aRadius, int aErrorMax, int aIndex)
	Return a filleted version of the aIndex-th polygon. More...

SHAPE_POLY_SET	Chamfer (int aDistance)
	Return a chamfered version of the polygon set. More...

SHAPE_POLY_SET	Fillet (int aRadius, int aErrorMax)
	Return a filleted version of the polygon set. More...

SEG::ecoord	SquaredDistanceToPolygon (VECTOR2I aPoint, int aIndex, VECTOR2I *aNearest) const
	Compute the minimum distance between the aIndex-th polygon and aPoint. More...

SEG::ecoord	SquaredDistanceToPolygon (const SEG &aSegment, int aIndex, VECTOR2I *aNearest) const
	Compute the minimum distance between the aIndex-th polygon and aSegment with a possible width. More...

SEG::ecoord	SquaredDistance (VECTOR2I aPoint, VECTOR2I *aNearest=nullptr) const
	Compute the minimum distance squared between aPoint and all the polygons in the set. More...

SEG::ecoord	SquaredDistance (const SEG &aSegment, VECTOR2I *aNearest=nullptr) const
	Compute the minimum distance squared between aSegment and all the polygons in the set. More...

bool	IsVertexInHole (int aGlobalIdx)
	Check whether the aGlobalIndex-th vertex belongs to a hole. More...

int	GetClearance (const SHAPE *aOther) const
	Return the actual minimum distance between two shapes. More...

bool	IsNull () const
	Return true if the shape is a null shape. More...

virtual bool	Collide (const SHAPE aShape, int aClearance, VECTOR2I aMTV) const
	Check if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating a collision. More...

virtual VECTOR2I	Centre () const
	Compute a center-of-mass of the shape. More...

FACET *	NewFacet ()

SGNODE *	CalcShape (SGNODE aParent, SGNODE aColor, WRL1_ORDER aVertexOrder, float aCreaseLimit=0.74317, bool isVRML2=false)

SHAPE_TYPE	Type () const
	Return the type of the shape. More...

wxString	TypeName () const

Static Public Member Functions
static const SHAPE_POLY_SET	BuildPolysetFromOrientedPaths (const std::vector< SHAPE_LINE_CHAIN > &aPaths, bool aReverseOrientation=false, bool aEvenOdd=false)
	Build a SHAPE_POLY_SET from a bunch of outlines in provided in random order. More...

Static Public Attributes
static const int	MIN_PRECISION_IU = 4
	This is the minimum precision for all the points in a shape. More...

Protected Types
typedef VECTOR2I::extended_type	ecoord

Protected Attributes
SHAPE_TYPE	m_type
	< type of our shape More...

Private Types
enum	DROP_TRIANGULATION_FLAG { SINGLETON }

enum	CORNER_MODE { CHAMFERED , FILLETED }
	Operation ChamferPolygon and FilletPolygon are computed under the private chamferFillet method; this enum is defined to make the necessary distinction when calling this method from the public ChamferPolygon and FilletPolygon methods. More...

Private Member Functions
	SHAPE_POLY_SET (const SHAPE_POLY_SET &aOther, DROP_TRIANGULATION_FLAG)

void	fractureSingle (POLYGON &paths)

void	unfractureSingle (POLYGON &path)

void	importTree (ClipperLib::PolyTree *tree, const std::vector< CLIPPER_Z_VALUE > &aZValueBuffer, const std::vector< SHAPE_ARC > &aArcBuffe)

void	importTree (Clipper2Lib::PolyTree64 &tree, const std::vector< CLIPPER_Z_VALUE > &aZValueBuffer, const std::vector< SHAPE_ARC > &aArcBuffe)

void	importPaths (Clipper2Lib::Paths64 &paths, const std::vector< CLIPPER_Z_VALUE > &aZValueBuffer, const std::vector< SHAPE_ARC > &aArcBuffe)

void	importPolyPath (Clipper2Lib::PolyPath64 *aPolyPath, const std::vector< CLIPPER_Z_VALUE > &aZValueBuffer, const std::vector< SHAPE_ARC > &aArcBuffer)

void	inflate1 (int aAmount, int aCircleSegCount, CORNER_STRATEGY aCornerStrategy)

void	inflate2 (int aAmount, int aCircleSegCount, CORNER_STRATEGY aCornerStrategy)

void	booleanOp (ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
	This is the engine to execute all polygon boolean transforms (AND, OR, ... and polygon simplification (merging overlapping polygons). More...

void	booleanOp (ClipperLib::ClipType aType, const SHAPE_POLY_SET &aShape, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)

void	booleanOp (Clipper2Lib::ClipType aType, const SHAPE_POLY_SET &aOtherShape)

void	booleanOp (Clipper2Lib::ClipType aType, const SHAPE_POLY_SET &aShape, const SHAPE_POLY_SET &aOtherShape)

bool	containsSingle (const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
	Check whether the point aP is inside the aSubpolyIndex-th polygon of the polyset. More...

POLYGON	chamferFilletPolygon (CORNER_MODE aMode, unsigned int aDistance, int aIndex, int aErrorMax)
	Return the chamfered or filleted version of the aIndex-th polygon in the set, depending on the aMode selected. More...

bool	hasTouchingHoles (const POLYGON &aPoly) const

MD5_HASH	checksum () const

Private Attributes
std::vector< POLYGON >	m_polys

std::vector< std::unique_ptr< TRIANGULATED_POLYGON > >	m_triangulatedPolys

bool	m_triangulationValid = false

MD5_HASH	m_hash

std::list< FACET * >	facets

Detailed Description

Represent a set of closed polygons.

Polygons may be nonconvex, self-intersecting and have holes. Provides boolean operations (using Clipper library as the backend).

Let us define the terms used on this class to clarify methods names and comments:

Polygon: each polygon in the set.
Outline: first polyline in each polygon; represents its outer contour.
Hole: second and following polylines in the polygon.
Contour: each polyline of each polygon in the set, whether or not it is an outline or a hole.
Vertex (or corner): each one of the points that define a contour.

TODO: add convex partitioning & spatial index

Definition at line 65 of file shape_poly_set.h.

Member Typedef Documentation

◆ CONST_ITERATOR

typedef ITERATOR_TEMPLATE<const VECTOR2I> SHAPE_POLY_SET::CONST_ITERATOR

Definition at line 473 of file shape_poly_set.h.

◆ CONST_SEGMENT_ITERATOR

typedef SEGMENT_ITERATOR_TEMPLATE<const SEG> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR

Definition at line 477 of file shape_poly_set.h.

◆ ecoord

typedef VECTOR2I::extended_type SHAPE::ecoord

protectedinherited

Definition at line 249 of file shape.h.

◆ ITERATOR

typedef ITERATOR_TEMPLATE<VECTOR2I> SHAPE_POLY_SET::ITERATOR

Definition at line 472 of file shape_poly_set.h.

◆ POLYGON

typedef std::vector<SHAPE_LINE_CHAIN> SHAPE_POLY_SET::POLYGON

< represents a single polygon outline with holes.

The first entry is the outline, the remaining (if any), are the holes N.B. SWIG only supports typedef, so avoid c++ 'using' keyword

Definition at line 71 of file shape_poly_set.h.

◆ SEGMENT_ITERATOR

typedef SEGMENT_ITERATOR_TEMPLATE<SEG> SHAPE_POLY_SET::SEGMENT_ITERATOR

Definition at line 476 of file shape_poly_set.h.

Member Enumeration Documentation

◆ CORNER_MODE

enum SHAPE_POLY_SET::CORNER_MODE

private

Operation ChamferPolygon and FilletPolygon are computed under the private chamferFillet method; this enum is defined to make the necessary distinction when calling this method from the public ChamferPolygon and FilletPolygon methods.

Enumerator
CHAMFERED
FILLETED

Definition at line 1452 of file shape_poly_set.h.

 {
 CHAMFERED,
 FILLETED
 };

◆ CORNER_STRATEGY

enum SHAPE_POLY_SET::CORNER_STRATEGY

< define how inflate transform build inflated polygon

Enumerator
ALLOW_ACUTE_CORNERS	just inflate the polygon. Acute angles create spikes
CHAMFER_ACUTE_CORNERS	Acute angles are chamfered.
ROUND_ACUTE_CORNERS	Acute angles are rounded.
CHAMFER_ALL_CORNERS	All angles are chamfered. The distance between new and old polygon edges is not constant, but do not change a lot
ROUND_ALL_CORNERS	All angles are rounded. The distance between new and old polygon edges is constant

Definition at line 985 of file shape_poly_set.h.

 {
 ALLOW_ACUTE_CORNERS, 
 CHAMFER_ACUTE_CORNERS, 
 ROUND_ACUTE_CORNERS, 
 CHAMFER_ALL_CORNERS, 
 ROUND_ALL_CORNERS 
 };

◆ DROP_TRIANGULATION_FLAG

enum SHAPE_POLY_SET::DROP_TRIANGULATION_FLAG

private

Enumerator
SINGLETON

Definition at line 1385 of file shape_poly_set.h.

1385{ SINGLETON };

SHAPE_POLY_SET::SINGLETON

@ SINGLETON

Definition: shape_poly_set.h:1385

◆ POLYGON_MODE

enum SHAPE_POLY_SET::POLYGON_MODE

Operations on polygons use a aFastMode param if aFastMode is PM_FAST (true) the result can be a weak polygon if aFastMode is PM_STRICTLY_SIMPLE (false) (default) the result is (theoretically) a strictly simple polygon, but calculations can be really significantly time consuming Most of time PM_FAST is preferable.

PM_STRICTLY_SIMPLE can be used in critical cases (Gerber output for instance)

Enumerator
PM_FAST
PM_STRICTLY_SIMPLE

Definition at line 952 of file shape_poly_set.h.

 {
 PM_FAST = true,
 PM_STRICTLY_SIMPLE = false
 };

Constructor & Destructor Documentation

◆ SHAPE_POLY_SET() [1/5]

SHAPE_POLY_SET::SHAPE_POLY_SET ( )

Definition at line 67 of file shape_poly_set.cpp.

 :
 SHAPE( SH_POLY_SET )
{
}

Referenced by Clone(), and CloneDropTriangulation().

◆ SHAPE_POLY_SET() [2/5]

SHAPE_POLY_SET::SHAPE_POLY_SET ( const BOX2D & aRect )

Definition at line 73 of file shape_poly_set.cpp.

 :
 SHAPE( SH_POLY_SET )
{
 NewOutline();
 Append( VECTOR2I( aRect.GetLeft(), aRect.GetTop() ) );
 Append( VECTOR2I( aRect.GetRight(), aRect.GetTop() ) );
 Append( VECTOR2I( aRect.GetRight(), aRect.GetBottom() ) );
 Append( VECTOR2I( aRect.GetLeft(), aRect.GetBottom() ) );
 Outline( 0 ).SetClosed( true );
}

References Append(), BOX2< Vec >::GetBottom(), BOX2< Vec >::GetLeft(), BOX2< Vec >::GetRight(), BOX2< Vec >::GetTop(), NewOutline(), Outline(), and SHAPE_LINE_CHAIN::SetClosed().

◆ SHAPE_POLY_SET() [3/5]

SHAPE_POLY_SET::SHAPE_POLY_SET ( const SHAPE_LINE_CHAIN & aOutline )

Construct a SHAPE_POLY_SET with the first outline given by aOutline.

Parameters

aOutline is a closed outline

Definition at line 85 of file shape_poly_set.cpp.

 :
 SHAPE( SH_POLY_SET )
{
 AddOutline( aOutline );
}

References AddOutline().

◆ SHAPE_POLY_SET() [4/5]

SHAPE_POLY_SET::SHAPE_POLY_SET ( const SHAPE_POLY_SET & aOther )

Copy constructor SHAPE_POLY_SET Performs a deep copy of aOther into this.

Parameters

aOther is the SHAPE_POLY_SET object that will be copied.

Definition at line 92 of file shape_poly_set.cpp.

 :
 SHAPE( aOther ),
 m_polys( aOther.m_polys )
{
 if( aOther.IsTriangulationUpToDate() )
 {
 m_triangulatedPolys.reserve( aOther.TriangulatedPolyCount() );
 
 for( unsigned i = 0; i < aOther.TriangulatedPolyCount(); i++ )
 {
 const TRIANGULATED_POLYGON* poly = aOther.TriangulatedPolygon( i );
 m_triangulatedPolys.push_back( std::make_unique<TRIANGULATED_POLYGON>( *poly ) );
 }
 
 m_hash = aOther.GetHash();
 m_triangulationValid = true;
 }
 else
 {
 m_triangulationValid = false;
 m_hash = MD5_HASH();
 m_triangulatedPolys.clear();
 }
}

References GetHash(), IsTriangulationUpToDate(), m_hash, m_triangulatedPolys, m_triangulationValid, TriangulatedPolyCount(), and TriangulatedPolygon().

◆ ~SHAPE_POLY_SET()

SHAPE_POLY_SET::~SHAPE_POLY_SET ( )

Definition at line 128 of file shape_poly_set.cpp.

129{

130}

◆ SHAPE_POLY_SET() [5/5]

SHAPE_POLY_SET::SHAPE_POLY_SET	(	const SHAPE_POLY_SET &	aOther,
		DROP_TRIANGULATION_FLAG
	)

private

Definition at line 118 of file shape_poly_set.cpp.

 :
 SHAPE( aOther ),
 m_polys( aOther.m_polys )
{
 m_triangulationValid = false;
 m_hash = MD5_HASH();
 m_triangulatedPolys.clear();
}

References m_hash, m_triangulatedPolys, and m_triangulationValid.

Member Function Documentation

◆ AddHole()

int SHAPE_POLY_SET::AddHole	(	const SHAPE_LINE_CHAIN &	aHole,
		int	aOutline = `-1`
	)

Return the area of this poly set.

Definition at line 540 of file shape_poly_set.cpp.

{
 assert( m_polys.size() );
 
 if( aOutline < 0 )
 aOutline += m_polys.size();
 
 assert( aOutline < (int)m_polys.size() );
 
 POLYGON& poly = m_polys[aOutline];
 
 assert( poly.size() );
 
 poly.push_back( aHole );
 
 return poly.size() - 2;
}

References m_polys.

Referenced by ZONE::AddPolygon(), BuildBoardPolygonOutlines(), BuildFootprintPolygonOutlines(), KI_TEST::BuildHollowSquare(), CacheTriangulation(), KI_TEST::CommonTestData::CommonTestData(), ConvertOutlineToPolygon(), CADSTAR_ARCHIVE_PARSER::SHAPE::ConvertToPolySet(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), FABMASTER::loadFootprints(), FABMASTER::loadShapePolySet(), FABMASTER::loadZone(), ALTIUM_PCB::ParseRegions6Data(), and PCB_PARSER::parseRenderCache().

◆ AddOutline()

int SHAPE_POLY_SET::AddOutline ( const SHAPE_LINE_CHAIN & aOutline )

Adds a new hole to the given outline (default: last) and returns its index.

Definition at line 526 of file shape_poly_set.cpp.

{
 assert( aOutline.IsClosed() );
 
 POLYGON poly;
 
 poly.push_back( aOutline );
 
 m_polys.push_back( poly );
 
 return m_polys.size() - 1;
}

References SHAPE_LINE_CHAIN::IsClosed(), and m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), ZONE::AddPolygon(), BOARD_ADAPTER::addText(), BOOST_AUTO_TEST_CASE(), buildBoardBoundingBoxPoly(), KI_TEST::BuildHollowSquare(), KI_TEST::BuildPolyset(), KI_TEST::CommonTestData::CommonTestData(), ConvertOutlineToPolygon(), ConvertPolygonToBlocks(), ALTIUM_PCB::ConvertShapeBasedRegions6ToBoardItem(), ALTIUM_PCB::ConvertShapeBasedRegions6ToFootprintItem(), CADSTAR_ARCHIVE_PARSER::SHAPE::ConvertToPolySet(), FOOTPRINT::CoverageRatio(), BOARD_ADAPTER::createPadWithMargin(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), ZONE_FILLER::Fill(), ZONE_FILLER::fillCopperZone(), GEOM_TEST::FilletPolySet(), FOOTPRINT::GetBoundingHull(), PNS::SOLID::HoleHull(), PNS::SOLID::Hull(), IteratorFixture::IteratorFixture(), DSN::SPECCTRA_DB::makeIMAGE(), CONVERT_TOOL::makePolysFromChainedSegs(), PAD::MergePrimitivesAsPolygon(), NormalizeAreaOutlines(), EAGLE_PLUGIN::packagePolygon(), ALTIUM_PCB::ParsePolygons6Data(), ALTIUM_PCB::ParseRegions6Data(), PCB_PARSER::parseRenderCache(), partitionPolyIntoRegularCellGrid(), ZONE_CREATE_HELPER::performZoneCutout(), BRDITEMS_PLOTTER::PlotFootprintShape(), BRDITEMS_PLOTTER::PlotPcbText(), PlotStandardLayer(), SHAPE_POLY_SET(), TestConcaveSquareFillet(), and TestSquareFillet().

◆ Append() [1/4]

void SHAPE_POLY_SET::Append ( const SHAPE_POLY_SET & aSet )

Append a vertex at the end of the given outline/hole (default: the last outline)

Definition at line 2031 of file shape_poly_set.cpp.

{
 m_polys.insert( m_polys.end(), aSet.m_polys.begin(), aSet.m_polys.end() );
}

References m_polys.

◆ Append() [2/4]

void SHAPE_POLY_SET::Append	(	const VECTOR2I &	aP,
		int	aOutline = `-1`,
		int	aHole = `-1`
	)

Definition at line 2037 of file shape_poly_set.cpp.

{
 Append( aP.x, aP.y, aOutline, aHole );
}

References Append(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ Append() [3/4]

int SHAPE_POLY_SET::Append	(	int	x,
		int	y,
		int	aOutline = `-1`,
		int	aHole = `-1`,
		bool	aAllowDuplication = `false`
	)

Add a new vertex to the contour indexed by aOutline and aHole (defaults to the outline of the last polygon).

Parameters

x	is the x coordinate of the new vertex.
y	is the y coordinate of the new vertex.
aOutline	is the index of the polygon.
aHole	is the index of the hole (-1 for the main outline),
aAllowDuplication	is a flag to indicate whether it is allowed to add this corner even if it is duplicated.

Returns: the number of corners of the selected contour after the addition. Merge polygons from two sets.

Definition at line 253 of file shape_poly_set.cpp.

{
 assert( m_polys.size() );
 
 if( aOutline < 0 )
 aOutline += m_polys.size();
 
 int idx;
 
 if( aHole < 0 )
 idx = 0;
 else
 idx = aHole + 1;
 
 assert( aOutline < (int) m_polys.size() );
 assert( idx < (int) m_polys[aOutline].size() );
 
 m_polys[aOutline][idx].Append( x, y, aAllowDuplication );
 
 return m_polys[aOutline][idx].PointCount();
}

References m_polys.

Referenced by AR_AUTOPLACER::addFpBody(), addHoleToPolygon(), ZONE_FILLER::addKnockout(), AR_AUTOPLACER::addPad(), PAD::AddPrimitivePoly(), Append(), ZONE::AppendCorner(), BOARD::BOARD(), BOOST_AUTO_TEST_CASE(), BuildBoardPolygonOutlines(), ZONE_FILLER::buildCopperItemClearances(), BuildFootprintPolygonOutlines(), TEARDROP_MANAGER::ComputePointsOnPadVia(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), CornerListToPolygon(), BITMAPCONV_INFO::createOutputData(), BOARD_ADAPTER::createPadWithMargin(), CONVERT_TOOL::CreatePolys(), TEARDROP_MANAGER::createTeardrop(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), GERBER_FILE_IMAGE::Execute_G_Command(), fillArcPOLY(), PCB_BASE_FRAME::FocusOnItems(), FOOTPRINT::GetBoundingHull(), getRectangleAlongCentreLine(), EDA_SHAPE::hitTest(), InsertVertex(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadShapePolySet(), SCH_EAGLE_PLUGIN::loadSymbolPolyLine(), FABMASTER::loadZone(), LEGACY_PLUGIN::loadZONE_CONTAINER(), DSN::SPECCTRA_DB::makeIMAGE(), CONVERT_TOOL::makePolysFromClosedGraphics(), DXF_PLOTTER::PlotPoly(), PlotStandardLayer(), RENDER_3D_OPENGL::reload(), EDA_SHAPE::rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), EDA_SHAPE::SetPolyPoints(), SHAPE_POLY_SET(), DS_DATA_ITEM_POLYGONS::SyncDrawItems(), TransformArcToPolygon(), EDA_TEXT::TransformBoundingBoxToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), TransformRingToPolygon(), TransformRoundChamferedRectToPolygon(), EDA_SHAPE::TransformShapeToPolygon(), FP_TEXT::TransformShapeToPolygon(), FP_TEXTBOX::TransformShapeToPolygon(), PCB_TEXTBOX::TransformShapeToPolygon(), ZONE::TransformShapeToPolygon(), PAD::TransformShapeToPolygon(), ZONE::TransformSmoothedOutlineToPolygon(), ZONE::TransformSolidAreasShapesToPolygon(), FP_TEXT::TransformTextToPolySet(), FP_TEXTBOX::TransformTextToPolySet(), PCB_TEXT::TransformTextToPolySet(), PCB_TEXTBOX::TransformTextToPolySet(), TransformTrapezoidToPolygon(), PCB_DIM_ALIGNED::updateGeometry(), PCB_DIM_ORTHOGONAL::updateGeometry(), PCB_DIM_RADIAL::updateGeometry(), PCB_DIM_LEADER::updateGeometry(), and EE_POINT_EDITOR::updateParentItem().

◆ Append() [4/4]

int SHAPE_POLY_SET::Append	(	SHAPE_ARC &	aArc,
		int	aOutline = `-1`,
		int	aHole = `-1`,
		double	aAccuracy = `SHAPE_ARC::DefaultAccuracyForPCB()`
	)

Append a new arc to the contour indexed by aOutline and aHole (defaults to the outline of the last polygon).

Parameters

aArc	The arc to be inserted
aOutline	Index of the polygon
aHole	Index of the hole (-1 for the main outline)
aAccuracy	Accuracy of the arc representation in IU

Returns: the number of points in the arc (including the interpolated points from the arc)

Definition at line 276 of file shape_poly_set.cpp.

{
 assert( m_polys.size() );
 
 if( aOutline < 0 )
 aOutline += m_polys.size();
 
 int idx;
 
 if( aHole < 0 )
 idx = 0;
 else
 idx = aHole + 1;
 
 assert( aOutline < (int) m_polys.size() );
 assert( idx < (int) m_polys[aOutline].size() );
 
 m_polys[aOutline][idx].Append( aArc, aAccuracy );
 
 return m_polys[aOutline][idx].PointCount();
}

References m_polys.

◆ ArcCount()

int SHAPE_POLY_SET::ArcCount ( ) const

Appends all the arcs in this polyset to aArcBuffer.

Definition at line 575 of file shape_poly_set.cpp.

{
 int retval = 0;
 
 for( const POLYGON& poly : m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 retval += poly[i].ArcCount();
 }
 
 return retval;
}

References ArcCount(), and m_polys.

Referenced by ArcCount(), and booleanOp().

◆ Area()

double SHAPE_POLY_SET::Area ( )

Count the number of arc shapes present.

Definition at line 559 of file shape_poly_set.cpp.

{
 double area = 0.0;
 
 for( int i = 0; i < OutlineCount(); i++ )
 {
 area += Outline( i ).Area( true );
 
 for( int j = 0; j < HoleCount( i ); j++ )
 area -= Hole( i, j ).Area( true );
 }
 
 return area;
}

References SHAPE_LINE_CHAIN::Area(), Hole(), HoleCount(), Outline(), and OutlineCount().

Referenced by BOOST_AUTO_TEST_CASE(), ZONE::CalculateOutlineArea(), CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities(), ZONE_FILLER::Fill(), polygonArea(), and DRC_TEST_PROVIDER_TEXT_DIMS::Run().

◆ BBox()

const BOX2I SHAPE_POLY_SET::BBox ( int aClearance = 0 ) const

overridevirtual

Compute a bounding box of the shape, with a margin of aClearance a collision.

Parameters

aClearance how much the bounding box is expanded wrs to the minimum enclosing rectangle for the shape.

Returns: the bounding box.

Implements SHAPE.

Definition at line 1744 of file shape_poly_set.cpp.

{
 BOX2I bb;
 
 for( unsigned i = 0; i < m_polys.size(); i++ )
 {
 if( i == 0 )
 bb = m_polys[i][0].BBox();
 else
 bb.Merge( m_polys[i][0].BBox() );
 }
 
 bb.Inflate( aClearance );
 return bb;
}

References BBox(), BOX2< Vec >::Inflate(), m_polys, and BOX2< Vec >::Merge().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BBox(), KIFONT::OUTLINE_GLYPH::BoundingBox(), ZONE::CacheBoundingBox(), DRAWING_TOOL::DrawBoardCharacteristics(), PCB_BASE_FRAME::FocusOnItems(), PAD::GetBestAnchorPosition(), GERBER_DRAW_ITEM::GetBoundingBox(), DS_DRAW_ITEM_POLYPOLYGONS::GetBoundingBox(), ZONE::GetBoundingBox(), D_CODE::GetShapeDim(), partitionPolyIntoRegularCellGrid(), KIGFX::VIEW::SetCenter(), BOARD::TestZoneIntersection(), KIGFX::PREVIEW::CENTRELINE_RECT_ITEM::ViewBBox(), KIGFX::PREVIEW::POLYGON_ITEM::ViewBBox(), and GERBER_DRAW_ITEM::ViewGetLOD().

◆ BBoxFromCaches()

const BOX2I SHAPE_POLY_SET::BBoxFromCaches ( ) const

Definition at line 1761 of file shape_poly_set.cpp.

{
 BOX2I bb;
 
 for( unsigned i = 0; i < m_polys.size(); i++ )
 {
 if( i == 0 )
 bb = *m_polys[i][0].GetCachedBBox();
 else
 bb.Merge( *m_polys[i][0].GetCachedBBox() );
 }
 
 return bb;
}

References m_polys, and BOX2< Vec >::Merge().

Referenced by DRC_INTERACTIVE_COURTYARD_CLEARANCE::testCourtyardClearances(), and DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances().

◆ BooleanAdd() [1/2]

void SHAPE_POLY_SET::BooleanAdd	(	const SHAPE_POLY_SET &	a,
		const SHAPE_POLY_SET &	b,
		POLYGON_MODE	aFastMode
	)

Perform boolean polyset difference between a and b, store the result in it self For aFastMode meaning, see function booleanOp.

Definition at line 865 of file shape_poly_set.cpp.

{
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 booleanOp( Clipper2Lib::ClipType::Union, a, b );
 else
 booleanOp( ClipperLib::ctUnion, a, b, aFastMode );
}

References booleanOp(), and ADVANCED_CFG::GetCfg().

◆ BooleanAdd() [2/2]

void SHAPE_POLY_SET::BooleanAdd	(	const SHAPE_POLY_SET &	b,
		POLYGON_MODE	aFastMode
	)

Perform boolean polyset difference For aFastMode meaning, see function booleanOp.

Definition at line 838 of file shape_poly_set.cpp.

{
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 booleanOp( Clipper2Lib::ClipType::Union, b );
 else
 booleanOp( ClipperLib::ctUnion, b, aFastMode );
}

References booleanOp(), and ADVANCED_CFG::GetCfg().

Referenced by DRC_TEST_PROVIDER_SOLDER_MASK::addItemToRTrees(), PAD::addPadPrimitivesToPolygon(), BOOST_AUTO_TEST_CASE(), BOOST_FIXTURE_TEST_CASE(), ZONE::BuildSmoothedPoly(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), ALTIUM_PCB::ParseRegions6Data(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), and ZONE::RemoveCutout().

◆ BooleanIntersection() [1/2]

void SHAPE_POLY_SET::BooleanIntersection	(	const SHAPE_POLY_SET &	a,
		const SHAPE_POLY_SET &	b,
		POLYGON_MODE	aFastMode
	)

Definition at line 885 of file shape_poly_set.cpp.

{
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 booleanOp( Clipper2Lib::ClipType::Intersection, a, b );
 else
 booleanOp( ClipperLib::ctIntersection, a, b, aFastMode );
}

References booleanOp(), and ADVANCED_CFG::GetCfg().

◆ BooleanIntersection() [2/2]

void SHAPE_POLY_SET::BooleanIntersection	(	const SHAPE_POLY_SET &	b,
		POLYGON_MODE	aFastMode
	)

Perform boolean polyset union between a and b, store the result in it self For aFastMode meaning, see function booleanOp.

Definition at line 856 of file shape_poly_set.cpp.

{
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 booleanOp( Clipper2Lib::ClipType::Intersection, b );
 else
 booleanOp( ClipperLib::ctIntersection, b, aFastMode );
}

References booleanOp(), and ADVANCED_CFG::GetCfg().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BOOST_AUTO_TEST_CASE(), ZONE::BuildSmoothedPoly(), CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities(), TEARDROP_MANAGER::ComputePointsOnPadVia(), ConvertPolygonToBlocks(), ZONE_FILLER::Fill(), ZONE_FILLER::fillCopperZone(), PCB_BASE_FRAME::FocusOnItems(), isCopperOutside(), PAD_TOOL::RecombinePad(), RENDER_3D_OPENGL::reload(), and TransformOvalToPolygon().

◆ booleanOp() [1/4]

void SHAPE_POLY_SET::booleanOp	(	Clipper2Lib::ClipType	aType,
		const SHAPE_POLY_SET &	aOtherShape
	)

private

Definition at line 724 of file shape_poly_set.cpp.

{
 booleanOp( aType, *this, aOtherShape );
}

References booleanOp().

◆ booleanOp() [2/4]

void SHAPE_POLY_SET::booleanOp	(	Clipper2Lib::ClipType	aType,
		const SHAPE_POLY_SET &	aShape,
		const SHAPE_POLY_SET &	aOtherShape
	)

private

Definition at line 730 of file shape_poly_set.cpp.

{
 if( ( aShape.OutlineCount() > 1 || aOtherShape.OutlineCount() > 0 )
 && ( aShape.ArcCount() > 0 || aOtherShape.ArcCount() > 0 ) )
 {
 wxFAIL_MSG( wxT( "Boolean ops on curved polygons are not supported. You should call "
 "ClearArcs() before carrying out the boolean operation." ) );
 }
 
 Clipper2Lib::Clipper64 c;
 
 std::vector<CLIPPER_Z_VALUE> zValues;
 std::vector<SHAPE_ARC> arcBuffer;
 std::map<VECTOR2I, CLIPPER_Z_VALUE> newIntersectPoints;
 
 Clipper2Lib::Paths64 paths;
 Clipper2Lib::Paths64 clips;
 
 for( const POLYGON& poly : aShape.m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 {
 paths.push_back( poly[i].convertToClipper2( i == 0, zValues, arcBuffer ) );
 }
 }
 
 for( const POLYGON& poly : aOtherShape.m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 {
 clips.push_back( poly[i].convertToClipper2( i == 0, zValues, arcBuffer ) );
 }
 }
 
 c.AddSubject( paths );
 c.AddClip( clips );
 
 Clipper2Lib::PolyTree64 solution;
 
 Clipper2Lib::ZCallback64 callback =
 [&]( const Clipper2Lib::Point64 & e1bot, const Clipper2Lib::Point64 & e1top,
 const Clipper2Lib::Point64 & e2bot, const Clipper2Lib::Point64 & e2top,
 Clipper2Lib::Point64 & pt )
 {
 auto arcIndex =
 [&]( const ssize_t& aZvalue, const ssize_t& aCompareVal = -1 ) -> ssize_t
 {
 ssize_t retval;
 
 retval = zValues.at( aZvalue ).m_SecondArcIdx;
 
 if( retval == -1 || ( aCompareVal > 0 && retval != aCompareVal ) )
 retval = zValues.at( aZvalue ).m_FirstArcIdx;
 
 return retval;
 };
 
 auto arcSegment =
 [&]( const ssize_t& aBottomZ, const ssize_t aTopZ ) -> ssize_t
 {
 ssize_t retval = arcIndex( aBottomZ );
 
 if( retval != -1 )
 {
 if( retval != arcIndex( aTopZ, retval ) )
 retval = -1; // Not an arc segment as the two indices do not match
 }
 
 return retval;
 };
 
 ssize_t e1ArcSegmentIndex = arcSegment( e1bot.z, e1top.z );
 ssize_t e2ArcSegmentIndex = arcSegment( e2bot.z, e2top.z );
 
 CLIPPER_Z_VALUE newZval;
 
 if( e1ArcSegmentIndex != -1 )
 {
 newZval.m_FirstArcIdx = e1ArcSegmentIndex;
 newZval.m_SecondArcIdx = e2ArcSegmentIndex;
 }
 else
 {
 newZval.m_FirstArcIdx = e2ArcSegmentIndex;
 newZval.m_SecondArcIdx = -1;
 }
 
 size_t z_value_ptr = zValues.size();
 zValues.push_back( newZval );
 
 // Only worry about arc segments for later processing
 if( newZval.m_FirstArcIdx != -1 )
 newIntersectPoints.insert( { VECTOR2I( pt.x, pt.y ), newZval } );
 
 pt.z = z_value_ptr;
 //@todo amend X,Y values to true intersection between arcs or arc and segment
 };
 
 c.SetZCallback( callback ); // register callback
 
 c.Execute( aType, Clipper2Lib::FillRule::NonZero, solution );
 
 importTree( solution, zValues, arcBuffer );
 solution.Clear(); // Free used memory (not done in dtor)
}

References ArcCount(), importTree(), CLIPPER_Z_VALUE::m_FirstArcIdx, m_polys, CLIPPER_Z_VALUE::m_SecondArcIdx, and OutlineCount().

◆ booleanOp() [3/4]

void SHAPE_POLY_SET::booleanOp	(	ClipperLib::ClipType	aType,
		const SHAPE_POLY_SET &	aOtherShape,
		POLYGON_MODE	aFastMode
	)

private

This is the engine to execute all polygon boolean transforms (AND, OR, ... and polygon simplification (merging overlapping polygons).

Parameters

aType	is the transform type ( see ClipperLib::ClipType )
aOtherShape	is the SHAPE_LINE_CHAIN to combine with me.
aFastMode	is an option to choose if the result can be a weak polygon or a strictly simple polygon. if aFastMode is PM_FAST the result can be a weak polygon if aFastMode is PM_STRICTLY_SIMPLE (default) the result is (theoretically) a strictly simple polygon, but calculations can be really significantly time consuming

Definition at line 612 of file shape_poly_set.cpp.

{
 booleanOp( aType, *this, aOtherShape, aFastMode );
}

References booleanOp().

Referenced by BooleanAdd(), BooleanIntersection(), booleanOp(), BooleanSubtract(), and Simplify().

◆ booleanOp() [4/4]

void SHAPE_POLY_SET::booleanOp	(	ClipperLib::ClipType	aType,
		const SHAPE_POLY_SET &	aShape,
		const SHAPE_POLY_SET &	aOtherShape,
		POLYGON_MODE	aFastMode
	)

private

Definition at line 619 of file shape_poly_set.cpp.

{
 if( ( aShape.OutlineCount() > 1 || aOtherShape.OutlineCount() > 0 )
 && ( aShape.ArcCount() > 0 || aOtherShape.ArcCount() > 0 ) )
 {
 wxFAIL_MSG( wxT( "Boolean ops on curved polygons are not supported. You should call "
 "ClearArcs() before carrying out the boolean operation." ) );
 }
 
 ClipperLib::Clipper c;
 
 c.StrictlySimple( aFastMode == PM_STRICTLY_SIMPLE );
 
 std::vector<CLIPPER_Z_VALUE> zValues;
 std::vector<SHAPE_ARC> arcBuffer;
 std::map<VECTOR2I, CLIPPER_Z_VALUE> newIntersectPoints;
 
 for( const POLYGON& poly : aShape.m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 {
 c.AddPath( poly[i].convertToClipper( i == 0, zValues, arcBuffer ),
 ClipperLib::ptSubject, true );
 }
 }
 
 for( const POLYGON& poly : aOtherShape.m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 {
 c.AddPath( poly[i].convertToClipper( i == 0, zValues, arcBuffer ),
 ClipperLib::ptClip, true );
 }
 }
 
 ClipperLib::PolyTree solution;
 
 ClipperLib::ZFillCallback callback =
 [&]( ClipperLib::IntPoint & e1bot, ClipperLib::IntPoint & e1top,
 ClipperLib::IntPoint & e2bot, ClipperLib::IntPoint & e2top,
 ClipperLib::IntPoint & pt )
 {
 auto arcIndex =
 [&]( const ssize_t& aZvalue, const ssize_t& aCompareVal = -1 ) -> ssize_t
 {
 ssize_t retval;
 
 retval = zValues.at( aZvalue ).m_SecondArcIdx;
 
 if( retval == -1 || ( aCompareVal > 0 && retval != aCompareVal ) )
 retval = zValues.at( aZvalue ).m_FirstArcIdx;
 
 return retval;
 };
 
 auto arcSegment =
 [&]( const ssize_t& aBottomZ, const ssize_t aTopZ ) -> ssize_t
 {
 ssize_t retval = arcIndex( aBottomZ );
 
 if( retval != -1 )
 {
 if( retval != arcIndex( aTopZ, retval ) )
 retval = -1; // Not an arc segment as the two indices do not match
 }
 
 return retval;
 };
 
 ssize_t e1ArcSegmentIndex = arcSegment( e1bot.Z, e1top.Z );
 ssize_t e2ArcSegmentIndex = arcSegment( e2bot.Z, e2top.Z );
 
 CLIPPER_Z_VALUE newZval;
 
 if( e1ArcSegmentIndex != -1 )
 {
 newZval.m_FirstArcIdx = e1ArcSegmentIndex;
 newZval.m_SecondArcIdx = e2ArcSegmentIndex;
 }
 else
 {
 newZval.m_FirstArcIdx = e2ArcSegmentIndex;
 newZval.m_SecondArcIdx = -1;
 }
 
 size_t z_value_ptr = zValues.size();
 zValues.push_back( newZval );
 
 // Only worry about arc segments for later processing
 if( newZval.m_FirstArcIdx != -1 )
 newIntersectPoints.insert( { VECTOR2I( pt.X, pt.Y ), newZval } );
 
 pt.Z = z_value_ptr;
 //@todo amend X,Y values to true intersection between arcs or arc and segment
 };
 
 c.ZFillFunction( callback ); // register callback
 
 c.Execute( aType, solution, ClipperLib::pftNonZero, ClipperLib::pftNonZero );
 
 importTree( &solution, zValues, arcBuffer );
}

References ArcCount(), importTree(), CLIPPER_Z_VALUE::m_FirstArcIdx, m_polys, CLIPPER_Z_VALUE::m_SecondArcIdx, OutlineCount(), and PM_STRICTLY_SIMPLE.

◆ BooleanSubtract() [1/2]

void SHAPE_POLY_SET::BooleanSubtract	(	const SHAPE_POLY_SET &	a,
		const SHAPE_POLY_SET &	b,
		POLYGON_MODE	aFastMode
	)

Perform boolean polyset intersection between a and b, store the result in it self For aFastMode meaning, see function booleanOp.

Definition at line 875 of file shape_poly_set.cpp.

{
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 booleanOp( Clipper2Lib::ClipType::Difference, a, b );
 else
 booleanOp( ClipperLib::ctDifference, a, b, aFastMode );
}

References booleanOp(), and ADVANCED_CFG::GetCfg().

◆ BooleanSubtract() [2/2]

void SHAPE_POLY_SET::BooleanSubtract	(	const SHAPE_POLY_SET &	b,
		POLYGON_MODE	aFastMode
	)

Perform boolean polyset intersection For aFastMode meaning, see function booleanOp.

Definition at line 847 of file shape_poly_set.cpp.

{
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 booleanOp( Clipper2Lib::ClipType::Difference, b );
 else
 booleanOp( ClipperLib::ctDifference, b, aFastMode );
}

References booleanOp(), and ADVANCED_CFG::GetCfg().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), addHoleToPolygon(), BOARD_ADAPTER::addText(), ZONE::BuildSmoothedPoly(), CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities(), FOOTPRINT::CheckPads(), BITMAPCONV_INFO::createOutputData(), TRACKS_CLEANER::deleteTracksInPads(), KIGFX::PCB_PAINTER::draw(), EXPORTER_PCB_VRML::ExportVrmlSolderMask(), ZONE_FILLER::fillCopperZone(), ZONE_FILLER::fillNonCopperZone(), PCB_BASE_FRAME::FocusOnItems(), RENDER_3D_OPENGL::generateViasAndPads(), AR_AUTOPLACER::genModuleOnRoutingMatrix(), APERTURE_MACRO::GetApertureMacroShape(), FP_TEXT::GetEffectiveShape(), PCB_TEXT::GetEffectiveShape(), ZONE_FILLER::knockoutThermalReliefs(), NormalizeAreaOutlines(), DIALOG_PAD_PROPERTIES::padValuesOK(), ZONE_CREATE_HELPER::performZoneCutout(), BRDITEMS_PLOTTER::PlotPcbText(), PlotSolderMaskLayer(), RENDER_3D_OPENGL::reload(), RENDER_3D_RAYTRACE::Reload(), KIGFX::VIEW::SetCenter(), and ZONE_FILLER::subtractHigherPriorityZones().

◆ BuildBBoxCaches()

void SHAPE_POLY_SET::BuildBBoxCaches ( ) const

Construct BBoxCaches for Contains(), below.

Note: These caches must be built before a group of calls to Contains(). They are not kept up-to-date by editing actions.

Definition at line 2116 of file shape_poly_set.cpp.

{
 for( int polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
 {
 COutline( polygonIdx ).GenerateBBoxCache();
 
 for( int holeIdx = 0; holeIdx < HoleCount( polygonIdx ); holeIdx++ )
 CHole( polygonIdx, holeIdx ).GenerateBBoxCache();
 }
}

References CHole(), COutline(), SHAPE_LINE_CHAIN::GenerateBBoxCache(), HoleCount(), and OutlineCount().

Referenced by ZONE_FILLER::fillCopperZone().

◆ BuildPolysetFromOrientedPaths()

const SHAPE_POLY_SET SHAPE_POLY_SET::BuildPolysetFromOrientedPaths	(	const std::vector< SHAPE_LINE_CHAIN > &	aPaths,
		bool	aReverseOrientation = `false`,
		bool	aEvenOdd = `false`
	)

static

Build a SHAPE_POLY_SET from a bunch of outlines in provided in random order.

Parameters

aPath	set of closed outlines forming the polygon. Positive orientation = outline, negative = hole
aReverseOrientation	inverts the sign of the orientation of aPaths (so negative = outline)
aEvenOdd	forces the even-off fill rule (default is non zero)

Returns: the constructed poly set

Definition at line 2962 of file shape_poly_set.cpp.

{
 ClipperLib::Clipper clipper;
 ClipperLib::PolyTree tree;
 
 // fixme: do we need aReverseOrientation?
 
 for( const SHAPE_LINE_CHAIN& path : aPaths )
 {
 ClipperLib::Path lc;
 
 for( int i = 0; i < path.PointCount(); i++ )
 {
 lc.emplace_back( path.CPoint( i ).x, path.CPoint( i ).y );
 }
 
 clipper.AddPath( lc, ClipperLib::ptSubject, true );
 }
 
 clipper.StrictlySimple( true );
 clipper.Execute( ClipperLib::ctUnion, tree,
 aEvenOdd ? ClipperLib::pftEvenOdd : ClipperLib::pftNonZero,
 ClipperLib::pftNonZero );
 SHAPE_POLY_SET result;
 
 for( ClipperLib::PolyNode* n = tree.GetFirst(); n; n = n->GetNext() )
 {
 if( !n->IsHole() )
 {
 int outl = result.NewOutline();
 
 for( unsigned int i = 0; i < n->Contour.size(); i++ )
 result.Outline( outl ).Append( n->Contour[i].X, n->Contour[i].Y );
 
 for( unsigned int i = 0; i < n->Childs.size(); i++ )
 {
 int outh = result.NewHole( outl );
 for( unsigned int j = 0; j < n->Childs[i]->Contour.size(); j++ )
 {
 result.Hole( outl, outh )
 .Append( n->Childs[i]->Contour[j].X, n->Childs[i]->Contour[j].Y );
 }
 }
 }
 }
 
 return result;
}

References SHAPE_LINE_CHAIN::Append(), Hole(), NewHole(), NewOutline(), Outline(), and path.

Referenced by convertPolygon().

◆ CacheTriangulation()

void SHAPE_POLY_SET::CacheTriangulation	(	bool	aPartition = `true`,
		bool	aSimplify = `false`
	)

Build a polygon triangulation, needed to draw a polygon on OpenGL and in some other calculations.

Parameters

aPartition	= true to created a trinagulation in a partition on a grid false to create a more basic triangulation of the polygons Note in partition calculations the grid size is hard coded to 1e7. This is a good value for Pcbnew: 1cm, in internal units. But not good for Gerbview (1e7 = 10cm), however using a partition is not useful.
aSimplify	= force the algorithm to simplify the POLY_SET before triangulating

Definition at line 2709 of file shape_poly_set.cpp.

{
 bool recalculate = !m_hash.IsValid();
 MD5_HASH hash;
 
 if( !m_triangulationValid )
 recalculate = true;
 
 if( !recalculate )
 {
 hash = checksum();
 
 if( m_hash != hash )
 {
 m_hash = hash;
 recalculate = true;
 }
 }
 
 if( !recalculate )
 return;
 
 auto triangulate =
 []( SHAPE_POLY_SET& polySet, int forOutline,
 std::vector<std::unique_ptr<TRIANGULATED_POLYGON>>& dest )
 {
 bool triangulationValid = false;
 int pass = 0;
 
 while( polySet.OutlineCount() > 0 )
 {
 if( !dest.empty() && dest.back()->GetTriangleCount() == 0 )
 dest.erase( dest.end() - 1 );
 
 dest.push_back( std::make_unique<TRIANGULATED_POLYGON>( forOutline ) );
 PolygonTriangulation tess( *dest.back() );
 
 // If the tessellation fails, we re-fracture the polygon, which will
 // first simplify the system before fracturing and removing the holes
 // This may result in multiple, disjoint polygons.
 if( !tess.TesselatePolygon( polySet.Polygon( 0 ).front() ) )
 {
 ++pass;
 
 if( pass == 1 )
 polySet.Fracture( PM_FAST );
 else if( pass == 2 )
 polySet.Fracture( PM_STRICTLY_SIMPLE );
 else
 break;
 
 triangulationValid = false;
 continue;
 }
 
 polySet.DeletePolygon( 0 );
 triangulationValid = true;
 }
 
 return triangulationValid;
 };
 
 m_triangulatedPolys.clear();
 m_triangulationValid = true;
 
 if( aPartition )
 {
 for( int ii = 0; ii < OutlineCount(); ++ii )
 {
 // This partitions into regularly-sized grids (1cm in Pcbnew)
 SHAPE_POLY_SET flattened( Outline( ii ) );
 
 for( int jj = 0; jj < HoleCount( ii ); ++jj )
 flattened.AddHole( Hole( ii, jj ) );
 
 flattened.ClearArcs();
 
 if( flattened.HasHoles() || flattened.IsSelfIntersecting() )
 flattened.Fracture( PM_FAST );
 else if( aSimplify )
 flattened.Simplify( PM_FAST );
 
 SHAPE_POLY_SET partitions = partitionPolyIntoRegularCellGrid( flattened, 1e7 );
 
 // This pushes the triangulation for all polys in partitions
 // to be referenced to the ii-th polygon
 m_triangulationValid &= triangulate( partitions, ii , m_triangulatedPolys );
 }
 }
 else
 {
 SHAPE_POLY_SET tmpSet( *this );
 
 tmpSet.ClearArcs();
 
 if( tmpSet.HasHoles() || tmpSet.IsSelfIntersecting() )
 tmpSet.Fracture( PM_FAST );
 else if( aSimplify )
 tmpSet.Simplify( PM_FAST );
 
 m_triangulationValid = triangulate( tmpSet, -1, m_triangulatedPolys );
 }
 
 if( m_triangulationValid )
 m_hash = checksum();
}

References AddHole(), checksum(), ClearArcs(), DeletePolygon(), Fracture(), HasHoles(), Hole(), HoleCount(), IsSelfIntersecting(), MD5_HASH::IsValid(), m_hash, m_triangulatedPolys, m_triangulationValid, Outline(), OutlineCount(), partitionPolyIntoRegularCellGrid(), PM_FAST, PM_STRICTLY_SIMPLE, Polygon(), Simplify(), and PolygonTriangulation::TesselatePolygon().

Referenced by FOOTPRINT::BuildCourtyardCaches(), ZONE::CacheTriangulation(), Collide(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), Mirror(), Rotate(), PNS_KICAD_IFACE_BASE::syncZone(), and KIFONT::OUTLINE_GLYPH::Triangulate().

◆ CalcShape()

SGNODE * SHAPE::CalcShape	(	SGNODE *	aParent,
		SGNODE *	aColor,
		WRL1_ORDER	aVertexOrder,
		float	aCreaseLimit = `0.74317`,
		bool	isVRML2 = `false`
	)

inherited

Definition at line 703 of file wrlfacet.cpp.

{
 if( facets.empty() || !facets.front()->HasMinPoints() )
 return nullptr;
 
 std::vector< std::list< FACET* > > flist;
 
 // determine the max. index and size flist as appropriate
 std::list< FACET* >::iterator sF = facets.begin();
 std::list< FACET* >::iterator eF = facets.end();
 
 int maxIdx = 0;
 int tmi;
 float maxV = 0.0;
 float tV = 0.0;
 
 while( sF != eF )
 {
 tV = ( *sF )->CalcFaceNormal();
 tmi = ( *sF )->GetMaxIndex();
 
 if( tmi > maxIdx )
 maxIdx = tmi;
 
 if( tV > maxV )
 maxV = tV;
 
 ++sF;
 }
 
 ++maxIdx;
 
 if( maxIdx < 3 )
 return nullptr;
 
 flist.resize( maxIdx );
 
 // create the lists of facets common to indices
 sF = facets.begin();
 
 while( sF != eF )
 {
 ( *sF )->Renormalize( tV );
 ( *sF )->CollectVertices( flist );
 ++sF;
 }
 
 // calculate the normals
 size_t vs = flist.size();
 
 for( size_t i = 0; i < vs; ++i )
 {
 sF = flist[i].begin();
 eF = flist[i].end();
 
 while( sF != eF )
 {
 ( *sF )->CalcVertexNormal( static_cast<int>( i ), flist[i], aCreaseLimit );
 ++sF;
 }
 }
 
 std::vector< WRLVEC3F > vertices;
 std::vector< WRLVEC3F > normals;
 std::vector< SGCOLOR > colors;
 
 // push the facet data to the final output list
 sF = facets.begin();
 eF = facets.end();
 
 while( sF != eF )
 {
 ( *sF )->GetData( vertices, normals, colors, aVertexOrder );
 ++sF;
 }
 
 flist.clear();
 
 if( vertices.size() < 3 )
 return nullptr;
 
 IFSG_SHAPE shapeNode( false );
 
 if( !isVRML2 )
 {
 shapeNode.NewNode( aParent );
 
 if( aColor )
 {
 if( nullptr == S3D::GetSGNodeParent( aColor ) )
 shapeNode.AddChildNode( aColor );
 else
 shapeNode.AddRefNode( aColor );
 }
 }
 
 std::vector< SGPOINT > lCPts; // vertex points in SGPOINT (double) format
 std::vector< SGVECTOR > lCNorm; // per-vertex normals
 vs = vertices.size();
 
 for( size_t i = 0; i < vs; ++i )
 {
 SGPOINT pt;
 pt.x = vertices[i].x;
 pt.y = vertices[i].y;
 pt.z = vertices[i].z;
 lCPts.push_back( pt );
 lCNorm.emplace_back( normals[i].x, normals[i].y, normals[i].z );
 }
 
 vertices.clear();
 normals.clear();
 
 IFSG_FACESET fsNode( false );
 
 if( !isVRML2 )
 fsNode.NewNode( shapeNode );
 else
 fsNode.NewNode( aParent );
 
 IFSG_COORDS cpNode( fsNode );
 cpNode.SetCoordsList( lCPts.size(), &lCPts[0] );
 IFSG_COORDINDEX ciNode( fsNode );
 
 for( int i = 0; i < (int)lCPts.size(); ++i )
 ciNode.AddIndex( i );
 
 IFSG_NORMALS nmNode( fsNode );
 nmNode.SetNormalList( lCNorm.size(), &lCNorm[0] );
 
 if( !colors.empty() )
 {
 IFSG_COLORS nmColor( fsNode );
 nmColor.SetColorList( colors.size(), &colors[0] );
 colors.clear();
 }
 
 if( !isVRML2 )
 return shapeNode.GetRawPtr();
 
 return fsNode.GetRawPtr();
}

References IFSG_NODE::AddChildNode(), IFSG_INDEX::AddIndex(), IFSG_NODE::AddRefNode(), SHAPE::facets, IFSG_NODE::GetRawPtr(), S3D::GetSGNodeParent(), IFSG_FACESET::NewNode(), IFSG_SHAPE::NewNode(), IFSG_COLORS::SetColorList(), IFSG_COORDS::SetCoordsList(), IFSG_NORMALS::SetNormalList(), SGPOINT::x, SGPOINT::y, and SGPOINT::z.

Referenced by WRL2FACESET::TranslateToSG(), X3DIFACESET::TranslateToSG(), and WRL1FACESET::TranslateToSG().

◆ Centre()

virtual VECTOR2I SHAPE::Centre ( ) const

inlinevirtualinherited

Compute a center-of-mass of the shape.

Returns: the center-of-mass point

Definition at line 229 of file shape.h.

 {
 return BBox( 0 ).Centre(); // if nothing better is available....
 }

References SHAPE::BBox(), and BOX2< Vec >::Centre().

Referenced by Collide().

◆ Chamfer()

SHAPE_POLY_SET SHAPE_POLY_SET::Chamfer ( int aDistance )

Return a chamfered version of the polygon set.

Parameters

aDistance is the chamfering distance.

Returns: A set containing the chamfered version of this set.

Definition at line 2413 of file shape_poly_set.cpp.

{
 SHAPE_POLY_SET chamfered;
 
 for( unsigned int idx = 0; idx < m_polys.size(); idx++ )
 chamfered.m_polys.push_back( ChamferPolygon( aDistance, idx ) );
 
 return chamfered;
}

References ChamferPolygon(), and m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone().

◆ chamferFilletPolygon()

SHAPE_POLY_SET::POLYGON SHAPE_POLY_SET::chamferFilletPolygon	(	CORNER_MODE	aMode,
		unsigned int	aDistance,
		int	aIndex,
		int	aErrorMax
	)

private

Return the chamfered or filleted version of the aIndex-th polygon in the set, depending on the aMode selected.

Parameters

aMode	represent which action will be taken: CORNER_MODE::CHAMFERED will return a chamfered version of the polygon, CORNER_MODE::FILLETED will return a filleted version of the polygon.
aDistance	is the chamfering distance if aMode = CHAMFERED; if aMode = FILLETED, is the filleting radius.
aIndex	is the index of the polygon that will be chamfered/filleted.
aErrorMax	is the maximum allowable deviation of the polygon from the circle if aMode = FILLETED. If aMode = CHAMFERED, it is unused.

Returns: the chamfered/filleted version of the polygon. Return true if the polygon set has any holes that touch share a vertex.

Definition at line 2435 of file shape_poly_set.cpp.

{
 // Null segments create serious issues in calculations. Remove them:
 RemoveNullSegments();
 
 SHAPE_POLY_SET::POLYGON currentPoly = Polygon( aIndex );
 SHAPE_POLY_SET::POLYGON newPoly;
 
 // If the chamfering distance is zero, then the polygon remain intact.
 if( aDistance == 0 )
 {
 return currentPoly;
 }
 
 // Iterate through all the contours (outline and holes) of the polygon.
 for( SHAPE_LINE_CHAIN& currContour : currentPoly )
 {
 // Generate a new contour in the new polygon
 SHAPE_LINE_CHAIN newContour;
 
 // Iterate through the vertices of the contour
 for( int currVertex = 0; currVertex < currContour.PointCount(); currVertex++ )
 {
 // Current vertex
 int x1 = currContour.CPoint( currVertex ).x;
 int y1 = currContour.CPoint( currVertex ).y;
 
 // Indices for previous and next vertices.
 int prevVertex;
 int nextVertex;
 
 // Previous and next vertices indices computation. Necessary to manage the edge cases.
 
 // Previous vertex is the last one if the current vertex is the first one
 prevVertex = currVertex == 0 ? currContour.PointCount() - 1 : currVertex - 1;
 
 // next vertex is the first one if the current vertex is the last one.
 nextVertex = currVertex == currContour.PointCount() - 1 ? 0 : currVertex + 1;
 
 // Previous vertex computation
 double xa = currContour.CPoint( prevVertex ).x - x1;
 double ya = currContour.CPoint( prevVertex ).y - y1;
 
 // Next vertex computation
 double xb = currContour.CPoint( nextVertex ).x - x1;
 double yb = currContour.CPoint( nextVertex ).y - y1;
 
 // Compute the new distances
 double lena = hypot( xa, ya );
 double lenb = hypot( xb, yb );
 
 // Make the final computations depending on the mode selected, chamfered or filleted.
 if( aMode == CORNER_MODE::CHAMFERED )
 {
 double distance = aDistance;
 
 // Chamfer one half of an edge at most
 if( 0.5 * lena < distance )
 distance = 0.5 * lena;
 
 if( 0.5 * lenb < distance )
 distance = 0.5 * lenb;
 
 int nx1 = KiROUND( distance * xa / lena );
 int ny1 = KiROUND( distance * ya / lena );
 
 newContour.Append( x1 + nx1, y1 + ny1 );
 
 int nx2 = KiROUND( distance * xb / lenb );
 int ny2 = KiROUND( distance * yb / lenb );
 
 newContour.Append( x1 + nx2, y1 + ny2 );
 }
 else // CORNER_MODE = FILLETED
 {
 double cosine = ( xa * xb + ya * yb ) / ( lena * lenb );
 
 double radius = aDistance;
 double denom = sqrt( 2.0 / ( 1 + cosine ) - 1 );
 
 // Do nothing in case of parallel edges
 if( std::isinf( denom ) )
 continue;
 
 // Limit rounding distance to one half of an edge
 if( 0.5 * lena * denom < radius )
 radius = 0.5 * lena * denom;
 
 if( 0.5 * lenb * denom < radius )
 radius = 0.5 * lenb * denom;
 
 // Calculate fillet arc absolute center point (xc, yx)
 double k = radius / sqrt( .5 * ( 1 - cosine ) );
 double lenab = sqrt( ( xa / lena + xb / lenb ) * ( xa / lena + xb / lenb ) +
 ( ya / lena + yb / lenb ) * ( ya / lena + yb / lenb ) );
 double xc = x1 + k * ( xa / lena + xb / lenb ) / lenab;
 double yc = y1 + k * ( ya / lena + yb / lenb ) / lenab;
 
 // Calculate arc start and end vectors
 k = radius / sqrt( 2 / ( 1 + cosine ) - 1 );
 double xs = x1 + k * xa / lena - xc;
 double ys = y1 + k * ya / lena - yc;
 double xe = x1 + k * xb / lenb - xc;
 double ye = y1 + k * yb / lenb - yc;
 
 // Cosine of arc angle
 double argument = ( xs * xe + ys * ye ) / ( radius * radius );
 
 // Make sure the argument is in [-1,1], interval in which the acos function is
 // defined
 if( argument < -1 )
 argument = -1;
 else if( argument > 1 )
 argument = 1;
 
 double arcAngle = acos( argument );
 int segments = GetArcToSegmentCount( radius, aErrorMax,
 EDA_ANGLE( arcAngle, RADIANS_T ) );
 
 double deltaAngle = arcAngle / segments;
 double startAngle = atan2( -ys, xs );
 
 // Flip arc for inner corners
 if( xa * yb - ya * xb <= 0 )
 deltaAngle *= -1;
 
 double nx = xc + xs;
 double ny = yc + ys;
 
 newContour.Append( KiROUND( nx ), KiROUND( ny ) );
 
 // Store the previous added corner to make a sanity check
 int prevX = KiROUND( nx );
 int prevY = KiROUND( ny );
 
 for( int j = 0; j < segments; j++ )
 {
 nx = xc + cos( startAngle + ( j + 1 ) * deltaAngle ) * radius;
 ny = yc - sin( startAngle + ( j + 1 ) * deltaAngle ) * radius;
 
 // Sanity check: the rounding can produce repeated corners; do not add them.
 if( KiROUND( nx ) != prevX || KiROUND( ny ) != prevY )
 {
 newContour.Append( KiROUND( nx ), KiROUND( ny ) );
 prevX = KiROUND( nx );
 prevY = KiROUND( ny );
 }
 }
 }
 }
 
 // Close the current contour and add it the new polygon
 newContour.SetClosed( true );
 newPoly.push_back( newContour );
 }
 
 return newPoly;
}

References SHAPE_LINE_CHAIN::Append(), SHAPE_LINE_CHAIN::CPoint(), distance(), GetArcToSegmentCount(), KiROUND(), Polygon(), RADIANS_T, RemoveNullSegments(), SHAPE_LINE_CHAIN::SetClosed(), and VECTOR2< T >::x.

Referenced by ChamferPolygon(), and FilletPolygon().

◆ ChamferPolygon()

SHAPE_POLY_SET::POLYGON SHAPE_POLY_SET::ChamferPolygon	(	unsigned int	aDistance,
		int	aIndex
	)

Return a chamfered version of the aIndex-th polygon.

Parameters

aDistance	is the chamfering distance.
aIndex	is the index of the polygon to be chamfered.

Returns: A polygon containing the chamfered version of the aIndex-th polygon.

Definition at line 2264 of file shape_poly_set.cpp.

{
 return chamferFilletPolygon( CHAMFERED, aDistance, aIndex, 0 );
}

References CHAMFERED, and chamferFilletPolygon().

Referenced by Chamfer().

◆ checksum()

MD5_HASH SHAPE_POLY_SET::checksum ( ) const

private

Definition at line 2817 of file shape_poly_set.cpp.

{
 MD5_HASH hash;
 
 hash.Hash( m_polys.size() );
 
 for( const POLYGON& outline : m_polys )
 {
 hash.Hash( outline.size() );
 
 for( const SHAPE_LINE_CHAIN& lc : outline )
 {
 hash.Hash( lc.PointCount() );
 
 for( int i = 0; i < lc.PointCount(); i++ )
 {
 hash.Hash( lc.CPoint( i ).x );
 hash.Hash( lc.CPoint( i ).y );
 }
 }
 }
 
 hash.Finalize();
 
 return hash;
}

References MD5_HASH::Finalize(), MD5_HASH::Hash(), and m_polys.

Referenced by CacheTriangulation(), DeletePolygonAndTriangulationData(), GetHash(), IsTriangulationUpToDate(), Move(), and UpdateTriangulationDataHash().

◆ CHole()

const SHAPE_LINE_CHAIN & SHAPE_POLY_SET::CHole	(	int	aOutline,
		int	aHole
	)		const

inline

Definition at line 737 of file shape_poly_set.h.

 {
 return m_polys[aOutline][aHole + 1];
 }

References m_polys.

Referenced by TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), BuildBBoxCaches(), containsSingle(), KIGFX::PCB_PAINTER::draw(), CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape(), GEOM_TEST::IsPolySetValid(), ZONE_CREATE_HELPER::performZoneCutout(), PlotLayerOutlines(), and HYPERLYNX_EXPORTER::writeNetObjects().

◆ CIterate() [1/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( ) const

inline

Definition at line 834 of file shape_poly_set.h.

 {
 return CIterate( 0, OutlineCount() - 1 );
 }

References CIterate(), and OutlineCount().

Referenced by CIterate(), and CIterateWithHoles().

◆ CIterate() [2/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate	(	int	aFirst,
		int	aLast,
		bool	aIterateHoles = `false`
	)		const

inline

Definition at line 810 of file shape_poly_set.h.

 {
 CONST_ITERATOR iter;
 
 iter.m_poly = const_cast<SHAPE_POLY_SET*>( this );
 iter.m_currentPolygon = aFirst;
 iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
 iter.m_currentContour = 0;
 iter.m_currentVertex = 0;
 iter.m_iterateHoles = aIterateHoles;
 
 return iter;
 }

References SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentContour, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentPolygon, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentVertex, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_iterateHoles, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_lastPolygon, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_poly, and OutlineCount().

Referenced by ConvertOutlineToPolygon(), EDA_SHAPE::DupPolyPointsList(), and EDA_SHAPE::getBoundingBox().

◆ CIterate() [3/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( int aOutline ) const

inline

Definition at line 824 of file shape_poly_set.h.

 {
 return CIterate( aOutline, aOutline );
 }

References CIterate().

◆ CIterateSegments() [1/3]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegments ( ) const

inline

Returns an iterator object, for all outlines in the set (with holes)

Definition at line 915 of file shape_poly_set.h.

References CIterateSegments(), and OutlineCount().

Referenced by CIterateSegments(), and CIterateSegmentsWithHoles().

◆ CIterateSegments() [2/3]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegments	(	int	aFirst,
		int	aLast,
		bool	aIterateHoles = `false`
	)		const

inline

Return an iterator object, for iterating aPolygonIdx-th polygon edges.

Definition at line 881 of file shape_poly_set.h.

References SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_currentContour, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_currentPolygon, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_currentSegment, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_iterateHoles, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_lastPolygon, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_poly, and OutlineCount().

Referenced by BRDITEMS_PLOTTER::PlotPcbShape(), projectPointOnSegment(), and PCB_DIMENSION_BASE::segPolyIntersection().

◆ CIterateSegments() [3/3]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegments ( int aPolygonIdx ) const

inline

Return an iterator object, for all outlines in the set (no holes).

Definition at line 903 of file shape_poly_set.h.

References CIterateSegments().

◆ CIterateSegmentsWithHoles() [1/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegmentsWithHoles ( ) const

inline

Return an iterator object, for the aOutline-th outline in the set (with holes).

Definition at line 933 of file shape_poly_set.h.

References CIterateSegments(), and OutlineCount().

Referenced by CollideEdge(), IsPolygonSelfIntersecting(), and SquaredDistanceToPolygon().

◆ CIterateSegmentsWithHoles() [2/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegmentsWithHoles ( int aOutline ) const

inline

Definition at line 939 of file shape_poly_set.h.

 {
 return CIterateSegments( aOutline, aOutline, true );
 }

References CIterateSegments().

◆ CIterateWithHoles() [1/2]

CONST_ITERATOR SHAPE_POLY_SET::CIterateWithHoles ( ) const

inline

Definition at line 839 of file shape_poly_set.h.

 {
 return CIterate( 0, OutlineCount() - 1, true );
 }

References CIterate(), and OutlineCount().

Referenced by CollideVertex().

◆ CIterateWithHoles() [2/2]

CONST_ITERATOR SHAPE_POLY_SET::CIterateWithHoles ( int aOutline ) const

inline

Definition at line 829 of file shape_poly_set.h.

 {
 return CIterate( aOutline, aOutline, true );
 }

References CIterate().

Referenced by PCB_POINT_EDITOR::buildForPolyOutline(), ZONE::CIterateWithHoles(), and PCB_GRID_HELPER::computeAnchors().

◆ ClearArcs()

void SHAPE_POLY_SET::ClearArcs ( )

Appends a vertex at the end of the given outline/hole (default: the last outline)

Definition at line 602 of file shape_poly_set.cpp.

{
 for( POLYGON& poly : m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 poly[i].ClearArcs();
 }
}

References ClearArcs(), and m_polys.

Referenced by BOOST_AUTO_TEST_CASE(), ZONE::BuildSmoothedPoly(), CacheTriangulation(), ClearArcs(), CONVERT_TOOL::CreatePolys(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), and ZONE_FILLER::subtractHigherPriorityZones().

◆ Clone()

SHAPE * SHAPE_POLY_SET::Clone ( ) const

overridevirtual

Return a dynamically allocated copy of the shape.

Return values

copy	of the shape

Reimplemented from SHAPE.

Definition at line 133 of file shape_poly_set.cpp.

{
 return new SHAPE_POLY_SET( *this );
}

References SHAPE_POLY_SET().

◆ CloneDropTriangulation()

SHAPE_POLY_SET SHAPE_POLY_SET::CloneDropTriangulation ( ) const

Creates a new empty polygon in the set and returns its index.

Definition at line 139 of file shape_poly_set.cpp.

{
 return SHAPE_POLY_SET( *this, DROP_TRIANGULATION_FLAG::SINGLETON );
}

References SHAPE_POLY_SET().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), ZONE::BuildSmoothedPoly(), collidesWithArea(), AR_AUTOPLACER::drawPlacementRoutingMatrix(), ZONE_FILLER::fillCopperZone(), AR_AUTOPLACER::fillMatrix(), GERBER_PLOTTER::FlashPadCustom(), isCopperOutside(), BRDITEMS_PLOTTER::PlotPcbShape(), PlotStandardLayer(), RENDER_3D_OPENGL::reload(), DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_TEXT_DIMS::Run(), HYPERLYNX_EXPORTER::writeNetObjects(), GBR_TO_PCB_EXPORTER::writePcbZoneItem(), and zonesNeedUpdate().

◆ Collide() [1/4]

bool SHAPE_POLY_SET::Collide	(	const SEG &	aSeg,
		int	aClearance = `0`,
		int *	aActual = `nullptr`,
		VECTOR2I *	aLocation = `nullptr`
	)		const

overridevirtual

Check whether the segment aSeg collides with the polygon set (or its edge).

Note that prior to Jul 2020 we considered the edge to not be part of the polygon. However, most other shapes (rects, circles, segments, etc.) include their edges and the difference was causing issues when used for DRC.

(FWIW, SHAPE_LINE_CHAIN was a split personality, with Collide() including its edges but PointInside() not. That has also been corrected.)

Parameters

aSeg	is the SEG segment whose collision with respect to the poly set will be tested.
aClearance	is the security distance; if the segment passes closer to the polygon than aClearance distance, then there is a collision.
aActual	an optional pointer to an int to store the actual distance in the event of a collision.

Returns: true if the segment aSeg collides with the polygon, false in any other case.

Implements SHAPE.

Definition at line 1794 of file shape_poly_set.cpp.

{
 VECTOR2I nearest;
 ecoord dist_sq = SquaredDistance( aSeg, aLocation ? &nearest : nullptr );
 
 if( dist_sq == 0 || dist_sq < SEG::Square( aClearance ) )
 {
 if( aLocation )
 *aLocation = nearest;
 
 if( aActual )
 *aActual = sqrt( dist_sq );
 
 return true;
 }
 
 return false;
}

References SEG::Square(), and SquaredDistance().

◆ Collide() [2/4]

bool SHAPE::Collide	(	const SHAPE *	aShape,
		int	aClearance,
		VECTOR2I *	aMTV
	)		const

virtualinherited

Check if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating a collision.

Parameters

aShape	shape to check collision against
aClearance	minimum clearance
aMTV	minimum translation vector
aActual	[out] an optional pointer to an int to store the actual distance in the event of a collision.
aLocation	[out] an option pointer to a point to store a nearby location in the event of a collision.

Returns: true, if there is a collision.

Reimplemented in SHAPE_COMPOUND, SHAPE_RECT, and SHAPE_SEGMENT.

Definition at line 1109 of file shape_collisions.cpp.

{
 return collideShapes( this, aShape, aClearance, nullptr, nullptr, aMTV );
}

References collideShapes().

◆ Collide() [3/4]

bool SHAPE_POLY_SET::Collide	(	const SHAPE *	aShape,
		int	aClearance = `0`,
		int *	aActual = `nullptr`,
		VECTOR2I *	aLocation = `nullptr`
	)		const

overridevirtual

Check if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating a collision.

Parameters

aShape	shape to check collision against
aClearance	minimum clearance
aActual	[out] an optional pointer to an int to store the actual distance in the event of a collision.
aLocation	[out] an option pointer to a point to store a nearby location in the event of a collision.

Returns: true if there is a collision.

Reimplemented from SHAPE.

Definition at line 1839 of file shape_poly_set.cpp.

{
 // A couple of simple cases are worth trying before we fall back on triangulation.
 
 if( aShape->Type() == SH_SEGMENT )
 {
 const SHAPE_SEGMENT* segment = static_cast<const SHAPE_SEGMENT*>( aShape );
 int extra = segment->GetWidth() / 2;
 
 if( Collide( segment->GetSeg(), aClearance + extra, aActual, aLocation ) )
 {
 if( aActual )
 *aActual = std::max( 0, *aActual - extra );
 
 return true;
 }
 
 return false;
 }
 
 if( aShape->Type() == SH_CIRCLE )
 {
 const SHAPE_CIRCLE* circle = static_cast<const SHAPE_CIRCLE*>( aShape );
 int extra = circle->GetRadius();
 
 if( Collide( circle->GetCenter(), aClearance + extra, aActual, aLocation ) )
 {
 if( aActual )
 *aActual = std::max( 0, *aActual - extra );
 
 return true;
 }
 
 return false;
 }
 
 const_cast<SHAPE_POLY_SET*>( this )->CacheTriangulation( false );
 
 int actual = INT_MAX;
 VECTOR2I location;
 
 for( const std::unique_ptr<TRIANGULATED_POLYGON>& tpoly : m_triangulatedPolys )
 {
 for( const TRIANGULATED_POLYGON::TRI& tri : tpoly->Triangles() )
 {
 if( aActual || aLocation )
 {
 int triActual;
 VECTOR2I triLocation;
 
 if( aShape->Collide( &tri, aClearance, &triActual, &triLocation ) )
 {
 if( triActual < actual )
 {
 actual = triActual;
 location = triLocation;
 }
 }
 }
 else // A much faster version of above
 {
 if( aShape->Collide( &tri, aClearance ) )
  return true;
 }
 }
 }
 
 if( actual < INT_MAX )
 {
 if( aActual )
 *aActual = std::max( 0, actual );
 
 if( aLocation )
 *aLocation = location;
 
 return true;
 }
 
 return false;
}

References CacheTriangulation(), Collide(), SHAPE::Collide(), SHAPE_CIRCLE::GetCenter(), SHAPE_CIRCLE::GetRadius(), SHAPE_SEGMENT::GetSeg(), SHAPE_SEGMENT::GetWidth(), m_triangulatedPolys, SH_CIRCLE, SH_SEGMENT, and SHAPE_BASE::Type().

Referenced by Collide(), collidesWithArea(), collidesWithCourtyard(), DRAWING_TOOL::DrawVia(), ZONE_FILLER::Fill(), ZONE::GetInteractingZones(), EDA_SHAPE::hitTest(), DS_DRAW_ITEM_POLYPOLYGONS::HitTest(), FOOTPRINT::HitTestAccurate(), PCB_SELECTION_TOOL::hitTestDistance(), DIALOG_PAD_PROPERTIES::padValuesOK(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_INTERACTIVE_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_PHYSICAL_CLEARANCE::testItemAgainstZones(), and PCB_TEXT::TextHitTest().

◆ Collide() [4/4]

bool SHAPE_POLY_SET::Collide	(	const VECTOR2I &	aP,
		int	aClearance = `0`,
		int *	aActual = `nullptr`,
		VECTOR2I *	aLocation = `nullptr`
	)		const

overridevirtual

Check whether the point aP is either inside or on the edge of the polygon set.

Note that prior to Jul 2020 we considered the edge to not be part of the polygon. However, most other shapes (rects, circles, segments, etc.) include their edges and the difference was causing issues when used for DRC.

(FWIW, SHAPE_LINE_CHAIN was a split personality, with Collide() including its edges but PointInside() not. That has also been corrected.)

Parameters

aP	is the VECTOR2I point whose collision with respect to the poly set will be tested.
aClearance	is the security distance; if the point lies closer to the polygon than aClearance distance, then there is a collision.
aActual	an optional pointer to an int to store the actual distance in the event of a collision.

Returns: true if the point aP collides with the polygon; false in any other case.

Reimplemented from SHAPE.

Definition at line 1815 of file shape_poly_set.cpp.

{
 if( IsEmpty() || VertexCount() == 0 )
 return false;
 
 VECTOR2I nearest;
 ecoord dist_sq = SquaredDistance( aP, aLocation ? &nearest : nullptr );
 
 if( dist_sq == 0 || dist_sq < SEG::Square( aClearance ) )
 {
 if( aLocation )
 *aLocation = nearest;
 
 if( aActual )
 *aActual = sqrt( dist_sq );
 
 return true;
 }
 
 return false;
}

References IsEmpty(), SEG::Square(), SquaredDistance(), and VertexCount().

◆ CollideEdge()

bool SHAPE_POLY_SET::CollideEdge	(	const VECTOR2I &	aPoint,
		SHAPE_POLY_SET::VERTEX_INDEX *	aClosestVertex = `nullptr`,
		int	aClearance = `0`
	)		const

Check whether aPoint collides with any edge of any of the contours of the polygon.

Parameters

aPoint	is the VECTOR2I point whose collision with respect to the polygon will be tested.
aClearance	is the security distance; if `aPoint` lies closer to a vertex than aClearance distance, then there is a collision.
aClosestVertex	is the index of the closes vertex to `aPoint`.

Returns: bool - true if there is a collision, false in any other case.

Definition at line 2083 of file shape_poly_set.cpp.

{
 // Shows whether there was a collision
 bool collision = false;
 ecoord clearance_squared = SEG::Square( aClearance );
 
 for( CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles(); iterator; iterator++ )
 {
 const SEG currentSegment = *iterator;
 ecoord distance_squared = currentSegment.SquaredDistance( aPoint );
 
 // Check for collisions
 if( distance_squared <= clearance_squared )
 {
 if( !aClosestVertex )
 return true;
 
 collision = true;
 
 // Update clearance to look for closer edges
 clearance_squared = distance_squared;
 
 // Store the indices that identify the vertex
 *aClosestVertex = iterator.GetIndex();
 }
 }
 
 return collision;
}

References CIterateSegmentsWithHoles(), SEG::Square(), and SEG::SquaredDistance().

Referenced by EDA_SHAPE::hitTest(), and ZONE::HitTestForEdge().

◆ CollideVertex()

bool SHAPE_POLY_SET::CollideVertex	(	const VECTOR2I &	aPoint,
		SHAPE_POLY_SET::VERTEX_INDEX *	aClosestVertex = `nullptr`,
		int	aClearance = `0`
	)		const

Check whether aPoint collides with any vertex of any of the contours of the polygon.

Parameters

aPoint	is the VECTOR2I point whose collision with respect to the polygon will be tested.
aClearance	is the security distance; if `aPoint` lies closer to a vertex than aClearance distance, then there is a collision.
aClosestVertex	is the index of the closes vertex to `aPoint`.

Returns: bool - true if there is a collision, false in any other case.

Definition at line 2043 of file shape_poly_set.cpp.

{
 // Shows whether there was a collision
 bool collision = false;
 
 // Difference vector between each vertex and aPoint.
 VECTOR2D delta;
 ecoord distance_squared;
 ecoord clearance_squared = SEG::Square( aClearance );
 
 for( CONST_ITERATOR iterator = CIterateWithHoles(); iterator; iterator++ )
 {
 // Get the difference vector between current vertex and aPoint
 delta = *iterator - aPoint;
 
 // Compute distance
 distance_squared = delta.SquaredEuclideanNorm();
 
 // Check for collisions
 if( distance_squared <= clearance_squared )
 {
 if( !aClosestVertex )
 return true;
 
 collision = true;
 
 // Update clearance to look for closer vertices
 clearance_squared = distance_squared;
 
 // Store the indices that identify the vertex
 *aClosestVertex = iterator.GetIndex();
 }
 }
 
 return collision;
}

References CIterateWithHoles(), delta, and SEG::Square().

Referenced by ZONE::HitTestForCorner().

◆ Contains()

bool SHAPE_POLY_SET::Contains	(	const VECTOR2I &	aP,
		int	aSubpolyIndex = `-1`,
		int	aAccuracy = `0`,
		bool	aUseBBoxCaches = `false`
	)		const

Return true if a given subpolygon contains the point aP.

Parameters

aP	is the point to check
aSubpolyIndex	is the subpolygon to check, or -1 to check all
aUseBBoxCaches	gives faster performance when multiple calls are made with no editing in between, but the caller MUST cache the bbox caches before calling (via BuildBBoxCaches(), above)

Returns: true if the polygon contains the point Return true if the set is empty (no polygons at all)

Definition at line 2128 of file shape_poly_set.cpp.

{
 if( m_polys.empty() )
 return false;
 
 // If there is a polygon specified, check the condition against that polygon
 if( aSubpolyIndex >= 0 )
 return containsSingle( aP, aSubpolyIndex, aAccuracy, aUseBBoxCaches );
 
 // In any other case, check it against all polygons in the set
 for( int polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
 {
 if( containsSingle( aP, polygonIdx, aAccuracy, aUseBBoxCaches ) )
 return true;
 }
 
 return false;
}

References containsSingle(), m_polys, and OutlineCount().

Referenced by ZONE_FILLER::fillCopperZone(), PAD::GetBestAnchorPosition(), CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPad(), GERBER_DRAW_ITEM::HitTest(), ZONE::HitTestFilledArea(), PCB_DIMENSION_BASE::segPolyIntersection(), BOARD::TestZoneIntersection(), PCB_DIM_ALIGNED::updateGeometry(), and PCB_DIM_ORTHOGONAL::updateGeometry().

◆ containsSingle()

bool SHAPE_POLY_SET::containsSingle	(	const VECTOR2I &	aP,
		int	aSubpolyIndex,
		int	aAccuracy,
		bool	aUseBBoxCaches = `false`
	)		const

private

Check whether the point aP is inside the aSubpolyIndex-th polygon of the polyset.

If the points lies on an edge, the polygon is considered to contain it.

Parameters

aP	is the VECTOR2I point whose position with respect to the inside of the aSubpolyIndex-th polygon will be tested.
aSubpolyIndex	is an integer specifying which polygon in the set has to be checked.
aAccuracy	accuracy in internal units
aUseBBoxCaches	gives faster performance when multiple calls are made with no editing in between, but the caller MUST cache the bbox caches before calling (via BuildBBoxCaches(), above)

Returns: true if aP is inside aSubpolyIndex-th polygon; false in any other case.

Definition at line 2184 of file shape_poly_set.cpp.

{
 // Check that the point is inside the outline
 if( m_polys[aSubpolyIndex][0].PointInside( aP, aAccuracy ) )
 {
 // Check that the point is not in any of the holes
 for( int holeIdx = 0; holeIdx < HoleCount( aSubpolyIndex ); holeIdx++ )
 {
 const SHAPE_LINE_CHAIN& hole = CHole( aSubpolyIndex, holeIdx );
 
 // If the point is inside a hole it is outside of the polygon. Do not use aAccuracy
 // here as it's meaning would be inverted.
 if( hole.PointInside( aP, 1, aUseBBoxCaches ) )
 return false;
 }
 
 return true;
 }
 
 return false;
}

References CHole(), HoleCount(), m_polys, and SHAPE_LINE_CHAIN_BASE::PointInside().

Referenced by Contains(), and SquaredDistanceToPolygon().

◆ COutline()

const SHAPE_LINE_CHAIN & SHAPE_POLY_SET::COutline ( int aIndex ) const

inline

Definition at line 732 of file shape_poly_set.h.

 {
 return m_polys[aIndex][0];
 }

References m_polys.

Referenced by STEP_PCB_MODEL::AddPadHole(), PAD::AddPrimitivePoly(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), BuildBBoxCaches(), BuildConvexHull(), PAD::BuildEffectiveShapes(), convertPolygon(), ConvertPolygonToBlocks(), CreatePadsShapesSection(), STEP_PCB_MODEL::CreatePCB(), CONVERT_TOOL::CreatePolys(), KIGFX::PCB_PAINTER::Draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), KIGFX::CAIRO_GAL_BASE::DrawPolygon(), KIGFX::OPENGL_GAL::DrawPolygon(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), KIGFX::PREVIEW::POLYGON_ITEM::drawPreviewShape(), EDA_SHAPE::DupPolyPointsList(), EXPORTER_PCB_VRML::ExportVrmlBoard(), EXPORTER_PCB_VRML::ExportVrmlPolygonSet(), PAD::GetBestAnchorPosition(), FOOTPRINT::GetBoundingHull(), FOOTPRINT::GetEffectiveShape(), EDA_SHAPE::GetLength(), CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape(), DS_DRAW_ITEM_POLYPOLYGONS::HitTest(), CONNECTIVITY_DATA::IsConnectedOnLayer(), FABMASTER::loadGraphics(), FABMASTER::loadPolygon(), EAGLE_PLUGIN::loadPolygon(), EDA_SHAPE::makeEffectiveShapes(), DSN::SPECCTRA_DB::makePADSTACK(), PlotLayerOutlines(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), DXF_PLOTTER::ThickSegment(), HYPERLYNX_EXPORTER::writeBoardInfo(), HYPERLYNX_EXPORTER::writeNetObjects(), and GBR_TO_PCB_EXPORTER::writePcbPolygon().

◆ CPolygon()

const POLYGON & SHAPE_POLY_SET::CPolygon ( int aIndex ) const

inline

Definition at line 742 of file shape_poly_set.h.

 {
 return m_polys[aIndex];
 }

References m_polys.

Referenced by SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::Advance(), SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::Advance(), GetRelativeIndices(), HasTouchingHoles(), SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::IsAdjacent(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::IsEndContour(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::operator bool(), and PlotStandardLayer().

◆ CVertex() [1/3]

const VECTOR2I & SHAPE_POLY_SET::CVertex ( int aGlobalIndex ) const

Return the index-th vertex in a given hole outline within a given outline.

Definition at line 399 of file shape_poly_set.cpp.

{
 SHAPE_POLY_SET::VERTEX_INDEX index;
 
 // Assure the passed index references a legal position; abort otherwise
 if( !GetRelativeIndices( aGlobalIndex, &index ) )
 throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
 
 return m_polys[index.m_polygon][index.m_contour].CPoint( index.m_vertex );
}

References GetRelativeIndices(), SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, m_polys, and SHAPE_POLY_SET::VERTEX_INDEX::m_vertex.

◆ CVertex() [2/3]

const VECTOR2I & SHAPE_POLY_SET::CVertex	(	int	aIndex,
		int	aOutline,
		int	aHole
	)		const

Return the aGlobalIndex-th vertex in the poly set.

Definition at line 380 of file shape_poly_set.cpp.

{
 if( aOutline < 0 )
 aOutline += m_polys.size();
 
 int idx;
 
 if( aHole < 0 )
 idx = 0;
 else
 idx = aHole + 1;
 
 assert( aOutline < (int) m_polys.size() );
 assert( idx < (int) m_polys[aOutline].size() );
 
 return m_polys[aOutline][idx].CPoint( aIndex );
}

References m_polys.

Referenced by PCB_POINT_EDITOR::addCorner(), EDA_SHAPE::Compare(), CVertex(), D_CODE::DrawFlashedPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), GERBER_FILE_IMAGE::Execute_G_Command(), findVertex(), ZONE::GetCornerPosition(), EDA_SHAPE::getPosition(), ZONE::HatchBorder(), ZONE::HitTest(), ZONE::MoveEdge(), FOOTPRINT::cmp_drawings::operator()(), FOOTPRINT::cmp_zones::operator()(), SCH_EDITOR_CONTROL::Paste(), ZONE::SetCornerPosition(), shapesNeedUpdate(), PCB_POINT_EDITOR::updateItem(), PCB_POINT_EDITOR::updatePoints(), and zonesNeedUpdate().

◆ CVertex() [3/3]

const VECTOR2I & SHAPE_POLY_SET::CVertex ( SHAPE_POLY_SET::VERTEX_INDEX index ) const

Definition at line 411 of file shape_poly_set.cpp.

{
 return CVertex( index.m_vertex, index.m_polygon, index.m_contour - 1 );
}

References CVertex(), SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, and SHAPE_POLY_SET::VERTEX_INDEX::m_vertex.

◆ Deflate()

void SHAPE_POLY_SET::Deflate	(	int	aAmount,
		int	aCircleSegmentsCount,
		CORNER_STRATEGY	aCornerStrategy = `ROUND_ALL_CORNERS`
	)

inline

Definition at line 1014 of file shape_poly_set.h.

 {
 Inflate( -aAmount, aCircleSegmentsCount, aCornerStrategy );
 }

References Inflate().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), DRC_TEST_PROVIDER_SOLDER_MASK::buildRTrees(), collidesWithArea(), KIGFX::PCB_PAINTER::draw(), ZONE_FILLER::fillCopperZone(), ZONE_FILLER::fillNonCopperZone(), PCB_BASE_FRAME::FocusOnItems(), PlotSolderMaskLayer(), DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_SLIVER_CHECKER::Run(), DRC_TEST_PROVIDER_TEXT_DIMS::Run(), KIGFX::VIEW::SetCenter(), and TEARDROP_MANAGER::SetTeardrops().

◆ DeletePolygon()

void SHAPE_POLY_SET::DeletePolygon ( int aIdx )

Delete aIdx-th polygon and its triangulation data from the set.

If called with aUpdateHash false, caller must call UpdateTriangulationDataHash().

Definition at line 1997 of file shape_poly_set.cpp.

{
 m_polys.erase( m_polys.begin() + aIdx );
}

References m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BOOST_AUTO_TEST_CASE(), CacheTriangulation(), ZONE_FILLER::fillCopperZone(), and PlotStandardLayer().

◆ DeletePolygonAndTriangulationData()

void SHAPE_POLY_SET::DeletePolygonAndTriangulationData	(	int	aIdx,
		bool	aUpdateHash = `true`
	)

Definition at line 2003 of file shape_poly_set.cpp.

{
 m_polys.erase( m_polys.begin() + aIdx );
 
 if( m_triangulationValid )
 {
 for( int ii = m_triangulatedPolys.size() - 1; ii >= 0; --ii )
 {
 std::unique_ptr<TRIANGULATED_POLYGON>& triangleSet = m_triangulatedPolys[ii];
 
 if( triangleSet->GetSourceOutlineIndex() == aIdx )
 m_triangulatedPolys.erase( m_triangulatedPolys.begin() + ii );
 else if( triangleSet->GetSourceOutlineIndex() > aIdx )
 triangleSet->SetSourceOutlineIndex( triangleSet->GetSourceOutlineIndex() - 1 );
 }
 
 if( aUpdateHash )
 m_hash = checksum();
 }
}

References checksum(), m_hash, m_polys, m_triangulatedPolys, and m_triangulationValid.

◆ Fillet()

SHAPE_POLY_SET SHAPE_POLY_SET::Fillet	(	int	aRadius,
		int	aErrorMax
	)

Return a filleted version of the polygon set.

Parameters

aRadius	is the fillet radius.
aErrorMax	is the maximum allowable deviation of the polygon from the circle

Returns: A set containing the filleted version of this set.

Definition at line 2424 of file shape_poly_set.cpp.

{
 SHAPE_POLY_SET filleted;
 
 for( size_t idx = 0; idx < m_polys.size(); idx++ )
 filleted.m_polys.push_back( FilletPolygon( aRadius, aErrorMax, idx ) );
 
 return filleted;
}

References FilletPolygon(), and m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone().

◆ FilletPolygon()

SHAPE_POLY_SET::POLYGON SHAPE_POLY_SET::FilletPolygon	(	unsigned int	aRadius,
		int	aErrorMax,
		int	aIndex
	)

Return a filleted version of the aIndex-th polygon.

Parameters

aRadius	is the fillet radius.
aErrorMax	is the maximum allowable deviation of the polygon from the circle
aIndex	is the index of the polygon to be filleted

Returns: A polygon containing the filleted version of the aIndex-th polygon.

Definition at line 2270 of file shape_poly_set.cpp.

{
 return chamferFilletPolygon( FILLETED, aRadius, aIndex, aErrorMax );
}

References chamferFilletPolygon(), and FILLETED.

Referenced by Fillet(), and GEOM_TEST::FilletPolySet().

◆ Format()

const std::string SHAPE_POLY_SET::Format ( bool aCplusPlus = true ) const

overridevirtual

Reimplemented from SHAPE.

Definition at line 1654 of file shape_poly_set.cpp.

{
 std::stringstream ss;
 
 ss << "SHAPE_LINE_CHAIN poly; \n";
 
 for( unsigned i = 0; i < m_polys.size(); i++ )
 {
 for( unsigned j = 0; j < m_polys[i].size(); j++ )
 {
 
 ss << "{ auto tmp = " << m_polys[i][j].Format() << ";\n";
 
 SHAPE_POLY_SET poly;
 
 if( j == 0 )
 {
 ss << " poly.AddOutline(tmp); } \n";
 }
 else
 {
 ss << " poly.AddHole(tmp); } \n";
 }
 
 }
 }
 
 return ss.str();
}

References m_polys.

◆ Fracture()

void SHAPE_POLY_SET::Fracture ( POLYGON_MODE aFastMode )

Convert a single outline slitted ("fractured") polygon into a set ouf outlines with holes.

Definition at line 1408 of file shape_poly_set.cpp.

{
 Simplify( aFastMode ); // remove overlapping holes/degeneracy
 
 for( POLYGON& paths : m_polys )
 fractureSingle( paths );
}

References fractureSingle(), m_polys, and Simplify().

Referenced by addHoleToPolygon(), PAD::addPadPrimitivesToPolygon(), PAD::AddPrimitivePoly(), BOARD_ADAPTER::addText(), CacheTriangulation(), convertPolygon(), BITMAPCONV_INFO::createOutputData(), KIGFX::PCB_PAINTER::draw(), CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarShape(), CALLBACK_GAL::DrawGlyph(), AR_AUTOPLACER::drawPlacementRoutingMatrix(), EXPORTER_PCB_VRML::ExportStandardLayers(), EXPORTER_PCB_VRML::ExportVrmlSolderMask(), ZONE_FILLER::fillCopperZone(), AR_AUTOPLACER::fillMatrix(), ZONE_FILLER::fillNonCopperZone(), APERTURE_MACRO::GetApertureMacroShape(), FP_TEXT::GetEffectiveShape(), PCB_TEXT::GetEffectiveShape(), InflateWithLinkedHoles(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadShapePolySet(), ALTIUM_PCB::ParseRegions6Data(), BRDITEMS_PLOTTER::PlotFootprintShape(), BRDITEMS_PLOTTER::PlotPcbShape(), BRDITEMS_PLOTTER::PlotPcbText(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), RENDER_3D_RAYTRACE::Reload(), DRC_TEST_PROVIDER_DISALLOW::Run(), EDA_SHAPE::SetPolyShape(), TransformRingToPolygon(), PAD::TransformShapeToPolygon(), and ZONE::TransformSmoothedOutlineToPolygon().

◆ fractureSingle()

void SHAPE_POLY_SET::fractureSingle ( POLYGON & paths )

private

Definition at line 1292 of file shape_poly_set.cpp.

{
 FractureEdgeSet edges;
 FractureEdgeSet border_edges;
 FractureEdge* root = nullptr;
 
 bool first = true;
 
 if( paths.size() == 1 )
 return;
 
 int num_unconnected = 0;
 
 for( const SHAPE_LINE_CHAIN& path : paths )
 {
 const std::vector<VECTOR2I>& points = path.CPoints();
 int pointCount = points.size();
 
 FractureEdge* prev = nullptr, * first_edge = nullptr;
 
 int x_min = std::numeric_limits<int>::max();
 
 for( int i = 0; i < pointCount; i++ )
 {
 if( points[i].x < x_min )
 x_min = points[i].x;
 
 // Do not use path.CPoint() here; open-coding it using the local variables "points"
 // and "pointCount" gives a non-trivial performance boost to zone fill times.
 FractureEdge* fe = new FractureEdge( first, points[ i ],
 points[ i+1 == pointCount ? 0 : i+1 ] );
 
 if( !root )
 root = fe;
 
 if( !first_edge )
 first_edge = fe;
 
 if( prev )
 prev->m_next = fe;
 
 if( i == pointCount - 1 )
 fe->m_next = first_edge;
 
 prev = fe;
 edges.push_back( fe );
 
 if( !first )
 {
 if( fe->m_p1.x == x_min )
 border_edges.push_back( fe );
 }
 
 if( !fe->m_connected )
 num_unconnected++;
 }
 
 first = false; // first path is always the outline
 }
 
 // keep connecting holes to the main outline, until there's no holes left...
 while( num_unconnected > 0 )
 {
 int x_min = std::numeric_limits<int>::max();
 auto it = border_edges.begin();
 
 FractureEdge* smallestX = nullptr;
 
 // find the left-most hole edge and merge with the outline
 for( ; it != border_edges.end(); ++it )
 {
 FractureEdge* border_edge = *it;
 int xt = border_edge->m_p1.x;
 
 if( ( xt <= x_min ) && !border_edge->m_connected )
 {
 x_min = xt;
 smallestX = border_edge;
 }
 }
 
 int num_processed = processEdge( edges, smallestX );
 
 // If we can't handle the edge, the zone is broken (maybe)
 if( !num_processed )
 {
 wxLogWarning( wxT( "Broken polygon, dropping path" ) );
 
 for( FractureEdge* edge : edges )
 delete edge;
 
 return;
 }
 
 num_unconnected -= num_processed;
 }
 
 paths.clear();
 SHAPE_LINE_CHAIN newPath;
 
 newPath.SetClosed( true );
 
 FractureEdge* e;
 
 for( e = root; e->m_next != root; e = e->m_next )
 newPath.Append( e->m_p1 );
 
 newPath.Append( e->m_p1 );
 
 for( FractureEdge* edge : edges )
 delete edge;
 
 paths.push_back( std::move( newPath ) );
}

References SHAPE_LINE_CHAIN::Append(), FractureEdge::m_connected, FractureEdge::m_next, FractureEdge::m_p1, path, processEdge(), SHAPE_LINE_CHAIN::SetClosed(), and VECTOR2< T >::x.

Referenced by Fracture().

◆ FullPointCount()

int SHAPE_POLY_SET::FullPointCount ( ) const

Returns the number of holes in a given outline.

Definition at line 346 of file shape_poly_set.cpp.

{
 int full_count = 0;
 
 if( m_polys.size() == 0 ) // Empty poly set
 return full_count;
 
 for( int ii = 0; ii < OutlineCount(); ii++ )
 {
 // the first polygon in m_polys[ii] is the main contour,
 // only others are holes:
 for( int idx = 0; idx <= HoleCount( ii ); idx++ )
 {
 full_count += m_polys[ii][idx].PointCount();
 }
 }
 
 return full_count;
}

References HoleCount(), m_polys, and OutlineCount().

Referenced by IsPolygonSelfIntersecting().

◆ GetArcs()

void SHAPE_POLY_SET::GetArcs ( std::vector< SHAPE_ARC > & aArcBuffer ) const

Removes all arc references from all the outlines and holes in the polyset.

Definition at line 589 of file shape_poly_set.cpp.

{
 for( const POLYGON& poly : m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 {
 for( SHAPE_ARC arc : poly[i].m_arcs )
 aArcBuffer.push_back( arc );
 }
 }
}

References m_polys.

Referenced by BOOST_AUTO_TEST_CASE().

◆ GetClearance()

int SHAPE::GetClearance ( const SHAPE * aOther ) const

inherited

Return the actual minimum distance between two shapes.

Return values

distance in IU

Definition at line 49 of file shape.cpp.

{
 int actual_clearance = std::numeric_limits<int>::max();
 std::vector<const SHAPE*> a_shapes;
 std::vector<const SHAPE*> b_shapes;
 
 GetIndexableSubshapes( a_shapes );
 aOther->GetIndexableSubshapes( b_shapes );
 
 if( GetIndexableSubshapeCount() == 0 )
 a_shapes.push_back( this );
 
 if( aOther->GetIndexableSubshapeCount() == 0 )
 b_shapes.push_back( aOther );
 
 for( const SHAPE* a : a_shapes )
 {
 for( const SHAPE* b : b_shapes )
 {
 int temp_dist = 0;
 a->Collide( b, std::numeric_limits<int>::max() / 2, &temp_dist );
 
 if( temp_dist < actual_clearance )
 actual_clearance = temp_dist;
 }
 }
 
 return actual_clearance;
}

References SHAPE_BASE::GetIndexableSubshapeCount(), and SHAPE_BASE::GetIndexableSubshapes().

◆ GetGlobalIndex()

bool SHAPE_POLY_SET::GetGlobalIndex	(	SHAPE_POLY_SET::VERTEX_INDEX	aRelativeIndices,
		int &	aGlobalIdx
	)		const

Compute the global index of a vertex from the relative indices of polygon, contour and vertex.

Parameters

aRelativeIndices	is the set of relative indices.
aGlobalIdx	[out] is the computed global index.

Returns: true if the relative indices are correct; false otherwise. The computed global index is returned in the aGlobalIdx reference.

Definition at line 185 of file shape_poly_set.cpp.

{
 int selectedVertex = aRelativeIndices.m_vertex;
 unsigned int selectedContour = aRelativeIndices.m_contour;
 unsigned int selectedPolygon = aRelativeIndices.m_polygon;
 
 // Check whether the vertex indices make sense in this poly set
 if( selectedPolygon < m_polys.size() && selectedContour < m_polys[selectedPolygon].size()
 && selectedVertex < m_polys[selectedPolygon][selectedContour].PointCount() )
 {
 POLYGON currentPolygon;
 
 aGlobalIdx = 0;
 
 for( unsigned int polygonIdx = 0; polygonIdx < selectedPolygon; polygonIdx++ )
 {
 currentPolygon = Polygon( polygonIdx );
 
 for( unsigned int contourIdx = 0; contourIdx < currentPolygon.size(); contourIdx++ )
 aGlobalIdx += currentPolygon[contourIdx].PointCount();
 }
 
 currentPolygon = Polygon( selectedPolygon );
 
 for( unsigned int contourIdx = 0; contourIdx < selectedContour; contourIdx++ )
 aGlobalIdx += currentPolygon[contourIdx].PointCount();
 
 aGlobalIdx += selectedVertex;
 
 return true;
 }
 else
 {
 return false;
 }
}

References SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, m_polys, SHAPE_POLY_SET::VERTEX_INDEX::m_vertex, and Polygon().

Referenced by GetNeighbourIndexes(), and ZONE::GetSelectedCorner().

◆ GetHash()

MD5_HASH SHAPE_POLY_SET::GetHash ( ) const

Definition at line 2617 of file shape_poly_set.cpp.

{
 if( !m_hash.IsValid() )
 return checksum();
 
 return m_hash;
}

References checksum(), MD5_HASH::IsValid(), and m_hash.

Referenced by ZONE::BuildHashValue(), ZONE::GetHashValue(), DSN::SPECCTRA_DB::makePADSTACK(), and SHAPE_POLY_SET().

◆ GetIndexableSubshapeCount()

size_t SHAPE_POLY_SET::GetIndexableSubshapeCount ( ) const

overridevirtual

Reimplemented from SHAPE_BASE.

Definition at line 2884 of file shape_poly_set.cpp.

{
 size_t n = 0;
 
 for( const std::unique_ptr<TRIANGULATED_POLYGON>& t : m_triangulatedPolys )
 n += t->GetTriangleCount();
 
 return n;
}

References m_triangulatedPolys.

Referenced by GetIndexableSubshapes().

◆ GetIndexableSubshapes()

void SHAPE_POLY_SET::GetIndexableSubshapes ( std::vector< const SHAPE * > & aSubshapes ) const

overridevirtual

Reimplemented from SHAPE_BASE.

Definition at line 2895 of file shape_poly_set.cpp.

{
 aSubshapes.reserve( GetIndexableSubshapeCount() );
 
 for( const std::unique_ptr<TRIANGULATED_POLYGON>& tpoly : m_triangulatedPolys )
 {
 for( TRIANGULATED_POLYGON::TRI& tri : tpoly->Triangles() )
 aSubshapes.push_back( &tri );
 }
}

References GetIndexableSubshapeCount(), and m_triangulatedPolys.

◆ GetNeighbourIndexes()

bool SHAPE_POLY_SET::GetNeighbourIndexes	(	int	aGlobalIndex,
		int *	aPrevious,
		int *	aNext
	)

Return the global indexes of the previous and the next corner of the aGlobalIndex-th corner of a contour in the polygon set.

They are often aGlobalIndex-1 and aGlobalIndex+1, but not for the first and last corner of the contour.

Parameters

aGlobalIndex	is index of the corner, globally indexed between all edges in all contours
aPrevious	is the globalIndex of the previous corner of the same contour.
aNext	is the globalIndex of the next corner of the same contour.

Returns: true if OK, false if aGlobalIndex is out of range

Definition at line 417 of file shape_poly_set.cpp.

{
 SHAPE_POLY_SET::VERTEX_INDEX index;
 
 // If the edge does not exist, throw an exception, it is an illegal access memory error
 if( !GetRelativeIndices( aGlobalIndex, &index ) )
 return false;
 
 // Calculate the previous and next index of aGlobalIndex, corresponding to
 // the same contour;
 VERTEX_INDEX inext = index;
 int lastpoint = m_polys[index.m_polygon][index.m_contour].SegmentCount();
 
 if( index.m_vertex == 0 )
 {
 index.m_vertex = lastpoint;
 inext.m_vertex = 1;
 }
 else if( index.m_vertex == lastpoint )
 {
 index.m_vertex--;
 inext.m_vertex = 0;
 }
 else
 {
 inext.m_vertex++;
 index.m_vertex--;
 }
 
 if( aPrevious )
 {
 int previous;
 GetGlobalIndex( index, previous );
 *aPrevious = previous;
 }
 
 if( aNext )
 {
 int next;
 GetGlobalIndex( inext, next );
 *aNext = next;
 }
 
 return true;
}

References GetGlobalIndex(), GetRelativeIndices(), SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, m_polys, SHAPE_POLY_SET::VERTEX_INDEX::m_vertex, and next().

Referenced by ZONE::MoveEdge().

◆ GetRelativeIndices()

bool SHAPE_POLY_SET::GetRelativeIndices	(	int	aGlobalIdx,
		SHAPE_POLY_SET::VERTEX_INDEX *	aRelativeIndices
	)		const

Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated list of all vertices in all contours— and get the index of the vertex relative to the contour relative to the polygon in which it is.

Parameters

aGlobalIdx	is the global index of the corner whose structured index wants to be found
aRelativeIndices	is a pointer to the set of relative indices to store.

Returns: true if the global index is correct and the information in aRelativeIndices is valid; false otherwise.

Definition at line 145 of file shape_poly_set.cpp.

{
 int polygonIdx = 0;
 unsigned int contourIdx = 0;
 int vertexIdx = 0;
 
 int currentGlobalIdx = 0;
 
 for( polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
 {
 const POLYGON& currentPolygon = CPolygon( polygonIdx );
 
 for( contourIdx = 0; contourIdx < currentPolygon.size(); contourIdx++ )
 {
 const SHAPE_LINE_CHAIN& currentContour = currentPolygon[contourIdx];
 int totalPoints = currentContour.PointCount();
 
 for( vertexIdx = 0; vertexIdx < totalPoints; vertexIdx++ )
 {
 // Check if the current vertex is the globally indexed as aGlobalIdx
 if( currentGlobalIdx == aGlobalIdx )
 {
 aRelativeIndices->m_polygon = polygonIdx;
 aRelativeIndices->m_contour = contourIdx;
 aRelativeIndices->m_vertex = vertexIdx;
 
 return true;
 }
 
 // Advance
 currentGlobalIdx++;
 }
 }
 }
 
 return false;
}

References CPolygon(), SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, SHAPE_POLY_SET::VERTEX_INDEX::m_vertex, OutlineCount(), and SHAPE_LINE_CHAIN::PointCount().

Referenced by CVertex(), ZONE::GetCornerPosition(), GetNeighbourIndexes(), InsertVertex(), IsVertexInHole(), IterateFromVertexWithHoles(), RemoveVertex(), ZONE::SetCornerPosition(), ZONE::SetSelectedCorner(), and SetVertex().

◆ HasHoles()

bool SHAPE_POLY_SET::HasHoles ( ) const

Return true if the polygon set has any holes that share a vertex.

Definition at line 1584 of file shape_poly_set.cpp.

{
 // Iterate through all the polygons on the set
 for( const POLYGON& paths : m_polys )
 {
 // If any of them has more than one contour, it is a hole.
 if( paths.size() > 1 )
 return true;
 }
 
 // Return false if and only if every polygon has just one outline, without holes.
 return false;
}

References m_polys.

Referenced by PAD::AddPrimitivePoly(), CacheTriangulation(), and CALLBACK_GAL::DrawGlyph().

◆ HasIndexableSubshapes()

bool SHAPE_POLY_SET::HasIndexableSubshapes ( ) const

overridevirtual

Reimplemented from SHAPE_BASE.

Definition at line 2878 of file shape_poly_set.cpp.

{
 return IsTriangulationUpToDate();
}

References IsTriangulationUpToDate().

◆ HasTouchingHoles()

bool SHAPE_POLY_SET::HasTouchingHoles ( ) const

Simplify the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFastMode meaning, see function booleanOp.

Definition at line 2845 of file shape_poly_set.cpp.

{
 for( int i = 0; i < OutlineCount(); i++ )
 {
 if( hasTouchingHoles( CPolygon( i ) ) )
 return true;
 }
 
 return false;
}

References CPolygon(), hasTouchingHoles(), and OutlineCount().

◆ hasTouchingHoles()

bool SHAPE_POLY_SET::hasTouchingHoles ( const POLYGON & aPoly ) const

private

Definition at line 2857 of file shape_poly_set.cpp.

{
 std::set<long long> ptHashes;
 
 for( const SHAPE_LINE_CHAIN& lc : aPoly )
 {
 for( const VECTOR2I& pt : lc.CPoints() )
 {
 const long long ptHash = (long long) pt.x << 32 | pt.y;
 
 if( ptHashes.count( ptHash ) > 0 )
 return true;
 
 ptHashes.insert( ptHash );
 }
 }
 
 return false;
}

Referenced by HasTouchingHoles().

◆ Hole()

SHAPE_LINE_CHAIN & SHAPE_POLY_SET::Hole	(	int	aOutline,
		int	aHole
	)

inline

◆ HoleCount()

int SHAPE_POLY_SET::HoleCount ( int aOutline ) const

inline

Return the reference to aIndex-th outline in the set.

Definition at line 672 of file shape_poly_set.h.

References m_polys.

Referenced by TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), ZONE::AppendCorner(), Area(), BOOST_AUTO_TEST_CASE(), BuildBBoxCaches(), BuildFootprintPolygonOutlines(), CacheTriangulation(), containsSingle(), ConvertPolygonToBlocks(), STEP_PCB_MODEL::CreatePCB(), CONVERT_TOOL::CreatePolys(), KIGFX::PCB_PAINTER::draw(), EXPORTER_PCB_VRML::ExportVrmlBoard(), DSN::SPECCTRA_DB::fillBOUNDARY(), PCB_PLUGIN::formatRenderCache(), FullPointCount(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape(), ZONE::HitTestCutout(), GEOM_TEST::IsPolySetValid(), ZONE_CREATE_HELPER::performZoneCutout(), PlotLayerOutlines(), polygonArea(), ZONE::RemoveCutout(), DRC_TEST_PROVIDER_TEXT_DIMS::Run(), EDA_SHAPE::SetPolyShape(), DRC_TEST_PROVIDER_PHYSICAL_CLEARANCE::testZoneLayer(), and HYPERLYNX_EXPORTER::writeNetObjects().

◆ importPaths()

void SHAPE_POLY_SET::importPaths	(	Clipper2Lib::Paths64 &	paths,
		const std::vector< CLIPPER_Z_VALUE > &	aZValueBuffer,
		const std::vector< SHAPE_ARC > &	aArcBuffe
	)

private

Definition at line 1157 of file shape_poly_set.cpp.

{
 m_polys.clear();
 POLYGON path;
 
 for( const Clipper2Lib::Path64& n : aPath )
 {
 if( Clipper2Lib::Area( n ) > 0 )
 {
 if( !path.empty() )
 m_polys.emplace_back( path );
 
 path.clear();
 }
 else
 {
 wxCHECK2_MSG( !path.empty(), continue, wxT( "Cannot add a hole before an outline" ) );
 }
 
 path.emplace_back( n, aZValueBuffer, aArcBuffer );
 }
 
 if( !path.empty() )
 m_polys.emplace_back( path );
}

References m_polys, and path.

◆ importPolyPath()

void SHAPE_POLY_SET::importPolyPath	(	Clipper2Lib::PolyPath64 *	aPolyPath,
		const std::vector< CLIPPER_Z_VALUE > &	aZValueBuffer,
		const std::vector< SHAPE_ARC > &	aArcBuffer
	)

private

Definition at line 1123 of file shape_poly_set.cpp.

{
 if( !aPolyPath->IsHole() )
 {
 POLYGON paths;
 paths.reserve( aPolyPath->Count() + 1 );
 paths.emplace_back( aPolyPath->Polygon(), aZValueBuffer, aArcBuffer );
 
 for( Clipper2Lib::PolyPath64* child : *aPolyPath )
 {
 paths.emplace_back( child->Polygon(), aZValueBuffer, aArcBuffer );
 
 for( Clipper2Lib::PolyPath64* grandchild : *child )
 importPolyPath( grandchild, aZValueBuffer, aArcBuffer );
 }
 
 m_polys.push_back( paths );
 }
}

References importPolyPath(), and m_polys.

Referenced by importPolyPath(), and importTree().

◆ importTree() [1/2]

void SHAPE_POLY_SET::importTree	(	Clipper2Lib::PolyTree64 &	tree,
		const std::vector< CLIPPER_Z_VALUE > &	aZValueBuffer,
		const std::vector< SHAPE_ARC > &	aArcBuffe
	)

private

Definition at line 1146 of file shape_poly_set.cpp.

{
 m_polys.clear();
 
 for( Clipper2Lib::PolyPath64* n : tree )
 importPolyPath( n, aZValueBuffer, aArcBuffer );
}

References importPolyPath(), and m_polys.

◆ importTree() [2/2]

void SHAPE_POLY_SET::importTree	(	ClipperLib::PolyTree *	tree,
		const std::vector< CLIPPER_Z_VALUE > &	aZValueBuffer,
		const std::vector< SHAPE_ARC > &	aArcBuffe
	)

private

Definition at line 1099 of file shape_poly_set.cpp.

{
 m_polys.clear();
 
 for( ClipperLib::PolyNode* n = tree->GetFirst(); n; n = n->GetNext() )
 {
 if( !n->IsHole() )
 {
 POLYGON paths;
 paths.reserve( n->Childs.size() + 1 );
 
 paths.emplace_back( n->Contour, aZValueBuffer, aArcBuffer );
 
 for( unsigned int i = 0; i < n->Childs.size(); i++ )
 paths.emplace_back( n->Childs[i]->Contour, aZValueBuffer, aArcBuffer );
 
 m_polys.push_back( paths );
 }
 }
}

References m_polys.

Referenced by booleanOp(), inflate1(), and inflate2().

◆ Inflate()

void SHAPE_POLY_SET::Inflate	(	int	aAmount,
		int	aCircleSegCount,
		CORNER_STRATEGY	aCornerStrategy = `ROUND_ALL_CORNERS`
	)

Perform outline inflation/deflation.

Polygons can have holes, but not linked holes with main outlines, if aFactor < 0. For those use InflateWithLinkedHoles() to avoid odd corners where the link segments meet the outline.

Parameters

aAmount	is the number of units to offset edges.
aCircleSegCount	is the number of segments per 360 degrees to use in curve approx
aCornerStrategy	ALLOW_ACUTE_CORNERS to preserve all angles, CHAMFER_ACUTE_CORNERS to chop angles less than 90°, ROUND_ACUTE_CORNERS to round off angles less than 90°, ROUND_ALL_CORNERS to round regardless of angles

Definition at line 1090 of file shape_poly_set.cpp.

{
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 inflate2( aAmount, aCircleSegCount, aCornerStrategy );
 else
 inflate1( aAmount, aCircleSegCount, aCornerStrategy );
}

References ADVANCED_CFG::GetCfg(), inflate1(), and inflate2().

Referenced by FOOTPRINT::BuildCourtyardCaches(), ZONE::BuildSmoothedPoly(), CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities(), BOARD_ADAPTER::createPadWithMargin(), Deflate(), ZONE_FILLER::fillCopperZone(), ZONE_FILLER::fillNonCopperZone(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), InflateWithLinkedHoles(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), EAGLE_PLUGIN::loadPolygon(), EAGLE_PLUGIN::packagePolygon(), PlotSolderMaskLayer(), DRC_TEST_PROVIDER_TEXT_DIMS::Run(), TEARDROP_MANAGER::SetTeardrops(), PAD::TransformShapeToPolygon(), and ZONE::TransformSmoothedOutlineToPolygon().

◆ inflate1()

void SHAPE_POLY_SET::inflate1	(	int	aAmount,
		int	aCircleSegCount,
		CORNER_STRATEGY	aCornerStrategy
	)

private

Definition at line 904 of file shape_poly_set.cpp.

{
 using namespace ClipperLib;
 // A static table to avoid repetitive calculations of the coefficient
 // 1.0 - cos( M_PI / aCircleSegCount )
 // aCircleSegCount is most of time <= 64 and usually 8, 12, 16, 32
 #define SEG_CNT_MAX 64
 static double arc_tolerance_factor[SEG_CNT_MAX + 1];
 
 ClipperOffset c;
 
 // N.B. see the Clipper documentation for jtSquare/jtMiter/jtRound. They are poorly named
 // and are not what you'd think they are.
 // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/JoinType.htm
 JoinType joinType = jtRound; // The way corners are offsetted
 double miterLimit = 2.0; // Smaller value when using jtMiter for joinType
 JoinType miterFallback = jtSquare;
 
 switch( aCornerStrategy )
 {
 case ALLOW_ACUTE_CORNERS:
 joinType = jtMiter;
 miterLimit = 10; // Allows large spikes
 miterFallback = jtSquare;
 break;
 
 case CHAMFER_ACUTE_CORNERS: // Acute angles are chamfered
 joinType = jtMiter;
 miterFallback = jtRound;
 break;
 
 case ROUND_ACUTE_CORNERS: // Acute angles are rounded
 joinType = jtMiter;
 miterFallback = jtSquare;
 break;
 
 case CHAMFER_ALL_CORNERS: // All angles are chamfered.
 joinType = jtSquare;
 miterFallback = jtSquare;
 break;
 
 case ROUND_ALL_CORNERS: // All angles are rounded.
 joinType = jtRound;
 miterFallback = jtSquare;
 break;
 }
 
 std::vector<CLIPPER_Z_VALUE> zValues;
 std::vector<SHAPE_ARC> arcBuffer;
 
 for( const POLYGON& poly : m_polys )
 {
 for( size_t i = 0; i < poly.size(); i++ )
 {
 c.AddPath( poly[i].convertToClipper( i == 0, zValues, arcBuffer ),
 joinType, etClosedPolygon );
 }
 }
 
 PolyTree solution;
 
 // Calculate the arc tolerance (arc error) from the seg count by circle. The seg count is
 // nn = M_PI / acos(1.0 - c.ArcTolerance / abs(aAmount))
 // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Classes/ClipperOffset/Properties/ArcTolerance.htm
 
 if( aCircleSegCount < 6 ) // avoid incorrect aCircleSegCount values
 aCircleSegCount = 6;
 
 double coeff;
 
 if( aCircleSegCount > SEG_CNT_MAX || arc_tolerance_factor[aCircleSegCount] == 0 )
 {
 coeff = 1.0 - cos( M_PI / aCircleSegCount );
 
 if( aCircleSegCount <= SEG_CNT_MAX )
 arc_tolerance_factor[aCircleSegCount] = coeff;
 }
 else
 {
 coeff = arc_tolerance_factor[aCircleSegCount];
 }
 
 c.ArcTolerance = std::abs( aAmount ) * coeff;
 c.MiterLimit = miterLimit;
 c.MiterFallback = miterFallback;
 c.Execute( solution, aAmount );
 
 importTree( &solution, zValues, arcBuffer );
}

References std::abs(), ALLOW_ACUTE_CORNERS, CHAMFER_ACUTE_CORNERS, CHAMFER_ALL_CORNERS, importTree(), m_polys, ROUND_ACUTE_CORNERS, ROUND_ALL_CORNERS, and SEG_CNT_MAX.

Referenced by Inflate().

◆ inflate2()

void SHAPE_POLY_SET::inflate2	(	int	aAmount,
		int	aCircleSegCount,
		CORNER_STRATEGY	aCornerStrategy
	)

private

Definition at line 995 of file shape_poly_set.cpp.

{
 using namespace Clipper2Lib;
 // A static table to avoid repetitive calculations of the coefficient
 // 1.0 - cos( M_PI / aCircleSegCount )
 // aCircleSegCount is most of time <= 64 and usually 8, 12, 16, 32
 #define SEG_CNT_MAX 64
 static double arc_tolerance_factor[SEG_CNT_MAX + 1];
 
 ClipperOffset c;
 
 // N.B. see the Clipper documentation for jtSquare/jtMiter/jtRound. They are poorly named
 // and are not what you'd think they are.
 // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/JoinType.htm
 JoinType joinType = JoinType::Round; // The way corners are offsetted
 double miterLimit = 2.0; // Smaller value when using jtMiter for joinType
 JoinType miterFallback = JoinType::Square;
 
 switch( aCornerStrategy )
 {
 case ALLOW_ACUTE_CORNERS:
 joinType = JoinType::Miter;
 miterLimit = 10; // Allows large spikes
 break;
 
 case CHAMFER_ACUTE_CORNERS: // Acute angles are chamfered
 joinType = JoinType::Miter;
 break;
 
 case ROUND_ACUTE_CORNERS: // Acute angles are rounded
 joinType = JoinType::Miter;
 break;
 
 case CHAMFER_ALL_CORNERS: // All angles are chamfered.
 joinType = JoinType::Square;
 break;
 
 case ROUND_ALL_CORNERS: // All angles are rounded.
 joinType = JoinType::Round;
 break;
 }
 
 std::vector<CLIPPER_Z_VALUE> zValues;
 std::vector<SHAPE_ARC> arcBuffer;
 
 for( const POLYGON& poly : m_polys )
 {
 Paths64 paths;
 
 for( size_t i = 0; i < poly.size(); i++ )
 paths.push_back( poly[i].convertToClipper2( i == 0, zValues, arcBuffer ) );
 
 c.AddPaths( paths, joinType, EndType::Polygon );
 }
 
 // Calculate the arc tolerance (arc error) from the seg count by circle. The seg count is
 // nn = M_PI / acos(1.0 - c.ArcTolerance / abs(aAmount))
 // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Classes/ClipperOffset/Properties/ArcTolerance.htm
 
 if( aCircleSegCount < 6 ) // avoid incorrect aCircleSegCount values
 aCircleSegCount = 6;
 
 double coeff;
 
 if( aCircleSegCount > SEG_CNT_MAX || arc_tolerance_factor[aCircleSegCount] == 0 )
 {
 coeff = 1.0 - cos( M_PI / aCircleSegCount );
 
 if( aCircleSegCount <= SEG_CNT_MAX )
 arc_tolerance_factor[aCircleSegCount] = coeff;
 }
 else
 {
 coeff = arc_tolerance_factor[aCircleSegCount];
 }
 
 c.ArcTolerance( std::abs( aAmount ) * coeff );
 c.MiterLimit( miterLimit );
 c.MergeGroups( true );
 Paths64 solution = c.Execute( aAmount );
 
 // We get paths back but we need the tree to assign the holes to the correct
 // outlines
 Clipper64 c2;
 PolyTree64 tree;
 c2.PreserveCollinear = false;
 c2.ReverseSolution = false;
 c2.AddSubject( solution );
 c2.Execute(ClipType::Union, FillRule::Positive, tree);
 
 importTree( tree, zValues, arcBuffer );
 tree.Clear();
}

References std::abs(), ALLOW_ACUTE_CORNERS, CHAMFER_ACUTE_CORNERS, CHAMFER_ALL_CORNERS, importTree(), m_polys, ROUND_ACUTE_CORNERS, ROUND_ALL_CORNERS, and SEG_CNT_MAX.

Referenced by Inflate().

◆ InflateWithLinkedHoles()

void SHAPE_POLY_SET::InflateWithLinkedHoles	(	int	aFactor,
		int	aCircleSegmentsCount,
		POLYGON_MODE	aFastMode
	)

Perform outline inflation/deflation, using round corners.

Polygons can have holes and/or linked holes with main outlines. The resulting polygons are also polygons with linked holes to main outlines. For aFastMode meaning, see function booleanOp . Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the outer ring to the inner holes For aFastMode meaning, see function booleanOp

Definition at line 895 of file shape_poly_set.cpp.

{
 Unfracture( aFastMode );
 Inflate( aFactor, aCircleSegmentsCount );
 Fracture( aFastMode );
}

References Fracture(), Inflate(), and Unfracture().

Referenced by PlotStandardLayer(), and ZONE::TransformShapeToPolygon().

◆ InsertVertex()

void SHAPE_POLY_SET::InsertVertex	(	int	aGlobalIndex,
		const VECTOR2I &	aNewVertex
	)

Adds a vertex in the globally indexed position aGlobalIndex.

Parameters

aGlobalIndex	is the global index of the position in which the new vertex will be inserted.
aNewVertex	is the new inserted vertex. Return the index-th vertex in a given hole outline within a given outline

Definition at line 299 of file shape_poly_set.cpp.

{
 VERTEX_INDEX index;
 
 if( aGlobalIndex < 0 )
 aGlobalIndex = 0;
 
 if( aGlobalIndex >= TotalVertices() )
 {
 Append( aNewVertex );
 }
 else
 {
 // Assure the position to be inserted exists; throw an exception otherwise
 if( GetRelativeIndices( aGlobalIndex, &index ) )
 m_polys[index.m_polygon][index.m_contour].Insert( index.m_vertex, aNewVertex );
 else
 throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
 }
}

References Append(), GetRelativeIndices(), SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, m_polys, SHAPE_POLY_SET::VERTEX_INDEX::m_vertex, and TotalVertices().

Referenced by PCB_POINT_EDITOR::addCorner().

◆ IsEmpty()

bool SHAPE_POLY_SET::IsEmpty ( ) const

inline

Definition at line 1208 of file shape_poly_set.h.

 {
 return m_polys.empty();
 }

References m_polys.

Referenced by LIB_SHAPE::AddPoint(), SCH_SHAPE::AddPoint(), BOARD_ADAPTER::addShape(), FOOTPRINT::CheckPads(), Collide(), ConvertOutlineToPolygon(), BOARD_ADAPTER::createPadWithMargin(), CONVERT_TOOL::CreatePolys(), TRACKS_CLEANER::deleteTracksInPads(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::DIALOG_PAD_PRIMITIVE_POLY_PROPS(), DRC_ENGINE::EvalRules(), PCB_BASE_FRAME::FocusOnItems(), EDA_SHAPE::getBoundingBox(), ZONE::HatchBorder(), ALTIUM_PCB::HelperShapeSetLocalCoord(), BOARD_INSPECTION_TOOL::InspectClearance(), EDA_SHAPE::IsClosed(), DIALOG_PAD_PROPERTIES::padValuesOK(), PCB_PARSER::parseZONE(), BRDITEMS_PLOTTER::PlotFilledAreas(), PlotStandardLayer(), PAD_TOOL::RecombinePad(), EE_POINT_EDITOR::removeCornerCondition(), KIGFX::VIEW::SetCenter(), and DRC_INTERACTIVE_COURTYARD_CLEARANCE::testCourtyardClearances().

◆ IsNull()

bool SHAPE::IsNull ( ) const

inlineinherited

Return true if the shape is a null shape.

Return values

true	if null :-)

Definition at line 163 of file shape.h.

 {
 return m_type == SH_NULL;
 }

References SHAPE_BASE::m_type, and SH_NULL.

◆ IsPolygonSelfIntersecting()

bool SHAPE_POLY_SET::IsPolygonSelfIntersecting ( int aPolygonIndex ) const

Check whether the aPolygonIndex-th polygon in the set is self intersecting.

Parameters

aPolygonIndex is the index of the polygon that wants to be checked.

Returns: true if the aPolygonIndex-th polygon is self intersecting, false otherwise.

Definition at line 464 of file shape_poly_set.cpp.

{
 std::vector<SEG> segments;
 segments.reserve( FullPointCount() );
 
 for( CONST_SEGMENT_ITERATOR it = CIterateSegmentsWithHoles( aPolygonIndex ); it; it++ )
 segments.emplace_back( *it );
 
 std::sort( segments.begin(), segments.end(), []( const SEG& a, const SEG& b )
 {
 int min_a_x = std::min( a.A.x, a.B.x );
 int min_b_x = std::min( b.A.x, b.B.x );
 
 return min_a_x < min_b_x || ( min_a_x == min_b_x && std::min( a.A.y, a.B.y ) < std::min( b.A.y, b.B.y ) );
 } );
 
 for( auto it = segments.begin(); it != segments.end(); ++it )
 {
 SEG& firstSegment = *it;
 
 // Iterate through all remaining segments.
 auto innerIterator = it;
 int max_x = std::max( firstSegment.A.x, firstSegment.B.x );
 int max_y = std::max( firstSegment.A.y, firstSegment.B.y );
 
 // Start in the next segment, we don't want to check collision between a segment and itself
 for( innerIterator++; innerIterator != segments.end(); innerIterator++ )
 {
 SEG& secondSegment = *innerIterator;
 int min_x = std::min( secondSegment.A.x, secondSegment.B.x );
 int min_y = std::min( secondSegment.A.y, secondSegment.B.y );
 
 // We are ordered in minimum point order, so checking the static max (first segment) against
 // the ordered min will tell us if any of the following segments are withing the BBox
 if( max_x < min_x || ( max_x == min_x && max_y < min_y ) )
 break;
 
 int index_diff = std::abs( firstSegment.Index() - secondSegment.Index() );
 bool adjacent = ( index_diff == 1) || (index_diff == (segments.size() - 1) ); 
 
 // Check whether the two segments built collide, only when they are not adjacent.
 if( !adjacent && firstSegment.Collide( secondSegment, 0 ) )
 return true;
 }
 }
 
 return false;
}

References SEG::A, std::abs(), SEG::B, CIterateSegmentsWithHoles(), SEG::Collide(), FullPointCount(), SEG::Index(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by IsSelfIntersecting().

◆ IsSelfIntersecting()

bool SHAPE_POLY_SET::IsSelfIntersecting ( ) const

Check whether any of the polygons in the set is self intersecting.

Returns: true if any of the polygons is self intersecting, false otherwise. Return the number of triangulated polygons

Definition at line 514 of file shape_poly_set.cpp.

{
 for( unsigned int polygon = 0; polygon < m_polys.size(); polygon++ )
 {
 if( IsPolygonSelfIntersecting( polygon ) )
 return true;
 }
 
 return false;
}

References IsPolygonSelfIntersecting(), and m_polys.

Referenced by CacheTriangulation().

◆ IsSolid()

bool SHAPE_POLY_SET::IsSolid ( ) const

inlineoverridevirtual

Implements SHAPE.

Definition at line 1086 of file shape_poly_set.h.

 {
 return true;
 }

◆ IsTriangulationUpToDate()

bool SHAPE_POLY_SET::IsTriangulationUpToDate ( ) const

Definition at line 2626 of file shape_poly_set.cpp.

{
 if( !m_triangulationValid )
 return false;
 
 if( !m_hash.IsValid() )
 return false;
 
 MD5_HASH hash = checksum();
 
 return hash == m_hash;
}

References checksum(), MD5_HASH::IsValid(), m_hash, and m_triangulationValid.

Referenced by KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::OPENGL_GAL::DrawPolygon(), HasIndexableSubshapes(), SHAPE_POLY_SET(), and PNS_KICAD_IFACE_BASE::syncZone().

◆ IsVertexInHole()

bool SHAPE_POLY_SET::IsVertexInHole ( int aGlobalIdx )

Check whether the aGlobalIndex-th vertex belongs to a hole.

Parameters

aGlobalIdx is the index of the vertex.

Returns: true if the globally indexed aGlobalIdx-th vertex belongs to a hole.

Definition at line 2400 of file shape_poly_set.cpp.

{
 VERTEX_INDEX index;
 
 // Get the polygon and contour where the vertex is. If the vertex does not exist, return false
 if( !GetRelativeIndices( aGlobalIdx, &index ) )
 return false;
 
 // The contour is a hole if its index is greater than zero
 return index.m_contour > 0;
}

References GetRelativeIndices(), and SHAPE_POLY_SET::VERTEX_INDEX::m_contour.

◆ Iterate() [1/3]

ITERATOR SHAPE_POLY_SET::Iterate ( )

inline

Returns: an iterator object to visit all points in all outlines of the set, without visiting the points in the holes.

Definition at line 795 of file shape_poly_set.h.

 {
 return Iterate( 0, OutlineCount() - 1 );
 }

References Iterate(), and OutlineCount().

Referenced by Iterate(), and IterateWithHoles().

◆ Iterate() [2/3]

ITERATOR SHAPE_POLY_SET::Iterate	(	int	aFirst,
		int	aLast,
		bool	aIterateHoles = `false`
	)

inline

Return an object to iterate through the points of the polygons between aFirst and aLast.

Parameters

aFirst	is the first polygon whose points will be iterated.
aLast	is the last polygon whose points will be iterated.
aIterateHoles	is a flag to indicate whether the points of the holes should be iterated.

Returns: ITERATOR - the iterator object.

Definition at line 757 of file shape_poly_set.h.

 {
 ITERATOR iter;
 
 iter.m_poly = this;
 iter.m_currentPolygon = aFirst;
 iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
 iter.m_currentContour = 0;
 iter.m_currentVertex = 0;
 iter.m_iterateHoles = aIterateHoles;
 
 return iter;
 }

References SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentContour, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentPolygon, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentVertex, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_iterateHoles, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_lastPolygon, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_poly, and OutlineCount().

Referenced by PCB_POINT_EDITOR::addCorner(), and ZONE::Iterate().

◆ Iterate() [3/3]

ITERATOR SHAPE_POLY_SET::Iterate ( int aOutline )

inline

Parameters

aOutline is the index of the polygon to be iterated.

Returns: an iterator object to visit all points in the main outline of the aOutline-th polygon, without visiting the points in the holes.

Definition at line 776 of file shape_poly_set.h.

 {
 return Iterate( aOutline, aOutline );
 }

References Iterate().

◆ IterateFromVertexWithHoles()

ITERATOR SHAPE_POLY_SET::IterateFromVertexWithHoles ( int aGlobalIdx )

inline

Return an iterator object, for iterating between aFirst and aLast outline, with or without holes (default: without)

Definition at line 844 of file shape_poly_set.h.

References GetRelativeIndices(), IterateWithHoles(), SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentContour, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentPolygon, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::m_currentVertex, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, and SHAPE_POLY_SET::VERTEX_INDEX::m_vertex.

◆ IterateSegments() [1/3]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegments ( )

inline

Returns an iterator object, for all outlines in the set (no holes)

Definition at line 909 of file shape_poly_set.h.

References IterateSegments(), and OutlineCount().

Referenced by IterateSegments(), and IterateSegmentsWithHoles().

◆ IterateSegments() [2/3]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegments	(	int	aFirst,
		int	aLast,
		bool	aIterateHoles = `false`
	)

inline

Return an iterator object, for iterating between aFirst and aLast outline, with or without holes (default: without)

Definition at line 865 of file shape_poly_set.h.

References SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_currentContour, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_currentPolygon, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_currentSegment, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_iterateHoles, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_lastPolygon, SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::m_poly, and OutlineCount().

Referenced by TestConcaveSquareFillet(), TestSquareFillet(), and PCB_DIM_LEADER::updateGeometry().

◆ IterateSegments() [3/3]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegments ( int aPolygonIdx )

inline

Return an iterator object, for iterating aPolygonIdx-th polygon edges.

Definition at line 897 of file shape_poly_set.h.

References IterateSegments().

◆ IterateSegmentsWithHoles() [1/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( )

inline

Return an iterator object, for the aOutline-th outline in the set (with holes).

Definition at line 921 of file shape_poly_set.h.

References IterateSegments(), and OutlineCount().

Referenced by ConvertOutlineToPolygon(), ZONE::HatchBorder(), and BOARD::TestZoneIntersection().

◆ IterateSegmentsWithHoles() [2/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( int aOutline )

inline

Return an iterator object, for the aOutline-th outline in the set (with holes).

Definition at line 927 of file shape_poly_set.h.

References IterateSegments().

◆ IterateWithHoles() [1/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( )

inline

Returns: an iterator object to visit all points in all outlines of the set, visiting also the points in the holes.

Definition at line 804 of file shape_poly_set.h.

 {
 return Iterate( 0, OutlineCount() - 1, true );
 }

References Iterate(), and OutlineCount().

Referenced by IterateFromVertexWithHoles(), and RemoveNullSegments().

◆ IterateWithHoles() [2/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( int aOutline )

inline

Parameters

aOutline the index of the polygon to be iterated.

Returns: an iterator object to visit all points in the main outline of the aOutline-th polygon, visiting also the points in the holes.

Definition at line 786 of file shape_poly_set.h.

 {
 return Iterate( aOutline, aOutline, true );
 }

References Iterate().

Referenced by findVertex(), ZONE::HatchBorder(), ZONE::IterateWithHoles(), and BOARD::TestZoneIntersection().

◆ Mirror()

void SHAPE_POLY_SET::Mirror	(	bool	aX = `true`,
		bool	aY = `false`,
		const VECTOR2I &	aRef = `{ 0, 0 }`
	)

Mirror the line points about y or x (or both)

Parameters

aX	If true, mirror about the y axis (flip x coordinate)
aY	If true, mirror about the x axis
aRef	sets the reference point about which to mirror

Definition at line 2223 of file shape_poly_set.cpp.

{
 for( POLYGON& poly : m_polys )
 {
 for( SHAPE_LINE_CHAIN& path : poly )
 path.Mirror( aX, aY, aRef );
 }
 
 if( m_triangulationValid )
 CacheTriangulation();
}

References CacheTriangulation(), m_polys, m_triangulationValid, and path.

Referenced by GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), EDA_SHAPE::flip(), FOOTPRINT::Flip(), FP_SHAPE::Flip(), FABMASTER::loadFootprints(), PCB_SHAPE::Mirror(), FP_SHAPE::Mirror(), and ZONE::Mirror().

◆ Move()

void SHAPE_POLY_SET::Move ( const VECTOR2I & aVector )

overridevirtual

Implements SHAPE.

Definition at line 2208 of file shape_poly_set.cpp.

{
 for( POLYGON& poly : m_polys )
 {
 for( SHAPE_LINE_CHAIN& path : poly )
 path.Move( aVector );
 }
 
 for( std::unique_ptr<TRIANGULATED_POLYGON>& tri : m_triangulatedPolys )
 tri->Move( aVector );
 
 m_hash = checksum();
}

References checksum(), m_hash, m_polys, m_triangulatedPolys, and path.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), TEARDROP_MANAGER::ComputePointsOnPadVia(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), ALTIUM_PCB::HelperShapeSetLocalCoord(), GERBER_DRAW_ITEM::HitTest(), FABMASTER::loadFootprints(), CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryCoppers(), EDA_SHAPE::move(), FP_SHAPE::Move(), ZONE::Move(), FOOTPRINT::MoveAnchorPosition(), GERBER_DRAW_ITEM::MoveXY(), DS_DRAW_ITEM_POLYPOLYGONS::SetPosition(), FOOTPRINT::SetPosition(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), PAD::TransformShapeToPolygon(), TransformTrapezoidToPolygon(), and zonesNeedUpdate().

◆ NewFacet()

FACET * SHAPE::NewFacet ( )

inherited

Definition at line 695 of file wrlfacet.cpp.

{
 FACET* fp = new FACET;
 facets.push_back( fp );
 return fp;
}

References SHAPE::facets.

Referenced by WRL2FACESET::TranslateToSG(), X3DIFACESET::TranslateToSG(), and WRL1FACESET::TranslateToSG().

◆ NewHole()

int SHAPE_POLY_SET::NewHole ( int aOutline = -1 )

Adds a new outline to the set and returns its index.

Definition at line 236 of file shape_poly_set.cpp.

{
 SHAPE_LINE_CHAIN empty_path;
 
 empty_path.SetClosed( true );
 
 // Default outline is the last one
 if( aOutline < 0 )
 aOutline += m_polys.size();
 
 // Add hole to the selected outline
 m_polys[aOutline].push_back( empty_path );
 
 return m_polys.back().size() - 2;
}

References m_polys, and SHAPE_LINE_CHAIN::SetClosed().

Referenced by BuildPolysetFromOrientedPaths(), ZONE::NewHole(), and TransformRingToPolygon().

◆ NewOutline()

int SHAPE_POLY_SET::NewOutline ( )

Creates a new hole in a given outline.

Definition at line 224 of file shape_poly_set.cpp.

{
 SHAPE_LINE_CHAIN empty_path;
 POLYGON poly;
 
 empty_path.SetClosed( true );
 poly.push_back( empty_path );
 m_polys.push_back( poly );
 return m_polys.size() - 1;
}

References m_polys, and SHAPE_LINE_CHAIN::SetClosed().

Referenced by AR_AUTOPLACER::addFpBody(), addHoleToPolygon(), ZONE_FILLER::addKnockout(), AR_AUTOPLACER::addPad(), LIB_SHAPE::AddPoint(), SCH_SHAPE::AddPoint(), ZONE::AppendCorner(), EDA_SHAPE::beginEdit(), BOARD::BOARD(), BOOST_AUTO_TEST_CASE(), BuildBoardPolygonOutlines(), BuildFootprintPolygonOutlines(), BuildPolysetFromOrientedPaths(), KI_TEST::CommonTestData::CommonTestData(), TEARDROP_MANAGER::ComputePointsOnPadVia(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), CornerListToPolygon(), BITMAPCONV_INFO::createOutputData(), BOARD_ADAPTER::createPadWithMargin(), TEARDROP_MANAGER::createTeardrop(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), fillArcPOLY(), PCB_BASE_FRAME::FocusOnItems(), FOOTPRINT::GetBoundingHull(), getRectangleAlongCentreLine(), EDA_SHAPE::hitTest(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadShapePolySet(), FABMASTER::loadZone(), LEGACY_PLUGIN::loadZONE_CONTAINER(), PCB_PARSER::parseZONE(), DXF_PLOTTER::PlotPoly(), PlotStandardLayer(), RENDER_3D_OPENGL::reload(), EDA_SHAPE::rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), EDA_SHAPE::SetPolyPoints(), SHAPE_POLY_SET(), DS_DATA_ITEM_POLYGONS::SyncDrawItems(), TransformArcToPolygon(), EDA_TEXT::TransformBoundingBoxToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), EDA_SHAPE::TransformShapeToPolygon(), FP_TEXTBOX::TransformShapeToPolygon(), PCB_TEXTBOX::TransformShapeToPolygon(), FP_TEXT::TransformTextToPolySet(), FP_TEXTBOX::TransformTextToPolySet(), PCB_TEXT::TransformTextToPolySet(), PCB_TEXTBOX::TransformTextToPolySet(), PCB_DIM_ALIGNED::updateGeometry(), PCB_DIM_ORTHOGONAL::updateGeometry(), PCB_DIM_RADIAL::updateGeometry(), PCB_DIM_LEADER::updateGeometry(), and EE_POINT_EDITOR::updateParentItem().

◆ NormalizeAreaOutlines()

int SHAPE_POLY_SET::NormalizeAreaOutlines ( )

Convert a self-intersecting polygon to one (or more) non self-intersecting polygon(s).

Removes null segments.

Returns: the polygon count (always >= 1, because there is at least one polygon) There are new polygons only if the polygon count is > 1.

Definition at line 1619 of file shape_poly_set.cpp.

{
 // We are expecting only one main outline, but this main outline can have holes
 // if holes: combine holes and remove them from the main outline.
 // Note also we are using SHAPE_POLY_SET::PM_STRICTLY_SIMPLE in polygon
 // calculations, but it is not mandatory. It is used mainly
 // because there is usually only very few vertices in area outlines
 SHAPE_POLY_SET::POLYGON& outline = Polygon( 0 );
 SHAPE_POLY_SET holesBuffer;
 
 // Move holes stored in outline to holesBuffer:
 // The first SHAPE_LINE_CHAIN is the main outline, others are holes
 while( outline.size() > 1 )
 {
 holesBuffer.AddOutline( outline.back() );
 outline.pop_back();
 }
 
 Simplify( SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
 
 // If any hole, subtract it to main outline
 if( holesBuffer.OutlineCount() )
 {
 holesBuffer.Simplify( SHAPE_POLY_SET::PM_FAST );
 BooleanSubtract( holesBuffer, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
 }
 
 // In degenerate cases, simplify might return no outlines
 if( OutlineCount() > 0 )
 RemoveNullSegments();
 
 return OutlineCount();
}

References AddOutline(), BooleanSubtract(), OutlineCount(), PM_FAST, PM_STRICTLY_SIMPLE, Polygon(), RemoveNullSegments(), and Simplify().

Referenced by BITMAPCONV_INFO::createOutputData().

◆ operator=()

SHAPE_POLY_SET & SHAPE_POLY_SET::operator= ( const SHAPE_POLY_SET & aOther )

Definition at line 2597 of file shape_poly_set.cpp.

{
 static_cast<SHAPE&>(*this) = aOther;
 m_polys = aOther.m_polys;
 
 m_triangulatedPolys.clear();
 
 for( unsigned i = 0; i < aOther.TriangulatedPolyCount(); i++ )
 {
 const TRIANGULATED_POLYGON* poly = aOther.TriangulatedPolygon( i );
 m_triangulatedPolys.push_back( std::make_unique<TRIANGULATED_POLYGON>( *poly ) );
 }
 
 m_hash = aOther.m_hash;
 m_triangulationValid = aOther.m_triangulationValid;
 
 return *this;
}

References m_hash, m_polys, m_triangulatedPolys, m_triangulationValid, TriangulatedPolyCount(), and TriangulatedPolygon().

◆ Outline() [1/2]

SHAPE_LINE_CHAIN & SHAPE_POLY_SET::Outline ( int aIndex )

inline

Definition at line 684 of file shape_poly_set.h.

 {
 return m_polys[aIndex][0];
 }

References m_polys.

Referenced by EE_POINT_EDITOR::addCorner(), ZONE_FILLER::addHatchFillTypeOnZone(), LIB_SHAPE::AddPoint(), SCH_SHAPE::AddPoint(), Area(), EDA_SHAPE::beginEdit(), BOOST_AUTO_TEST_CASE(), BuildBoardPolygonOutlines(), BuildFootprintPolygonOutlines(), BuildPolysetFromOrientedPaths(), ZONE::BuildSmoothedPoly(), CacheTriangulation(), EDA_SHAPE::calcEdit(), FOOTPRINT::CheckNetTies(), collidesWithArea(), TEARDROP_MANAGER::ComputePointsOnPadVia(), EDA_SHAPE::continueEdit(), ConvertOutlineToPolygon(), ConvertPolygonToBlocks(), FOOTPRINT::CoverageRatio(), BITMAPCONV_INFO::createOutputData(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::DIALOG_PAD_PRIMITIVE_POLY_PROPS(), KIGFX::DS_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), CALLBACK_GAL::DrawGlyph(), EDA_SHAPE::endEdit(), GBR_TO_PCB_EXPORTER::export_flashed_copper_item(), DSN::SPECCTRA_DB::fillBOUNDARY(), AR_AUTOPLACER::fillMatrix(), TEARDROP_MANAGER::findAnchorPointsOnTrack(), CADSTAR_SCH_ARCHIVE_LOADER::fixUpLibraryPins(), GERBER_PLOTTER::FlashPadChamferRoundRect(), DXF_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadCustom(), PSLIKE_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), DXF_PLOTTER::FlashPadRoundRect(), GERBER_PLOTTER::FlashPadRoundRect(), HPGL_PLOTTER::FlashPadRoundRect(), PSLIKE_PLOTTER::FlashPadRoundRect(), PCB_PLUGIN::format(), formatPoly(), PCB_PLUGIN::formatRenderCache(), PCB_SHAPE::GetCorners(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), PCB_SHAPE::GetFocusPosition(), LIB_SHAPE::GetItemDescription(), SCH_SHAPE::GetItemDescription(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), CADSTAR_SCH_ARCHIVE_LOADER::getScaledLibPart(), EDA_SHAPE::hitTest(), PNS::SOLID::HoleHull(), PNS::SOLID::Hull(), EDA_SHAPE::IsClosed(), GEOM_TEST::IsPolySetValid(), FABMASTER::loadFootprints(), FABMASTER::loadZone(), EDIT_POINTS_FACTORY::Make(), DSN::SPECCTRA_DB::makeIMAGE(), DSN::SPECCTRA_DB::makePADSTACK(), SCH_SEXPR_PARSER::ParseSchematic(), PCB_PARSER::parseZONE(), ZONE_CREATE_HELPER::performZoneCutout(), SCH_SHAPE::Plot(), LIB_SHAPE::Plot(), PlotDrawingSheet(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintShape(), BRDITEMS_PLOTTER::PlotPcbShape(), BRDITEMS_PLOTTER::PlotPcbText(), polygonArea(), SCH_SHAPE::Print(), LIB_SHAPE::print(), SCH_SHAPE::PrintBackground(), GERBER_DRAW_ITEM::PrintGerberPoly(), DS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem(), DRC_RTREE::QueryColliding(), RENDER_3D_OPENGL::reload(), EE_POINT_EDITOR::removeCorner(), EE_POINT_EDITOR::removeCornerCondition(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), DRC_TEST_PROVIDER_SLIVER_CHECKER::Run(), SCH_LEGACY_PLUGIN_CACHE::savePolyLine(), EDA_SHAPE::scale(), TEARDROP_MANAGER::SetTeardrops(), SHAPE_POLY_SET(), ZONE_FILLER::subtractHigherPriorityZones(), PNS_KICAD_IFACE_BASE::syncTextItem(), DRC_INTERACTIVE_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_ZONE_CONNECTIONS::testZoneLayer(), DRC_TEST_PROVIDER_PHYSICAL_CLEARANCE::testZoneLayer(), TransformArcToPolygon(), EE_POINT_EDITOR::updatePoints(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

◆ Outline() [2/2]

const SHAPE_LINE_CHAIN & SHAPE_POLY_SET::Outline ( int aIndex ) const

inline

Definition at line 689 of file shape_poly_set.h.

 {
 return m_polys[aIndex][0];
 }

References m_polys.

◆ OutlineCount()

int SHAPE_POLY_SET::OutlineCount ( ) const

inline

Return the number of vertices in a given outline/hole.

Definition at line 662 of file shape_poly_set.h.

References m_polys.

Referenced by PCB_POINT_EDITOR::addCorner(), ZONE_FILLER::addHatchFillTypeOnZone(), STEP_PCB_MODEL::AddPadHole(), PAD::addPadPrimitivesToPolygon(), ZONE::AddPolygon(), PAD::AddPrimitivePoly(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), ZONE::AppendCorner(), Area(), booleanOp(), BOOST_AUTO_TEST_CASE(), BOOST_FIXTURE_TEST_CASE(), BuildBBoxCaches(), BuildBoardPolygonOutlines(), BuildConvexHull(), BuildFootprintPolygonOutlines(), CacheTriangulation(), FOOTPRINT::CheckNetTies(), KI_TEST::CheckShapePolySet(), CIterate(), CIterateSegments(), CIterateSegmentsWithHoles(), CIterateWithHoles(), collidesWithArea(), Contains(), ConvertOutlineToPolygon(), convertPolygon(), ConvertPolygonToBlocks(), RENDER_3D_OPENGL::createBoard(), BITMAPCONV_INFO::createOutputData(), CreatePadsShapesSection(), STEP_PCB_MODEL::CreatePCB(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), CONVERT_TOOL::CreatePolys(), KIGFX::DS_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), D_CODE::DrawFlashedPolygon(), D_CODE::DrawFlashedShape(), KIGFX::GERBVIEW_PAINTER::drawFlashedShape(), CALLBACK_GAL::DrawGlyph(), AR_AUTOPLACER::drawPlacementRoutingMatrix(), KIGFX::CAIRO_GAL_BASE::DrawPolygon(), KIGFX::OPENGL_GAL::DrawPolygon(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), KIGFX::PREVIEW::POLYGON_ITEM::drawPreviewShape(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), EDA_SHAPE::DupPolyPointsList(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), EXPORTER_PCB_VRML::ExportVrmlBoard(), EXPORTER_PCB_VRML::ExportVrmlPolygonSet(), fillArcPOLY(), DSN::SPECCTRA_DB::fillBOUNDARY(), ZONE_FILLER::fillCopperZone(), GEOM_TEST::FilletPolySet(), DXF_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadCustom(), PSLIKE_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), PCB_PLUGIN::formatRenderCache(), FullPointCount(), RENDER_3D_OPENGL::generateHoles(), RENDER_3D_OPENGL::generateLayerList(), RENDER_3D_OPENGL::generateViasAndPads(), APERTURE_MACRO::GetApertureMacroShape(), PAD::GetBestAnchorPosition(), GERBER_DRAW_ITEM::GetBoundingBox(), FOOTPRINT::GetBoundingHull(), PCB_SHAPE::GetCorners(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), FOOTPRINT::GetEffectiveShape(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), GetRelativeIndices(), D_CODE::GetShapeDim(), HasTouchingHoles(), EDA_SHAPE::hitTest(), DS_DRAW_ITEM_POLYPOLYGONS::HitTest(), ZONE::HitTestCutout(), isCopperOutside(), GEOM_TEST::IsPolySetValid(), Iterate(), IterateSegments(), IterateSegmentsWithHoles(), IterateWithHoles(), FABMASTER::loadFootprints(), FABMASTER::loadGraphics(), FABMASTER::loadPolygon(), EDA_SHAPE::makeEffectiveShapes(), NormalizeAreaOutlines(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::operator bool(), DIALOG_PAD_PROPERTIES::padValuesOK(), PCB_PARSER::parseRenderCache(), ZONE_CREATE_HELPER::performZoneCutout(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintShape(), PlotLayerOutlines(), BRDITEMS_PLOTTER::PlotPcbShape(), BRDITEMS_PLOTTER::PlotPcbText(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), PlotStandardLayer(), polygonArea(), GERBER_DRAW_ITEM::Print(), DS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem(), DRC_RTREE::QueryColliding(), RENDER_3D_RAYTRACE::Reload(), ZONE::RemoveCutout(), DRC_TEST_PROVIDER_SLIVER_CHECKER::Run(), DRC_TEST_PROVIDER_TEXT_DIMS::Run(), EDA_SHAPE::scale(), EDA_SHAPE::SetPolyShape(), Subset(), PNS_KICAD_IFACE_BASE::syncZone(), TestConcaveSquareFillet(), DRC_INTERACTIVE_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), TestSquareFillet(), DRC_TEST_PROVIDER_PHYSICAL_CLEARANCE::testZoneLayer(), HYPERLYNX_EXPORTER::writeBoardInfo(), HYPERLYNX_EXPORTER::writeNetObjects(), GBR_TO_PCB_EXPORTER::writePcbPolygon(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

◆ Parse()

bool SHAPE_POLY_SET::Parse ( std::stringstream & aStream )

overridevirtual

Reimplemented from SHAPE.

Definition at line 1685 of file shape_poly_set.cpp.

{
 std::string tmp;
 
 aStream >> tmp;
 
 if( tmp != "polyset" )
 return false;
 
 aStream >> tmp;
 
 int n_polys = atoi( tmp.c_str() );
 
 if( n_polys < 0 )
 return false;
 
 for( int i = 0; i < n_polys; i++ )
 {
 POLYGON paths;
 
 aStream >> tmp;
 
 if( tmp != "poly" )
 return false;
 
 aStream >> tmp;
 int n_outlines = atoi( tmp.c_str() );
 
 if( n_outlines < 0 )
 return false;
 
 for( int j = 0; j < n_outlines; j++ )
 {
 SHAPE_LINE_CHAIN outline;
 
 outline.SetClosed( true );
 
 aStream >> tmp;
 int n_vertices = atoi( tmp.c_str() );
 
 for( int v = 0; v < n_vertices; v++ )
 {
 VECTOR2I p;
 
 aStream >> tmp; p.x = atoi( tmp.c_str() );
 aStream >> tmp; p.y = atoi( tmp.c_str() );
 outline.Append( p );
 }
 
 paths.push_back( outline );
 }
 
 m_polys.push_back( paths );
 }
 
 return true;
}

References SHAPE_LINE_CHAIN::Append(), m_polys, SHAPE_LINE_CHAIN::SetClosed(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ PointOnEdge()

bool SHAPE_POLY_SET::PointOnEdge ( const VECTOR2I & aP ) const

Check if point aP lies on an edge or vertex of some of the outlines or holes.

Parameters

aP	is the point to check.

Returns: true if the point lies on the edge of any polygon.

Definition at line 1777 of file shape_poly_set.cpp.

{
 // Iterate through all the polygons in the set
 for( const POLYGON& polygon : m_polys )
 {
 // Iterate through all the line chains in the polygon
 for( const SHAPE_LINE_CHAIN& lineChain : polygon )
 {
 if( lineChain.PointOnEdge( aP ) )
 return true;
 }
 }
 
 return false;
}

References m_polys.

◆ Polygon() [1/2]

POLYGON & SHAPE_POLY_SET::Polygon ( int aIndex )

inline

Definition at line 717 of file shape_poly_set.h.

 {
 return m_polys[aIndex];
 }

References m_polys.

Referenced by CacheTriangulation(), chamferFilletPolygon(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), ZONE_FILLER::fillCopperZone(), PCB_PLUGIN::format(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::Get(), SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::Get(), GetGlobalIndex(), FABMASTER::loadFootprints(), NormalizeAreaOutlines(), PCB_POINT_EDITOR::removeCorner(), PCB_POINT_EDITOR::removeCornerCondition(), and Subset().

◆ Polygon() [2/2]

const POLYGON & SHAPE_POLY_SET::Polygon ( int aIndex ) const

inline

Definition at line 722 of file shape_poly_set.h.

 {
 return m_polys[aIndex];
 }

References m_polys.

◆ RemoveAllContours()

void SHAPE_POLY_SET::RemoveAllContours ( )

Definition at line 1922 of file shape_poly_set.cpp.

{
 m_polys.clear();
}

References m_polys.

Referenced by buildBoardBoundingBoxPoly(), BuildBoardPolygonOutlines(), FOOTPRINT::BuildCourtyardCaches(), AR_AUTOPLACER::buildFpAreas(), DRC_TEST_PROVIDER_SOLDER_MASK::buildRTrees(), D_CODE::Clear_D_CODE_Data(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), BOARD_ADAPTER::createBoardPolygon(), BITMAPCONV_INFO::createOutputData(), BOARD_ADAPTER::destroyLayers(), EXPORTER_PCB_VRML::ExportStandardLayers(), EXPORTER_PCB_VRML::ExportVrmlSolderMask(), ZONE_FILLER::Fill(), RENDER_3D_OPENGL::generateViasAndPads(), APERTURE_MACRO::GetApertureMacroShape(), FOOTPRINT::GetBoundingHull(), PAD::MergePrimitivesAsPolygon(), PlotLayerOutlines(), RENDER_3D_OPENGL::reload(), ZONE::RemoveAllContours(), EDA_SHAPE::rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), EDA_SHAPE::SetPolyPoints(), and EE_POINT_EDITOR::updateParentItem().

◆ RemoveContour()

void SHAPE_POLY_SET::RemoveContour	(	int	aContourIdx,
		int	aPolygonIdx = `-1`
	)

Delete the aContourIdx-th contour of the aPolygonIdx-th polygon in the set.

Parameters

aContourIdx	is the index of the contour in the aPolygonIdx-th polygon to be removed.
aPolygonIdx	is the index of the polygon in which the to-be-removed contour is. Defaults to the last polygon in the set.

Definition at line 1928 of file shape_poly_set.cpp.

{
 // Default polygon is the last one
 if( aPolygonIdx < 0 )
 aPolygonIdx += m_polys.size();
 
 m_polys[aPolygonIdx].erase( m_polys[aPolygonIdx].begin() + aContourIdx );
}

References m_polys.

Referenced by PCB_POINT_EDITOR::removeCorner().

◆ RemoveNullSegments()

int SHAPE_POLY_SET::RemoveNullSegments ( )

Look for null segments; ie, segments whose ends are exactly the same and deletes them.

Returns: the number of deleted segments.

Definition at line 1938 of file shape_poly_set.cpp.

{
 int removed = 0;
 
 ITERATOR iterator = IterateWithHoles();
 
 VECTOR2I contourStart = *iterator;
 VECTOR2I segmentStart, segmentEnd;
 
 VERTEX_INDEX indexStart;
 std::vector<VERTEX_INDEX> indices_to_remove;
 
 while( iterator )
 {
 // Obtain first point and its index
 segmentStart = *iterator;
 indexStart = iterator.GetIndex();
 
 // Obtain last point
 if( iterator.IsEndContour() )
 {
 segmentEnd = contourStart;
 
 // Advance
 iterator++;
 
 // If we have rolled into the next contour, remember its position
 // segmentStart and segmentEnd remain valid for comparison here
 if( iterator )
 contourStart = *iterator;
 }
 else
 {
 // Advance
 iterator++;
 
 // If we have reached the end of the SHAPE_POLY_SET, something is broken here
 wxCHECK_MSG( iterator, removed, wxT( "Invalid polygon. Reached end without noticing. Please report this error" ) );
 
 segmentEnd = *iterator;
 }
 
 // Remove segment start if both points are equal
 if( segmentStart == segmentEnd )
 {
  indices_to_remove.push_back( indexStart );
 removed++;
 }
 }
 
 // Proceed in reverse direction to remove the vertices because they are stored as absolute indices in a vector
 // Removing in reverse order preserves the remaining index values
 for( auto it = indices_to_remove.rbegin(); it != indices_to_remove.rend(); ++it )
 RemoveVertex( *it );
 
 return removed;
}

References SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::GetIndex(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::IsEndContour(), IterateWithHoles(), and RemoveVertex().

Referenced by BOOST_AUTO_TEST_CASE(), chamferFilletPolygon(), and NormalizeAreaOutlines().

◆ RemoveVertex() [1/2]

void SHAPE_POLY_SET::RemoveVertex ( int aGlobalIndex )

Delete the aGlobalIndex-th vertex.

Parameters

aGlobalIndex is the global index of the to-be-removed vertex.

Definition at line 2149 of file shape_poly_set.cpp.

{
 VERTEX_INDEX index;
 
 // Assure the to be removed vertex exists, abort otherwise
 if( GetRelativeIndices( aGlobalIndex, &index ) )
 RemoveVertex( index );
 else
 throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
}

References GetRelativeIndices(), and RemoveVertex().

Referenced by PCB_POINT_EDITOR::removeCorner(), RemoveNullSegments(), and RemoveVertex().

◆ RemoveVertex() [2/2]

void SHAPE_POLY_SET::RemoveVertex ( VERTEX_INDEX aRelativeIndices )

Delete the vertex indexed by aRelativeIndex (index of polygon, contour and vertex).

Parameters

aRelativeIndices is the set of relative indices of the to-be-removed vertex. Remove all outlines & holes (clears) the polygon set.

Definition at line 2161 of file shape_poly_set.cpp.

{
 m_polys[aIndex.m_polygon][aIndex.m_contour].Remove( aIndex.m_vertex );
}

References SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, m_polys, and SHAPE_POLY_SET::VERTEX_INDEX::m_vertex.

◆ Rotate()

void SHAPE_POLY_SET::Rotate	(	const EDA_ANGLE &	aAngle,
		const VECTOR2I &	aCenter = `{ 0, 0 }`
	)

overridevirtual

Rotate all vertices by a given angle.

Parameters

aCenter	is the rotation center.
aAngle	is the rotation angle.

Implements SHAPE.

Definition at line 2236 of file shape_poly_set.cpp.

{
 for( POLYGON& poly : m_polys )
 {
 for( SHAPE_LINE_CHAIN& path : poly )
 path.Rotate( aAngle, aCenter );
 }
 
 // Don't re-cache if the triangulation is already invalid
 if( m_triangulationValid )
 CacheTriangulation();
}

References CacheTriangulation(), m_polys, m_triangulationValid, and path.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), TEARDROP_MANAGER::ComputePointsOnPadVia(), D_CODE::ConvertShapeToPolygon(), ALTIUM_PCB::HelperShapeSetLocalCoord(), FABMASTER::loadFootprints(), ZONE::Rotate(), EDA_SHAPE::rotate(), FOOTPRINT::SetOrientation(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), PAD::TransformShapeToPolygon(), TransformTrapezoidToPolygon(), PCB_DIM_ALIGNED::updateGeometry(), PCB_DIM_ORTHOGONAL::updateGeometry(), PCB_DIM_RADIAL::updateGeometry(), PCB_DIM_LEADER::updateGeometry(), and zonesNeedUpdate().

◆ SetVertex() [1/2]

void SHAPE_POLY_SET::SetVertex	(	const VERTEX_INDEX &	aIndex,
		const VECTOR2I &	aPos
	)

Accessor function to set the position of a specific point.

Parameters

aIndex	#VERTEX_INDEX of the point to move.
aPos	destination position of the specified point.

Definition at line 2178 of file shape_poly_set.cpp.

{
 m_polys[aIndex.m_polygon][aIndex.m_contour].SetPoint( aIndex.m_vertex, aPos );
}

References SHAPE_POLY_SET::VERTEX_INDEX::m_contour, SHAPE_POLY_SET::VERTEX_INDEX::m_polygon, m_polys, and SHAPE_POLY_SET::VERTEX_INDEX::m_vertex.

Referenced by ZONE::MoveEdge(), ZONE::SetCornerPosition(), SetVertex(), and PCB_POINT_EDITOR::updateItem().

◆ SetVertex() [2/2]

void SHAPE_POLY_SET::SetVertex	(	int	aGlobalIndex,
		const VECTOR2I &	aPos
	)

Set the vertex based on the global index.

Throws if the index doesn't exist.

Parameters

aGlobalIndex	global index of the to-be-moved vertex
aPos	New position on the vertex Return total number of vertices stored in the set.

Definition at line 2167 of file shape_poly_set.cpp.

{
 VERTEX_INDEX index;
 
 if( GetRelativeIndices( aGlobalIndex, &index ) )
 SetVertex( index, aPos );
 else
 throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
}

References GetRelativeIndices(), and SetVertex().

◆ Simplify()

void SHAPE_POLY_SET::Simplify ( POLYGON_MODE aFastMode )

Definition at line 1608 of file shape_poly_set.cpp.

{
 SHAPE_POLY_SET empty;
 
 if( ADVANCED_CFG::GetCfg().m_UseClipper2 )
 booleanOp( Clipper2Lib::ClipType::Union, empty );
 else
 booleanOp( ClipperLib::ctUnion, empty, aFastMode );
}

References booleanOp(), empty(), and ADVANCED_CFG::GetCfg().

Referenced by PAD::addPadPrimitivesToPolygon(), BOARD_ADAPTER::addShape(), BOOST_AUTO_TEST_CASE(), ZONE_FILLER::buildCopperItemClearances(), DRC_TEST_PROVIDER_SOLDER_MASK::buildRTrees(), CacheTriangulation(), FOOTPRINT::CheckNetTies(), BOARD_ADAPTER::createBoardPolygon(), BITMAPCONV_INFO::createOutputData(), CONVERT_TOOL::CreatePolys(), Fracture(), APERTURE_MACRO::GetApertureMacroShape(), BOARD::GetBoardPolygonOutlines(), PNS::SOLID::HoleHull(), PNS::SOLID::Hull(), DSN::SPECCTRA_DB::makeIMAGE(), NormalizeAreaOutlines(), PlotLayerOutlines(), PlotSolderMaskLayer(), DRC_TEST_PROVIDER_SLIVER_CHECKER::Run(), DRC_TEST_PROVIDER_TEXT_DIMS::Run(), DRC_TEST_PROVIDER_PHYSICAL_CLEARANCE::testZoneLayer(), PAD::TransformShapeToPolygon(), FP_TEXT::TransformTextToPolySet(), FP_TEXTBOX::TransformTextToPolySet(), PCB_TEXT::TransformTextToPolySet(), PCB_TEXTBOX::TransformTextToPolySet(), Unfracture(), HYPERLYNX_EXPORTER::writeNetObjects(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

◆ SquaredDistance() [1/2]

SEG::ecoord SHAPE_POLY_SET::SquaredDistance	(	const SEG &	aSegment,
		VECTOR2I *	aNearest = `nullptr`
	)		const

Compute the minimum distance squared between aSegment and all the polygons in the set.

Squared distances are used because they avoid the cost of doing square-roots.

Parameters

aSegment	is the segment whose distance to the polygon set has to be measured.
aSegmentWidth	is the width of the segment; defaults to zero.
aNearest	[out] an optional pointer to be filled in with the point on the polyset which is closest to aSegment.

Returns: The minimum distance squared between aSegment and all the polygons in the set. If the point is contained in the polygon, the distance is zero.

Definition at line 2375 of file shape_poly_set.cpp.

{
 SEG::ecoord currentDistance_sq;
 SEG::ecoord minDistance_sq = VECTOR2I::ECOORD_MAX;
 VECTOR2I nearest;
 
 // Iterate through all the polygons and get the minimum distance.
 for( unsigned int polygonIdx = 0; polygonIdx < m_polys.size(); polygonIdx++ )
 {
 currentDistance_sq = SquaredDistanceToPolygon( aSegment, polygonIdx,
 aNearest ? &nearest : nullptr );
 
 if( currentDistance_sq < minDistance_sq )
 {
 if( aNearest )
 *aNearest = nearest;
 
 minDistance_sq = currentDistance_sq;
 }
 }
 
 return minDistance_sq;
}

References VECTOR2< int >::ECOORD_MAX, m_polys, and SquaredDistanceToPolygon().

◆ SquaredDistance() [2/2]

SEG::ecoord SHAPE_POLY_SET::SquaredDistance	(	VECTOR2I	aPoint,
		VECTOR2I *	aNearest = `nullptr`
	)		const

Compute the minimum distance squared between aPoint and all the polygons in the set.

Squared distances are used because they avoid the cost of doing square-roots.

Parameters

aPoint	is the point whose distance to the set has to be measured.
aNearest	[out] an optional pointer to be filled in with the point on the polyset which is closest to aPoint.

Returns: The minimum distance squared between aPoint and all the polygons in the set. If the point is contained in any of the polygons, the distance is zero.

Definition at line 2350 of file shape_poly_set.cpp.

{
 SEG::ecoord currentDistance_sq;
 SEG::ecoord minDistance_sq = VECTOR2I::ECOORD_MAX;
 VECTOR2I nearest;
 
 // Iterate through all the polygons and get the minimum distance.
 for( unsigned int polygonIdx = 0; polygonIdx < m_polys.size(); polygonIdx++ )
 {
 currentDistance_sq = SquaredDistanceToPolygon( aPoint, polygonIdx,
 aNearest ? &nearest : nullptr );
 
 if( currentDistance_sq < minDistance_sq )
 {
 if( aNearest )
  *aNearest = nearest;
 
 minDistance_sq = currentDistance_sq;
 }
 }
 
 return minDistance_sq;
}

References VECTOR2< int >::ECOORD_MAX, m_polys, and SquaredDistanceToPolygon().

Referenced by BOOST_AUTO_TEST_CASE(), Collide(), and DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run().

◆ SquaredDistanceToPolygon() [1/2]

SEG::ecoord SHAPE_POLY_SET::SquaredDistanceToPolygon	(	const SEG &	aSegment,
		int	aIndex,
		VECTOR2I *	aNearest
	)		const

Compute the minimum distance between the aIndex-th polygon and aSegment with a possible width.

Parameters

aSegment	is the segment whose distance to the aIndex-th polygon has to be measured.
aIndex	is the index of the polygon whose distance to aPoint has to be measured.
aNearest	[out] an optional pointer to be filled in with the point on the polyset which is closest to aSegment.

Returns: The minimum distance between aSegment and all the segments of the aIndex-th polygon. If the point is contained in the polygon, the distance is zero.

Definition at line 2313 of file shape_poly_set.cpp.

{
 // Check if the segment is fully-contained. If so, its midpoint is a good-enough nearest point.
 if( containsSingle( aSegment.A, aPolygonIndex, 1 ) &&
 containsSingle( aSegment.B, aPolygonIndex, 1 ) )
 {
 if( aNearest )
 *aNearest = ( aSegment.A + aSegment.B ) / 2;
 
 return 0;
 }
 
 CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
 SEG::ecoord minDistance = (*iterator).SquaredDistance( aSegment );
 
 if( aNearest && minDistance == 0 )
 *aNearest = ( *iterator ).NearestPoint( aSegment );
 
 for( iterator++; iterator && minDistance > 0; iterator++ )
 {
 SEG::ecoord currentDistance = (*iterator).SquaredDistance( aSegment );
 
 if( currentDistance < minDistance )
 {
 if( aNearest )
 *aNearest = (*iterator).NearestPoint( aSegment );
 
 minDistance = currentDistance;
 }
 }
 
 // Return the maximum of minDistance and zero
 return minDistance < 0 ? 0 : minDistance;
}

References SEG::A, SEG::B, CIterateSegmentsWithHoles(), and containsSingle().

◆ SquaredDistanceToPolygon() [2/2]

SEG::ecoord SHAPE_POLY_SET::SquaredDistanceToPolygon	(	VECTOR2I	aPoint,
		int	aIndex,
		VECTOR2I *	aNearest
	)		const

Compute the minimum distance between the aIndex-th polygon and aPoint.

Parameters

aPoint	is the point whose distance to the aIndex-th polygon has to be measured.
aIndex	is the index of the polygon whose distance to aPoint has to be measured.
aNearest	[out] an optional pointer to be filled in with the point on the polyset which is closest to aPoint.

Returns: The minimum distance between aPoint and all the segments of the aIndex-th polygon. If the point is contained in the polygon, the distance is zero.

Definition at line 2277 of file shape_poly_set.cpp.

{
 // We calculate the min dist between the segment and each outline segment. However, if the
 // segment to test is inside the outline, and does not cross any edge, it can be seen outside
 // the polygon. Therefore test if a segment end is inside (testing only one end is enough).
 // Use an accuracy of "1" to say that we don't care if it's exactly on the edge or not.
 if( containsSingle( aPoint, aPolygonIndex, 1 ) )
 {
 if( aNearest )
 *aNearest = aPoint;
 
 return 0;
 }
 
 CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
 
 SEG::ecoord minDistance = (*iterator).SquaredDistance( aPoint );
 
 for( iterator++; iterator && minDistance > 0; iterator++ )
 {
 SEG::ecoord currentDistance = (*iterator).SquaredDistance( aPoint );
 
 if( currentDistance < minDistance )
 {
 if( aNearest )
 *aNearest = (*iterator).NearestPoint( aPoint );
 
 minDistance = currentDistance;
 }
 }
 
 return minDistance;
}

References CIterateSegmentsWithHoles(), and containsSingle().

Referenced by SquaredDistance().

◆ Subset()

SHAPE_POLY_SET SHAPE_POLY_SET::Subset	(	int	aFirstPolygon,
		int	aLastPolygon
	)

Return a subset of the polygons in this set, the ones between aFirstPolygon and aLastPolygon.

Parameters

aFirstPolygon	is the first polygon to be included in the returned set.
aLastPolygon	is the last polygon to be excluded of the returned set.

Returns: a set containing the polygons between aFirstPolygon (included) and aLastPolygon (excluded).

Definition at line 367 of file shape_poly_set.cpp.

{
 assert( aFirstPolygon >= 0 && aLastPolygon <= OutlineCount() );
 
 SHAPE_POLY_SET newPolySet;
 
 for( int index = aFirstPolygon; index < aLastPolygon; index++ )
 newPolySet.m_polys.push_back( Polygon( index ) );
 
 return newPolySet;
}

References m_polys, OutlineCount(), and Polygon().

Referenced by UnitSet().

◆ TotalVertices()

int SHAPE_POLY_SET::TotalVertices ( ) const

Delete aIdx-th polygon from the set.

Definition at line 2250 of file shape_poly_set.cpp.

{
 int c = 0;
 
 for( const POLYGON& poly : m_polys )
 {
 for( const SHAPE_LINE_CHAIN& path : poly )
 c += path.PointCount();
 }
 
 return c;
}

References m_polys, and path.

Referenced by PCB_POINT_EDITOR::buildForPolyOutline(), KI_TEST::CheckShapePolySet(), EDA_SHAPE::Compare(), ZONE::GetNumCorners(), ZONE::HitTest(), InsertVertex(), FOOTPRINT::cmp_drawings::operator()(), FOOTPRINT::cmp_zones::operator()(), shapesNeedUpdate(), PCB_POINT_EDITOR::updateItem(), PCB_POINT_EDITOR::updatePoints(), and zonesNeedUpdate().

◆ TriangulatedPolyCount()

unsigned int SHAPE_POLY_SET::TriangulatedPolyCount ( ) const

inline

Return the number of outlines in the set.

Definition at line 659 of file shape_poly_set.h.

References m_triangulatedPolys.

Referenced by ConvertPolygonToTriangles(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), operator=(), SHAPE_POLY_SET(), and KIFONT::OUTLINE_GLYPH::Triangulate().

◆ TriangulatedPolygon()

const TRIANGULATED_POLYGON * SHAPE_POLY_SET::TriangulatedPolygon ( int aIndex ) const

inline

Definition at line 727 of file shape_poly_set.h.

 {
 return m_triangulatedPolys[aIndex].get();
 }

References m_triangulatedPolys.

Referenced by ConvertPolygonToTriangles(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), operator=(), SHAPE_POLY_SET(), PNS_KICAD_IFACE_BASE::syncZone(), and KIFONT::OUTLINE_GLYPH::Triangulate().

◆ Type()

SHAPE_TYPE SHAPE_BASE::Type ( ) const

inlineinherited

Return the type of the shape.

Return values

the type

Definition at line 95 of file shape.h.

 {
 return m_type;
 }

References SHAPE_BASE::m_type.

Referenced by PNS::DP_GATEWAYS::BuildFromPrimitivePair(), PNS::buildHullForPrimitiveShape(), PNS_LOG_VIEWER_FRAME::buildListTree(), Collide(), Collide(), collideShapes(), collideSingleShapes(), PNS::OPTIMIZER::computeBreakouts(), ROUTER_PREVIEW_ITEM::drawShape(), PNS_LOG_VIEWER_FRAME::drawSimpleShape(), PNS::SOLID::HoleHull(), PNS::SOLID::Hull(), STROKE_PARAMS::Stroke(), and SHAPE_FILE_IO::Write().

◆ TypeName()

wxString SHAPE_BASE::TypeName ( ) const

inlineinherited

Definition at line 100 of file shape.h.

 {
 return SHAPE_TYPE_asString( m_type );
 }

References SHAPE_BASE::m_type, and SHAPE_TYPE_asString().

Referenced by Collide().

◆ Unfracture()

void SHAPE_POLY_SET::Unfracture ( POLYGON_MODE aFastMode )

Return true if the polygon set has any holes.

Definition at line 1599 of file shape_poly_set.cpp.

{
 for( POLYGON& path : m_polys )
 unfractureSingle( path );
 
 Simplify( aFastMode ); // remove overlapping holes/degeneracy
}

References m_polys, path, Simplify(), and unfractureSingle().

Referenced by InflateWithLinkedHoles().

◆ unfractureSingle()

void SHAPE_POLY_SET::unfractureSingle ( SHAPE_POLY_SET::POLYGON & aPoly )

private

Definition at line 1417 of file shape_poly_set.cpp.

{
 assert( aPoly.size() == 1 );
 
 struct EDGE
 {
 int m_index = 0;
 SHAPE_LINE_CHAIN* m_poly = nullptr;
 bool m_duplicate = false;
 
 EDGE( SHAPE_LINE_CHAIN* aPolygon, int aIndex ) :
 m_index( aIndex ),
 m_poly( aPolygon )
 {}
 
 bool compareSegs( const SEG& s1, const SEG& s2 ) const
 {
 return (s1.A == s2.B && s1.B == s2.A);
 }
 
 bool operator==( const EDGE& aOther ) const
 {
 return compareSegs( m_poly->CSegment( m_index ),
 aOther.m_poly->CSegment( aOther.m_index ) );
 }
 
 bool operator!=( const EDGE& aOther ) const
 {
 return !compareSegs( m_poly->CSegment( m_index ),
 aOther.m_poly->CSegment( aOther.m_index ) );
 }
 
 struct HASH
 {
 std::size_t operator()( const EDGE& aEdge ) const
 {
 const SEG& a = aEdge.m_poly->CSegment( aEdge.m_index );
 std::size_t seed = 0xa82de1c0;
 hash_combine( seed, a.A.x, a.B.x, a.A.y, a.B.y );
 return seed;
 }
 };
 };
 
 struct EDGE_LIST_ENTRY
 {
 int index;
 EDGE_LIST_ENTRY* next;
 };
 
 std::unordered_set<EDGE, EDGE::HASH> uniqueEdges;
 
 SHAPE_LINE_CHAIN lc = aPoly[0];
 lc.Simplify();
 
 auto edgeList = std::make_unique<EDGE_LIST_ENTRY[]>( lc.SegmentCount() );
 
 for( int i = 0; i < lc.SegmentCount(); i++ )
 {
 edgeList[i].index = i;
 edgeList[i].next = &edgeList[ (i != lc.SegmentCount() - 1) ? i + 1 : 0 ];
 }
 
 std::unordered_set<EDGE_LIST_ENTRY*> queue;
 
 for( int i = 0; i < lc.SegmentCount(); i++ )
 {
 EDGE e( &lc, i );
 uniqueEdges.insert( e );
 }
 
 for( int i = 0; i < lc.SegmentCount(); i++ )
 {
 EDGE e( &lc, i );
 auto it = uniqueEdges.find( e );
 
 if( it != uniqueEdges.end() && it->m_index != i )
 {
 int e1 = it->m_index;
 int e2 = i;
 
 if( e1 > e2 )
 std::swap( e1, e2 );
 
 int e1_prev = e1 - 1;
 
 if( e1_prev < 0 )
 e1_prev = lc.SegmentCount() - 1;
 
 int e2_prev = e2 - 1;
 
 if( e2_prev < 0 )
 e2_prev = lc.SegmentCount() - 1;
 
 int e1_next = e1 + 1;
 
 if( e1_next == lc.SegmentCount() )
 e1_next = 0;
 
 int e2_next = e2 + 1;
 
 if( e2_next == lc.SegmentCount() )
 e2_next = 0;
 
 edgeList[e1_prev].next = &edgeList[ e2_next ];
 edgeList[e2_prev].next = &edgeList[ e1_next ];
 edgeList[i].next = nullptr;
 edgeList[it->m_index].next = nullptr;
 }
 }
 
 for( int i = 0; i < lc.SegmentCount(); i++ )
 {
 if( edgeList[i].next )
 queue.insert( &edgeList[i] );
 }
 
 auto edgeBuf = std::make_unique<EDGE_LIST_ENTRY* []>( lc.SegmentCount() );
 
 int n = 0;
 int outline = -1;
 
 POLYGON result;
 double max_poly = 0.0;
 
 while( queue.size() )
 {
 EDGE_LIST_ENTRY* e_first = *queue.begin();
 EDGE_LIST_ENTRY* e = e_first;
 int cnt = 0;
 
 do
 {
 edgeBuf[cnt++] = e;
 e = e->next;
 } while( e && e != e_first );
 
 SHAPE_LINE_CHAIN outl;
 
 for( int i = 0; i < cnt; i++ )
 {
 VECTOR2I p = lc.CPoint( edgeBuf[i]->index );
 outl.Append( p );
 queue.erase( edgeBuf[i] );
 }
 
 outl.SetClosed( true );
 
 double area = std::fabs( outl.Area() );
 
 if( area > max_poly )
 {
 outline = n;
 max_poly = area;
 }
 
 result.push_back( outl );
 n++;
 }
 
 if( outline > 0 )
 std::swap( result[0], result[outline] );
 
 aPoly = result;
}

References SEG::A, SHAPE_LINE_CHAIN::Append(), SHAPE_LINE_CHAIN::Area(), SEG::B, SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::CSegment(), hash_combine(), next(), KIGFX::operator!=(), KIGFX::operator==(), SHAPE_LINE_CHAIN::SegmentCount(), SHAPE_LINE_CHAIN::SetClosed(), SHAPE_LINE_CHAIN::Simplify(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Unfracture().

◆ UnitSet()

SHAPE_POLY_SET SHAPE_POLY_SET::UnitSet ( int aPolygonIndex )

inline

Return the reference to aHole-th hole in the aIndex-th outline.

Definition at line 705 of file shape_poly_set.h.

References Subset().

◆ UpdateTriangulationDataHash()

void SHAPE_POLY_SET::UpdateTriangulationDataHash ( )

Definition at line 2025 of file shape_poly_set.cpp.

{
 m_hash = checksum();
}

References checksum(), and m_hash.

◆ VertexCount()

int SHAPE_POLY_SET::VertexCount	(	int	aOutline = `-1`,
		int	aHole = `-1`
	)		const

Return the number of points in the shape poly set.

mainly for reports

Definition at line 321 of file shape_poly_set.cpp.

{
 if( m_polys.size() == 0 ) // Empty poly set
 return 0;
 
 if( aOutline < 0 ) // Use last outline
 aOutline += m_polys.size();
 
 int idx;
 
 if( aHole < 0 )
 idx = 0;
 else
 idx = aHole + 1;
 
 if( aOutline >= (int) m_polys.size() ) // not existing outline
 return 0;
 
 if( idx >= (int) m_polys[aOutline].size() ) // not existing hole
 return 0;
 
 return m_polys[aOutline][idx].PointCount();
}

References m_polys.

Referenced by BOOST_AUTO_TEST_CASE(), Collide(), D_CODE::DrawFlashedPolygon(), GERBER_FILE_IMAGE::Execute_G_Command(), EDA_SHAPE::GetPointCount(), FABMASTER::loadFootprints(), FABMASTER::loadShapePolySet(), and FABMASTER::loadZone().

Member Data Documentation

◆ facets

std::list< FACET* > SHAPE::facets

privateinherited

Definition at line 143 of file wrlfacet.h.

Referenced by SHAPE::CalcShape(), and SHAPE::NewFacet().

◆ m_hash

MD5_HASH SHAPE_POLY_SET::m_hash

private

Definition at line 1484 of file shape_poly_set.h.

Referenced by CacheTriangulation(), DeletePolygonAndTriangulationData(), GetHash(), IsTriangulationUpToDate(), Move(), operator=(), SHAPE_POLY_SET(), and UpdateTriangulationDataHash().

◆ m_polys

std::vector<POLYGON> SHAPE_POLY_SET::m_polys

private

Definition at line 1480 of file shape_poly_set.h.

Referenced by AddHole(), AddOutline(), Append(), ArcCount(), BBox(), BBoxFromCaches(), booleanOp(), Chamfer(), checksum(), CHole(), ClearArcs(), Contains(), containsSingle(), COutline(), CPolygon(), CVertex(), DeletePolygon(), DeletePolygonAndTriangulationData(), Fillet(), Format(), Fracture(), FullPointCount(), GetArcs(), GetGlobalIndex(), GetNeighbourIndexes(), HasHoles(), Hole(), HoleCount(), importPaths(), importPolyPath(), importTree(), inflate1(), inflate2(), InsertVertex(), IsEmpty(), IsSelfIntersecting(), Mirror(), Move(), NewHole(), NewOutline(), operator=(), Outline(), OutlineCount(), Parse(), PointOnEdge(), Polygon(), RemoveAllContours(), RemoveContour(), RemoveVertex(), Rotate(), SetVertex(), SquaredDistance(), Subset(), TotalVertices(), Unfracture(), and VertexCount().

◆ m_triangulatedPolys

std::vector<std::unique_ptr<TRIANGULATED_POLYGON> > SHAPE_POLY_SET::m_triangulatedPolys

private

Definition at line 1481 of file shape_poly_set.h.

Referenced by CacheTriangulation(), Collide(), DeletePolygonAndTriangulationData(), GetIndexableSubshapeCount(), GetIndexableSubshapes(), Move(), operator=(), SHAPE_POLY_SET(), TriangulatedPolyCount(), and TriangulatedPolygon().

◆ m_triangulationValid

bool SHAPE_POLY_SET::m_triangulationValid = false

private

Definition at line 1483 of file shape_poly_set.h.

Referenced by CacheTriangulation(), DeletePolygonAndTriangulationData(), IsTriangulationUpToDate(), Mirror(), operator=(), Rotate(), and SHAPE_POLY_SET().

◆ m_type

SHAPE_TYPE SHAPE_BASE::m_type

protectedinherited

< type of our shape

Definition at line 116 of file shape.h.

Referenced by SHAPE::Format(), SHAPE::IsNull(), SHAPE_BASE::Type(), and SHAPE_BASE::TypeName().

◆ MIN_PRECISION_IU

const int SHAPE::MIN_PRECISION_IU = 4

staticinherited

This is the minimum precision for all the points in a shape.

Definition at line 128 of file shape.h.

Referenced by BOOST_AUTO_TEST_CASE(), DIRECTION_45::BuildInitialTrace(), CompareLength(), CIRCLE::Contains(), EDIT_TOOL::FilletTracks(), and CIRCLE::IntersectLine().

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CONST_ITERATOR

◆ CONST_SEGMENT_ITERATOR

◆ ecoord

◆ ITERATOR

◆ POLYGON

◆ SEGMENT_ITERATOR

Member Enumeration Documentation

◆ CORNER_MODE

◆ CORNER_STRATEGY

◆ DROP_TRIANGULATION_FLAG

◆ POLYGON_MODE

Constructor & Destructor Documentation

◆ SHAPE_POLY_SET() [1/5]

◆ SHAPE_POLY_SET() [2/5]

◆ SHAPE_POLY_SET() [3/5]

◆ SHAPE_POLY_SET() [4/5]

◆ ~SHAPE_POLY_SET()

◆ SHAPE_POLY_SET() [5/5]

Member Function Documentation

◆ AddHole()

◆ AddOutline()

◆ Append() [1/4]

◆ Append() [2/4]

◆ Append() [3/4]

◆ Append() [4/4]

◆ ArcCount()

◆ Area()

◆ BBox()

◆ BBoxFromCaches()

◆ BooleanAdd() [1/2]

◆ BooleanAdd() [2/2]

◆ BooleanIntersection() [1/2]

◆ BooleanIntersection() [2/2]

◆ booleanOp() [1/4]

◆ booleanOp() [2/4]

◆ booleanOp() [3/4]

◆ booleanOp() [4/4]

◆ BooleanSubtract() [1/2]

◆ BooleanSubtract() [2/2]

◆ BuildBBoxCaches()

◆ BuildPolysetFromOrientedPaths()

◆ CacheTriangulation()

◆ CalcShape()

◆ Centre()

◆ Chamfer()

◆ chamferFilletPolygon()

◆ ChamferPolygon()

◆ checksum()

◆ CHole()

◆ CIterate() [1/3]

◆ CIterate() [2/3]

◆ CIterate() [3/3]

◆ CIterateSegments() [1/3]

◆ CIterateSegments() [2/3]

◆ CIterateSegments() [3/3]

◆ CIterateSegmentsWithHoles() [1/2]

◆ CIterateSegmentsWithHoles() [2/2]

◆ CIterateWithHoles() [1/2]

◆ CIterateWithHoles() [2/2]

◆ ClearArcs()

◆ Clone()

◆ CloneDropTriangulation()

◆ Collide() [1/4]

◆ Collide() [2/4]

◆ Collide() [3/4]

◆ Collide() [4/4]

◆ CollideEdge()

◆ CollideVertex()