SHAPE_POLY_SET Class Reference

SHAPE_POLY_SET. More...

#include <shape_poly_set.h>

Inheritance diagram for SHAPE_POLY_SET:

Classes
class	ITERATOR_TEMPLATE
	ITERATOR_TEMPLATE. More...
class	SEGMENT_ITERATOR_TEMPLATE
	SEGMENT_ITERATOR_TEMPLATE. More...
class	TRIANGULATED_POLYGON
struct	VERTEX_INDEX
	Struct VERTEX_INDEX. 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 (theorically) 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 struct SHAPE_POLY_SET::VERTEX_INDEX	VERTEX_INDEX
	Struct VERTEX_INDEX. 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 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 &)
void	CacheTriangulation (bool aPartition=true)
bool	IsTriangulationUpToDate () const
MD5_HASH	GetHash () const
virtual bool	HasIndexableSubshapes () const override
virtual size_t	GetIndexableSubshapeCount () const override
virtual void	GetIndexableSubshapes (std::vector< SHAPE * > &aSubshapes) override
bool	GetRelativeIndices (int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
	Function GetRelativeIndices. More...
bool	GetGlobalIndex (VERTEX_INDEX aRelativeIndices, int &aGlobalIdx)
	Function GetGlobalIndex computes the global index of a vertex from the relative indices of polygon, contour and vertex. More...
SHAPE *	Clone () const override
	Function Clone() More...
int	NewOutline ()
	Creates a new empty polygon in the set and returns its index More...
int	NewHole (int aOutline=-1)
	Creates a new hole in a given outline More...
int	AddOutline (const SHAPE_LINE_CHAIN &aOutline)
	Adds a new outline to the set and returns its index More...
int	AddHole (const SHAPE_LINE_CHAIN &aHole, int aOutline=-1)
	Adds a new hole to the given outline (default: last) and returns its index More...
int	Append (int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
	Appends a vertex at the end of the given outline/hole (default: the last outline) More...
void	Append (const SHAPE_POLY_SET &aSet)
	Merges polygons from two sets. More...
void	Append (const VECTOR2I &aP, int aOutline=-1, int aHole=-1)
	Appends a vertex at the end of the given outline/hole (default: the last outline) More...
void	InsertVertex (int aGlobalIndex, VECTOR2I aNewVertex)
	Function InsertVertex Adds a vertex in the globally indexed position aGlobalIndex. More...
const VECTOR2I &	CVertex (int aIndex, int aOutline, int aHole) const
	Returns the index-th vertex in a given hole outline within a given outline More...
const VECTOR2I &	CVertex (int aGlobalIndex) const
	Returns the aGlobalIndex-th vertex in the poly set More...
const VECTOR2I &	CVertex (VERTEX_INDEX aIndex) const
	Returns the index-th vertex in a given hole outline within a given outline More...
bool	GetNeighbourIndexes (int aGlobalIndex, int *aPrevious, int *aNext)
	Returns 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
	Function IsPolygonSelfIntersecting. More...
bool	IsSelfIntersecting () const
	Function IsSelfIntersecting Checks whether any of the polygons in the set is self intersecting. More...
unsigned int	TriangulatedPolyCount () const
	Returns the number of triangulated polygons More...
int	OutlineCount () const
	Returns the number of outlines in the set More...
int	VertexCount (int aOutline=-1, int aHole=-1) const
	Returns the number of vertices in a given outline/hole More...
int	HoleCount (int aOutline) const
	Returns the number of holes in a given outline More...
SHAPE_LINE_CHAIN &	Outline (int aIndex)
	Returns the reference to aIndex-th outline in the set More...
const SHAPE_LINE_CHAIN &	Outline (int aIndex) const
SHAPE_POLY_SET	Subset (int aFirstPolygon, int aLastPolygon)
	Function Subset returns a subset of the polygons in this set, the ones between aFirstPolygon and aLastPolygon. More...
SHAPE_POLY_SET	UnitSet (int aPolygonIndex)
SHAPE_LINE_CHAIN &	Hole (int aOutline, int aHole)
	Returns the reference to aHole-th hole in the aIndex-th outline More...
POLYGON &	Polygon (int aIndex)
	Returns the aIndex-th subpolygon in the set More...
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)
	Function Iterate returns an object to iterate through the points of the polygons between aFirst and aLast. More...
ITERATOR	Iterate (int aOutline)
	Function Iterate. More...
ITERATOR	IterateWithHoles (int aOutline)
	Function IterateWithHoles. More...
ITERATOR	Iterate ()
	Function Iterate. More...
ITERATOR	IterateWithHoles ()
	Function IterateWithHoles. More...
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)
SEGMENT_ITERATOR	IterateSegments (int aFirst, int aLast, bool aIterateHoles=false)
	Returns 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
	Returns an iterator object, for iterating between aFirst and aLast outline, with or without holes (default: without) More...
SEGMENT_ITERATOR	IterateSegments (int aPolygonIdx)
	Returns an iterator object, for iterating aPolygonIdx-th polygon edges More...
CONST_SEGMENT_ITERATOR	CIterateSegments (int aPolygonIdx) const
	Returns an iterator object, for iterating aPolygonIdx-th polygon edges More...
SEGMENT_ITERATOR	IterateSegments ()
	Returns an iterator object, for all outlines in the set (no holes) More...
SEGMENT_ITERATOR	IterateSegmentsWithHoles ()
	Returns an iterator object, for all outlines in the set (with holes) More...
SEGMENT_ITERATOR	IterateSegmentsWithHoles (int aOutline)
	Returns an iterator object, for the aOutline-th outline in the set (with holes) More...
CONST_SEGMENT_ITERATOR	CIterateSegmentsWithHoles () const
	Returns an iterator object, for the aOutline-th outline in the set (with holes) More...
CONST_SEGMENT_ITERATOR	CIterateSegmentsWithHoles (int aOutline) const
	Returns an iterator object, for the aOutline-th outline in the set (with holes) More...
void	BooleanAdd (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Performs boolean polyset union For aFastMode meaning, see function booleanOp More...
void	BooleanSubtract (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Performs boolean polyset difference For aFastMode meaning, see function booleanOp More...
void	BooleanIntersection (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Performs boolean polyset intersection For aFastMode meaning, see function booleanOp More...
void	BooleanAdd (const SHAPE_POLY_SET &a, const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
	Performs boolean polyset union 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)
	Performs boolean polyset difference 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)
	Performs boolean polyset intersection between a and b, store the result in it self For aFastMode meaning, see function booleanOp More...
void	Inflate (int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
	Performs 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)
	Performs outline inflation/deflation, using round corners. More...
void	Fracture (POLYGON_MODE aFastMode)
	Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the outer ring to the inner holes For aFastMode meaning, see function booleanOp More...
void	Unfracture (POLYGON_MODE aFastMode)
	Converts a single outline slitted ("fractured") polygon into a set ouf outlines with holes. More...
bool	HasHoles () const
	Returns true if the polygon set has any holes. More...
bool	HasTouchingHoles () const
	Returns true if the polygon set has any holes tha share a vertex. More...
void	Simplify (POLYGON_MODE aFastMode)
	Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFastMode meaning, see function booleanOp More...
int	NormalizeAreaOutlines ()
	Function NormalizeAreaOutlines Convert a self-intersecting polygon to one (or more) non self-intersecting polygon(s) Removes null segments. More...
const std::string	Format () 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 })
	Mirrors the line points about y or x (or both) More...
void	Rotate (double aAngle, const VECTOR2I &aCenter={ 0, 0 }) override
	Function Rotate rotates all vertices by a given angle. More...
bool	IsSolid () const override
const BOX2I	BBox (int aClearance=0) const override
	Function BBox() More...
bool	PointOnEdge (const VECTOR2I &aP) const
	Function PointOnEdge() More...
bool	Collide (const SHAPE *aShape, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
	Function Collide() More...
bool	Collide (const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
	Function Collide Checks 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
	Function Collide Checks whether the segment aSeg collides with the polygon set (or its edge). More...
bool	CollideVertex (const VECTOR2I &aPoint, VERTEX_INDEX &aClosestVertex, int aClearance=0) const
	Function CollideVertex Checks whether aPoint collides with any vertex of any of the contours of the polygon. More...
bool	CollideEdge (const VECTOR2I &aPoint, VERTEX_INDEX &aClosestVertex, int aClearance=0) const
	Function CollideEdge Checks whether aPoint collides with any edge of any of the contours of the polygon. More...
void	BuildBBoxCaches ()
	Constructs BBoxCaches for Contains(), below. More...
const BOX2I	BBoxFromCaches () const
bool	Contains (const VECTOR2I &aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=false) const
	Returns true if a given subpolygon contains the point aP. More...
bool	IsEmpty () const
	Returns true if the set is empty (no polygons at all) More...
void	RemoveVertex (int aGlobalIndex)
	Function RemoveVertex deletes the aGlobalIndex-th vertex. More...
void	RemoveVertex (VERTEX_INDEX aRelativeIndices)
	Function RemoveVertex deletes the vertex indexed by aIndex (index of polygon, contour and vertex). More...
void	RemoveAllContours ()
	Removes all outlines & holes (clears) the polygon set. More...
void	RemoveContour (int aContourIdx, int aPolygonIdx=-1)
	Function RemoveContour deletes the aContourIdx-th contour of the aPolygonIdx-th polygon in the set. More...
int	RemoveNullSegments ()
	Function RemoveNullSegments looks for null segments; ie, segments whose ends are exactly the same and deletes them. More...
void	SetVertex (const VERTEX_INDEX &aIndex, const VECTOR2I &aPos)
	Function SetVertex Accessor function to set the position of a specific point. More...
void	SetVertex (int aGlobalIndex, const VECTOR2I &aPos)
	Sets the vertex based on the global index. More...
int	TotalVertices () const
	Returns total number of vertices stored in the set. More...
void	DeletePolygon (int aIdx)
	Deletes aIdx-th polygon from the set More...
POLYGON	ChamferPolygon (unsigned int aDistance, int aIndex)
	Function Chamfer returns a chamfered version of the aIndex-th polygon. More...
POLYGON	FilletPolygon (unsigned int aRadius, int aErrorMax, int aIndex)
	Function Fillet returns a filleted version of the aIndex-th polygon. More...
SHAPE_POLY_SET	Chamfer (int aDistance)
	Function Chamfer returns a chamfered version of the polygon set. More...
SHAPE_POLY_SET	Fillet (int aRadius, int aErrorMax)
	Function Fillet returns a filleted version of the polygon set. More...
SEG::ecoord	SquaredDistanceToPolygon (VECTOR2I aPoint, int aIndex, VECTOR2I *aNearest) const
	Function DistanceToPolygon computes the minimum distance between the aIndex-th polygon and aPoint. More...
SEG::ecoord	SquaredDistanceToPolygon (const SEG &aSegment, int aIndex, VECTOR2I *aNearest) const
	Function DistanceToPolygon computes the minimum distance between the aIndex-th polygon and aSegment with a possible width. More...
SEG::ecoord	SquaredDistance (VECTOR2I aPoint, VECTOR2I *aNearest=nullptr) const
	Function SquaredDistance computes the minimum distance squared between aPoint and all the polygons in the set. More...
SEG::ecoord	SquaredDistance (const SEG &aSegment, VECTOR2I *aNearest=nullptr) const
	Function SquaredDistance computes the minimum distance squared between aSegment and all the polygons in the set. More...
bool	IsVertexInHole (int aGlobalIdx)
	Function IsVertexInHole. More...
bool	IsNull () const
	Function IsNull() More...
virtual bool	Collide (const SHAPE *aShape, int aClearance, VECTOR2I *aMTV) const
	Function Collide() More...
virtual VECTOR2I	Centre () const
	Function Centre() More...
FACET *	NewFacet ()
SGNODE *	CalcShape (SGNODE *aParent, SGNODE *aColor, WRL1_ORDER aVertexOrder, float aCreaseLimit=0.74317, bool isVRML2=false)
SHAPE_TYPE	Type () const
	Function Type() More...

Protected Types
typedef VECTOR2I::extended_type	ecoord

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

Private Types
enum	CORNER_MODE { CHAMFERED, FILLETED }
	Operations 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...
typedef std::vector< POLYGON >	POLYSET

Private Member Functions
void	fractureSingle (POLYGON &paths)
void	unfractureSingle (POLYGON &path)
void	importTree (ClipperLib::PolyTree *tree)
void	booleanOp (ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
	Function booleanOp this is the engine to execute all polygon boolean transforms (AND, OR, ... More...
void	booleanOp (ClipperLib::ClipType aType, const SHAPE_POLY_SET &aShape, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
bool	containsSingle (const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
	containsSingle function Checks 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)
	Function chamferFilletPolygon Returns the camfered or filleted version of the aIndex-th polygon in the set, depending on the aMode selected. More...
bool	hasTouchingHoles (const POLYGON &aPoly) const
	Returns true if the polygon set has any holes that touch share a vertex. More...
MD5_HASH	checksum () const

Private Attributes
POLYSET	m_polys
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > >	m_triangulatedPolys
bool	m_triangulationValid = false
MD5_HASH	m_hash

Detailed Description

SHAPE_POLY_SET.

Represents 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 64 of file shape_poly_set.h.

Member Typedef Documentation

CONST_ITERATOR

typedef ITERATOR_TEMPLATE<const VECTOR2I> SHAPE_POLY_SET::CONST_ITERATOR

Definition at line 486 of file shape_poly_set.h.

CONST_SEGMENT_ITERATOR

typedef SEGMENT_ITERATOR_TEMPLATE<const SEG> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR

Definition at line 490 of file shape_poly_set.h.

ecoord

typedef VECTOR2I::extended_type SHAPE::ecoord

protectedinherited

Definition at line 250 of file shape.h.

ITERATOR

typedef ITERATOR_TEMPLATE<VECTOR2I> SHAPE_POLY_SET::ITERATOR

Definition at line 485 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 70 of file shape_poly_set.h.

POLYSET

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

private

Definition at line 1405 of file shape_poly_set.h.

SEGMENT_ITERATOR

typedef SEGMENT_ITERATOR_TEMPLATE<SEG> SHAPE_POLY_SET::SEGMENT_ITERATOR

Definition at line 489 of file shape_poly_set.h.

VERTEX_INDEX

typedef struct SHAPE_POLY_SET::VERTEX_INDEX SHAPE_POLY_SET::VERTEX_INDEX

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.

Member Enumeration Documentation

CORNER_MODE

enum SHAPE_POLY_SET::CORNER_MODE

private

Operations 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 1376 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 952 of file shape_poly_set.h.

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

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 (theorically) 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 919 of file shape_poly_set.h.

    {
        PM_FAST = true,
        PM_STRICTLY_SIMPLE = false
    };

Constructor & Destructor Documentation

SHAPE_POLY_SET() [1/3]

SHAPE_POLY_SET::SHAPE_POLY_SET

(

)

Definition at line 60 of file shape_poly_set.cpp.

                               :
    SHAPE( SH_POLY_SET )
{
}

Referenced by Clone().

SHAPE_POLY_SET() [2/3]

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 66 of file shape_poly_set.cpp.

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

References AddOutline().

SHAPE_POLY_SET() [3/3]

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 73 of file shape_poly_set.cpp.

                                                             :
    SHAPE( aOther ), m_polys( aOther.m_polys )
{
    if( aOther.IsTriangulationUpToDate() )
    {
        for( unsigned i = 0; i < aOther.TriangulatedPolyCount(); i++ )
            m_triangulatedPolys.push_back(
                    std::make_unique<TRIANGULATED_POLYGON>( *aOther.TriangulatedPolygon( i ) ) );

        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 94 of file shape_poly_set.cpp.

{
}

Member Function Documentation

AddHole()

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

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

Definition at line 439 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(), BuildFootprintPolygonOutlines(), KI_TEST::BuildHollowSquare(), KI_TEST::CommonTestData::CommonTestData(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), FABMASTER::loadFootprints(), FABMASTER::loadPolygon(), and FABMASTER::loadZone().

AddOutline()

int SHAPE_POLY_SET::AddOutline

(

const SHAPE_LINE_CHAIN &

aOutline

)

Adds a new outline to the set and returns its index

Definition at line 425 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(), buildBoardBoundingBoxPoly(), KI_TEST::BuildHollowSquare(), KI_TEST::BuildPolyset(), KI_TEST::CommonTestData::CommonTestData(), ZONE_FILLER::computeRawFilledArea(), FOOTPRINT::CoverageRatio(), CovertPolygonToBlocks(), BOARD_ADAPTER::createPadWithClearance(), KIGFX::GERBVIEW_PAINTER::draw(), GEOM_TEST::FilletPolySet(), FOOTPRINT::GetBoundingHull(), IteratorFixture::IteratorFixture(), CONVERT_TOOL::makePolysFromCircles(), CONVERT_TOOL::makePolysFromRects(), CONVERT_TOOL::makePolysFromSegs(), PAD::MergePrimitivesAsPolygon(), NormalizeAreaOutlines(), EAGLE_PLUGIN::packagePolygon(), ALTIUM_PCB::ParsePolygons6Data(), ALTIUM_PCB::ParseRegions6Data(), ALTIUM_PCB::ParseShapeBasedRegions6Data(), partitionPolyIntoRegularCellGrid(), ZONE_CREATE_HELPER::performZoneCutout(), PGPartitionFixture::PGPartitionFixture(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), PlotStandardLayer(), CONVERT_TOOL::PolyToLines(), SHAPE_POLY_SET(), TestConcaveSquareFillet(), and TestSquareFillet().

Append() [1/3]

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

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

Function Append adds 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

int - the number of corners of the selected contour after the addition.

Definition at line 217 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(), BuildBoardPolygonOutlines(), ZONE_FILLER::buildCopperItemClearances(), BuildFootprintPolygonOutlines(), ConvertOutlineToPolygon(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), BITMAPCONV_INFO::createOutputData(), BOARD_ADAPTER::createPadWithClearance(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), GERBER_FILE_IMAGE::Execute_G_Command(), fillArcPOLY(), FOOTPRINT::GetBoundingHull(), getRectangleAlongCentreLine(), PCB_SHAPE::HitTest(), PAD::HitTest(), InsertVertex(), CONVERT_TOOL::LinesToPoly(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadPolygon(), FABMASTER::loadZone(), LEGACY_PLUGIN::loadZONE_CONTAINER(), PCB_PARSER::parseZONE(), DXF_PLOTTER::PlotPoly(), RENDER_3D_LEGACY::reload(), PCB_SHAPE::Rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), PCB_SHAPE::SetPolyPoints(), WS_DATA_ITEM_POLYGONS::SyncDrawItems(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), TransformRingToPolygon(), TransformRoundChamferedRectToPolygon(), TransformRoundRectToPolygon(), PCB_SHAPE::TransformShapeWithClearanceToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), ZONE::TransformSmoothedOutlineToPolygon(), ZONE::TransformSolidAreasShapesToPolygon(), ALIGNED_DIMENSION::updateGeometry(), ORTHOGONAL_DIMENSION::updateGeometry(), and LEADER::updateGeometry().

Append() [2/3]

void SHAPE_POLY_SET::Append

(

const SHAPE_POLY_SET &

aSet

)

Merges polygons from two sets.

Definition at line 1432 of file shape_poly_set.cpp.

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

References m_polys.

Append() [3/3]

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

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

Definition at line 1438 of file shape_poly_set.cpp.

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

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

BBox()

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

overridevirtual

Function BBox()

Computes 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 1187 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 BOX2< Vec >::Inflate(), m_polys, and BOX2< Vec >::Merge().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BOARD::CombineAllZonesInNet(), APERTURE_MACRO::GetApertureMacroShape(), PAD::GetBestAnchorPosition(), ZONE::GetBoundingBox(), WS_DRAW_ITEM_POLYPOLYGONS::GetBoundingBox(), GERBER_DRAW_ITEM::GetBoundingBox(), DIALOG_PAD_PROPERTIES::padValuesOK(), partitionPolyIntoRegularCellGrid(), BOARD::TestZoneIntersection(), KIGFX::PREVIEW::POLYGON_ITEM::ViewBBox(), and KIGFX::PREVIEW::CENTRELINE_RECT_ITEM::ViewBBox().

BBoxFromCaches()

const BOX2I SHAPE_POLY_SET::BBoxFromCaches

(

)

const

Definition at line 1204 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].BBoxFromCache();
        else
            bb.Merge( m_polys[i][0].BBoxFromCache() );
    }

    return bb;
}

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

Referenced by DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances().

BooleanAdd() [1/2]

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

Performs boolean polyset union For aFastMode meaning, see function booleanOp

Definition at line 494 of file shape_poly_set.cpp.

{
    booleanOp( ctUnion, b, aFastMode );
}

References booleanOp().

Referenced by PAD::addPadPrimitivesToPolygon(), ZONE::BuildSmoothedPoly(), BOARD::CombineZones(), ALTIUM_PCB::ParseRegions6Data(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), ZONE::RemoveCutout(), and TransformRoundChamferedRectToPolygon().

BooleanAdd() [2/2]

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

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

Definition at line 512 of file shape_poly_set.cpp.

{
    booleanOp( ctUnion, a, b, aFastMode );
}

References booleanOp().

BooleanIntersection() [1/2]

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

Performs boolean polyset intersection For aFastMode meaning, see function booleanOp

Definition at line 506 of file shape_poly_set.cpp.

{
    booleanOp( ctIntersection, b, aFastMode );
}

References booleanOp().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), ZONE::BuildSmoothedPoly(), ZONE_FILLER::computeRawFilledArea(), CovertPolygonToBlocks(), PAD::HitTest(), isCopperOutside(), PAD_TOOL::recombinePad(), RENDER_3D_LEGACY::reload(), TransformOvalToPolygon(), and TransformRoundRectToPolygon().

BooleanIntersection() [2/2]

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

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

Definition at line 528 of file shape_poly_set.cpp.

{
    booleanOp( ctIntersection, a, b, aFastMode );
}

References booleanOp().

booleanOp() [1/2]

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

private

Function booleanOp this is the engine to execute all polygon boolean transforms (AND, OR, ...

and polygon simplification (merging overlaping 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 stricty simple polygon. if aFastMode is PM_FAST the result can be a weak polygon if aFastMode is PM_STRICTLY_SIMPLE (default) the result is (theorically) a strictly simple polygon, but calculations can be really significantly time consuming

Definition at line 458 of file shape_poly_set.cpp.

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

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

booleanOp() [2/2]

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 465 of file shape_poly_set.cpp.

{
    Clipper c;

    c.StrictlySimple( aFastMode == PM_STRICTLY_SIMPLE );

    for( auto poly : aShape.m_polys )
    {
        for( size_t i = 0 ; i < poly.size(); i++ )
            c.AddPath( poly[i].convertToClipper( i == 0 ), ptSubject, true );
    }

    for( auto poly : aOtherShape.m_polys )
    {
        for( size_t i = 0; i < poly.size(); i++ )
            c.AddPath( poly[i].convertToClipper( i == 0 ), ptClip, true );
    }

    PolyTree solution;

    c.Execute( aType, solution, pftNonZero, pftNonZero );

    importTree( &solution );
}

References importTree(), m_polys, and PM_STRICTLY_SIMPLE.

BooleanSubtract() [1/2]

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

Performs boolean polyset difference For aFastMode meaning, see function booleanOp

Definition at line 500 of file shape_poly_set.cpp.

{
    booleanOp( ctDifference, b, aFastMode );
}

References booleanOp().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), addHoleToPolygon(), ZONE_FILLER::computeRawFilledArea(), FOOTPRINT::CoverageRatio(), BOARD_ADAPTER::createLayers(), BITMAPCONV_INFO::createOutputData(), TRACKS_CLEANER::deleteTracksInPads(), RENDER_3D_LEGACY::generateViasAndPads(), AR_AUTOPLACER::genModuleOnRoutingMatrix(), APERTURE_MACRO::GetApertureMacroShape(), ZONE_FILLER::knockoutThermalReliefs(), NormalizeAreaOutlines(), DIALOG_PAD_PROPERTIES::padValuesOK(), ZONE_CREATE_HELPER::performZoneCutout(), PlotSolderMaskLayer(), RENDER_3D_RAYTRACE::Reload(), RENDER_3D_LEGACY::reload(), ZONE_FILLER::subtractHigherPriorityZones(), and TransformRoundChamferedRectToPolygon().

BooleanSubtract() [2/2]

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

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

Definition at line 520 of file shape_poly_set.cpp.

{
    booleanOp( ctDifference, a, b, aFastMode );
}

References booleanOp().

BuildBBoxCaches()

void SHAPE_POLY_SET::BuildBBoxCaches

(

)

Constructs BBoxCaches for Contains(), below.

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 1512 of file shape_poly_set.cpp.

{
    for( int polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
    {
        Outline( polygonIdx ).GenerateBBoxCache();

        for( int holeIdx = 0; holeIdx < HoleCount( polygonIdx ); holeIdx++ )
            Hole( polygonIdx, holeIdx ).GenerateBBoxCache();
    }
}

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

Referenced by ZONE_FILLER::computeRawFilledArea().

CacheTriangulation()

void SHAPE_POLY_SET::CacheTriangulation

(

bool

aPartition = true

)

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

    SHAPE_POLY_SET tmpSet;

    if( aPartition )
    {
        // This partitions into regularly-sized grids (1cm in pcbnew)
        partitionPolyIntoRegularCellGrid( *this, 1e7, tmpSet );
    }
    else
    {
        tmpSet = *this;

        if( tmpSet.HasHoles() )
            tmpSet.Fracture( PM_FAST );
    }

    m_triangulatedPolys.clear();
    m_triangulationValid = true;

    while( tmpSet.OutlineCount() > 0 )
    {
        m_triangulatedPolys.push_back( std::make_unique<TRIANGULATED_POLYGON>() );
        PolygonTriangulation tess( *m_triangulatedPolys.back() );

        // If the tesselation 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( tmpSet.Polygon( 0 ).front() ) )
        {
            tmpSet.Fracture( PM_FAST );
            m_triangulationValid = false;
            continue;
        }

        tmpSet.DeletePolygon( 0 );
        m_triangulationValid = true;
    }

    if( m_triangulationValid )
        m_hash = checksum();
}

References checksum(), DeletePolygon(), Fracture(), HasHoles(), MD5_HASH::IsValid(), m_hash, m_triangulatedPolys, m_triangulationValid, OutlineCount(), partitionPolyIntoRegularCellGrid(), PM_FAST, and Polygon().

Referenced by FOOTPRINT::BuildPolyCourtyards(), ConvertPolygonToTriangles(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), Mirror(), polygon_triangulation_main(), Rotate(), and PNS_KICAD_IFACE_BASE::syncZone().

CalcShape()

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

inherited

Definition at line 713 of file wrlfacet.cpp.

{
    if( facets.empty() || !facets.front()->HasMinPoints() )
        return NULL;

    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 NULL;

    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 NULL;

    IFSG_SHAPE shapeNode( false );

    if( !isVRML2 )
    {
        shapeNode.NewNode( aParent );

        if( aColor )
        {
            if( NULL == 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(), colors, SHAPE::facets, IFSG_NODE::GetRawPtr(), S3D::GetSGNodeParent(), IFSG_FACESET::NewNode(), IFSG_SHAPE::NewNode(), NULL, IFSG_COLORS::SetColorList(), IFSG_COORDS::SetCoordsList(), IFSG_NORMALS::SetNormalList(), SGPOINT::x, SGPOINT::y, and SGPOINT::z.

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

Centre()

virtual VECTOR2I SHAPE::Centre ( ) const

inlinevirtualinherited

Function Centre()

Computes 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

)

Function Chamfer returns a chamfered version of the polygon set.

Parameters

aDistance

is the chamfering distance.

Returns

SHAPE_POLY_SET - A set containing the chamfered version of this set.

Definition at line 1808 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

Function chamferFilletPolygon Returns the camfered 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

POLYGON - the chamfered/filleted version of the polygon.

Definition at line 1830 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 );
                double arcAngleDegrees = arcAngle * 180.0 / M_PI;
                int    segments = GetArcToSegmentCount( radius, aErrorMax, arcAngleDegrees );

                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(), 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
	)

Function Chamfer returns 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

POLYGON - A polygon containing the chamfered version of the aIndex-th polygon.

Definition at line 1660 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 2170 of file shape_poly_set.cpp.

{
    MD5_HASH hash;

    hash.Hash( m_polys.size() );

    for( const auto& outline : m_polys )
    {
        hash.Hash( outline.size() );

        for( const auto& 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(), GetHash(), IsTriangulationUpToDate(), and Move().

CHole()

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

inline

Definition at line 707 of file shape_poly_set.h.

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

References m_polys.

Referenced by BOARD_ADAPTER::addSolidAreasShapes(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), containsSingle(), KIGFX::PCB_PAINTER::draw(), CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape(), PlotLayerOutlines(), and HYPERLYNX_EXPORTER::writeNetObjects().

CIterate() [1/3]

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

inline

Definition at line 784 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 PAD::AddPrimitivePoly(), PCB_SHAPE::BuildPolyPointsList(), ConvertOutlineToPolygon(), PCB_IO::format(), PCB_SHAPE::GetBoundingBox(), ZONE::GetInteractingZones(), and insideArea().

CIterate() [2/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( int  aOutline ) const

inline

Definition at line 798 of file shape_poly_set.h.

    {
        return CIterate( aOutline, aOutline );
    }

References CIterate().

CIterate() [3/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( ) const

inline

Definition at line 808 of file shape_poly_set.h.

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

References OutlineCount().

Referenced by CIterate(), and CIterateWithHoles().

CIterateSegments() [1/2]

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

inline

Returns an iterator object, for iterating between aFirst and aLast outline, with or

without holes (default: without)

Definition at line 855 of file shape_poly_set.h.

    {
        CONST_SEGMENT_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_currentSegment = 0;
        iter.m_iterateHoles = aIterateHoles;

        return iter;
    }

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 CIterateSegments(), CIterateSegmentsWithHoles(), BRDITEMS_PLOTTER::PlotPcbShape(), and projectPointOnSegment().

CIterateSegments() [2/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegments ( int  aPolygonIdx ) const

inline

Returns an iterator object, for iterating aPolygonIdx-th polygon edges

Definition at line 877 of file shape_poly_set.h.

    {
        return CIterateSegments( aPolygonIdx, aPolygonIdx );
    }

References CIterateSegments().

CIterateSegmentsWithHoles() [1/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegmentsWithHoles ( ) const

inline

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

Definition at line 901 of file shape_poly_set.h.

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

References CIterateSegments(), and OutlineCount().

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

CIterateSegmentsWithHoles() [2/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegmentsWithHoles ( int  aOutline ) const

inline

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

Definition at line 907 of file shape_poly_set.h.

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

References CIterateSegments().

CIterateWithHoles() [1/2]

CONST_ITERATOR SHAPE_POLY_SET::CIterateWithHoles ( int  aOutline ) const

inline

Definition at line 803 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().

CIterateWithHoles() [2/2]

CONST_ITERATOR SHAPE_POLY_SET::CIterateWithHoles ( ) const

inline

Definition at line 813 of file shape_poly_set.h.

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

References CIterate(), and OutlineCount().

Referenced by CollideVertex().

Clone()

SHAPE * SHAPE_POLY_SET::Clone ( ) const

overridevirtual

Function Clone()

Returns a dynamically allocated copy of the shape

Return values

copy	of the shape

Reimplemented from SHAPE.

Definition at line 99 of file shape_poly_set.cpp.

{
    return new SHAPE_POLY_SET( *this );
}

References SHAPE_POLY_SET().

Collide() [1/4]

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

virtualinherited

Function Collide()

Checks 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_RECT, SHAPE_SEGMENT, and SHAPE_COMPOUND.

Definition at line 852 of file shape_collisions.cpp.

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

References collideShapes().

Collide() [2/4]

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

overridevirtual

Function Collide()

Checks 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 1279 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( true );

    int      actual = INT_MAX;
    VECTOR2I location;

    for( auto& tpoly : m_triangulatedPolys )
    {
        for ( auto& tri : tpoly->Triangles() )
        {
            int      triActual;
            VECTOR2I triLocation;

            if( aShape->Collide( &tri, aClearance, &triActual, &triLocation ) )
            {
                if( !aActual && !aLocation )
                    return true;

                if( triActual < actual )
                {
                    actual = triActual;
                    location = triLocation;
                }
            }
        }
    }

    if( actual < INT_MAX )
    {
        if( aActual )
            *aActual = std::max( 0, actual );

        if( aLocation )
            *aLocation = location;

        return true;
    }

    return false;
}

References 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 WS_DRAW_ITEM_POLYPOLYGONS::HitTest(), PCB_SHAPE::HitTest(), FOOTPRINT::HitTestAccurate(), PCB_SELECTION_TOOL::hitTestDistance(), insideCourtyard(), and DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances().

Collide() [3/4]

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

overridevirtual

Function Collide Checks 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

bool - true if the point aP collides with the polygon; false in any other case.

Reimplemented from SHAPE.

Definition at line 1258 of file shape_poly_set.cpp.

{
    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 SEG::Square(), and SquaredDistance().

Collide() [4/4]

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

overridevirtual

Function Collide Checks 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

bool - true if the segment aSeg collides with the polygon; false in any other case.

Implements SHAPE.

Definition at line 1237 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().

CollideEdge()

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

Function CollideEdge Checks 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 1483 of file shape_poly_set.cpp.

{
    // Shows whether there was a collision
    bool collision = false;

    for( CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles(); iterator; iterator++ )
    {
        const SEG currentSegment = *iterator;
        int distance = currentSegment.Distance( aPoint );

        // Check for collisions
        if( distance <= aClearance )
        {
            collision = true;

            // Update aClearance to look for closer edges
            aClearance = distance;

            // Store the indices that identify the vertex
            aClosestVertex = iterator.GetIndex();
        }
    }

    return collision;
}

References CIterateSegmentsWithHoles(), SEG::Distance(), and distance().

Referenced by PCB_SHAPE::HitTest(), and ZONE::HitTestForEdge().

CollideVertex()

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

Function CollideVertex Checks 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 1444 of file shape_poly_set.cpp.

{
    // Shows whether there was a collision
    bool collision = false;

    // Difference vector between each vertex and aPoint.
    VECTOR2D    delta;
    double      distance, clearance;

    // Convert clearance to double for precission when comparing distances
    clearance = aClearance;

    for( CONST_ITERATOR iterator = CIterateWithHoles(); iterator; iterator++ )
    {
        // Get the difference vector between current vertex and aPoint
        delta = *iterator - aPoint;

        // Compute distance
        distance = delta.EuclideanNorm();

        // Check for collisions
        if( distance <= clearance )
        {
            collision = true;

            // Update aClearance to look for closer vertices
            clearance = distance;

            // Store the indices that identify the vertex
            aClosestVertex = iterator.GetIndex();
        }
    }

    return collision;
}

References CIterateWithHoles(), distance(), and VECTOR2< T >::EuclideanNorm().

Referenced by ZONE::HitTestForCorner().

Contains()

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

Returns 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

Definition at line 1524 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 SHAPE_RECT::Collide(), ZONE_FILLER::computeRawFilledArea(), ZONE_FILLER::Fill(), PAD::GetBestAnchorPosition(), CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPad(), GERBER_DRAW_ITEM::HitTest(), ZONE::HitTestFilledArea(), DIMENSION_BASE::segPolyIntersection(), BOARD::TestZoneIntersection(), ALIGNED_DIMENSION::updateGeometry(), and ORTHOGONAL_DIMENSION::updateGeometry().

containsSingle()

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

private

containsSingle function Checks 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

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

Definition at line 1580 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 702 of file shape_poly_set.h.

    {
        return m_polys[aIndex][0];
    }

References m_polys.

Referenced by CN_LIST::Add(), BOARD_ADAPTER::addSolidAreasShapes(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), CN_ZONE_LAYER::AnchorCount(), BuildConvexHull(), PAD::BuildEffectiveShapes(), PCB_SHAPE::BuildPolyPointsList(), CN_VISITOR::checkZoneZoneConnection(), CN_ZONE_LAYER::CN_ZONE_LAYER(), CovertPolygonToBlocks(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), KIGFX::CAIRO_GAL_BASE::DrawPolygon(), KIGFX::OPENGL_GAL::DrawPolygon(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), KIGFX::PREVIEW::POLYGON_ITEM::drawPreviewShape(), export_vrml_board(), export_vrml_polygon(), export_vrml_zones(), CN_ZONE_LAYER::GetAnchor(), PAD::GetBestAnchorPosition(), FOOTPRINT::GetBoundingHull(), PCB_SHAPE::GetLength(), CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape(), WS_DRAW_ITEM_POLYPOLYGONS::HitTest(), CONVERT_TOOL::LinesToPoly(), EAGLE_PLUGIN::loadPolygon(), PCB_SHAPE::MakeEffectiveShapes(), DSN::SPECCTRA_DB::makePADSTACK(), PlotLayerOutlines(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), DXF_PLOTTER::ThickSegment(), HYPERLYNX_EXPORTER::writeBoardInfo(), and HYPERLYNX_EXPORTER::writeNetObjects().

CPolygon()

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

inline

Definition at line 712 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	aIndex,
		int	aOutline,
		int	aHole
	)		const

Returns the index-th vertex in a given hole outline within a given outline

Definition at line 302 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(), CVertex(), D_CODE::DrawFlashedPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), GERBER_FILE_IMAGE::Execute_G_Command(), findVertex(), ZONE::GetCornerPosition(), PCB_SHAPE::GetPosition(), ZONE::HatchBorder(), PCB_SHAPE::HitTest(), ZONE::HitTest(), ZONE::MoveEdge(), ZONE::SetCornerPosition(), PCB_POINT_EDITOR::updateItem(), and PCB_POINT_EDITOR::updatePoints().

CVertex() [2/3]

const VECTOR2I & SHAPE_POLY_SET::CVertex

(

int

aGlobalIndex

)

const

Returns the aGlobalIndex-th vertex in the poly set

Definition at line 321 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() [3/3]

const VECTOR2I & SHAPE_POLY_SET::CVertex

(

SHAPE_POLY_SET::VERTEX_INDEX

index

)

const

Returns the index-th vertex in a given hole outline within a given outline

Definition at line 333 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 979 of file shape_poly_set.h.

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

References Inflate().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), ZONE::BuildSmoothedPoly(), ZONE_FILLER::computeRawFilledArea(), ZONE_FILLER::fillSingleZone(), and PlotSolderMaskLayer().

DeletePolygon()

void SHAPE_POLY_SET::DeletePolygon

(

int

aIdx

)

Deletes aIdx-th polygon from the set

Definition at line 1426 of file shape_poly_set.cpp.

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

References m_polys.

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

Fillet()

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

Function Fillet returns 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

SHAPE_POLY_SET - A set containing the filleted version of this set.

Definition at line 1819 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
	)

Function Fillet returns 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

POLYGON - A polygon containing the filleted version of the aIndex-th polygon.

Definition at line 1666 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 ( ) const

overridevirtual

Reimplemented from SHAPE.

Definition at line 1097 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

)

Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the outer ring to the inner holes For aFastMode meaning, see function booleanOp

Definition at line 858 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(), CacheTriangulation(), ZONE_FILLER::computeRawFilledArea(), FOOTPRINT::CoverageRatio(), BITMAPCONV_INFO::createOutputData(), AR_AUTOPLACER::drawPlacementRoutingMatrix(), export_vrml_polygon(), AR_AUTOPLACER::fillMatrix(), ZONE_FILLER::fillSingleZone(), APERTURE_MACRO::GetApertureMacroShape(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), InflateWithLinkedHoles(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadPolygon(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), BRDITEMS_PLOTTER::PlotPcbShape(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), RENDER_3D_RAYTRACE::Reload(), TransformRingToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), ZONE::TransformSmoothedOutlineToPolygon(), and GBR_TO_PCB_EXPORTER::writePcbPolygon().

fractureSingle()

void SHAPE_POLY_SET::fractureSingle ( POLYGON &  paths )

private

Definition at line 754 of file shape_poly_set.cpp.

{
    FractureEdgeSet edges;
    FractureEdgeSet border_edges;
    FractureEdge*   root = NULL;

    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 = NULL, * first_edge = NULL;

        int x_min = std::numeric_limits<int>::max();

        for( const VECTOR2I& p : points )
        {
            if( p.x < x_min )
                x_min = p.x;
        }

        for( int i = 0; i < pointCount; i++ )
        {
            // 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();

        FractureEdge* smallestX = NULL;

        // find the left-most hole edge and merge with the outline
        for( FractureEdge* border_edge : border_edges )
        {
            int xt = border_edge->m_p1.x;

            if( ( xt < x_min ) && !border_edge->m_connected )
            {
                x_min = xt;
                smallestX = border_edge;
            }
        }

        num_unconnected -= processEdge( edges, smallestX );
    }

    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, NULL, processEdge(), SHAPE_LINE_CHAIN::SetClosed(), and VECTOR2< T >::x.

Referenced by Fracture().

GetGlobalIndex()

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

Function GetGlobalIndex computes 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

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

Definition at line 145 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 2013 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(), operator=(), and SHAPE_POLY_SET().

GetIndexableSubshapeCount()

size_t SHAPE_POLY_SET::GetIndexableSubshapeCount ( ) const

overridevirtual

Reimplemented from SHAPE_BASE.

Definition at line 2241 of file shape_poly_set.cpp.

{
    size_t n = 0;

    for( auto& t : m_triangulatedPolys )
        n += t->GetTriangleCount();

    return n;
}

References m_triangulatedPolys.

Referenced by GetIndexableSubshapes().

GetIndexableSubshapes()

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

overridevirtual

Reimplemented from SHAPE_BASE.

Definition at line 2252 of file shape_poly_set.cpp.

{
    aSubshapes.reserve( GetIndexableSubshapeCount() );

    for( auto& tpoly : m_triangulatedPolys )
    {
        for ( auto& tri : tpoly->Triangles() )
        {
            aSubshapes.push_back( &tri );
        }
    }
}

References GetIndexableSubshapeCount(), and m_triangulatedPolys.

GetNeighbourIndexes()

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

Returns 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	- the globalIndex of the previous corner of the same contour.
aNext	- the globalIndex of the next corner of the same contour.

Returns

true if OK, false if aGlobalIndex is out of range

Definition at line 339 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

Function GetRelativeIndices.

Converts 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

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

Definition at line 105 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

Returns true if the polygon set has any holes.

Definition at line 1030 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 CacheTriangulation().

HasIndexableSubshapes()

bool SHAPE_POLY_SET::HasIndexableSubshapes ( ) const

overridevirtual

Reimplemented from SHAPE_BASE.

Definition at line 2235 of file shape_poly_set.cpp.

{
    return IsTriangulationUpToDate();
}

References IsTriangulationUpToDate().

HasTouchingHoles()

bool SHAPE_POLY_SET::HasTouchingHoles

(

)

const

Returns true if the polygon set has any holes tha share a vertex.

Definition at line 2198 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

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

Definition at line 2212 of file shape_poly_set.cpp.

{
    std::set< long long > ptHashes;

    for( const auto& 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

Returns the reference to aHole-th hole in the aIndex-th outline

Definition at line 681 of file shape_poly_set.h.

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

References m_polys.

Referenced by BuildBBoxCaches(), BuildFootprintPolygonOutlines(), ZONE::CalculateFilledArea(), CovertPolygonToBlocks(), export_vrml_board(), DSN::SPECCTRA_DB::fillBOUNDARY(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), ZONE::HitTestCutout(), FABMASTER::loadFootprints(), FABMASTER::loadPolygon(), FABMASTER::loadZone(), ZONE::RemoveCutout(), and TransformRingToPolygon().

HoleCount()

int SHAPE_POLY_SET::HoleCount ( int  aOutline ) const

inline

Returns the number of holes in a given outline

Definition at line 643 of file shape_poly_set.h.

    {
        if( ( aOutline < 0 ) || (aOutline >= (int)m_polys.size()) || (m_polys[aOutline].size() < 2) )
            return 0;

        // the first polygon in m_polys[aOutline] is the main contour,
        // only others are holes:
        return m_polys[aOutline].size() - 1;
    }

References m_polys.

Referenced by BOARD_ADAPTER::addSolidAreasShapes(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), ZONE::AppendCorner(), BuildBBoxCaches(), BuildFootprintPolygonOutlines(), ZONE::CalculateFilledArea(), containsSingle(), CovertPolygonToBlocks(), KIGFX::PCB_PAINTER::draw(), export_vrml_board(), DSN::SPECCTRA_DB::fillBOUNDARY(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape(), ZONE::HitTestCutout(), PlotLayerOutlines(), ZONE::RemoveCutout(), and HYPERLYNX_EXPORTER::writeNetObjects().

importTree()

void SHAPE_POLY_SET::importTree ( ClipperLib::PolyTree *  tree )

private

Definition at line 628 of file shape_poly_set.cpp.

{
    m_polys.clear();

    for( PolyNode* n = tree->GetFirst(); n; n = n->GetNext() )
    {
        if( !n->IsHole() )
        {
            POLYGON paths;
            paths.reserve( n->Childs.size() + 1 );
            paths.push_back( n->Contour );

            for( unsigned int i = 0; i < n->Childs.size(); i++ )
                paths.push_back( n->Childs[i]->Contour );

            m_polys.push_back( paths );
        }
    }
}

References m_polys.

Referenced by booleanOp(), and Inflate().

Inflate()

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

Performs 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	- number of units to offset edges
aCircleSegmentsCount	- number of segments per 360 degrees to use in curve approx
aCornerStrategy	- ALLOW_ACUTE_CORNERS to preserve all angles, CHOP_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 545 of file shape_poly_set.cpp.

{
    // A static table to avoid repetitive calculations of the coefficient
    // 1.0 - cos( M_PI / aCircleSegmentsCount )
    // aCircleSegmentsCount 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;
    }

    for( const POLYGON& poly : m_polys )
    {
        for( size_t i = 0; i < poly.size(); i++ )
            c.AddPath( poly[i].convertToClipper( i == 0 ), 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( aCircleSegmentsCount < 6 ) // avoid incorrect aCircleSegmentsCount values
        aCircleSegmentsCount = 6;

    double coeff;

    if( aCircleSegmentsCount > SEG_CNT_MAX || arc_tolerance_factor[aCircleSegmentsCount] == 0 )
    {
        coeff = 1.0 - cos( M_PI / aCircleSegmentsCount );

        if( aCircleSegmentsCount <= SEG_CNT_MAX )
            arc_tolerance_factor[aCircleSegmentsCount] = coeff;
    }
    else
        coeff = arc_tolerance_factor[aCircleSegmentsCount];

    c.ArcTolerance = std::abs( aAmount ) * coeff;
    c.MiterLimit = miterLimit;
    c.MiterFallback = miterFallback;
    c.Execute( solution, aAmount );

    importTree( &solution );
}

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

Referenced by ZONE::BuildSmoothedPoly(), ZONE_FILLER::computeRawFilledArea(), BOARD_ADAPTER::createPadWithClearance(), Deflate(), export_vrml_polygon(), GERBER_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadRoundRect(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), InflateWithLinkedHoles(), EAGLE_PLUGIN::loadPolygon(), EAGLE_PLUGIN::packagePolygon(), PlotSolderMaskLayer(), PAD::TransformShapeWithClearanceToPolygon(), ZONE::TransformShapeWithClearanceToPolygon(), and ZONE::TransformSmoothedOutlineToPolygon().

InflateWithLinkedHoles()

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

Performs outline inflation/deflation, using round corners.

Polygons can have holes, and/or linked holes with main outlines. The resulting polygons are laso polygons with linked holes to main outlines. For aFastMode meaning, see function booleanOp .

Definition at line 536 of file shape_poly_set.cpp.

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

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

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

InsertVertex()

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

Function InsertVertex Adds a vertex in the globally indexed position aGlobalIndex.

Parameters

aGlobalIndex	is the global index of the position in which teh new vertex will be inserted.
aNewVertex	is the new inserted vertex.

Definition at line 240 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

Returns true if the set is empty (no polygons at all)

Definition at line 1172 of file shape_poly_set.h.

    {
        return m_polys.size() == 0;
    }

References m_polys.

Referenced by BOARD_ADAPTER::addShapeWithClearance(), BOARD_ADAPTER::createPadWithClearance(), TRACKS_CLEANER::deleteTracksInPads(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::DIALOG_PAD_PRIMITIVE_POLY_PROPS(), CN_CONNECTIVITY_ALGO::FindIsolatedCopperIslands(), PCB_IO::format(), PCB_SHAPE::GetBoundingBox(), ZONE::HatchBorder(), ALTIUM_PCB::HelperDrawsegmentSetLocalCoord(), CONVERT_TOOL::LinesToPoly(), PCB_PARSER::parseZONE(), BRDITEMS_PLOTTER::PlotFilledAreas(), PlotStandardLayer(), and PAD_TOOL::recombinePad().

IsNull()

bool SHAPE::IsNull ( ) const

inlineinherited

Function IsNull()

Returns true if the shape is a null shape.

Return values

true	if null :-)

Definition at line 157 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

Function IsPolygonSelfIntersecting.

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

Parameters

aPolygonIndex

index of the polygon that wants to be checked.

Returns

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

Definition at line 386 of file shape_poly_set.cpp.

{
    CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
    CONST_SEGMENT_ITERATOR innerIterator;

    for( iterator = CIterateSegmentsWithHoles( aPolygonIndex ); iterator; iterator++ )
    {
        SEG firstSegment = *iterator;

        // Iterate through all remaining segments.
        innerIterator = iterator;

        // Start in the next segment, we don't want to check collision between a segment and itself
        for( innerIterator++; innerIterator; innerIterator++ )
        {
            SEG secondSegment = *innerIterator;

            // Check whether the two segments built collide, only when they are not adjacent.
            if( !iterator.IsAdjacent( innerIterator ) && firstSegment.Collide( secondSegment, 0 ) )
                return true;
        }
    }

    return false;
}

References CIterateSegmentsWithHoles(), SEG::Collide(), and SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::IsAdjacent().

Referenced by IsSelfIntersecting().

IsSelfIntersecting()

bool SHAPE_POLY_SET::IsSelfIntersecting

(

)

const

Function IsSelfIntersecting Checks whether any of the polygons in the set is self intersecting.

Returns

bool - true if any of the polygons is self intersecting, false otherwise.

Definition at line 413 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 BOARD::NormalizeAreaPolygon(), and PCB_POINT_EDITOR::validatePolygon().

IsSolid()

bool SHAPE_POLY_SET::IsSolid ( ) const

inlineoverridevirtual

Implements SHAPE.

Definition at line 1047 of file shape_poly_set.h.

    {
        return true;
    }

IsTriangulationUpToDate()

bool SHAPE_POLY_SET::IsTriangulationUpToDate

(

)

const

Definition at line 2022 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::OPENGL_GAL::DrawPolygon(), HasIndexableSubshapes(), operator=(), SHAPE_POLY_SET(), and PNS_KICAD_IFACE_BASE::syncZone().

IsVertexInHole()

bool SHAPE_POLY_SET::IsVertexInHole

(

int

aGlobalIdx

)

Function IsVertexInHole.

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

Parameters

aGlobalIdx

is the index of the vertex.

Returns

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

Definition at line 1795 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 ( int  aFirst, int  aLast, bool  aIterateHoles = false  )

inline

Function Iterate returns 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 727 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() [2/3]

ITERATOR SHAPE_POLY_SET::Iterate ( int  aOutline )

inline

Function Iterate.

Parameters

aOutline

the index of the polygon to be iterated.

Returns

ITERATOR - 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 747 of file shape_poly_set.h.

    {
        return Iterate( aOutline, aOutline );
    }

References Iterate().

Iterate() [3/3]

ITERATOR SHAPE_POLY_SET::Iterate ( )

inline

Function Iterate.

Returns

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

Definition at line 768 of file shape_poly_set.h.

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

References OutlineCount().

Referenced by Iterate(), and IterateWithHoles().

IterateFromVertexWithHoles()

ITERATOR SHAPE_POLY_SET::IterateFromVertexWithHoles ( int  aGlobalIdx )

inline

Definition at line 818 of file shape_poly_set.h.

    {
        // Build iterator
        ITERATOR iter = IterateWithHoles();

        // Get the relative indices of the globally indexed vertex
        VERTEX_INDEX indices;

        if( !GetRelativeIndices( aGlobalIdx, &indices ) )
            throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );

        // Adjust where the iterator is pointing
        iter.m_currentPolygon = indices.m_polygon;
        iter.m_currentContour = indices.m_contour;
        iter.m_currentVertex = indices.m_vertex;

        return iter;
    }

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 ( int  aFirst, int  aLast, bool  aIterateHoles = false  )

inline

Returns an iterator object, for iterating between aFirst and aLast outline, with or

without holes (default: without)

Definition at line 839 of file shape_poly_set.h.

    {
        SEGMENT_ITERATOR iter;

        iter.m_poly = this;
        iter.m_currentPolygon = aFirst;
        iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
        iter.m_currentContour = 0;
        iter.m_currentSegment = 0;
        iter.m_iterateHoles = aIterateHoles;

        return iter;
    }

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 DIMENSION_BASE::segPolyIntersection(), TestConcaveSquareFillet(), TestSquareFillet(), and LEADER::updateGeometry().

IterateSegments() [2/3]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegments ( int  aPolygonIdx )

inline

Returns an iterator object, for iterating aPolygonIdx-th polygon edges

Definition at line 871 of file shape_poly_set.h.

    {
        return IterateSegments( aPolygonIdx, aPolygonIdx );
    }

References IterateSegments().

IterateSegments() [3/3]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegments ( )

inline

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

Definition at line 883 of file shape_poly_set.h.

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

References OutlineCount().

Referenced by IterateSegments(), and IterateSegmentsWithHoles().

IterateSegmentsWithHoles() [1/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( )

inline

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

Definition at line 889 of file shape_poly_set.h.

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

References IterateSegments(), and OutlineCount().

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

IterateSegmentsWithHoles() [2/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( int  aOutline )

inline

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

Definition at line 895 of file shape_poly_set.h.

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

References IterateSegments().

IterateWithHoles() [1/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( int  aOutline )

inline

Function IterateWithHoles.

Parameters

aOutline

the index of the polygon to be iterated.

Returns

ITERATOR - 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 758 of file shape_poly_set.h.

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

References Iterate().

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

IterateWithHoles() [2/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( )

inline

Function IterateWithHoles.

Returns

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

Definition at line 778 of file shape_poly_set.h.

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

References Iterate(), and OutlineCount().

Referenced by IterateFromVertexWithHoles(), and RemoveNullSegments().

Mirror()

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

Mirrors 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 1619 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, and m_triangulationValid.

Referenced by GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), FP_SHAPE::Flip(), PCB_SHAPE::Flip(), FP_SHAPE::Mirror(), and ZONE::Mirror().

Move()

void SHAPE_POLY_SET::Move ( const VECTOR2I &  aVector )

overridevirtual

Implements SHAPE.

Definition at line 1604 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, and m_triangulatedPolys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), export_vrml_polygon(), ALTIUM_PCB::HelperDrawsegmentSetLocalCoord(), GERBER_DRAW_ITEM::HitTest(), FP_SHAPE::Move(), PCB_SHAPE::Move(), ZONE::Move(), GERBER_DRAW_ITEM::MoveAB(), GERBER_DRAW_ITEM::MoveXY(), WS_DRAW_ITEM_POLYPOLYGONS::SetPosition(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), and PAD::TransformShapeWithClearanceToPolygon().

NewFacet()

FACET * SHAPE::NewFacet ( )

inherited

Definition at line 705 of file wrlfacet.cpp.

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

References SHAPE::facets.

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

NewHole()

int SHAPE_POLY_SET::NewHole

(

int

aOutline = -1

)

Creates a new hole in a given outline

Definition at line 200 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 ConvertOutlineToPolygon(), ZONE::NewHole(), and TransformRingToPolygon().

NewOutline()

int SHAPE_POLY_SET::NewOutline

(

)

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

Definition at line 188 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(), ZONE::AppendCorner(), BuildBoardPolygonOutlines(), BuildFootprintPolygonOutlines(), KI_TEST::CommonTestData::CommonTestData(), ConvertOutlineToPolygon(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), BITMAPCONV_INFO::createOutputData(), BOARD_ADAPTER::createPadWithClearance(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), fillArcPOLY(), FOOTPRINT::GetBoundingHull(), getRectangleAlongCentreLine(), PCB_SHAPE::HitTest(), PAD::HitTest(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadPolygon(), FABMASTER::loadZone(), LEGACY_PLUGIN::loadZONE_CONTAINER(), PCB_PARSER::parseZONE(), DXF_PLOTTER::PlotPoly(), RENDER_3D_LEGACY::reload(), PCB_SHAPE::Rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), PCB_SHAPE::SetPolyPoints(), WS_DATA_ITEM_POLYGONS::SyncDrawItems(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), TransformRoundRectToPolygon(), PCB_SHAPE::TransformShapeWithClearanceToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), ALIGNED_DIMENSION::updateGeometry(), ORTHOGONAL_DIMENSION::updateGeometry(), and LEADER::updateGeometry().

NormalizeAreaOutlines()

int SHAPE_POLY_SET::NormalizeAreaOutlines

(

)

Function NormalizeAreaOutlines Convert a self-intersecting polygon to one (or more) non self-intersecting polygon(s) Removes null segments.

Returns

int - 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 1064 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, substract it to main outline
    if( holesBuffer.OutlineCount() )
    {
        holesBuffer.Simplify( SHAPE_POLY_SET::PM_FAST );
        BooleanSubtract( holesBuffer, SHAPE_POLY_SET::PM_STRICTLY_SIMPLE );
    }

    RemoveNullSegments();

    return OutlineCount();
}

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

Referenced by BITMAPCONV_INFO::createOutputData(), and BOARD::NormalizeAreaPolygon().

operator=()

SHAPE_POLY_SET & SHAPE_POLY_SET::operator=

(

const SHAPE_POLY_SET &

aOther

)

Definition at line 1991 of file shape_poly_set.cpp.

{
    static_cast<SHAPE&>(*this) = aOther;
    m_polys = aOther.m_polys;
    m_triangulatedPolys.clear();
    m_triangulationValid = false;

    if( aOther.IsTriangulationUpToDate() )
    {
        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;
    }

    return *this;
}

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

Outline() [1/2]

SHAPE_LINE_CHAIN& SHAPE_POLY_SET::Outline ( int  aIndex )

inline

Returns the reference to aIndex-th outline in the set

Definition at line 654 of file shape_poly_set.h.

    {
        return m_polys[aIndex][0];
    }

References m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BuildBBoxCaches(), BuildFootprintPolygonOutlines(), ZONE::CalculateFilledArea(), PCB_GRID_HELPER::computeAnchors(), FOOTPRINT::CoverageRatio(), CovertPolygonToBlocks(), BITMAPCONV_INFO::createOutputData(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::DIALOG_PAD_PRIMITIVE_POLY_PROPS(), KIGFX::WS_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), APERTURE_MACRO::DrawApertureMacroShape(), export_vrml_padshape(), DSN::SPECCTRA_DB::fillBOUNDARY(), AR_AUTOPLACER::fillMatrix(), GERBER_PLOTTER::FlashPadChamferRoundRect(), PSLIKE_PLOTTER::FlashPadCustom(), DXF_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), PSLIKE_PLOTTER::FlashPadRoundRect(), DXF_PLOTTER::FlashPadRoundRect(), HPGL_PLOTTER::FlashPadRoundRect(), GERBER_PLOTTER::FlashPadRoundRect(), PCB_IO::format(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), insideArea(), FABMASTER::loadZone(), DSN::SPECCTRA_DB::makePADSTACK(), BOARD::NormalizeAreaPolygon(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), PlotWorkSheet(), polygonArea(), CONVERT_TOOL::PolyToLines(), GERBER_DRAW_ITEM::PrintGerberPoly(), WS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem(), RENDER_3D_LEGACY::reload(), PCB_POINT_EDITOR::removeCornerCondition(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), PCB_SHAPE::Scale(), TransformRoundRectToPolygon(), GBR_TO_PCB_EXPORTER::writePcbPolygon(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

Outline() [2/2]

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

inline

Definition at line 659 of file shape_poly_set.h.

    {
        return m_polys[aIndex][0];
    }

References m_polys.

OutlineCount()

int SHAPE_POLY_SET::OutlineCount ( ) const

inline

Returns the number of outlines in the set

Definition at line 637 of file shape_poly_set.h.

{ return m_polys.size(); }

References m_polys.

Referenced by PCB_POINT_EDITOR::addCorner(), ZONE_FILLER::addHatchFillTypeOnZone(), PAD::addPadPrimitivesToPolygon(), ZONE::AddPolygon(), BOARD_ADAPTER::addSolidAreasShapes(), TRIANGLE_DISPLAY_LIST::AddToMiddleContourns(), ZONE::AppendCorner(), BuildBBoxCaches(), BuildBoardPolygonOutlines(), BuildConvexHull(), BuildFootprintPolygonOutlines(), PCB_SHAPE::BuildPolyPointsList(), CacheTriangulation(), ZONE::CalculateFilledArea(), CIterate(), CIterateSegments(), CIterateSegmentsWithHoles(), CIterateWithHoles(), BOARD::CombineZones(), Contains(), CovertPolygonToBlocks(), RENDER_3D_LEGACY::createBoard(), BITMAPCONV_INFO::createOutputData(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), KIGFX::WS_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), APERTURE_MACRO::DrawApertureMacroShape(), D_CODE::DrawFlashedPolygon(), D_CODE::DrawFlashedShape(), KIGFX::GERBVIEW_PAINTER::drawFlashedShape(), 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(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), export_vrml_board(), export_vrml_padshape(), export_vrml_zones(), ZONE_FILLER::Fill(), fillArcPOLY(), DSN::SPECCTRA_DB::fillBOUNDARY(), GEOM_TEST::FilletPolySet(), PSLIKE_PLOTTER::FlashPadCustom(), DXF_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), RENDER_3D_LEGACY::generateHoles(), RENDER_3D_LEGACY::generateLayerList(), RENDER_3D_LEGACY::generateViasAndPads(), APERTURE_MACRO::GetApertureMacroShape(), PAD::GetBestAnchorPosition(), GERBER_DRAW_ITEM::GetBoundingBox(), FOOTPRINT::GetBoundingHull(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), GetRelativeIndices(), HasTouchingHoles(), WS_DRAW_ITEM_POLYPOLYGONS::HitTest(), ZONE::HitTestCutout(), insideArea(), isCopperOutside(), Iterate(), IterateSegments(), IterateSegmentsWithHoles(), IterateWithHoles(), CONVERT_TOOL::LinesToPoly(), NormalizeAreaOutlines(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::operator bool(), DIALOG_PAD_PROPERTIES::padValuesOK(), partitionPolyIntoRegularCellGrid(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), PlotLayerOutlines(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), PlotStandardLayer(), PlotWorkSheet(), polygon_triangulation_main(), polygonArea(), GERBER_DRAW_ITEM::Print(), WS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem(), RENDER_3D_RAYTRACE::Reload(), ZONE::RemoveCutout(), Subset(), PNS_KICAD_IFACE_BASE::syncZone(), TestConcaveSquareFillet(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), TestSquareFillet(), 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 1128 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

Function PointOnEdge()

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

Parameters

aP	is the point to check.

Returns

bool - true if the point lies on the edge of any polygon.

Definition at line 1220 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

Returns the aIndex-th subpolygon in the set

Definition at line 687 of file shape_poly_set.h.

    {
        return m_polys[aIndex];
    }

References m_polys.

Referenced by CacheTriangulation(), chamferFilletPolygon(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), ZONE_FILLER::Fill(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::Get(), SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::Get(), GetGlobalIndex(), FABMASTER::loadFootprints(), NormalizeAreaOutlines(), polygon_triangulation_main(), 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 692 of file shape_poly_set.h.

    {
        return m_polys[aIndex];
    }

References m_polys.

RemoveAllContours()

void SHAPE_POLY_SET::RemoveAllContours

(

)

Removes all outlines & holes (clears) the polygon set.

Definition at line 1357 of file shape_poly_set.cpp.

{
    m_polys.clear();
}

References m_polys.

Referenced by buildBoardBoundingBoxPoly(), BuildBoardPolygonOutlines(), AR_AUTOPLACER::buildFpAreas(), FOOTPRINT::BuildPolyCourtyards(), D_CODE::Clear_D_CODE_Data(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), BOARD_ADAPTER::createBoardPolygon(), BITMAPCONV_INFO::createOutputData(), BOARD_ADAPTER::destroyLayers(), ZONE_FILLER::Fill(), RENDER_3D_LEGACY::generateViasAndPads(), APERTURE_MACRO::GetApertureMacroShape(), PAD::MergePrimitivesAsPolygon(), PlotLayerOutlines(), RENDER_3D_LEGACY::reload(), ZONE::RemoveAllContours(), PCB_SHAPE::Rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), PCB_SHAPE::SetPolyPoints(), and TransformRoundChamferedRectToPolygon().

RemoveContour()

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

Function RemoveContour deletes 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 1363 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

(

)

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

Returns

int - the number of deleted segments.

Definition at line 1373 of file shape_poly_set.cpp.

{
    int removed = 0;

    ITERATOR iterator = IterateWithHoles();

    VECTOR2I    contourStart = *iterator;
    VECTOR2I    segmentStart, segmentEnd;

    VERTEX_INDEX indexStart;

    while( iterator )
    {
        // Obtain first point and its index
        segmentStart = *iterator;
        indexStart = iterator.GetIndex();

        // Obtain last point
        if( iterator.IsEndContour() )
        {
            segmentEnd = contourStart;

            // Advance
            iterator++;

            if( iterator )
                contourStart = *iterator;
        }
        else
        {
            // Advance
            iterator++;

            if( iterator )
                segmentEnd = *iterator;
        }

        // Remove segment start if both points are equal
        if( segmentStart == segmentEnd )
        {
            RemoveVertex( indexStart );
            removed++;

            // Advance the iterator one position, as there is one vertex less.
            if( iterator )
                iterator++;
        }
    }

    return removed;
}

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

Referenced by chamferFilletPolygon(), and NormalizeAreaOutlines().

RemoveVertex() [1/2]

void SHAPE_POLY_SET::RemoveVertex

(

int

aGlobalIndex

)

Function RemoveVertex deletes the aGlobalIndex-th vertex.

Parameters

aGlobalIndex

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

Definition at line 1545 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().

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

RemoveVertex() [2/2]

void SHAPE_POLY_SET::RemoveVertex

(

VERTEX_INDEX

aRelativeIndices

)

Function RemoveVertex deletes the vertex indexed by aIndex (index of polygon, contour and vertex).

Parameters

aRelativeIndices

is the set of relative indices of the to-be-removed vertex.

Definition at line 1557 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 ( double  aAngle, const VECTOR2I &  aCenter = { 0, 0 }  )

overridevirtual

Function Rotate rotates all vertices by a given angle.

Parameters

aCenter	is the rotation center
aAngle	rotation angle in radians

Implements SHAPE.

Definition at line 1632 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, and m_triangulationValid.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), D_CODE::ConvertShapeToPolygon(), export_vrml_polygon(), ALTIUM_PCB::HelperDrawsegmentSetLocalCoord(), PCB_SHAPE::Rotate(), ZONE::Rotate(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), ALIGNED_DIMENSION::updateGeometry(), ORTHOGONAL_DIMENSION::updateGeometry(), and LEADER::updateGeometry().

SetVertex() [1/2]

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

Function SetVertex 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 1574 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
	)

Sets 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

Definition at line 1563 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

)

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

Definition at line 1056 of file shape_poly_set.cpp.

{
    SHAPE_POLY_SET empty;

    booleanOp( ctUnion, empty, aFastMode );
}

References booleanOp(), and empty().

Referenced by PAD::addPadPrimitivesToPolygon(), BOARD_ADAPTER::addShapeWithClearance(), ZONE_FILLER::buildCopperItemClearances(), BOARD::CombineZones(), FOOTPRINT::CoverageRatio(), BOARD_ADAPTER::createBoardPolygon(), BOARD_ADAPTER::createLayers(), BITMAPCONV_INFO::createOutputData(), Fracture(), BOARD::GetBoardPolygonOutlines(), InflateWithLinkedHoles(), NormalizeAreaOutlines(), ALTIUM_PCB::ParseArcs6Data(), PlotLayerOutlines(), PlotSolderMaskLayer(), PAD::TransformShapeWithClearanceToPolygon(), ZONE::TransformShapeWithClearanceToPolygon(), Unfracture(), HYPERLYNX_EXPORTER::writeNetObjects(), GBR_TO_PCB_EXPORTER::writePcbPolygon(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

SquaredDistance() [1/2]

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

Function SquaredDistance computes 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 1745 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< T >::ECOORD_MAX, m_polys, and SquaredDistanceToPolygon().

Referenced by BOOST_AUTO_TEST_CASE(), and Collide().

SquaredDistance() [2/2]

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

Function SquaredDistance computes 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 1770 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< T >::ECOORD_MAX, m_polys, and SquaredDistanceToPolygon().

SquaredDistanceToPolygon() [1/2]

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

Function DistanceToPolygon computes 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 distace 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

int - 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 1673 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().

SquaredDistanceToPolygon() [2/2]

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

Function DistanceToPolygon computes 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 distace 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

int - 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 1709 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( aSegment.A, aPolygonIndex, 1 ) )
    {
        if( aNearest )
            *aNearest = ( aSegment.A + aSegment.B ) / 2;

        return 0;
    }

    CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
    SEG::ecoord            minDistance = (*iterator).SquaredDistance( 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().

Subset()

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

Function Subset returns 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 first polygon to be excluded of the returned set.

Returns

SHAPE_POLY_SET - a set containing the polygons between aFirstPolygon (included) and aLastPolygon (excluded).

Definition at line 287 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

Returns total number of vertices stored in the set.

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

Referenced by PCB_POINT_EDITOR::buildForPolyOutline(), ZONE::GetNumCorners(), PCB_SHAPE::HitTest(), ZONE::HitTest(), InsertVertex(), PCB_POINT_EDITOR::updateItem(), and PCB_POINT_EDITOR::updatePoints().

TriangulatedPolyCount()

unsigned int SHAPE_POLY_SET::TriangulatedPolyCount ( ) const

inline

Returns the number of triangulated polygons

Definition at line 634 of file shape_poly_set.h.

{ return m_triangulatedPolys.size(); }

References m_triangulatedPolys.

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

TriangulatedPolygon()

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

inline

Definition at line 697 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(), and PNS_KICAD_IFACE_BASE::syncZone().

Type()

SHAPE_TYPE SHAPE_BASE::Type ( ) const

inlineinherited

Function Type()

Returns the type of the shape.

Return values

the

type

Definition at line 99 of file shape.h.

    {
        return m_type;
    }

References SHAPE_BASE::m_type.

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

Unfracture()

void SHAPE_POLY_SET::Unfracture

(

POLYGON_MODE

aFastMode

)

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

Definition at line 1045 of file shape_poly_set.cpp.

{
    for( POLYGON& path : m_polys )
    {
        unfractureSingle( path );
    }

    Simplify( aFastMode );    // remove overlapping holes/degeneracy
}

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

Referenced by PGPartitionFixture::PGPartitionFixture(), and polygon_triangulation_main().

unfractureSingle()

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

private

Definition at line 869 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 auto& a = aEdge.m_poly->CSegment( aEdge.m_index );

                return (std::size_t) ( a.A.x + a.B.x + a.A.y + a.B.y );
            }
        };
    };

    struct EDGE_LIST_ENTRY
    {
        int index;
        EDGE_LIST_ENTRY* next;
    };

    std::unordered_set<EDGE, EDGE::HASH> uniqueEdges;

    auto 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;

    while( queue.size() )
    {
        auto    e_first = (*queue.begin() );
        auto    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++ )
        {
            auto p = lc.CPoint( edgeBuf[i]->index );
            outl.Append( p );
            queue.erase( edgeBuf[i] );
        }

        outl.SetClosed( true );

        bool cw = outl.Area() > 0.0;

        if( cw )
            outline = n;

        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(), next(), operator!=(), operator==(), and SHAPE_LINE_CHAIN::SetClosed().

Referenced by Unfracture().

UnitSet()

SHAPE_POLY_SET SHAPE_POLY_SET::UnitSet ( int  aPolygonIndex )

inline

Definition at line 675 of file shape_poly_set.h.

    {
        return Subset( aPolygonIndex, aPolygonIndex + 1 );
    }

References Subset().

Referenced by BOARD::NormalizeAreaPolygon().

VertexCount()

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

Returns the number of vertices in a given outline/hole

Definition at line 262 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 D_CODE::DrawFlashedPolygon(), GERBER_FILE_IMAGE::Execute_G_Command(), PCB_SHAPE::GetPointCount(), FABMASTER::loadFootprints(), FABMASTER::loadPolygon(), and FABMASTER::loadZone().

Member Data Documentation

m_hash

MD5_HASH SHAPE_POLY_SET::m_hash

private

Definition at line 1412 of file shape_poly_set.h.

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

m_polys

POLYSET SHAPE_POLY_SET::m_polys

private

Definition at line 1407 of file shape_poly_set.h.

Referenced by AddHole(), AddOutline(), Append(), BBox(), BBoxFromCaches(), booleanOp(), Chamfer(), checksum(), CHole(), Contains(), containsSingle(), COutline(), CPolygon(), CVertex(), DeletePolygon(), Fillet(), Format(), Fracture(), GetGlobalIndex(), GetNeighbourIndexes(), HasHoles(), Hole(), HoleCount(), importTree(), Inflate(), 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 1409 of file shape_poly_set.h.

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

m_triangulationValid

bool SHAPE_POLY_SET::m_triangulationValid = false

private

Definition at line 1411 of file shape_poly_set.h.

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

m_type

SHAPE_TYPE SHAPE_BASE::m_type

protectedinherited

type of our shape

Definition at line 115 of file shape.h.

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

---

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

• shape_poly_set.h
• shape_poly_set.cpp