KiCad PCB EDA Suite
SHAPE_POLY_SET Class Reference

Represent a set of closed polygons. More...

#include <shape_poly_set.h>

Inheritance diagram for SHAPE_POLY_SET:
SHAPE SHAPE_BASE

Classes

class  ITERATOR_TEMPLATE
 Base class for iterating over all vertices in a given SHAPE_POLY_SET. More...
 
class  SEGMENT_ITERATOR_TEMPLATE
 Base class for iterating over all segments in a given SHAPE_POLY_SET. More...
 
class  TRIANGULATED_POLYGON
 
struct  VERTEX_INDEX
 Structure to hold the necessary information in order to index a vertex on a SHAPE_POLY_SET object: the polygon index, the contour index relative to the polygon and the vertex index relative the contour. More...
 

Public Types

enum  POLYGON_MODE { PM_FAST = true, PM_STRICTLY_SIMPLE = false }
 Operations on polygons use a aFastMode param if aFastMode is PM_FAST (true) the result can be a weak polygon if aFastMode is PM_STRICTLY_SIMPLE (false) (default) the result is (theoretically) a strictly simple polygon, but calculations can be really significantly time consuming Most of time PM_FAST is preferable. More...
 
enum  CORNER_STRATEGY {
  ALLOW_ACUTE_CORNERS, CHAMFER_ACUTE_CORNERS, ROUND_ACUTE_CORNERS, CHAMFER_ALL_CORNERS,
  ROUND_ALL_CORNERS
}
 < define how inflate transform build inflated polygon More...
 
typedef std::vector< SHAPE_LINE_CHAINPOLYGON
 < represents a single polygon outline with holes. More...
 
typedef ITERATOR_TEMPLATE< VECTOR2IITERATOR
 
typedef ITERATOR_TEMPLATE< const VECTOR2ICONST_ITERATOR
 
typedef SEGMENT_ITERATOR_TEMPLATE< SEGSEGMENT_ITERATOR
 
typedef SEGMENT_ITERATOR_TEMPLATE< const SEGCONST_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_SEToperator= (const SHAPE_POLY_SET &aOther)
 
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
 Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated list of all vertices in all contours— and get the index of the vertex relative to the contour relative to the polygon in which it is. More...
 
bool GetGlobalIndex (VERTEX_INDEX aRelativeIndices, int &aGlobalIdx) const
 Compute the global index of a vertex from the relative indices of polygon, contour and vertex. More...
 
SHAPEClone () const override
 Return a dynamically allocated copy of the shape. More...
 
int NewOutline ()
 Creates a new hole in a given outline. More...
 
int NewHole (int aOutline=-1)
 Adds a new outline to the set and returns its index. More...
 
int AddOutline (const SHAPE_LINE_CHAIN &aOutline)
 Adds a new hole to the given outline (default: last) and returns its index. More...
 
int AddHole (const SHAPE_LINE_CHAIN &aHole, int aOutline=-1)
 Return the area of this poly set. More...
 
double Area ()
 Count the number of arc shapes present. More...
 
int ArcCount () const
 Appends all the arcs in this polyset to aArcBuffer. More...
 
void GetArcs (std::vector< SHAPE_ARC > &aArcBuffer) const
 Removes all arc references from all the outlines and holes in the polyset. More...
 
void ClearArcs ()
 Appends a vertex at the end of the given outline/hole (default: the last outline) More...
 
int Append (int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
 Add a new vertex to the contour indexed by aOutline and aHole (defaults to the outline of the last polygon). More...
 
void Append (const SHAPE_POLY_SET &aSet)
 Append a vertex at the end of the given outline/hole (default: the last outline) More...
 
void Append (const VECTOR2I &aP, int aOutline=-1, int aHole=-1)
 
int Append (SHAPE_ARC &aArc, int aOutline=-1, int aHole=-1)
 Append a new arc to the contour indexed by aOutline and aHole (defaults to the outline of the last polygon). More...
 
void InsertVertex (int aGlobalIndex, VECTOR2I aNewVertex)
 Adds a vertex in the globally indexed position aGlobalIndex. More...
 
const VECTOR2ICVertex (int aIndex, int aOutline, int aHole) const
 Return the aGlobalIndex-th vertex in the poly set. More...
 
const VECTOR2ICVertex (int aGlobalIndex) const
 Return the index-th vertex in a given hole outline within a given outline. More...
 
const VECTOR2ICVertex (VERTEX_INDEX aIndex) const
 
bool GetNeighbourIndexes (int aGlobalIndex, int *aPrevious, int *aNext)
 Return the global indexes of the previous and the next corner of the aGlobalIndex-th corner of a contour in the polygon set. More...
 
bool IsPolygonSelfIntersecting (int aPolygonIndex) const
 Check whether the aPolygonIndex-th polygon in the set is self intersecting. More...
 
bool IsSelfIntersecting () const
 Check whether any of the polygons in the set is self intersecting. More...
 
unsigned int TriangulatedPolyCount () const
 Return the number of outlines in the set. More...
 
int OutlineCount () const
 Return the number of vertices in a given outline/hole. More...
 
int VertexCount (int aOutline=-1, int aHole=-1) const
 Returns the number of holes in a given outline. More...
 
int HoleCount (int aOutline) const
 Return the reference to aIndex-th outline in the set. More...
 
SHAPE_LINE_CHAINOutline (int aIndex)
 
const SHAPE_LINE_CHAINOutline (int aIndex) const
 
SHAPE_POLY_SET Subset (int aFirstPolygon, int aLastPolygon)
 Return a subset of the polygons in this set, the ones between aFirstPolygon and aLastPolygon. More...
 
SHAPE_POLY_SET UnitSet (int aPolygonIndex)
 Return the reference to aHole-th hole in the aIndex-th outline. More...
 
SHAPE_LINE_CHAINHole (int aOutline, int aHole)
 Return the aIndex-th subpolygon in the set. More...
 
POLYGONPolygon (int aIndex)
 
const POLYGONPolygon (int aIndex) const
 
const TRIANGULATED_POLYGONTriangulatedPolygon (int aIndex) const
 
const SHAPE_LINE_CHAINCOutline (int aIndex) const
 
const SHAPE_LINE_CHAINCHole (int aOutline, int aHole) const
 
const POLYGONCPolygon (int aIndex) const
 
ITERATOR Iterate (int aFirst, int aLast, bool aIterateHoles=false)
 Return an object to iterate through the points of the polygons between aFirst and aLast. More...
 
ITERATOR Iterate (int aOutline)
 
ITERATOR IterateWithHoles (int aOutline)
 
ITERATOR Iterate ()
 
ITERATOR IterateWithHoles ()
 
CONST_ITERATOR CIterate (int aFirst, int aLast, bool aIterateHoles=false) const
 
CONST_ITERATOR CIterate (int aOutline) const
 
CONST_ITERATOR CIterateWithHoles (int aOutline) const
 
CONST_ITERATOR CIterate () const
 
CONST_ITERATOR CIterateWithHoles () const
 
ITERATOR IterateFromVertexWithHoles (int aGlobalIdx)
 Return an iterator object, for iterating between aFirst and aLast outline, with or without holes (default: without) More...
 
SEGMENT_ITERATOR IterateSegments (int aFirst, int aLast, bool aIterateHoles=false)
 Return an iterator object, for iterating between aFirst and aLast outline, with or without holes (default: without) More...
 
CONST_SEGMENT_ITERATOR CIterateSegments (int aFirst, int aLast, bool aIterateHoles=false) const
 Return an iterator object, for iterating aPolygonIdx-th polygon edges. More...
 
SEGMENT_ITERATOR IterateSegments (int aPolygonIdx)
 Return an iterator object, for iterating aPolygonIdx-th polygon edges. More...
 
CONST_SEGMENT_ITERATOR CIterateSegments (int aPolygonIdx) const
 Return an iterator object, for all outlines in the set (no holes). More...
 
SEGMENT_ITERATOR IterateSegments ()
 Returns an iterator object, for all outlines in the set (no holes) More...
 
CONST_SEGMENT_ITERATOR CIterateSegments () const
 Returns an iterator object, for all outlines in the set (with holes) More...
 
SEGMENT_ITERATOR IterateSegmentsWithHoles ()
 Return an iterator object, for the aOutline-th outline in the set (with holes). More...
 
SEGMENT_ITERATOR IterateSegmentsWithHoles (int aOutline)
 Return an iterator object, for the aOutline-th outline in the set (with holes). More...
 
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles () const
 Return an iterator object, for the aOutline-th outline in the set (with holes). More...
 
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles (int aOutline) const
 
void BooleanAdd (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 Perform boolean polyset difference For aFastMode meaning, see function booleanOp. More...
 
void BooleanSubtract (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 Perform boolean polyset intersection For aFastMode meaning, see function booleanOp. More...
 
void BooleanIntersection (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 Perform boolean polyset union between a and b, store the result in it self For aFastMode meaning, see function booleanOp. More...
 
void BooleanAdd (const SHAPE_POLY_SET &a, const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 Perform boolean polyset difference between a and b, store the result in it self For aFastMode meaning, see function booleanOp. More...
 
void BooleanSubtract (const SHAPE_POLY_SET &a, const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 Perform boolean polyset intersection between a and b, store the result in it self For aFastMode meaning, see function booleanOp. More...
 
void BooleanIntersection (const SHAPE_POLY_SET &a, const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 
void Inflate (int aAmount, int aCircleSegCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
 Perform outline inflation/deflation. More...
 
void Deflate (int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
 
void InflateWithLinkedHoles (int aFactor, int aCircleSegmentsCount, POLYGON_MODE aFastMode)
 Perform outline inflation/deflation, using round corners. More...
 
void Fracture (POLYGON_MODE aFastMode)
 Convert a single outline slitted ("fractured") polygon into a set ouf outlines with holes. More...
 
void Unfracture (POLYGON_MODE aFastMode)
 Return true if the polygon set has any holes. More...
 
bool HasHoles () const
 Return true if the polygon set has any holes that share a vertex. More...
 
bool HasTouchingHoles () const
 Simplify the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFastMode meaning, see function booleanOp. More...
 
void Simplify (POLYGON_MODE aFastMode)
 
int NormalizeAreaOutlines ()
 Convert a self-intersecting polygon to one (or more) non self-intersecting polygon(s). More...
 
const std::string Format () const override
 
bool Parse (std::stringstream &aStream) override
 
void Move (const VECTOR2I &aVector) override
 
void Mirror (bool aX=true, bool aY=false, const VECTOR2I &aRef={ 0, 0 })
 Mirror the line points about y or x (or both) More...
 
void Rotate (double aAngle, const VECTOR2I &aCenter={ 0, 0 }) override
 Rotate all vertices by a given angle. More...
 
bool IsSolid () const override
 
const BOX2I BBox (int aClearance=0) const override
 Compute a bounding box of the shape, with a margin of aClearance a collision. More...
 
bool PointOnEdge (const VECTOR2I &aP) const
 Check if point aP lies on an edge or vertex of some of the outlines or holes. More...
 
bool Collide (const SHAPE *aShape, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
 Check if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating a collision. More...
 
bool Collide (const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
 Check whether the point aP is either inside or on the edge of the polygon set. More...
 
bool Collide (const SEG &aSeg, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
 Check whether the segment aSeg collides with the polygon set (or its edge). More...
 
bool CollideVertex (const VECTOR2I &aPoint, VERTEX_INDEX &aClosestVertex, int aClearance=0) const
 Check whether aPoint collides with any vertex of any of the contours of the polygon. More...
 
bool CollideEdge (const VECTOR2I &aPoint, VERTEX_INDEX &aClosestVertex, int aClearance=0) const
 Check whether aPoint collides with any edge of any of the contours of the polygon. More...
 
void BuildBBoxCaches () const
 Construct BBoxCaches for Contains(), below. More...
 
const BOX2I BBoxFromCaches () const
 
bool Contains (const VECTOR2I &aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=false) const
 Return true if a given subpolygon contains the point aP. More...
 
bool IsEmpty () const
 
void RemoveVertex (int aGlobalIndex)
 Delete the aGlobalIndex-th vertex. More...
 
void RemoveVertex (VERTEX_INDEX aRelativeIndices)
 Delete the vertex indexed by aRelativeIndex (index of polygon, contour and vertex). More...
 
void RemoveAllContours ()
 
void RemoveContour (int aContourIdx, int aPolygonIdx=-1)
 Delete the aContourIdx-th contour of the aPolygonIdx-th polygon in the set. More...
 
int RemoveNullSegments ()
 Look for null segments; ie, segments whose ends are exactly the same and deletes them. More...
 
void SetVertex (const VERTEX_INDEX &aIndex, const VECTOR2I &aPos)
 Accessor function to set the position of a specific point. More...
 
void SetVertex (int aGlobalIndex, const VECTOR2I &aPos)
 Set the vertex based on the global index. More...
 
int TotalVertices () const
 Delete aIdx-th polygon from the set. More...
 
void DeletePolygon (int aIdx)
 
POLYGON ChamferPolygon (unsigned int aDistance, int aIndex)
 Return a chamfered version of the aIndex-th polygon. More...
 
POLYGON FilletPolygon (unsigned int aRadius, int aErrorMax, int aIndex)
 Return a filleted version of the aIndex-th polygon. More...
 
SHAPE_POLY_SET Chamfer (int aDistance)
 Return a chamfered version of the polygon set. More...
 
SHAPE_POLY_SET Fillet (int aRadius, int aErrorMax)
 Return a filleted version of the polygon set. More...
 
SEG::ecoord SquaredDistanceToPolygon (VECTOR2I aPoint, int aIndex, VECTOR2I *aNearest) const
 Compute the minimum distance between the aIndex-th polygon and aPoint. More...
 
SEG::ecoord SquaredDistanceToPolygon (const SEG &aSegment, int aIndex, VECTOR2I *aNearest) const
 Compute the minimum distance between the aIndex-th polygon and aSegment with a possible width. More...
 
SEG::ecoord SquaredDistance (VECTOR2I aPoint, VECTOR2I *aNearest=nullptr) const
 Compute the minimum distance squared between aPoint and all the polygons in the set. More...
 
SEG::ecoord SquaredDistance (const SEG &aSegment, VECTOR2I *aNearest=nullptr) const
 Compute the minimum distance squared between aSegment and all the polygons in the set. More...
 
bool IsVertexInHole (int aGlobalIdx)
 Check whether the aGlobalIndex-th vertex belongs to a hole. More...
 
bool IsNull () const
 Return true if the shape is a null shape. More...
 
virtual bool Collide (const SHAPE *aShape, int aClearance, VECTOR2I *aMTV) const
 Check if the boundary of shape (this) lies closer to the shape aShape than aClearance, indicating a collision. More...
 
virtual VECTOR2I Centre () const
 Compute a center-of-mass of the shape. More...
 
FACETNewFacet ()
 
SGNODECalcShape (SGNODE *aParent, SGNODE *aColor, WRL1_ORDER aVertexOrder, float aCreaseLimit=0.74317, bool isVRML2=false)
 
SHAPE_TYPE Type () const
 Return the type of the shape. More...
 

Static Public Attributes

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

Protected Types

typedef VECTOR2I::extended_type ecoord
 

Protected Attributes

SHAPE_TYPE m_type
 < type of our shape More...
 

Private Types

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

Private Member Functions

void fractureSingle (POLYGON &paths)
 
void unfractureSingle (POLYGON &path)
 
void importTree (ClipperLib::PolyTree *tree, const std::vector< CLIPPER_Z_VALUE > &aZValueBuffer, const std::vector< SHAPE_ARC > &aArcBuffe)
 
void booleanOp (ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
 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
 Check whether the point aP is inside the aSubpolyIndex-th polygon of the polyset. More...
 
POLYGON chamferFilletPolygon (CORNER_MODE aMode, unsigned int aDistance, int aIndex, int aErrorMax)
 Return the chamfered or filleted version of the aIndex-th polygon in the set, depending on the aMode selected. More...
 
bool hasTouchingHoles (const POLYGON &aPoly) const
 
MD5_HASH checksum () const
 

Private Attributes

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

Detailed Description

Represent a set of closed polygons.

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

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

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

TODO: add convex partitioning & spatial index

Definition at line 64 of file shape_poly_set.h.

Member Typedef Documentation

◆ CONST_ITERATOR

◆ CONST_SEGMENT_ITERATOR

◆ ecoord

typedef VECTOR2I::extended_type SHAPE::ecoord
protectedinherited

Definition at line 236 of file shape.h.

◆ ITERATOR

◆ 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 1422 of file shape_poly_set.h.

◆ SEGMENT_ITERATOR

Member Enumeration Documentation

◆ CORNER_MODE

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

Enumerator
CHAMFERED 
FILLETED 

Definition at line 1394 of file shape_poly_set.h.

◆ 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 964 of file shape_poly_set.h.

965  {
973  };
All angles are chamfered.
Acute angles are rounded.
Acute angles are chamfered.
just inflate the polygon. Acute angles create spikes

◆ POLYGON_MODE

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

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

Enumerator
PM_FAST 
PM_STRICTLY_SIMPLE 

Definition at line 931 of file shape_poly_set.h.

Constructor & Destructor Documentation

◆ SHAPE_POLY_SET() [1/3]

SHAPE_POLY_SET::SHAPE_POLY_SET ( )

Definition at line 59 of file shape_poly_set.cpp.

59  :
61 {
62 }
SHAPE(SHAPE_TYPE aType)
Create an empty shape of type aType.
Definition: shape.h:127
set of polygons (with holes, etc.)
Definition: shape.h:48

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
aOutlineis a closed outline

Definition at line 65 of file shape_poly_set.cpp.

65  :
67 {
68  AddOutline( aOutline );
69 }
SHAPE(SHAPE_TYPE aType)
Create an empty shape of type aType.
Definition: shape.h:127
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new hole to the given outline (default: last) and returns its index.
set of polygons (with holes, etc.)
Definition: shape.h:48

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
aOtheris the SHAPE_POLY_SET object that will be copied.

Definition at line 72 of file shape_poly_set.cpp.

72  :
73  SHAPE( aOther ),
74  m_polys( aOther.m_polys )
75 {
76  if( aOther.IsTriangulationUpToDate() )
77  {
78  for( unsigned i = 0; i < aOther.TriangulatedPolyCount(); i++ )
79  {
80  const TRIANGULATED_POLYGON* poly = aOther.TriangulatedPolygon( i );
81  m_triangulatedPolys.push_back( std::make_unique<TRIANGULATED_POLYGON>( *poly ) );
82  }
83 
84  m_hash = aOther.GetHash();
85  m_triangulationValid = true;
86  }
87  else
88  {
89  m_triangulationValid = false;
90  m_hash = MD5_HASH();
91  m_triangulatedPolys.clear();
92  }
93 }
SHAPE(SHAPE_TYPE aType)
Create an empty shape of type aType.
Definition: shape.h:127
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
bool IsTriangulationUpToDate() const
MD5_HASH GetHash() const
unsigned int TriangulatedPolyCount() const
Return the number of outlines in the set.
const TRIANGULATED_POLYGON * TriangulatedPolygon(int aIndex) const

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

◆ ~SHAPE_POLY_SET()

SHAPE_POLY_SET::~SHAPE_POLY_SET ( )

Definition at line 96 of file shape_poly_set.cpp.

97 {
98 }

Member Function Documentation

◆ AddHole()

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

Return the area of this poly set.

Definition at line 458 of file shape_poly_set.cpp.

459 {
460  assert( m_polys.size() );
461 
462  if( aOutline < 0 )
463  aOutline += m_polys.size();
464 
465  assert( aOutline < (int)m_polys.size() );
466 
467  POLYGON& poly = m_polys[aOutline];
468 
469  assert( poly.size() );
470 
471  poly.push_back( aHole );
472 
473  return poly.size() - 2;
474 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.

References m_polys.

Referenced by ZONE::AddPolygon(), BuildFootprintPolygonOutlines(), KI_TEST::BuildHollowSquare(), KI_TEST::CommonTestData::CommonTestData(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), FABMASTER::loadFootprints(), FABMASTER::loadShapePolySet(), FABMASTER::loadZone(), and ALTIUM_PCB::ParseRegions6Data().

◆ AddOutline()

int SHAPE_POLY_SET::AddOutline ( const SHAPE_LINE_CHAIN aOutline)

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

Definition at line 444 of file shape_poly_set.cpp.

445 {
446  assert( aOutline.IsClosed() );
447 
448  POLYGON poly;
449 
450  poly.push_back( aOutline );
451 
452  m_polys.push_back( poly );
453 
454  return m_polys.size() - 1;
455 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
bool IsClosed() const override

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(), ConvertPolygonToBlocks(), FOOTPRINT::CoverageRatio(), BOARD_ADAPTER::createPadWithClearance(), KIGFX::GERBVIEW_PAINTER::draw(), GEOM_TEST::FilletPolySet(), FOOTPRINT::GetBoundingHull(), IteratorFixture::IteratorFixture(), DSN::SPECCTRA_DB::makeIMAGE(), 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/4]

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

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

Parameters
xis the x coordinate of the new vertex.
yis the y coordinate of the new vertex.
aOutlineis the index of the polygon.
aHoleis the index of the hole (-1 for the main outline),
aAllowDuplicationis a flag to indicate whether it is allowed to add this corner even if it is duplicated.
Returns
the number of corners of the selected contour after the addition.Merge polygons from two sets.

Definition at line 215 of file shape_poly_set.cpp.

216 {
217  assert( m_polys.size() );
218 
219  if( aOutline < 0 )
220  aOutline += m_polys.size();
221 
222  int idx;
223 
224  if( aHole < 0 )
225  idx = 0;
226  else
227  idx = aHole + 1;
228 
229  assert( aOutline < (int) m_polys.size() );
230  assert( idx < (int) m_polys[aOutline].size() );
231 
232  m_polys[aOutline][idx].Append( x, y, aAllowDuplication );
233 
234  return m_polys[aOutline][idx].PointCount();
235 }

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(), CornerListToPolygon(), 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(), InsertVertex(), CONVERT_TOOL::LinesToPoly(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadShapePolySet(), FABMASTER::loadZone(), LEGACY_PLUGIN::loadZONE_CONTAINER(), DSN::SPECCTRA_DB::makeIMAGE(), DXF_PLOTTER::PlotPoly(), PlotStandardLayer(), RENDER_3D_LEGACY::reload(), PCB_SHAPE::Rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), PCB_SHAPE::SetPolyPoints(), DS_DATA_ITEM_POLYGONS::SyncDrawItems(), TransformArcToPolygon(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), TransformRingToPolygon(), TransformRoundChamferedRectToPolygon(), PCB_SHAPE::TransformShapeWithClearanceToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), ZONE::TransformSmoothedOutlineToPolygon(), ZONE::TransformSolidAreasShapesToPolygon(), TransformTrapezoidToPolygon(), PCB_DIM_ALIGNED::updateGeometry(), PCB_DIM_ORTHOGONAL::updateGeometry(), and PCB_DIM_LEADER::updateGeometry().

◆ Append() [2/4]

void SHAPE_POLY_SET::Append ( const SHAPE_POLY_SET aSet)

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

Definition at line 1626 of file shape_poly_set.cpp.

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

References m_polys.

◆ Append() [3/4]

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

Definition at line 1632 of file shape_poly_set.cpp.

1633 {
1634  Append( aP.x, aP.y, aOutline, aHole );
1635 }
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Add a new vertex to the contour indexed by aOutline and aHole (defaults to the outline of the last po...

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

◆ Append() [4/4]

int SHAPE_POLY_SET::Append ( SHAPE_ARC aArc,
int  aOutline = -1,
int  aHole = -1 
)

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

Parameters
aArcThe arc to be inserted
aOutlineIndex of the polygon
aHoleIndex of the hole (-1 for the main outline)
Returns
the number of points in the arc (including the interpolated points from the arc)

Definition at line 238 of file shape_poly_set.cpp.

239 {
240  assert( m_polys.size() );
241 
242  if( aOutline < 0 )
243  aOutline += m_polys.size();
244 
245  int idx;
246 
247  if( aHole < 0 )
248  idx = 0;
249  else
250  idx = aHole + 1;
251 
252  assert( aOutline < (int) m_polys.size() );
253  assert( idx < (int) m_polys[aOutline].size() );
254 
255  m_polys[aOutline][idx].Append( aArc );
256 
257  return m_polys[aOutline][idx].PointCount();
258 }

References m_polys.

◆ ArcCount()

int SHAPE_POLY_SET::ArcCount ( ) const

Appends all the arcs in this polyset to aArcBuffer.

Definition at line 493 of file shape_poly_set.cpp.

494 {
495  int retval = 0;
496 
497  for( const POLYGON& poly : m_polys )
498  {
499  for( size_t i = 0; i < poly.size(); i++ )
500  retval += poly[i].ArcCount();
501  }
502 
503  return retval;
504 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
int ArcCount() const
Appends all the arcs in this polyset to aArcBuffer.

References m_polys.

Referenced by booleanOp().

◆ Area()

double SHAPE_POLY_SET::Area ( )

Count the number of arc shapes present.

Definition at line 477 of file shape_poly_set.cpp.

478 {
479  double area = 0.0;
480 
481  for( int i = 0; i < OutlineCount(); i++ )
482  {
483  area += Outline( i ).Area();
484 
485  for( int j = 0; j < HoleCount( i ); j++ )
486  area -= Hole( i, j ).Area();
487  }
488 
489  return area;
490 }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
SHAPE_LINE_CHAIN & Hole(int aOutline, int aHole)
Return the aIndex-th subpolygon in the set.
double Area(bool aAbsolute=true) const
Return the area of this chain.
SHAPE_LINE_CHAIN & Outline(int aIndex)
int HoleCount(int aOutline) const
Return the reference to aIndex-th outline in the set.

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

Referenced by BOOST_AUTO_TEST_CASE(), and CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities().

◆ BBox()

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

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

Parameters
aClearancehow much the bounding box is expanded wrs to the minimum enclosing rectangle for the shape.
Returns
the bounding box.

Implements SHAPE.

Definition at line 1381 of file shape_poly_set.cpp.

1382 {
1383  BOX2I bb;
1384 
1385  for( unsigned i = 0; i < m_polys.size(); i++ )
1386  {
1387  if( i == 0 )
1388  bb = m_polys[i][0].BBox();
1389  else
1390  bb.Merge( m_polys[i][0].BBox() );
1391  }
1392 
1393  bb.Inflate( aClearance );
1394  return bb;
1395 }
A 2D bounding box built on top of an origin point and size vector.
Definition: box2.h:41
BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:363
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:281
const BOX2I BBox(int aClearance=0) const override
Compute a bounding box of the shape, with a margin of aClearance a collision.

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

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), APERTURE_MACRO::GetApertureMacroShape(), PAD::GetBestAnchorPosition(), ZONE::GetBoundingBox(), DS_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 1398 of file shape_poly_set.cpp.

1399 {
1400  BOX2I bb;
1401 
1402  for( unsigned i = 0; i < m_polys.size(); i++ )
1403  {
1404  if( i == 0 )
1405  bb = m_polys[i][0].BBoxFromCache();
1406  else
1407  bb.Merge( m_polys[i][0].BBoxFromCache() );
1408  }
1409 
1410  return bb;
1411 }
A 2D bounding box built on top of an origin point and size vector.
Definition: box2.h:41
BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:363

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 
)

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

Definition at line 682 of file shape_poly_set.cpp.

683 {
684  booleanOp( ClipperLib::ctUnion, b, aFastMode );
685 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
This is the engine to execute all polygon boolean transforms (AND, OR, ...

References booleanOp().

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

◆ BooleanAdd() [2/2]

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

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

Definition at line 700 of file shape_poly_set.cpp.

702 {
703  booleanOp( ClipperLib::ctUnion, a, b, aFastMode );
704 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
This is the engine to execute all polygon boolean transforms (AND, OR, ...

References booleanOp().

◆ BooleanIntersection() [1/2]

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

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

Definition at line 694 of file shape_poly_set.cpp.

695 {
696  booleanOp( ClipperLib::ctIntersection, b, aFastMode );
697 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
This is the engine to execute all polygon boolean transforms (AND, OR, ...

References booleanOp().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BOOST_AUTO_TEST_CASE(), ZONE::BuildSmoothedPoly(), CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities(), ZONE_FILLER::computeRawFilledArea(), ConvertPolygonToBlocks(), isCopperOutside(), PAD_TOOL::recombinePad(), RENDER_3D_LEGACY::reload(), and TransformOvalToPolygon().

◆ BooleanIntersection() [2/2]

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

Definition at line 714 of file shape_poly_set.cpp.

716 {
717  booleanOp( ClipperLib::ctIntersection, a, b, aFastMode );
718 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
This is the engine to execute all polygon boolean transforms (AND, OR, ...

References booleanOp().

◆ booleanOp() [1/2]

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

This is the engine to execute all polygon boolean transforms (AND, OR, ...

and polygon simplification (merging overlapping polygons).

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

Definition at line 530 of file shape_poly_set.cpp.

532 {
533  booleanOp( aType, *this, aOtherShape, aFastMode );
534 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
This is the engine to execute all polygon boolean transforms (AND, OR, ...

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

539 {
540  if( ( aShape.OutlineCount() > 1 || aOtherShape.OutlineCount() > 0 )
541  && ( aShape.ArcCount() > 0 || aOtherShape.ArcCount() > 0 ) )
542  {
543  wxFAIL_MSG( "Boolean ops on curved polygons are not supported. You should call "
544  "ClearArcs() before carrying out the boolean operation." );
545  }
546 
547  ClipperLib::Clipper c;
548 
549  c.StrictlySimple( aFastMode == PM_STRICTLY_SIMPLE );
550 
551  std::vector<CLIPPER_Z_VALUE> zValues;
552  std::vector<SHAPE_ARC> arcBuffer;
553  std::map<VECTOR2I, CLIPPER_Z_VALUE> newIntersectPoints;
554 
555  for( const POLYGON& poly : aShape.m_polys )
556  {
557  for( size_t i = 0; i < poly.size(); i++ )
558  {
559  c.AddPath( poly[i].convertToClipper( i == 0, zValues, arcBuffer ),
560  ClipperLib::ptSubject, true );
561  }
562  }
563 
564  for( const POLYGON& poly : aOtherShape.m_polys )
565  {
566  for( size_t i = 0; i < poly.size(); i++ )
567  {
568  c.AddPath( poly[i].convertToClipper( i == 0, zValues, arcBuffer ),
569  ClipperLib::ptClip, true );
570  }
571  }
572 
573  ClipperLib::PolyTree solution;
574 
575  ClipperLib::ZFillCallback callback =
576  [&]( ClipperLib::IntPoint & e1bot, ClipperLib::IntPoint & e1top,
577  ClipperLib::IntPoint & e2bot, ClipperLib::IntPoint & e2top,
578  ClipperLib::IntPoint & pt )
579  {
580  auto arcIndex =
581  [&]( const ssize_t& aZvalue, const ssize_t& aCompareVal = -1 ) -> ssize_t
582  {
583  ssize_t retval;
584 
585  retval = zValues.at( aZvalue ).m_SecondArcIdx;
586 
587  if( retval == -1 || ( aCompareVal > 0 && retval != aCompareVal ) )
588  retval = zValues.at( aZvalue ).m_FirstArcIdx;
589 
590  return retval;
591  };
592 
593  auto arcSegment =
594  [&]( const ssize_t& aBottomZ, const ssize_t aTopZ ) -> ssize_t
595  {
596  ssize_t retval = arcIndex( aBottomZ );
597 
598  if( retval != -1 )
599  {
600  if( retval != arcIndex( aTopZ, retval ) )
601  retval = -1; // Not an arc segment as the two indices do not match
602  }
603 
604  return retval;
605  };
606 
607  ssize_t e1ArcSegmentIndex = arcSegment( e1bot.Z, e1top.Z );
608  ssize_t e2ArcSegmentIndex = arcSegment( e2bot.Z, e2top.Z );
609 
610  CLIPPER_Z_VALUE newZval;
611 
612  if( e1ArcSegmentIndex != -1 )
613  {
614  newZval.m_FirstArcIdx = e1ArcSegmentIndex;
615  newZval.m_SecondArcIdx = e2ArcSegmentIndex;
616  }
617  else
618  {
619  newZval.m_FirstArcIdx = e2ArcSegmentIndex;
620  newZval.m_SecondArcIdx = -1;
621  }
622 
623  size_t z_value_ptr = zValues.size();
624  zValues.push_back( newZval );
625 
626  // Only worry about arc segments for later processing
627  if( newZval.m_FirstArcIdx != -1 )
628  newIntersectPoints.insert( { VECTOR2I( pt.X, pt.Y ), newZval } );
629 
630  pt.Z = z_value_ptr;
631  //@todo amend X,Y values to true intersection between arcs or arc and segment
632  };
633 
634  c.ZFillFunction( callback ); // register callback
635 
636  c.Execute( aType, solution, ClipperLib::pftNonZero, ClipperLib::pftNonZero );
637 
638  importTree( &solution, zValues, arcBuffer );
639 
640  // amend arcs for the intersection points
641  for( auto& poly : m_polys )
642  {
643  for( size_t i = 0; i < poly.size(); i++ )
644  {
645  for( int j = 0; j < poly[i].PointCount(); j++ )
646  {
647  const VECTOR2I& pt = poly[i].CPoint( j );
648 
649  if( newIntersectPoints.find( pt ) != newIntersectPoints.end() )
650  {
651  const std::pair<ssize_t, ssize_t>& shape = poly[i].CShapes()[j];
652  CLIPPER_Z_VALUE zval = newIntersectPoints.at( pt );
653 
654  // Fixup arc end points to match the new intersection points found in clipper
655  // @todo consider editing the intersection point to be the "true" arc
656  // intersection.
657  if( poly[i].IsSharedPt( j ) )
658  {
659  poly[i].amendArcEnd( shape.first, pt );
660  poly[i].amendArcStart( shape.second, pt );
661  }
662  else if( poly[i].IsArcStart( j ) )
663  {
664  poly[i].amendArcStart( shape.first, pt );
665  }
666  else if( poly[i].IsArcEnd( j ) )
667  {
668  poly[i].amendArcEnd( shape.first, pt );
669  }
670  else
671  {
672  poly[i].splitArc( j );
673  }
674  }
675  }
676  }
677 
678  }
679 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
Define a general 2D-vector/point.
Definition: vector2d.h:61
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
int ArcCount() const
Appends all the arcs in this polyset to aArcBuffer.
Holds information on each point of a SHAPE_LINE_CHAIN that is retrievable after an operation with Cli...
void importTree(ClipperLib::PolyTree *tree, const std::vector< CLIPPER_Z_VALUE > &aZValueBuffer, const std::vector< SHAPE_ARC > &aArcBuffe)

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

◆ BooleanSubtract() [1/2]

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

◆ BooleanSubtract() [2/2]

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

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

Definition at line 707 of file shape_poly_set.cpp.

709 {
710  booleanOp( ClipperLib::ctDifference, a, b, aFastMode );
711 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
This is the engine to execute all polygon boolean transforms (AND, OR, ...

References booleanOp().

◆ BuildBBoxCaches()

void SHAPE_POLY_SET::BuildBBoxCaches ( ) const

Construct BBoxCaches for Contains(), below.

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

Definition at line 1706 of file shape_poly_set.cpp.

1707 {
1708  for( int polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
1709  {
1710  COutline( polygonIdx ).GenerateBBoxCache();
1711 
1712  for( int holeIdx = 0; holeIdx < HoleCount( polygonIdx ); holeIdx++ )
1713  CHole( polygonIdx, holeIdx ).GenerateBBoxCache();
1714  }
1715 }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
int HoleCount(int aOutline) const
Return the reference to aIndex-th outline in the set.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
void GenerateBBoxCache() const

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

Referenced by ZONE_FILLER::computeRawFilledArea().

◆ CacheTriangulation()

void SHAPE_POLY_SET::CacheTriangulation ( bool  aPartition = true)

Definition at line 2303 of file shape_poly_set.cpp.

2304 {
2305  bool recalculate = !m_hash.IsValid();
2306  MD5_HASH hash;
2307 
2308  if( !m_triangulationValid )
2309  recalculate = true;
2310 
2311  if( !recalculate )
2312  {
2313  hash = checksum();
2314 
2315  if( m_hash != hash )
2316  {
2317  m_hash = hash;
2318  recalculate = true;
2319  }
2320  }
2321 
2322  if( !recalculate )
2323  return;
2324 
2325  SHAPE_POLY_SET tmpSet;
2326 
2327  if( aPartition )
2328  {
2329  // This partitions into regularly-sized grids (1cm in Pcbnew)
2330  SHAPE_POLY_SET flattened( *this );
2331  flattened.ClearArcs();
2332  partitionPolyIntoRegularCellGrid( flattened, 1e7, tmpSet );
2333  }
2334  else
2335  {
2336  tmpSet = *this;
2337 
2338  if( tmpSet.HasHoles() )
2339  tmpSet.Fracture( PM_FAST );
2340  }
2341 
2342  m_triangulatedPolys.clear();
2343  m_triangulationValid = false;
2344 
2345  while( tmpSet.OutlineCount() > 0 )
2346  {
2347  m_triangulatedPolys.push_back( std::make_unique<TRIANGULATED_POLYGON>() );
2348  PolygonTriangulation tess( *m_triangulatedPolys.back() );
2349 
2350  // If the tessellation fails, we re-fracture the polygon, which will
2351  // first simplify the system before fracturing and removing the holes
2352  // This may result in multiple, disjoint polygons.
2353  if( !tess.TesselatePolygon( tmpSet.Polygon( 0 ).front() ) )
2354  {
2355  tmpSet.Fracture( PM_FAST );
2356  m_triangulationValid = false;
2357  continue;
2358  }
2359 
2360  tmpSet.DeletePolygon( 0 );
2361  m_triangulationValid = true;
2362  }
2363 
2364  if( m_triangulationValid )
2365  m_hash = checksum();
2366 }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
bool HasHoles() const
Return true if the polygon set has any holes that share a vertex.
MD5_HASH checksum() const
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
void DeletePolygon(int aIdx)
static void partitionPolyIntoRegularCellGrid(const SHAPE_POLY_SET &aPoly, int aSize, SHAPE_POLY_SET &aOut)
Represent a set of closed polygons.
void Fracture(POLYGON_MODE aFastMode)
Convert a single outline slitted ("fractured") polygon into a set ouf outlines with holes.
POLYGON & Polygon(int aIndex)
bool IsValid() const
Definition: md5_hash.h:24

References checksum(), ClearArcs(), 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 704 of file wrlfacet.cpp.

706 {
707  if( facets.empty() || !facets.front()->HasMinPoints() )
708  return nullptr;
709 
710  std::vector< std::list< FACET* > > flist;
711 
712  // determine the max. index and size flist as appropriate
713  std::list< FACET* >::iterator sF = facets.begin();
714  std::list< FACET* >::iterator eF = facets.end();
715 
716  int maxIdx = 0;
717  int tmi;
718  float maxV = 0.0;
719  float tV = 0.0;
720 
721  while( sF != eF )
722  {
723  tV = ( *sF )->CalcFaceNormal();
724  tmi = ( *sF )->GetMaxIndex();
725 
726  if( tmi > maxIdx )
727  maxIdx = tmi;
728 
729  if( tV > maxV )
730  maxV = tV;
731 
732  ++sF;
733  }
734 
735  ++maxIdx;
736 
737  if( maxIdx < 3 )
738  return nullptr;
739 
740  flist.resize( maxIdx );
741 
742  // create the lists of facets common to indices
743  sF = facets.begin();
744 
745  while( sF != eF )
746  {
747  ( *sF )->Renormalize( tV );
748  ( *sF )->CollectVertices( flist );
749  ++sF;
750  }
751 
752  // calculate the normals
753  size_t vs = flist.size();
754 
755  for( size_t i = 0; i < vs; ++i )
756  {
757  sF = flist[i].begin();
758  eF = flist[i].end();
759 
760  while( sF != eF )
761  {
762  ( *sF )->CalcVertexNormal( static_cast<int>( i ), flist[i], aCreaseLimit );
763  ++sF;
764  }
765  }
766 
767  std::vector< WRLVEC3F > vertices;
768  std::vector< WRLVEC3F > normals;
769  std::vector< SGCOLOR > colors;
770 
771  // push the facet data to the final output list
772  sF = facets.begin();
773  eF = facets.end();
774 
775  while( sF != eF )
776  {
777  ( *sF )->GetData( vertices, normals, colors, aVertexOrder );
778  ++sF;
779  }
780 
781  flist.clear();
782 
783  if( vertices.size() < 3 )
784  return nullptr;
785 
786  IFSG_SHAPE shapeNode( false );
787 
788  if( !isVRML2 )
789  {
790  shapeNode.NewNode( aParent );
791 
792  if( aColor )
793  {
794  if( nullptr == S3D::GetSGNodeParent( aColor ) )
795  shapeNode.AddChildNode( aColor );
796  else
797  shapeNode.AddRefNode( aColor );
798  }
799  }
800 
801  std::vector< SGPOINT > lCPts; // vertex points in SGPOINT (double) format
802  std::vector< SGVECTOR > lCNorm; // per-vertex normals
803  vs = vertices.size();
804 
805  for( size_t i = 0; i < vs; ++i )
806  {
807  SGPOINT pt;
808  pt.x = vertices[i].x;
809  pt.y = vertices[i].y;
810  pt.z = vertices[i].z;
811  lCPts.push_back( pt );
812  lCNorm.emplace_back( normals[i].x, normals[i].y, normals[i].z );
813  }
814 
815  vertices.clear();
816  normals.clear();
817 
818  IFSG_FACESET fsNode( false );
819 
820  if( !isVRML2 )
821  fsNode.NewNode( shapeNode );
822  else
823  fsNode.NewNode( aParent );
824 
825  IFSG_COORDS cpNode( fsNode );
826  cpNode.SetCoordsList( lCPts.size(), &lCPts[0] );
827  IFSG_COORDINDEX ciNode( fsNode );
828 
829  for( int i = 0; i < (int)lCPts.size(); ++i )
830  ciNode.AddIndex( i );
831 
832  IFSG_NORMALS nmNode( fsNode );
833  nmNode.SetNormalList( lCNorm.size(), &lCNorm[0] );
834 
835  if( !colors.empty() )
836  {
837  IFSG_COLORS nmColor( fsNode );
838  nmColor.SetColorList( colors.size(), &colors[0] );
839  colors.clear();
840  }
841 
842  if( !isVRML2 )
843  return shapeNode.GetRawPtr();
844 
845  return fsNode.GetRawPtr();
846 }
double x
Definition: sg_base.h:70
IFSG_COORDS is the wrapper for SGCOORDS.
Definition: ifsg_coords.h:40
IFSG_COORDINDEX is the wrapper for SGCOORDINDEX.
IFSG_COLORS is the wrapper for SGCOLORS.
Definition: ifsg_colors.h:41
SGLIB_API SGNODE * GetSGNodeParent(SGNODE *aNode)
Definition: ifsg_api.cpp:492
double y
Definition: sg_base.h:71
IFSG_NORMALS is the wrapper for the SGNORMALS class.
Definition: ifsg_normals.h:40
std::list< FACET * > facets
Definition: wrlfacet.h:143
IFSG_FACESET is the wrapper for the SGFACESET class.
Definition: ifsg_faceset.h:40
double z
Definition: sg_base.h:72
IFSG_SHAPE is the wrapper for the SGSHAPE class.
Definition: ifsg_shape.h:40

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

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

◆ Centre()

virtual VECTOR2I SHAPE::Centre ( ) const
inlinevirtualinherited

Compute a center-of-mass of the shape.

Returns
the center-of-mass point

Definition at line 216 of file shape.h.

217  {
218  return BBox( 0 ).Centre(); // if nothing better is available....
219  }
virtual const BOX2I BBox(int aClearance=0) const =0
Compute a bounding box of the shape, with a margin of aClearance a collision.
Vec Centre() const
Definition: box2.h:63

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

Referenced by Collide().

◆ Chamfer()

SHAPE_POLY_SET SHAPE_POLY_SET::Chamfer ( int  aDistance)

Return a chamfered version of the polygon set.

Parameters
aDistanceis the chamfering distance.
Returns
A set containing the chamfered version of this set.

Definition at line 2003 of file shape_poly_set.cpp.

2004 {
2005  SHAPE_POLY_SET chamfered;
2006 
2007  for( unsigned int idx = 0; idx < m_polys.size(); idx++ )
2008  chamfered.m_polys.push_back( ChamferPolygon( aDistance, idx ) );
2009 
2010  return chamfered;
2011 }
Represent a set of closed polygons.
POLYGON ChamferPolygon(unsigned int aDistance, int aIndex)
Return a chamfered version of the aIndex-th polygon.

References ChamferPolygon(), and m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone().

◆ chamferFilletPolygon()

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

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

Parameters
aModerepresent 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.
aDistanceis the chamfering distance if aMode = CHAMFERED; if aMode = FILLETED, is the filleting radius.
aIndexis the index of the polygon that will be chamfered/filleted.
aErrorMaxis the maximum allowable deviation of the polygon from the circle if aMode = FILLETED. If aMode = CHAMFERED, it is unused.
Returns
the chamfered/filleted version of the polygon.Return true if the polygon set has any holes that touch share a vertex.

Definition at line 2025 of file shape_poly_set.cpp.

2028 {
2029  // Null segments create serious issues in calculations. Remove them:
2031 
2032  SHAPE_POLY_SET::POLYGON currentPoly = Polygon( aIndex );
2033  SHAPE_POLY_SET::POLYGON newPoly;
2034 
2035  // If the chamfering distance is zero, then the polygon remain intact.
2036  if( aDistance == 0 )
2037  {
2038  return currentPoly;
2039  }
2040 
2041  // Iterate through all the contours (outline and holes) of the polygon.
2042  for( SHAPE_LINE_CHAIN& currContour : currentPoly )
2043  {
2044  // Generate a new contour in the new polygon
2045  SHAPE_LINE_CHAIN newContour;
2046 
2047  // Iterate through the vertices of the contour
2048  for( int currVertex = 0; currVertex < currContour.PointCount(); currVertex++ )
2049  {
2050  // Current vertex
2051  int x1 = currContour.CPoint( currVertex ).x;
2052  int y1 = currContour.CPoint( currVertex ).y;
2053 
2054  // Indices for previous and next vertices.
2055  int prevVertex;
2056  int nextVertex;
2057 
2058  // Previous and next vertices indices computation. Necessary to manage the edge cases.
2059 
2060  // Previous vertex is the last one if the current vertex is the first one
2061  prevVertex = currVertex == 0 ? currContour.PointCount() - 1 : currVertex - 1;
2062 
2063  // next vertex is the first one if the current vertex is the last one.
2064  nextVertex = currVertex == currContour.PointCount() - 1 ? 0 : currVertex + 1;
2065 
2066  // Previous vertex computation
2067  double xa = currContour.CPoint( prevVertex ).x - x1;
2068  double ya = currContour.CPoint( prevVertex ).y - y1;
2069 
2070  // Next vertex computation
2071  double xb = currContour.CPoint( nextVertex ).x - x1;
2072  double yb = currContour.CPoint( nextVertex ).y - y1;
2073 
2074  // Compute the new distances
2075  double lena = hypot( xa, ya );
2076  double lenb = hypot( xb, yb );
2077 
2078  // Make the final computations depending on the mode selected, chamfered or filleted.
2079  if( aMode == CORNER_MODE::CHAMFERED )
2080  {
2081  double distance = aDistance;
2082 
2083  // Chamfer one half of an edge at most
2084  if( 0.5 * lena < distance )
2085  distance = 0.5 * lena;
2086 
2087  if( 0.5 * lenb < distance )
2088  distance = 0.5 * lenb;
2089 
2090  int nx1 = KiROUND( distance * xa / lena );
2091  int ny1 = KiROUND( distance * ya / lena );
2092 
2093  newContour.Append( x1 + nx1, y1 + ny1 );
2094 
2095  int nx2 = KiROUND( distance * xb / lenb );
2096  int ny2 = KiROUND( distance * yb / lenb );
2097 
2098  newContour.Append( x1 + nx2, y1 + ny2 );
2099  }
2100  else // CORNER_MODE = FILLETED
2101  {
2102  double cosine = ( xa * xb + ya * yb ) / ( lena * lenb );
2103 
2104  double radius = aDistance;
2105  double denom = sqrt( 2.0 / ( 1 + cosine ) - 1 );
2106 
2107  // Do nothing in case of parallel edges
2108  if( std::isinf( denom ) )
2109  continue;
2110 
2111  // Limit rounding distance to one half of an edge
2112  if( 0.5 * lena * denom < radius )
2113  radius = 0.5 * lena * denom;
2114 
2115  if( 0.5 * lenb * denom < radius )
2116  radius = 0.5 * lenb * denom;
2117 
2118  // Calculate fillet arc absolute center point (xc, yx)
2119  double k = radius / sqrt( .5 * ( 1 - cosine ) );
2120  double lenab = sqrt( ( xa / lena + xb / lenb ) * ( xa / lena + xb / lenb ) +
2121  ( ya / lena + yb / lenb ) * ( ya / lena + yb / lenb ) );
2122  double xc = x1 + k * ( xa / lena + xb / lenb ) / lenab;
2123  double yc = y1 + k * ( ya / lena + yb / lenb ) / lenab;
2124 
2125  // Calculate arc start and end vectors
2126  k = radius / sqrt( 2 / ( 1 + cosine ) - 1 );
2127  double xs = x1 + k * xa / lena - xc;
2128  double ys = y1 + k * ya / lena - yc;
2129  double xe = x1 + k * xb / lenb - xc;
2130  double ye = y1 + k * yb / lenb - yc;
2131 
2132  // Cosine of arc angle
2133  double argument = ( xs * xe + ys * ye ) / ( radius * radius );
2134 
2135  // Make sure the argument is in [-1,1], interval in which the acos function is
2136  // defined
2137  if( argument < -1 )
2138  argument = -1;
2139  else if( argument > 1 )
2140  argument = 1;
2141 
2142  double arcAngle = acos( argument );
2143  double arcAngleDegrees = arcAngle * 180.0 / M_PI;
2144  int segments = GetArcToSegmentCount( radius, aErrorMax, arcAngleDegrees );
2145 
2146  double deltaAngle = arcAngle / segments;
2147  double startAngle = atan2( -ys, xs );
2148 
2149  // Flip arc for inner corners
2150  if( xa * yb - ya * xb <= 0 )
2151  deltaAngle *= -1;
2152 
2153  double nx = xc + xs;
2154  double ny = yc + ys;
2155 
2156  newContour.Append( KiROUND( nx ), KiROUND( ny ) );
2157 
2158  // Store the previous added corner to make a sanity check
2159  int prevX = KiROUND( nx );
2160  int prevY = KiROUND( ny );
2161 
2162  for( int j = 0; j < segments; j++ )
2163  {
2164  nx = xc + cos( startAngle + ( j + 1 ) * deltaAngle ) * radius;
2165  ny = yc - sin( startAngle + ( j + 1 ) * deltaAngle ) * radius;
2166 
2167  // Sanity check: the rounding can produce repeated corners; do not add them.
2168  if( KiROUND( nx ) != prevX || KiROUND( ny ) != prevY )
2169  {
2170  newContour.Append( KiROUND( nx ), KiROUND( ny ) );
2171  prevX = KiROUND( nx );
2172  prevY = KiROUND( ny );
2173  }
2174  }
2175  }
2176  }
2177 
2178  // Close the current contour and add it the new polygon
2179  newContour.SetClosed( true );
2180  newPoly.push_back( newContour );
2181  }
2182 
2183  return newPoly;
2184 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)
int RemoveNullSegments()
Look for null segments; ie, segments whose ends are exactly the same and deletes them.
Represent a polyline (an zero-thickness chain of connected line segments).
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:73
POLYGON & Polygon(int aIndex)
int GetArcToSegmentCount(int aRadius, int aErrorMax, double aArcAngleDegree)

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 
)

Return a chamfered version of the aIndex-th polygon.

Parameters
aDistanceis the chamfering distance.
aIndexis the index of the polygon to be chamfered.
Returns
A polygon containing the chamfered version of the aIndex-th polygon.

Definition at line 1854 of file shape_poly_set.cpp.

1855 {
1856  return chamferFilletPolygon( CHAMFERED, aDistance, aIndex, 0 );
1857 }
POLYGON chamferFilletPolygon(CORNER_MODE aMode, unsigned int aDistance, int aIndex, int aErrorMax)
Return the chamfered or filleted version of the aIndex-th polygon in the set, depending on the aMode ...

References CHAMFERED, and chamferFilletPolygon().

Referenced by Chamfer().

◆ checksum()

MD5_HASH SHAPE_POLY_SET::checksum ( ) const
private

Definition at line 2369 of file shape_poly_set.cpp.

2370 {
2371  MD5_HASH hash;
2372 
2373  hash.Hash( m_polys.size() );
2374 
2375  for( const POLYGON& outline : m_polys )
2376  {
2377  hash.Hash( outline.size() );
2378 
2379  for( const SHAPE_LINE_CHAIN& lc : outline )
2380  {
2381  hash.Hash( lc.PointCount() );
2382 
2383  for( int i = 0; i < lc.PointCount(); i++ )
2384  {
2385  hash.Hash( lc.CPoint( i ).x );
2386  hash.Hash( lc.CPoint( i ).y );
2387  }
2388  }
2389  }
2390 
2391  hash.Finalize();
2392 
2393  return hash;
2394 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
void Hash(uint8_t *data, uint32_t length)
Definition: md5_hash.cpp:65
Represent a polyline (an zero-thickness chain of connected line segments).
void Finalize()
Definition: md5_hash.cpp:75

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

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

◆ CHole()

◆ CIterate() [1/3]

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

Definition at line 789 of file shape_poly_set.h.

790  {
791  CONST_ITERATOR iter;
792 
793  iter.m_poly = const_cast<SHAPE_POLY_SET*>( this );
794  iter.m_currentPolygon = aFirst;
795  iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
796  iter.m_currentContour = 0;
797  iter.m_currentVertex = 0;
798  iter.m_iterateHoles = aIterateHoles;
799 
800  return iter;
801  }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
ITERATOR_TEMPLATE< const VECTOR2I > CONST_ITERATOR

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_SHAPE::GetBoundingBox(), ZONE::GetInteractingZones(), and PNS_KICAD_IFACE_BASE::syncPad().

◆ CIterate() [2/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( int  aOutline) const
inline

Definition at line 803 of file shape_poly_set.h.

804  {
805  return CIterate( aOutline, aOutline );
806  }
CONST_ITERATOR CIterate() const

References CIterate().

◆ CIterate() [3/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( ) const
inline

Definition at line 813 of file shape_poly_set.h.

814  {
815  return CIterate( 0, OutlineCount() - 1 );
816  }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
CONST_ITERATOR CIterate() const

References OutlineCount().

Referenced by CIterate(), and CIterateWithHoles().

◆ CIterateSegments() [1/3]

◆ CIterateSegments() [2/3]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegments ( int  aPolygonIdx) const
inline

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

Definition at line 882 of file shape_poly_set.h.

References CIterateSegments().

◆ CIterateSegments() [3/3]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegments ( ) const
inline

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

Definition at line 894 of file shape_poly_set.h.

References OutlineCount().

Referenced by CIterateSegments(), and CIterateSegmentsWithHoles().

◆ CIterateSegmentsWithHoles() [1/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegmentsWithHoles ( ) const
inline

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

Definition at line 912 of file shape_poly_set.h.

References CIterateSegments(), and OutlineCount().

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

◆ CIterateSegmentsWithHoles() [2/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegmentsWithHoles ( int  aOutline) const
inline

Definition at line 918 of file shape_poly_set.h.

919  {
920  return CIterateSegments( aOutline, aOutline, true );
921  }
CONST_SEGMENT_ITERATOR CIterateSegments() const
Returns an iterator object, for all outlines in the set (with holes)

References CIterateSegments().

◆ CIterateWithHoles() [1/2]

CONST_ITERATOR SHAPE_POLY_SET::CIterateWithHoles ( int  aOutline) const
inline

Definition at line 808 of file shape_poly_set.h.

809  {
810  return CIterate( aOutline, aOutline, true );
811  }
CONST_ITERATOR CIterate() const

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

819  {
820  return CIterate( 0, OutlineCount() - 1, true );
821  }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
CONST_ITERATOR CIterate() const

References CIterate(), and OutlineCount().

Referenced by CollideVertex().

◆ ClearArcs()

void SHAPE_POLY_SET::ClearArcs ( )

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

Definition at line 520 of file shape_poly_set.cpp.

521 {
522  for( POLYGON& poly : m_polys )
523  {
524  for( size_t i = 0; i < poly.size(); i++ )
525  poly[i].ClearArcs();
526  }
527 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
void ClearArcs()
Appends a vertex at the end of the given outline/hole (default: the last outline)

References m_polys.

Referenced by BOOST_AUTO_TEST_CASE(), and CacheTriangulation().

◆ Clone()

SHAPE * SHAPE_POLY_SET::Clone ( ) const
overridevirtual

Return a dynamically allocated copy of the shape.

Return values
copyof the shape Creates a new empty polygon in the set and returns its index

Reimplemented from SHAPE.

Definition at line 101 of file shape_poly_set.cpp.

102 {
103  return new SHAPE_POLY_SET( *this );
104 }

References SHAPE_POLY_SET().

◆ Collide() [1/4]

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

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

Parameters
aShapeshape to check collision against
aClearanceminimum clearance
aMTVminimum 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 917 of file shape_collisions.cpp.

918 {
919  return collideShapes( this, aShape, aClearance, nullptr, nullptr, aMTV );
920 }
static bool collideShapes(const SHAPE *aA, const SHAPE *aB, int aClearance, int *aActual, VECTOR2I *aLocation, VECTOR2I *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

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

Parameters
aShapeshape to check collision against
aClearanceminimum 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 1473 of file shape_poly_set.cpp.

1475 {
1476  // A couple of simple cases are worth trying before we fall back on triangulation.
1477 
1478  if( aShape->Type() == SH_SEGMENT )
1479  {
1480  const SHAPE_SEGMENT* segment = static_cast<const SHAPE_SEGMENT*>( aShape );
1481  int extra = segment->GetWidth() / 2;
1482 
1483  if( Collide( segment->GetSeg(), aClearance + extra, aActual, aLocation ) )
1484  {
1485  if( aActual )
1486  *aActual = std::max( 0, *aActual - extra );
1487 
1488  return true;
1489  }
1490 
1491  return false;
1492  }
1493 
1494  if( aShape->Type() == SH_CIRCLE )
1495  {
1496  const SHAPE_CIRCLE* circle = static_cast<const SHAPE_CIRCLE*>( aShape );
1497  int extra = circle->GetRadius();
1498 
1499  if( Collide( circle->GetCenter(), aClearance + extra, aActual, aLocation ) )
1500  {
1501  if( aActual )
1502  *aActual = std::max( 0, *aActual - extra );
1503 
1504  return true;
1505  }
1506 
1507  return false;
1508  }
1509 
1510  const_cast<SHAPE_POLY_SET*>( this )->CacheTriangulation( true );
1511 
1512  int actual = INT_MAX;
1513  VECTOR2I location;
1514 
1515  for( const std::unique_ptr<TRIANGULATED_POLYGON>& tpoly : m_triangulatedPolys )
1516  {
1517  for( const TRIANGULATED_POLYGON::TRI& tri : tpoly->Triangles() )
1518  {
1519  int triActual;
1520  VECTOR2I triLocation;
1521 
1522  if( aShape->Collide( &tri, aClearance, &triActual, &triLocation ) )
1523  {
1524  if( !aActual && !aLocation )
1525  return true;
1526 
1527  if( triActual < actual )
1528  {
1529  actual = triActual;
1530  location = triLocation;
1531  }
1532  }
1533  }
1534  }
1535 
1536  if( actual < INT_MAX )
1537  {
1538  if( aActual )
1539  *aActual = std::max( 0, actual );
1540 
1541  if( aLocation )
1542  *aLocation = location;
1543 
1544  return true;
1545  }
1546 
1547  return false;
1548 }
int GetRadius() const
Definition: shape_circle.h:107
Define a general 2D-vector/point.
Definition: vector2d.h:61
const VECTOR2I GetCenter() const
Definition: shape_circle.h:112
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
virtual bool Collide(const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const
Check if the boundary of shape (this) lies closer to the point aP than aClearance,...
Definition: shape.h:165
const SEG & GetSeg() const
circle
Definition: shape.h:46
bool Collide(const SHAPE *aShape, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
Check if the boundary of shape (this) lies closer to the shape aShape than aClearance,...
int GetWidth() const
SHAPE_TYPE Type() const
Return the type of the shape.
Definition: shape.h:94
line segment
Definition: shape.h:44

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 DS_DRAW_ITEM_POLYPOLYGONS::HitTest(), PCB_SHAPE::HitTest(), FOOTPRINT::HitTestAccurate(), PCB_SELECTION_TOOL::hitTestDistance(), insideArea(), insideFootprintCourtyard(), 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

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

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

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

Parameters
aPis the VECTOR2I point whose collision with respect to the poly set will be tested.
aClearanceis the security distance; if the point lies closer to the polygon than aClearance distance, then there is a collision.
aActualan optional pointer to an int to store the actual distance in the event of a collision.
Returns
true if the point aP collides with the polygon; false in any other case.

Reimplemented from SHAPE.

Definition at line 1452 of file shape_poly_set.cpp.

1454 {
1455  VECTOR2I nearest;
1456  ecoord dist_sq = SquaredDistance( aP, aLocation ? &nearest : nullptr );
1457 
1458  if( dist_sq == 0 || dist_sq < SEG::Square( aClearance ) )
1459  {
1460  if( aLocation )
1461  *aLocation = nearest;
1462 
1463  if( aActual )
1464  *aActual = sqrt( dist_sq );
1465 
1466  return true;
1467  }
1468 
1469  return false;
1470 }
Define a general 2D-vector/point.
Definition: vector2d.h:61
static SEG::ecoord Square(int a)
Definition: seg.h:122
SEG::ecoord SquaredDistance(VECTOR2I aPoint, VECTOR2I *aNearest=nullptr) const
Compute the minimum distance squared between aPoint and all the polygons in the set.
VECTOR2I::extended_type ecoord

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

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

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

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

Parameters
aSegis the SEG segment whose collision with respect to the poly set will be tested.
aClearanceis the security distance; if the segment passes closer to the polygon than aClearance distance, then there is a collision.
aActualan optional pointer to an int to store the actual distance in the event of a collision.
Returns
true if the segment aSeg collides with the polygon, false in any other case.

Implements SHAPE.

Definition at line 1431 of file shape_poly_set.cpp.

1433 {
1434  VECTOR2I nearest;
1435  ecoord dist_sq = SquaredDistance( aSeg, aLocation ? &nearest : nullptr );
1436 
1437  if( dist_sq == 0 || dist_sq < SEG::Square( aClearance ) )
1438  {
1439  if( aLocation )
1440  *aLocation = nearest;
1441 
1442  if( aActual )
1443  *aActual = sqrt( dist_sq );
1444 
1445  return true;
1446  }
1447 
1448  return false;
1449 }
Define a general 2D-vector/point.
Definition: vector2d.h:61
static SEG::ecoord Square(int a)
Definition: seg.h:122
SEG::ecoord SquaredDistance(VECTOR2I aPoint, VECTOR2I *aNearest=nullptr) const
Compute the minimum distance squared between aPoint and all the polygons in the set.
VECTOR2I::extended_type ecoord

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

◆ CollideEdge()

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

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

Parameters
aPointis the VECTOR2I point whose collision with respect to the polygon will be tested.
aClearanceis the security distance; if aPoint lies closer to a vertex than aClearance distance, then there is a collision.
aClosestVertexis the index of the closes vertex to aPoint.
Returns
bool - true if there is a collision, false in any other case.

Definition at line 1677 of file shape_poly_set.cpp.

1680 {
1681  // Shows whether there was a collision
1682  bool collision = false;
1683 
1684  for( CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles(); iterator; iterator++ )
1685  {
1686  const SEG currentSegment = *iterator;
1687  int distance = currentSegment.Distance( aPoint );
1688 
1689  // Check for collisions
1690  if( distance <= aClearance )
1691  {
1692  collision = true;
1693 
1694  // Update aClearance to look for closer edges
1695  aClearance = distance;
1696 
1697  // Store the indices that identify the vertex
1698  aClosestVertex = iterator.GetIndex();
1699  }
1700  }
1701 
1702  return collision;
1703 }
int Distance(const SEG &aSeg) const
Compute minimum Euclidean distance to segment aSeg.
Definition: seg.cpp:285
SEGMENT_ITERATOR_TEMPLATE< const SEG > CONST_SEGMENT_ITERATOR
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles() const
Return an iterator object, for the aOutline-th outline in the set (with holes).
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)
Definition: seg.h:40

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

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

Parameters
aPointis the VECTOR2I point whose collision with respect to the polygon will be tested.
aClearanceis the security distance; if aPoint lies closer to a vertex than aClearance distance, then there is a collision.
aClosestVertexis the index of the closes vertex to aPoint.
Returns
bool - true if there is a collision, false in any other case.

Definition at line 1638 of file shape_poly_set.cpp.

1641 {
1642  // Shows whether there was a collision
1643  bool collision = false;
1644 
1645  // Difference vector between each vertex and aPoint.
1646  VECTOR2D delta;
1647  double distance, clearance;
1648 
1649  // Convert clearance to double for precision when comparing distances
1650  clearance = aClearance;
1651 
1652  for( CONST_ITERATOR iterator = CIterateWithHoles(); iterator; iterator++ )
1653  {
1654  // Get the difference vector between current vertex and aPoint
1655  delta = *iterator - aPoint;
1656 
1657  // Compute distance
1658  distance = delta.EuclideanNorm();
1659 
1660  // Check for collisions
1661  if( distance <= clearance )
1662  {
1663  collision = true;
1664 
1665  // Update aClearance to look for closer vertices
1666  clearance = distance;
1667 
1668  // Store the indices that identify the vertex
1669  aClosestVertex = iterator.GetIndex();
1670  }
1671  }
1672 
1673  return collision;
1674 }
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)
ITERATOR_TEMPLATE< const VECTOR2I > CONST_ITERATOR
T EuclideanNorm() const
Compute the Euclidean norm of the vector, which is defined as sqrt(x ** 2 + y ** 2).
Definition: vector2d.h:293
CONST_ITERATOR CIterateWithHoles() const

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

Return true if a given subpolygon contains the point aP.

Parameters
aPis the point to check
aSubpolyIndexis the subpolygon to check, or -1 to check all
aUseBBoxCachesgives 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 pointReturn true if the set is empty (no polygons at all)

Definition at line 1718 of file shape_poly_set.cpp.

1720 {
1721  if( m_polys.empty() )
1722  return false;
1723 
1724  // If there is a polygon specified, check the condition against that polygon
1725  if( aSubpolyIndex >= 0 )
1726  return containsSingle( aP, aSubpolyIndex, aAccuracy, aUseBBoxCaches );
1727 
1728  // In any other case, check it against all polygons in the set
1729  for( int polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
1730  {
1731  if( containsSingle( aP, polygonIdx, aAccuracy, aUseBBoxCaches ) )
1732  return true;
1733  }
1734 
1735  return false;
1736 }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
bool containsSingle(const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
Check whether the point aP is inside the aSubpolyIndex-th polygon of the polyset.

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(), PCB_DIMENSION_BASE::segPolyIntersection(), BOARD::TestZoneIntersection(), PCB_DIM_ALIGNED::updateGeometry(), and PCB_DIM_ORTHOGONAL::updateGeometry().

◆ containsSingle()

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

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

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

Parameters
aPis the VECTOR2I point whose position with respect to the inside of the aSubpolyIndex-th polygon will be tested.
aSubpolyIndexis an integer specifying which polygon in the set has to be checked.
aAccuracyaccuracy in internal units
aUseBBoxCachesgives faster performance when multiple calls are made with no editing in between, but the caller MUST cache the bbox caches before calling (via BuildBBoxCaches(), above)
Returns
true if aP is inside aSubpolyIndex-th polygon; false in any other case.

Definition at line 1774 of file shape_poly_set.cpp.

1776 {
1777  // Check that the point is inside the outline
1778  if( m_polys[aSubpolyIndex][0].PointInside( aP, aAccuracy ) )
1779  {
1780  // Check that the point is not in any of the holes
1781  for( int holeIdx = 0; holeIdx < HoleCount( aSubpolyIndex ); holeIdx++ )
1782  {
1783  const SHAPE_LINE_CHAIN& hole = CHole( aSubpolyIndex, holeIdx );
1784 
1785  // If the point is inside a hole it is outside of the polygon. Do not use aAccuracy
1786  // here as it's meaning would be inverted.
1787  if( hole.PointInside( aP, 1, aUseBBoxCaches ) )
1788  return false;
1789  }
1790 
1791  return true;
1792  }
1793 
1794  return false;
1795 }
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
bool PointInside(const VECTOR2I &aPt, int aAccuracy=0, bool aUseBBoxCache=false) const
Check if point aP lies inside a polygon (any type) defined by the line chain.
int HoleCount(int aOutline) const
Return the reference to aIndex-th outline in the set.
Represent a polyline (an zero-thickness chain of connected line segments).

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

◆ CPolygon()

◆ CVertex() [1/3]

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

Return the aGlobalIndex-th vertex in the poly set.

Definition at line 321 of file shape_poly_set.cpp.

322 {
323  if( aOutline < 0 )
324  aOutline += m_polys.size();
325 
326  int idx;
327 
328  if( aHole < 0 )
329  idx = 0;
330  else
331  idx = aHole + 1;
332 
333  assert( aOutline < (int) m_polys.size() );
334  assert( idx < (int) m_polys[aOutline].size() );
335 
336  return m_polys[aOutline][idx].CPoint( aIndex );
337 }

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

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

Definition at line 340 of file shape_poly_set.cpp.

341 {
343 
344  // Assure the passed index references a legal position; abort otherwise
345  if( !GetRelativeIndices( aGlobalIndex, &index ) )
346  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
347 
348  return m_polys[index.m_polygon][index.m_contour].CPoint( index.m_vertex );
349 }
Structure to hold the necessary information in order to index a vertex on a SHAPE_POLY_SET object: th...
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated lis...

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

Definition at line 352 of file shape_poly_set.cpp.

353 {
354  return CVertex( index.m_vertex, index.m_polygon, index.m_contour - 1 );
355 }
const VECTOR2I & CVertex(int aIndex, int aOutline, int aHole) const
Return the aGlobalIndex-th vertex in the poly set.

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

995  {
996  Inflate( -aAmount, aCircleSegmentsCount, aCornerStrategy );
997  }
void Inflate(int aAmount, int aCircleSegCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
Perform outline inflation/deflation.

References Inflate().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), ZONE_FILLER::computeRawFilledArea(), KIGFX::PCB_PAINTER::draw(), ZONE_FILLER::fillSingleZone(), insideArea(), ALTIUM_PCB::ParseRegions6Data(), and PlotSolderMaskLayer().

◆ DeletePolygon()

void SHAPE_POLY_SET::DeletePolygon ( int  aIdx)

Definition at line 1620 of file shape_poly_set.cpp.

1621 {
1622  m_polys.erase( m_polys.begin() + aIdx );
1623 }

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 
)

Return a filleted version of the polygon set.

Parameters
aRadiusis the fillet radius.
aErrorMaxis the maximum allowable deviation of the polygon from the circle
Returns
A set containing the filleted version of this set.

Definition at line 2014 of file shape_poly_set.cpp.

2015 {
2016  SHAPE_POLY_SET filleted;
2017 
2018  for( size_t idx = 0; idx < m_polys.size(); idx++ )
2019  filleted.m_polys.push_back( FilletPolygon( aRadius, aErrorMax, idx ) );
2020 
2021  return filleted;
2022 }
Represent a set of closed polygons.
POLYGON FilletPolygon(unsigned int aRadius, int aErrorMax, int aIndex)
Return a filleted version of the aIndex-th polygon.

References FilletPolygon(), and m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone().

◆ FilletPolygon()

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

Return a filleted version of the aIndex-th polygon.

Parameters
aRadiusis the fillet radius.
aErrorMaxis the maximum allowable deviation of the polygon from the circle
aIndexis the index of the polygon to be filleted
Returns
A polygon containing the filleted version of the aIndex-th polygon.

Definition at line 1860 of file shape_poly_set.cpp.

1862 {
1863  return chamferFilletPolygon( FILLETED, aRadius, aIndex, aErrorMax );
1864 }
POLYGON chamferFilletPolygon(CORNER_MODE aMode, unsigned int aDistance, int aIndex, int aErrorMax)
Return the chamfered or filleted version of the aIndex-th polygon in the set, depending on the aMode ...

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

1292 {
1293  std::stringstream ss;
1294 
1295  ss << "SHAPE_LINE_CHAIN poly; \n";
1296 
1297  for( unsigned i = 0; i < m_polys.size(); i++ )
1298  {
1299  for( unsigned j = 0; j < m_polys[i].size(); j++ )
1300  {
1301 
1302  ss << "{ auto tmp = " << m_polys[i][j].Format() << ";\n";
1303 
1304  SHAPE_POLY_SET poly;
1305 
1306  if( j == 0 )
1307  {
1308  ss << " poly.AddOutline(tmp); } \n";
1309  }
1310  else
1311  {
1312  ss << " poly.AddHole(tmp); } \n";
1313  }
1314 
1315  }
1316  }
1317 
1318  return ss.str();
1319 }
Represent a set of closed polygons.

References m_polys.

◆ Fracture()

void SHAPE_POLY_SET::Fracture ( POLYGON_MODE  aFastMode)

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

Definition at line 1055 of file shape_poly_set.cpp.

1056 {
1057  Simplify( aFastMode ); // remove overlapping holes/degeneracy
1058 
1059  for( POLYGON& paths : m_polys )
1060  fractureSingle( paths );
1061 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
void fractureSingle(POLYGON &paths)
void Simplify(POLYGON_MODE aFastMode)

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

Referenced by addHoleToPolygon(), PAD::addPadPrimitivesToPolygon(), PAD::AddPrimitivePoly(), CacheTriangulation(), ZONE_FILLER::computeRawFilledArea(), FOOTPRINT::CoverageRatio(), BITMAPCONV_INFO::createOutputData(), CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarShape(), AR_AUTOPLACER::drawPlacementRoutingMatrix(), EXPORTER_PCB_VRML::ExportStandardLayers(), EXPORTER_PCB_VRML::ExportVrmlSolderMask(), AR_AUTOPLACER::fillMatrix(), ZONE_FILLER::fillSingleZone(), APERTURE_MACRO::GetApertureMacroShape(), InflateWithLinkedHoles(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadShapePolySet(), ALTIUM_PCB::ParseRegions6Data(), 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 951 of file shape_poly_set.cpp.

952 {
953  FractureEdgeSet edges;
954  FractureEdgeSet border_edges;
955  FractureEdge* root = nullptr;
956 
957  bool first = true;
958 
959  if( paths.size() == 1 )
960  return;
961 
962  int num_unconnected = 0;
963 
964  for( const SHAPE_LINE_CHAIN& path : paths )
965  {
966  const std::vector<VECTOR2I>& points = path.CPoints();
967  int pointCount = points.size();
968 
969  FractureEdge* prev = nullptr, * first_edge = nullptr;
970 
971  int x_min = std::numeric_limits<int>::max();
972 
973  for( const VECTOR2I& p : points )
974  {
975  if( p.x < x_min )
976  x_min = p.x;
977  }
978 
979  for( int i = 0; i < pointCount; i++ )
980  {
981  // Do not use path.CPoint() here; open-coding it using the local variables "points"
982  // and "pointCount" gives a non-trivial performance boost to zone fill times.
983  FractureEdge* fe = new FractureEdge( first, points[ i ],
984  points[ i+1 == pointCount ? 0 : i+1 ] );
985 
986  if( !root )
987  root = fe;
988 
989  if( !first_edge )
990  first_edge = fe;
991 
992  if( prev )
993  prev->m_next = fe;
994 
995  if( i == pointCount - 1 )
996  fe->m_next = first_edge;
997 
998  prev = fe;
999  edges.push_back( fe );
1000 
1001  if( !first )
1002  {
1003  if( fe->m_p1.x == x_min )
1004  border_edges.push_back( fe );
1005  }
1006 
1007  if( !fe->m_connected )
1008  num_unconnected++;
1009  }
1010 
1011  first = false; // first path is always the outline
1012  }
1013 
1014  // keep connecting holes to the main outline, until there's no holes left...
1015  while( num_unconnected > 0 )
1016  {
1017  int x_min = std::numeric_limits<int>::max();
1018 
1019  FractureEdge* smallestX = nullptr;
1020 
1021  // find the left-most hole edge and merge with the outline
1022  for( FractureEdge* border_edge : border_edges )
1023  {
1024  int xt = border_edge->m_p1.x;
1025 
1026  if( ( xt < x_min ) && !border_edge->m_connected )
1027  {
1028  x_min = xt;
1029  smallestX = border_edge;
1030  }
1031  }
1032 
1033  num_unconnected -= processEdge( edges, smallestX );
1034  }
1035 
1036  paths.clear();
1037  SHAPE_LINE_CHAIN newPath;
1038 
1039  newPath.SetClosed( true );
1040 
1041  FractureEdge* e;
1042 
1043  for( e = root; e->m_next != root; e = e->m_next )
1044  newPath.Append( e->m_p1 );
1045 
1046  newPath.Append( e->m_p1 );
1047 
1048  for( FractureEdge* edge : edges )
1049  delete edge;
1050 
1051  paths.push_back( std::move( newPath ) );
1052 }
Define a general 2D-vector/point.
Definition: vector2d.h:61
static int processEdge(FractureEdgeSet &edges, FractureEdge *edge)
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
Represent a polyline (an zero-thickness chain of connected line segments).
FractureEdge * m_next
std::vector< FractureEdge * > FractureEdgeSet

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

Referenced by Fracture().

◆ GetArcs()

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

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

Definition at line 507 of file shape_poly_set.cpp.

508 {
509  for( const POLYGON& poly : m_polys )
510  {
511  for( size_t i = 0; i < poly.size(); i++ )
512  {
513  for( SHAPE_ARC arc : poly[i].m_arcs )
514  aArcBuffer.push_back( arc );
515  }
516  }
517 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.

References m_polys.

Referenced by BOOST_AUTO_TEST_CASE().

◆ GetGlobalIndex()

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

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

Parameters
aRelativeIndicesis the set of relative indices.
aGlobalIdx[out] is the computed global index.
Returns
true if the relative indices are correct; false otherwise. The computed global index is returned in the aGlobalIdx reference.

Definition at line 147 of file shape_poly_set.cpp.

149 {
150  int selectedVertex = aRelativeIndices.m_vertex;
151  unsigned int selectedContour = aRelativeIndices.m_contour;
152  unsigned int selectedPolygon = aRelativeIndices.m_polygon;
153 
154  // Check whether the vertex indices make sense in this poly set
155  if( selectedPolygon < m_polys.size() && selectedContour < m_polys[selectedPolygon].size()
156  && selectedVertex < m_polys[selectedPolygon][selectedContour].PointCount() )
157  {
158  POLYGON currentPolygon;
159 
160  aGlobalIdx = 0;
161 
162  for( unsigned int polygonIdx = 0; polygonIdx < selectedPolygon; polygonIdx++ )
163  {
164  currentPolygon = Polygon( polygonIdx );
165 
166  for( unsigned int contourIdx = 0; contourIdx < currentPolygon.size(); contourIdx++ )
167  aGlobalIdx += currentPolygon[contourIdx].PointCount();
168  }
169 
170  currentPolygon = Polygon( selectedPolygon );
171 
172  for( unsigned int contourIdx = 0; contourIdx < selectedContour; contourIdx++ )
173  aGlobalIdx += currentPolygon[contourIdx].PointCount();
174 
175  aGlobalIdx += selectedVertex;
176 
177  return true;
178  }
179  else
180  {
181  return false;
182  }
183 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
POLYGON & Polygon(int aIndex)

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

2211 {
2212  if( !m_hash.IsValid() )
2213  return checksum();
2214 
2215  return m_hash;
2216 }
MD5_HASH checksum() const
bool IsValid() const
Definition: md5_hash.h:24

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

2437 {
2438  size_t n = 0;
2439 
2440  for( const std::unique_ptr<TRIANGULATED_POLYGON>& t : m_triangulatedPolys )
2441  n += t->GetTriangleCount();
2442 
2443  return n;
2444 }
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys

References m_triangulatedPolys.

Referenced by GetIndexableSubshapes().

◆ GetIndexableSubshapes()

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

Reimplemented from SHAPE_BASE.

Definition at line 2447 of file shape_poly_set.cpp.

2448 {
2449  aSubshapes.reserve( GetIndexableSubshapeCount() );
2450 
2451  for( const std::unique_ptr<TRIANGULATED_POLYGON>& tpoly : m_triangulatedPolys )
2452  {
2453  for( TRIANGULATED_POLYGON::TRI& tri : tpoly->Triangles() )
2454  aSubshapes.push_back( &tri );
2455  }
2456 }
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
virtual size_t GetIndexableSubshapeCount() const override

References GetIndexableSubshapeCount(), and m_triangulatedPolys.

◆ GetNeighbourIndexes()

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

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

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

Parameters
aGlobalIndexis index of the corner, globally indexed between all edges in all contours
aPreviousis the globalIndex of the previous corner of the same contour.
aNextis the globalIndex of the next corner of the same contour.
Returns
true if OK, false if aGlobalIndex is out of range

Definition at line 358 of file shape_poly_set.cpp.

359 {
361 
362  // If the edge does not exist, throw an exception, it is an illegal access memory error
363  if( !GetRelativeIndices( aGlobalIndex, &index ) )
364  return false;
365 
366  // Calculate the previous and next index of aGlobalIndex, corresponding to
367  // the same contour;
368  VERTEX_INDEX inext = index;
369  int lastpoint = m_polys[index.m_polygon][index.m_contour].SegmentCount();
370 
371  if( index.m_vertex == 0 )
372  {
373  index.m_vertex = lastpoint;
374  inext.m_vertex = 1;
375  }
376  else if( index.m_vertex == lastpoint )
377  {
378  index.m_vertex--;
379  inext.m_vertex = 0;
380  }
381  else
382  {
383  inext.m_vertex++;
384  index.m_vertex--;
385  }
386 
387  if( aPrevious )
388  {
389  int previous;
390  GetGlobalIndex( index, previous );
391  *aPrevious = previous;
392  }
393 
394  if( aNext )
395  {
396  int next;
397  GetGlobalIndex( inext, next );
398  *aNext = next;
399  }
400 
401  return true;
402 }
CITER next(CITER it)
Definition: ptree.cpp:126
Structure to hold the necessary information in order to index a vertex on a SHAPE_POLY_SET object: th...
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated lis...
bool GetGlobalIndex(VERTEX_INDEX aRelativeIndices, int &aGlobalIdx) const
Compute the global index of a vertex from the relative indices of polygon, contour and vertex.

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

Referenced by ZONE::MoveEdge().

◆ GetRelativeIndices()

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

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

Parameters
aGlobalIdxis the global index of the corner whose structured index wants to be found
aRelativeIndicesis a pointer to the set of relative indices to store.
Returns
true if the global index is correct and the information in aRelativeIndices is valid; false otherwise.

Definition at line 107 of file shape_poly_set.cpp.

109 {
110  int polygonIdx = 0;
111  unsigned int contourIdx = 0;
112  int vertexIdx = 0;
113 
114  int currentGlobalIdx = 0;
115 
116  for( polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
117  {
118  const POLYGON& currentPolygon = CPolygon( polygonIdx );
119 
120  for( contourIdx = 0; contourIdx < currentPolygon.size(); contourIdx++ )
121  {
122  const SHAPE_LINE_CHAIN& currentContour = currentPolygon[contourIdx];
123  int totalPoints = currentContour.PointCount();
124 
125  for( vertexIdx = 0; vertexIdx < totalPoints; vertexIdx++ )
126  {
127  // Check if the current vertex is the globally indexed as aGlobalIdx
128  if( currentGlobalIdx == aGlobalIdx )
129  {
130  aRelativeIndices->m_polygon = polygonIdx;
131  aRelativeIndices->m_contour = contourIdx;
132  aRelativeIndices->m_vertex = vertexIdx;
133 
134  return true;
135  }
136 
137  // Advance
138  currentGlobalIdx++;
139  }
140  }
141  }
142 
143  return false;
144 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
const POLYGON & CPolygon(int aIndex) const
int OutlineCount() const
Return the number of vertices in a given outline/hole.
int PointCount() const
Return the number of points (vertices) in this line chain.
Represent a polyline (an zero-thickness chain of connected line segments).

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

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

◆ HasHoles()

bool SHAPE_POLY_SET::HasHoles ( ) const

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

Definition at line 1226 of file shape_poly_set.cpp.

1227 {
1228  // Iterate through all the polygons on the set
1229  for( const POLYGON& paths : m_polys )
1230  {
1231  // If any of them has more than one contour, it is a hole.
1232  if( paths.size() > 1 )
1233  return true;
1234  }
1235 
1236  // Return false if and only if every polygon has just one outline, without holes.
1237  return false;
1238 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.

References m_polys.

Referenced by CacheTriangulation().

◆ HasIndexableSubshapes()

bool SHAPE_POLY_SET::HasIndexableSubshapes ( ) const
overridevirtual

Reimplemented from SHAPE_BASE.

Definition at line 2430 of file shape_poly_set.cpp.

2431 {
2432  return IsTriangulationUpToDate();
2433 }
bool IsTriangulationUpToDate() const

References IsTriangulationUpToDate().

◆ HasTouchingHoles()

bool SHAPE_POLY_SET::HasTouchingHoles ( ) const

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

Definition at line 2397 of file shape_poly_set.cpp.

2398 {
2399  for( int i = 0; i < OutlineCount(); i++ )
2400  {
2401  if( hasTouchingHoles( CPolygon( i ) ) )
2402  return true;
2403  }
2404 
2405  return false;
2406 }
const POLYGON & CPolygon(int aIndex) const
int OutlineCount() const
Return the number of vertices in a given outline/hole.
bool hasTouchingHoles(const POLYGON &aPoly) const

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

◆ hasTouchingHoles()

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

Definition at line 2409 of file shape_poly_set.cpp.

2410 {
2411  std::set<long long> ptHashes;
2412 
2413  for( const SHAPE_LINE_CHAIN& lc : aPoly )
2414  {
2415  for( const VECTOR2I& pt : lc.CPoints() )
2416  {
2417  const long long ptHash = (long long) pt.x << 32 | pt.y;
2418 
2419  if( ptHashes.count( ptHash ) > 0 )
2420  return true;
2421 
2422  ptHashes.insert( ptHash );
2423  }
2424  }
2425 
2426  return false;
2427 }
Define a general 2D-vector/point.
Definition: vector2d.h:61
Represent a polyline (an zero-thickness chain of connected line segments).

Referenced by HasTouchingHoles().

◆ Hole()

◆ HoleCount()

◆ importTree()

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

Definition at line 821 of file shape_poly_set.cpp.

824 {
825  m_polys.clear();
826 
827  for( ClipperLib::PolyNode* n = tree->GetFirst(); n; n = n->GetNext() )
828  {
829  if( !n->IsHole() )
830  {
831  POLYGON paths;
832  paths.reserve( n->Childs.size() + 1 );
833 
834  paths.emplace_back( n->Contour, aZValueBuffer, aArcBuffer );
835 
836  for( unsigned int i = 0; i < n->Childs.size(); i++ )
837  paths.emplace_back( n->Childs[i]->Contour, aZValueBuffer, aArcBuffer );
838 
839  m_polys.push_back( paths );
840  }
841  }
842 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.

References m_polys.

Referenced by booleanOp(), and Inflate().

◆ Inflate()

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

Perform outline inflation/deflation.

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

Parameters
aAmountis the number of units to offset edges.
aCircleSegCountis the number of segments per 360 degrees to use in curve approx
aCornerStrategyALLOW_ACUTE_CORNERS to preserve all angles, CHAMFER_ACUTE_CORNERS to chop angles less than 90°, ROUND_ACUTE_CORNERS to round off angles less than 90°, ROUND_ALL_CORNERS to round regardless of angles

Definition at line 730 of file shape_poly_set.cpp.

731 {
732  using namespace ClipperLib;
733  // A static table to avoid repetitive calculations of the coefficient
734  // 1.0 - cos( M_PI / aCircleSegCount )
735  // aCircleSegCount is most of time <= 64 and usually 8, 12, 16, 32
736  #define SEG_CNT_MAX 64
737  static double arc_tolerance_factor[SEG_CNT_MAX + 1];
738 
739  ClipperOffset c;
740 
741  // N.B. see the Clipper documentation for jtSquare/jtMiter/jtRound. They are poorly named
742  // and are not what you'd think they are.
743  // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/JoinType.htm
744  JoinType joinType = jtRound; // The way corners are offsetted
745  double miterLimit = 2.0; // Smaller value when using jtMiter for joinType
746  JoinType miterFallback = jtSquare;
747 
748  switch( aCornerStrategy )
749  {
750  case ALLOW_ACUTE_CORNERS:
751  joinType = jtMiter;
752  miterLimit = 10; // Allows large spikes
753  miterFallback = jtSquare;
754  break;
755 
756  case CHAMFER_ACUTE_CORNERS: // Acute angles are chamfered
757  joinType = jtMiter;
758  miterFallback = jtRound;
759  break;
760 
761  case ROUND_ACUTE_CORNERS: // Acute angles are rounded
762  joinType = jtMiter;
763  miterFallback = jtSquare;
764  break;
765 
766  case CHAMFER_ALL_CORNERS: // All angles are chamfered.
767  joinType = jtSquare;
768  miterFallback = jtSquare;
769  break;
770 
771  case ROUND_ALL_CORNERS: // All angles are rounded.
772  joinType = jtRound;
773  miterFallback = jtSquare;
774  break;
775  }
776 
777  std::vector<CLIPPER_Z_VALUE> zValues;
778  std::vector<SHAPE_ARC> arcBuffer;
779 
780  for( const POLYGON& poly : m_polys )
781  {
782  for( size_t i = 0; i < poly.size(); i++ )
783  {
784  c.AddPath( poly[i].convertToClipper( i == 0, zValues, arcBuffer ),
785  joinType, etClosedPolygon );
786  }
787  }
788 
789  PolyTree solution;
790 
791  // Calculate the arc tolerance (arc error) from the seg count by circle. The seg count is
792  // nn = M_PI / acos(1.0 - c.ArcTolerance / abs(aAmount))
793  // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Classes/ClipperOffset/Properties/ArcTolerance.htm
794 
795  if( aCircleSegCount < 6 ) // avoid incorrect aCircleSegCount values
796  aCircleSegCount = 6;
797 
798  double coeff;
799 
800  if( aCircleSegCount > SEG_CNT_MAX || arc_tolerance_factor[aCircleSegCount] == 0 )
801  {
802  coeff = 1.0 - cos( M_PI / aCircleSegCount );
803 
804  if( aCircleSegCount <= SEG_CNT_MAX )
805  arc_tolerance_factor[aCircleSegCount] = coeff;
806  }
807  else
808  {
809  coeff = arc_tolerance_factor[aCircleSegCount];
810  }
811 
812  c.ArcTolerance = std::abs( aAmount ) * coeff;
813  c.MiterLimit = miterLimit;
814  c.MiterFallback = miterFallback;
815  c.Execute( solution, aAmount );
816 
817  importTree( &solution, zValues, arcBuffer );
818 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
All angles are chamfered.
#define SEG_CNT_MAX
Acute angles are rounded.
Acute angles are chamfered.
just inflate the polygon. Acute angles create spikes
void importTree(ClipperLib::PolyTree *tree, const std::vector< CLIPPER_Z_VALUE > &aZValueBuffer, const std::vector< SHAPE_ARC > &aArcBuffe)

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 FOOTPRINT::BuildPolyCourtyards(), ZONE::BuildSmoothedPoly(), ZONE_FILLER::computeRawFilledArea(), BOARD_ADAPTER::createPadWithClearance(), Deflate(), ZONE_FILLER::fillSingleZone(), GERBER_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadRoundRect(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), InflateWithLinkedHoles(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), 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 
)

Perform outline inflation/deflation, using round corners.

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

Definition at line 721 of file shape_poly_set.cpp.

723 {
724  Simplify( aFastMode );
725  Inflate( aFactor, aCircleSegmentsCount );
726  Fracture( aFastMode );
727 }
void Simplify(POLYGON_MODE aFastMode)
void Fracture(POLYGON_MODE aFastMode)
Convert a single outline slitted ("fractured") polygon into a set ouf outlines with holes.
void Inflate(int aAmount, int aCircleSegCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
Perform outline inflation/deflation.

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

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

◆ InsertVertex()

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

Adds a vertex in the globally indexed position aGlobalIndex.

Parameters
aGlobalIndexis the global index of the position in which the new vertex will be inserted.
aNewVertexis the new inserted vertex.Return the index-th vertex in a given hole outline within a given outline

Definition at line 261 of file shape_poly_set.cpp.

262 {
263  VERTEX_INDEX index;
264 
265  if( aGlobalIndex < 0 )
266  aGlobalIndex = 0;
267 
268  if( aGlobalIndex >= TotalVertices() )
269  {
270  Append( aNewVertex );
271  }
272  else
273  {
274  // Assure the position to be inserted exists; throw an exception otherwise
275  if( GetRelativeIndices( aGlobalIndex, &index ) )
276  m_polys[index.m_polygon][index.m_contour].Insert( index.m_vertex, aNewVertex );
277  else
278  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
279  }
280 }
int TotalVertices() const
Delete aIdx-th polygon from the set.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated lis...
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Add a new vertex to the contour indexed by aOutline and aHole (defaults to the outline of the last po...

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

◆ IsNull()

bool SHAPE::IsNull ( ) const
inlineinherited

Return true if the shape is a null shape.

Return values
trueif null :-)

Definition at line 150 of file shape.h.

151  {
152  return m_type == SH_NULL;
153  }
SHAPE_TYPE m_type
< type of our shape
Definition: shape.h:110
empty shape (no shape...),
Definition: shape.h:51

References SHAPE_BASE::m_type, and SH_NULL.

◆ IsPolygonSelfIntersecting()

bool SHAPE_POLY_SET::IsPolygonSelfIntersecting ( int  aPolygonIndex) const

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

Parameters
aPolygonIndexis the index of the polygon that wants to be checked.
Returns
true if the aPolygonIndex-th polygon is self intersecting, false otherwise.

Definition at line 405 of file shape_poly_set.cpp.

406 {
407  CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
408  CONST_SEGMENT_ITERATOR innerIterator;
409 
410  for( iterator = CIterateSegmentsWithHoles( aPolygonIndex ); iterator; iterator++ )
411  {
412  SEG firstSegment = *iterator;
413 
414  // Iterate through all remaining segments.
415  innerIterator = iterator;
416 
417  // Start in the next segment, we don't want to check collision between a segment and itself
418  for( innerIterator++; innerIterator; innerIterator++ )
419  {
420  SEG secondSegment = *innerIterator;
421 
422  // Check whether the two segments built collide, only when they are not adjacent.
423  if( !iterator.IsAdjacent( innerIterator ) && firstSegment.Collide( secondSegment, 0 ) )
424  return true;
425  }
426  }
427 
428  return false;
429 }
bool Collide(const SEG &aSeg, int aClearance, int *aActual=nullptr) const
Definition: seg.cpp:189
SEGMENT_ITERATOR_TEMPLATE< const SEG > CONST_SEGMENT_ITERATOR
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles() const
Return an iterator object, for the aOutline-th outline in the set (with holes).
Definition: seg.h:40

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

Referenced by IsSelfIntersecting().

◆ IsSelfIntersecting()

bool SHAPE_POLY_SET::IsSelfIntersecting ( ) const

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

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

Definition at line 432 of file shape_poly_set.cpp.

433 {
434  for( unsigned int polygon = 0; polygon < m_polys.size(); polygon++ )
435  {
436  if( IsPolygonSelfIntersecting( polygon ) )
437  return true;
438  }
439 
440  return false;
441 }
bool IsPolygonSelfIntersecting(int aPolygonIndex) const
Check whether the aPolygonIndex-th polygon in the set is self intersecting.

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

1066  {
1067  return true;
1068  }

◆ IsTriangulationUpToDate()

bool SHAPE_POLY_SET::IsTriangulationUpToDate ( ) const

Definition at line 2219 of file shape_poly_set.cpp.

2220 {
2221  if( !m_triangulationValid )
2222  return false;
2223 
2224  if( !m_hash.IsValid() )
2225  return false;
2226 
2227  MD5_HASH hash = checksum();
2228 
2229  return hash == m_hash;
2230 }
MD5_HASH checksum() const
bool IsValid() const
Definition: md5_hash.h:24

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)

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

Parameters
aGlobalIdxis the index of the vertex.
Returns
true if the globally indexed aGlobalIdx-th vertex belongs to a hole.

Definition at line 1990 of file shape_poly_set.cpp.

1991 {
1992  VERTEX_INDEX index;
1993 
1994  // Get the polygon and contour where the vertex is. If the vertex does not exist, return false
1995  if( !GetRelativeIndices( aGlobalIdx, &index ) )
1996  return false;
1997 
1998  // The contour is a hole if its index is greater than zero
1999  return index.m_contour > 0;
2000 }
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated lis...

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

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

Parameters
aFirstis the first polygon whose points will be iterated.
aLastis the last polygon whose points will be iterated.
aIterateHolesis a flag to indicate whether the points of the holes should be iterated.
Returns
ITERATOR - the iterator object.

Definition at line 736 of file shape_poly_set.h.

737  {
738  ITERATOR iter;
739 
740  iter.m_poly = this;
741  iter.m_currentPolygon = aFirst;
742  iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
743  iter.m_currentContour = 0;
744  iter.m_currentVertex = 0;
745  iter.m_iterateHoles = aIterateHoles;
746 
747  return iter;
748  }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
ITERATOR_TEMPLATE< VECTOR2I > ITERATOR

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
Parameters
aOutlineis the index of the polygon to be iterated.
Returns
an iterator object to visit all points in the main outline of the aOutline-th polygon, without visiting the points in the holes.

Definition at line 755 of file shape_poly_set.h.

756  {
757  return Iterate( aOutline, aOutline );
758  }
ITERATOR Iterate()

References Iterate().

◆ Iterate() [3/3]

ITERATOR SHAPE_POLY_SET::Iterate ( )
inline
Returns
an iterator object to visit all points in all outlines of the set, without visiting the points in the holes.

Definition at line 774 of file shape_poly_set.h.

775  {
776  return Iterate( 0, OutlineCount() - 1 );
777  }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
ITERATOR Iterate()

References OutlineCount().

Referenced by Iterate(), and IterateWithHoles().

◆ IterateFromVertexWithHoles()

ITERATOR SHAPE_POLY_SET::IterateFromVertexWithHoles ( int  aGlobalIdx)
inline

◆ IterateSegments() [1/3]

◆ IterateSegments() [2/3]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegments ( int  aPolygonIdx)
inline

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

Definition at line 876 of file shape_poly_set.h.

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

References OutlineCount().

Referenced by IterateSegments(), and IterateSegmentsWithHoles().

◆ IterateSegmentsWithHoles() [1/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( )
inline

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

Definition at line 900 of file shape_poly_set.h.

References IterateSegments(), and OutlineCount().

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

◆ IterateSegmentsWithHoles() [2/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( int  aOutline)
inline

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

Definition at line 906 of file shape_poly_set.h.

References IterateSegments().

◆ IterateWithHoles() [1/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( int  aOutline)
inline
Parameters
aOutlinethe index of the polygon to be iterated.
Returns
an iterator object to visit all points in the main outline of the aOutline-th polygon, visiting also the points in the holes.

Definition at line 765 of file shape_poly_set.h.

766  {
767  return Iterate( aOutline, aOutline, true );
768  }
ITERATOR Iterate()

References Iterate().

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

◆ IterateWithHoles() [2/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( )
inline
Returns
an iterator object to visit all points in all outlines of the set, visiting also the points in the holes.

Definition at line 783 of file shape_poly_set.h.

784  {
785  return Iterate( 0, OutlineCount() - 1, true );
786  }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
ITERATOR Iterate()

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

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

Parameters
aXIf true, mirror about the y axis (flip x coordinate)
aYIf true, mirror about the x axis
aRefsets the reference point about which to mirror

Definition at line 1813 of file shape_poly_set.cpp.

1814 {
1815  for( POLYGON& poly : m_polys )
1816  {
1817  for( SHAPE_LINE_CHAIN& path : poly )
1818  path.Mirror( aX, aY, aRef );
1819  }
1820 
1821  if( m_triangulationValid )
1823 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
Represent a polyline (an zero-thickness chain of connected line segments).
void CacheTriangulation(bool aPartition=true)

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

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

◆ Move()

void SHAPE_POLY_SET::Move ( const VECTOR2I aVector)
overridevirtual

Implements SHAPE.

Definition at line 1798 of file shape_poly_set.cpp.

1799 {
1800  for( POLYGON& poly : m_polys )
1801  {
1802  for( SHAPE_LINE_CHAIN& path : poly )
1803  path.Move( aVector );
1804  }
1805 
1806  for( std::unique_ptr<TRIANGULATED_POLYGON>& tri : m_triangulatedPolys )
1807  tri->Move( aVector );
1808 
1809  m_hash = checksum();
1810 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
MD5_HASH checksum() const
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
Represent a polyline (an zero-thickness chain of connected line segments).

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

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), ALTIUM_PCB::HelperDrawsegmentSetLocalCoord(), GERBER_DRAW_ITEM::HitTest(), FABMASTER::loadFootprints(), CADSTAR_PCB_ARCHIVE_LOADER::loadLibraryCoppers(), FP_SHAPE::Move(), PCB_SHAPE::Move(), ZONE::Move(), GERBER_DRAW_ITEM::MoveAB(), FOOTPRINT::MoveAnchorPosition(), GERBER_DRAW_ITEM::MoveXY(), DS_DRAW_ITEM_POLYPOLYGONS::SetPosition(), FOOTPRINT::SetPosition(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), and TransformTrapezoidToPolygon().

◆ NewFacet()

FACET * SHAPE::NewFacet ( )
inherited

Definition at line 696 of file wrlfacet.cpp.

697 {
698  FACET* fp = new FACET;
699  facets.push_back( fp );
700  return fp;
701 }
Definition: wrlfacet.h:41
std::list< FACET * > facets
Definition: wrlfacet.h:143

References SHAPE::facets.

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

◆ NewHole()

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

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

Definition at line 198 of file shape_poly_set.cpp.

199 {
200  SHAPE_LINE_CHAIN empty_path;
201 
202  empty_path.SetClosed( true );
203 
204  // Default outline is the last one
205  if( aOutline < 0 )
206  aOutline += m_polys.size();
207 
208  // Add hole to the selected outline
209  m_polys[aOutline].push_back( empty_path );
210 
211  return m_polys.back().size() - 2;
212 }
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
Represent a polyline (an zero-thickness chain of connected line segments).

References m_polys, and SHAPE_LINE_CHAIN::SetClosed().

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

◆ NewOutline()

int SHAPE_POLY_SET::NewOutline ( )

Creates a new hole in a given outline.

Definition at line 186 of file shape_poly_set.cpp.

187 {
188  SHAPE_LINE_CHAIN empty_path;
189  POLYGON poly;
190 
191  empty_path.SetClosed( true );
192  poly.push_back( empty_path );
193  m_polys.push_back( poly );
194  return m_polys.size() - 1;
195 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
Represent a polyline (an zero-thickness chain of connected line segments).

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(), CornerListToPolygon(), 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(), FABMASTER::loadFootprints(), EAGLE_PLUGIN::loadPolygon(), FABMASTER::loadShapePolySet(), FABMASTER::loadZone(), LEGACY_PLUGIN::loadZONE_CONTAINER(), PCB_PARSER::parseZONE(), DXF_PLOTTER::PlotPoly(), PlotStandardLayer(), RENDER_3D_LEGACY::reload(), PCB_SHAPE::Rotate(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), PCB_SHAPE::SetPolyPoints(), DS_DATA_ITEM_POLYGONS::SyncDrawItems(), TransformArcToPolygon(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), PCB_SHAPE::TransformShapeWithClearanceToPolygon(), PCB_DIM_ALIGNED::updateGeometry(), PCB_DIM_ORTHOGONAL::updateGeometry(), and PCB_DIM_LEADER::updateGeometry().

◆ NormalizeAreaOutlines()

int SHAPE_POLY_SET::NormalizeAreaOutlines ( )

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

Removes null segments.

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

Definition at line 1258 of file shape_poly_set.cpp.

1259 {
1260  // We are expecting only one main outline, but this main outline can have holes
1261  // if holes: combine holes and remove them from the main outline.
1262  // Note also we are using SHAPE_POLY_SET::PM_STRICTLY_SIMPLE in polygon
1263  // calculations, but it is not mandatory. It is used mainly
1264  // because there is usually only very few vertices in area outlines
1265  SHAPE_POLY_SET::POLYGON& outline = Polygon( 0 );
1266  SHAPE_POLY_SET holesBuffer;
1267 
1268  // Move holes stored in outline to holesBuffer:
1269  // The first SHAPE_LINE_CHAIN is the main outline, others are holes
1270  while( outline.size() > 1 )
1271  {
1272  holesBuffer.AddOutline( outline.back() );
1273  outline.pop_back();
1274  }
1275 
1277 
1278  // If any hole, subtract it to main outline
1279  if( holesBuffer.OutlineCount() )
1280  {
1281  holesBuffer.Simplify( SHAPE_POLY_SET::PM_FAST );
1283  }
1284 
1286 
1287  return OutlineCount();
1288 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
Represent a set of closed polygons.
void Simplify(POLYGON_MODE aFastMode)
int RemoveNullSegments()
Look for null segments; ie, segments whose ends are exactly the same and deletes them.
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new hole to the given outline (default: last) and returns its index.
void BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset intersection For aFastMode meaning, see function booleanOp.
POLYGON & Polygon(int aIndex)

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

2188 {
2189  static_cast<SHAPE&>(*this) = aOther;
2190  m_polys = aOther.m_polys;
2191  m_triangulatedPolys.clear();
2192  m_triangulationValid = false;
2193 
2194  if( aOther.IsTriangulationUpToDate() )
2195  {
2196  for( unsigned i = 0; i < aOther.TriangulatedPolyCount(); i++ )
2197  {
2198  const TRIANGULATED_POLYGON* poly = aOther.TriangulatedPolygon( i );
2199  m_triangulatedPolys.push_back( std::make_unique<TRIANGULATED_POLYGON>( *poly ) );
2200  }
2201 
2202  m_hash = aOther.GetHash();
2203  m_triangulationValid = true;
2204  }
2205 
2206  return *this;
2207 }
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
bool IsTriangulationUpToDate() const
MD5_HASH GetHash() const
unsigned int TriangulatedPolyCount() const
Return the number of outlines in the set.
const TRIANGULATED_POLYGON * TriangulatedPolygon(int aIndex) const

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

Definition at line 663 of file shape_poly_set.h.

664  {
665  return m_polys[aIndex][0];
666  }

References m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), Area(), BuildFootprintPolygonOutlines(), ZONE::CalculateFilledArea(), PCB_GRID_HELPER::computeAnchors(), ConvertPolygonToBlocks(), FOOTPRINT::CoverageRatio(), BITMAPCONV_INFO::createOutputData(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), DIALOG_PAD_PRIMITIVE_POLY_PROPS::DIALOG_PAD_PRIMITIVE_POLY_PROPS(), KIGFX::DS_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), APERTURE_MACRO::DrawApertureMacroShape(), DSN::SPECCTRA_DB::fillBOUNDARY(), AR_AUTOPLACER::fillMatrix(), GERBER_PLOTTER::FlashPadChamferRoundRect(), PSLIKE_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadCustom(), DXF_PLOTTER::FlashPadCustom(), PSLIKE_PLOTTER::FlashPadRoundRect(), GERBER_PLOTTER::FlashPadRoundRect(), HPGL_PLOTTER::FlashPadRoundRect(), DXF_PLOTTER::FlashPadRoundRect(), PCB_IO::format(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), PCB_SHAPE::GetFocusPosition(), CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape(), insideArea(), GEOM_TEST::IsPolySetValid(), FABMASTER::loadFootprints(), FABMASTER::loadZone(), DSN::SPECCTRA_DB::makeIMAGE(), DSN::SPECCTRA_DB::makePADSTACK(), BOARD::NormalizeAreaPolygon(), PCB_PARSER::parseZONE(), PlotDrawingSheet(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), polygonArea(), CONVERT_TOOL::PolyToLines(), GERBER_DRAW_ITEM::PrintGerberPoly(), DS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem(), RENDER_3D_LEGACY::reload(), PCB_POINT_EDITOR::removeCornerCondition(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), PCB_SHAPE::Scale(), TransformArcToPolygon(), 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 668 of file shape_poly_set.h.

669  {
670  return m_polys[aIndex][0];
671  }

References m_polys.

◆ OutlineCount()

int SHAPE_POLY_SET::OutlineCount ( ) const
inline

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

Definition at line 645 of file shape_poly_set.h.

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(), Area(), booleanOp(), BuildBBoxCaches(), BuildBoardPolygonOutlines(), BuildConvexHull(), BuildFootprintPolygonOutlines(), PCB_SHAPE::BuildPolyPointsList(), CacheTriangulation(), ZONE::CalculateFilledArea(), CIterate(), CIterateSegments(), CIterateSegmentsWithHoles(), CIterateWithHoles(), Contains(), ConvertPolygonToBlocks(), RENDER_3D_LEGACY::createBoard(), BITMAPCONV_INFO::createOutputData(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), KIGFX::DS_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(), EXPORTER_PCB_VRML::ExportVrmlBoard(), EXPORTER_PCB_VRML::ExportVrmlPolygonSet(), ZONE_FILLER::Fill(), fillArcPOLY(), DSN::SPECCTRA_DB::fillBOUNDARY(), GEOM_TEST::FilletPolySet(), PSLIKE_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadCustom(), DXF_PLOTTER::FlashPadCustom(), PCB_IO::format(), 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(), DS_DRAW_ITEM_POLYPOLYGONS::HitTest(), ZONE::HitTestCutout(), insideArea(), isCopperOutside(), GEOM_TEST::IsPolySetValid(), Iterate(), IterateSegments(), IterateSegmentsWithHoles(), IterateWithHoles(), CONVERT_TOOL::LinesToPoly(), FABMASTER::loadFootprints(), FABMASTER::loadGraphics(), FABMASTER::loadPolygon(), NormalizeAreaOutlines(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::operator bool(), DIALOG_PAD_PROPERTIES::padValuesOK(), partitionPolyIntoRegularCellGrid(), PlotDrawingSheet(), BRDITEMS_PLOTTER::PlotFilledAreas(), BRDITEMS_PLOTTER::PlotFootprintGraphicItem(), PlotLayerOutlines(), DXF_PLOTTER::PlotPoly(), PlotSolderMaskLayer(), PlotStandardLayer(), polygon_triangulation_main(), polygonArea(), GERBER_DRAW_ITEM::Print(), DS_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 1322 of file shape_poly_set.cpp.

1323 {
1324  std::string tmp;
1325 
1326  aStream >> tmp;
1327 
1328  if( tmp != "polyset" )
1329  return false;
1330 
1331  aStream >> tmp;
1332 
1333  int n_polys = atoi( tmp.c_str() );
1334 
1335  if( n_polys < 0 )
1336  return false;
1337 
1338  for( int i = 0; i < n_polys; i++ )
1339  {
1340  POLYGON paths;
1341 
1342  aStream >> tmp;
1343 
1344  if( tmp != "poly" )
1345  return false;
1346 
1347  aStream >> tmp;
1348  int n_outlines = atoi( tmp.c_str() );
1349 
1350  if( n_outlines < 0 )
1351  return false;
1352 
1353  for( int j = 0; j < n_outlines; j++ )
1354  {
1355  SHAPE_LINE_CHAIN outline;
1356 
1357  outline.SetClosed( true );
1358 
1359  aStream >> tmp;
1360  int n_vertices = atoi( tmp.c_str() );
1361 
1362  for( int v = 0; v < n_vertices; v++ )
1363  {
1364  VECTOR2I p;
1365 
1366  aStream >> tmp; p.x = atoi( tmp.c_str() );
1367  aStream >> tmp; p.y = atoi( tmp.c_str() );
1368  outline.Append( p );
1369  }
1370 
1371  paths.push_back( outline );
1372  }
1373 
1374  m_polys.push_back( paths );
1375  }
1376 
1377  return true;
1378 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
Define a general 2D-vector/point.
Definition: vector2d.h:61
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
Represent a polyline (an zero-thickness chain of connected line segments).

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

◆ PointOnEdge()

bool SHAPE_POLY_SET::PointOnEdge ( const VECTOR2I aP) const

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

Parameters
aPis the point to check.
Returns
true if the point lies on the edge of any polygon.

Definition at line 1414 of file shape_poly_set.cpp.

1415 {
1416  // Iterate through all the polygons in the set
1417  for( const POLYGON& polygon : m_polys )
1418  {
1419  // Iterate through all the line chains in the polygon
1420  for( const SHAPE_LINE_CHAIN& lineChain : polygon )
1421  {
1422  if( lineChain.PointOnEdge( aP ) )
1423  return true;
1424  }
1425  }
1426 
1427  return false;
1428 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
Represent a polyline (an zero-thickness chain of connected line segments).

References m_polys.

◆ Polygon() [1/2]

◆ Polygon() [2/2]

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

Definition at line 701 of file shape_poly_set.h.

702  {
703  return m_polys[aIndex];
704  }

References m_polys.

◆ RemoveAllContours()

◆ RemoveContour()

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

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

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

Definition at line 1557 of file shape_poly_set.cpp.

1558 {
1559  // Default polygon is the last one
1560  if( aPolygonIdx < 0 )
1561  aPolygonIdx += m_polys.size();
1562 
1563  m_polys[aPolygonIdx].erase( m_polys[aPolygonIdx].begin() + aContourIdx );
1564 }

References m_polys.

Referenced by PCB_POINT_EDITOR::removeCorner().

◆ RemoveNullSegments()

int SHAPE_POLY_SET::RemoveNullSegments ( )

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

Returns
the number of deleted segments.

Definition at line 1567 of file shape_poly_set.cpp.

1568 {
1569  int removed = 0;
1570 
1571  ITERATOR iterator = IterateWithHoles();
1572 
1573  VECTOR2I contourStart = *iterator;
1574  VECTOR2I segmentStart, segmentEnd;
1575 
1576  VERTEX_INDEX indexStart;
1577 
1578  while( iterator )
1579  {
1580  // Obtain first point and its index
1581  segmentStart = *iterator;
1582  indexStart = iterator.GetIndex();
1583 
1584  // Obtain last point
1585  if( iterator.IsEndContour() )
1586  {
1587  segmentEnd = contourStart;
1588 
1589  // Advance
1590  iterator++;
1591 
1592  if( iterator )
1593  contourStart = *iterator;
1594  }
1595  else
1596  {
1597  // Advance
1598  iterator++;
1599 
1600  if( iterator )
1601  segmentEnd = *iterator;
1602  }
1603 
1604  // Remove segment start if both points are equal
1605  if( segmentStart == segmentEnd )
1606  {
1607  RemoveVertex( indexStart );
1608  removed++;
1609 
1610  // Advance the iterator one position, as there is one vertex less.
1611  if( iterator )
1612  iterator++;
1613  }
1614  }
1615 
1616  return removed;
1617 }
Define a general 2D-vector/point.
Definition: vector2d.h:61
ITERATOR_TEMPLATE< VECTOR2I > ITERATOR
ITERATOR IterateWithHoles()
void RemoveVertex(int aGlobalIndex)
Delete the aGlobalIndex-th vertex.

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)

Delete the aGlobalIndex-th vertex.

Parameters
aGlobalIndexis the global index of the to-be-removed vertex.

Definition at line 1739 of file shape_poly_set.cpp.

1740 {
1741  VERTEX_INDEX index;
1742 
1743  // Assure the to be removed vertex exists, abort otherwise
1744  if( GetRelativeIndices( aGlobalIndex, &index ) )
1745  RemoveVertex( index );
1746  else
1747  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
1748 }
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated lis...
void RemoveVertex(int aGlobalIndex)
Delete the aGlobalIndex-th vertex.

References GetRelativeIndices().

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

◆ RemoveVertex() [2/2]

void SHAPE_POLY_SET::RemoveVertex ( VERTEX_INDEX  aRelativeIndices)

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

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

Definition at line 1751 of file shape_poly_set.cpp.

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

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

Rotate all vertices by a given angle.

Parameters
aCenteris the rotation center.
aAngleis the rotation angle in radians.

Implements SHAPE.

Definition at line 1826 of file shape_poly_set.cpp.

1827 {
1828  for( POLYGON& poly : m_polys )
1829  {
1830  for( SHAPE_LINE_CHAIN& path : poly )
1831  path.Rotate( aAngle, aCenter );
1832  }
1833 
1834  // Don't re-cache if the triangulation is already invalid
1835  if( m_triangulationValid )
1837 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
Represent a polyline (an zero-thickness chain of connected line segments).
void CacheTriangulation(bool aPartition=true)

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

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), D_CODE::ConvertShapeToPolygon(), ALTIUM_PCB::HelperDrawsegmentSetLocalCoord(), PCB_SHAPE::HitTest(), FABMASTER::loadFootprints(), PCB_SHAPE::Rotate(), ZONE::Rotate(), FOOTPRINT::SetOrientation(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), FP_TEXT::TransformShapeWithClearanceToPolygon(), PAD::TransformShapeWithClearanceToPolygon(), TransformTrapezoidToPolygon(), PCB_DIM_ALIGNED::updateGeometry(), PCB_DIM_ORTHOGONAL::updateGeometry(), and PCB_DIM_LEADER::updateGeometry().

◆ SetVertex() [1/2]

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

Accessor function to set the position of a specific point.

Parameters
aIndex#VERTEX_INDEX of the point to move.
aPosdestination position of the specified point.

Definition at line 1768 of file shape_poly_set.cpp.

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

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

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

◆ SetVertex() [2/2]

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

Set the vertex based on the global index.

Throws if the index doesn't exist.

Parameters
aGlobalIndexglobal index of the to-be-moved vertex
aPosNew position on the vertexReturn total number of vertices stored in the set.

Definition at line 1757 of file shape_poly_set.cpp.

1758 {
1759  VERTEX_INDEX index;
1760 
1761  if( GetRelativeIndices( aGlobalIndex, &index ) )
1762  SetVertex( index, aPos );
1763  else
1764  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
1765 }
void SetVertex(const VERTEX_INDEX &aIndex, const VECTOR2I &aPos)
Accessor function to set the position of a specific point.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Convert a global vertex index —i.e., a number that globally identifies a vertex in a concatenated lis...

References GetRelativeIndices(), and SetVertex().

◆ Simplify()

◆ SquaredDistance() [1/2]

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

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

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

Parameters
aPointis 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 1940 of file shape_poly_set.cpp.

1941 {
1942  SEG::ecoord currentDistance_sq;
1943  SEG::ecoord minDistance_sq = VECTOR2I::ECOORD_MAX;
1944  VECTOR2I nearest;
1945 
1946  // Iterate through all the polygons and get the minimum distance.
1947  for( unsigned int polygonIdx = 0; polygonIdx < m_polys.size(); polygonIdx++ )
1948  {
1949  currentDistance_sq = SquaredDistanceToPolygon( aPoint, polygonIdx,
1950  aNearest ? &nearest : nullptr );
1951 
1952  if( currentDistance_sq < minDistance_sq )
1953  {
1954  if( aNearest )
1955  *aNearest = nearest;
1956 
1957  minDistance_sq = currentDistance_sq;
1958  }
1959  }
1960 
1961  return minDistance_sq;
1962 }
VECTOR2I::extended_type ecoord
Definition: seg.h:43
Define a general 2D-vector/point.
Definition: vector2d.h:61
static constexpr extended_type ECOORD_MAX
Definition: vector2d.h:79
SEG::ecoord SquaredDistanceToPolygon(VECTOR2I aPoint, int aIndex, VECTOR2I *aNearest) const
Compute the minimum distance between the aIndex-th polygon and aPoint.

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

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

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

Parameters
aSegmentis the segment whose distance to the polygon set has to be measured.
aSegmentWidthis 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 1965 of file shape_poly_set.cpp.

1966 {
1967  SEG::ecoord currentDistance_sq;
1968  SEG::ecoord minDistance_sq = VECTOR2I::ECOORD_MAX;
1969  VECTOR2I nearest;
1970 
1971  // Iterate through all the polygons and get the minimum distance.
1972  for( unsigned int polygonIdx = 0; polygonIdx < m_polys.size(); polygonIdx++ )
1973  {
1974  currentDistance_sq = SquaredDistanceToPolygon( aSegment, polygonIdx,
1975  aNearest ? &nearest : nullptr );
1976 
1977  if( currentDistance_sq < minDistance_sq )
1978  {
1979  if( aNearest )
1980  *aNearest = nearest;
1981 
1982  minDistance_sq = currentDistance_sq;
1983  }
1984  }
1985 
1986  return minDistance_sq;
1987 }
VECTOR2I::extended_type ecoord
Definition: seg.h:43
Define a general 2D-vector/point.
Definition: vector2d.h:61
static constexpr extended_type ECOORD_MAX
Definition: vector2d.h:79
SEG::ecoord SquaredDistanceToPolygon(VECTOR2I aPoint, int aIndex, VECTOR2I *aNearest) const
Compute the minimum distance between the aIndex-th polygon and aPoint.

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

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

Parameters
aPointis the point whose distance to the aIndex-th polygon has to be measured.
aIndexis the index of the polygon whose distance to aPoint has to be measured.
aNearest[out] an optional pointer to be filled in with the point on the polyset which is closest to aPoint.
Returns
The minimum distance between aPoint and all the segments of the aIndex-th polygon. If the point is contained in the polygon, the distance is zero.

Definition at line 1867 of file shape_poly_set.cpp.

1869 {
1870  // We calculate the min dist between the segment and each outline segment. However, if the
1871  // segment to test is inside the outline, and does not cross any edge, it can be seen outside
1872  // the polygon. Therefore test if a segment end is inside (testing only one end is enough).
1873  // Use an accuracy of "1" to say that we don't care if it's exactly on the edge or not.
1874  if( containsSingle( aPoint, aPolygonIndex, 1 ) )
1875  {
1876  if( aNearest )
1877  *aNearest = aPoint;
1878 
1879  return 0;
1880  }
1881 
1882  CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
1883 
1884  SEG::ecoord minDistance = (*iterator).SquaredDistance( aPoint );
1885 
1886  for( iterator++; iterator && minDistance > 0; iterator++ )
1887  {
1888  SEG::ecoord currentDistance = (*iterator).SquaredDistance( aPoint );
1889 
1890  if( currentDistance < minDistance )
1891  {
1892  if( aNearest )
1893  *aNearest = (*iterator).NearestPoint( aPoint );
1894 
1895  minDistance = currentDistance;
1896  }
1897  }
1898 
1899  return minDistance;
1900 }
SEGMENT_ITERATOR_TEMPLATE< const SEG > CONST_SEGMENT_ITERATOR
VECTOR2I::extended_type ecoord
Definition: seg.h:43
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles() const
Return an iterator object, for the aOutline-th outline in the set (with holes).
bool containsSingle(const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
Check whether the point aP is inside the aSubpolyIndex-th polygon of the polyset.

References CIterateSegmentsWithHoles(), and containsSingle().

Referenced by SquaredDistance().

◆ SquaredDistanceToPolygon() [2/2]

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

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

Parameters
aSegmentis the segment whose distance to the aIndex-th polygon has to be measured.
aIndexis the index of the polygon whose distance to aPoint has to be measured.
aNearest[out] an optional pointer to be filled in with the point on the polyset which is closest to aSegment.
Returns
The minimum distance between aSegment and all the segments of the aIndex-th polygon. If the point is contained in the polygon, the distance is zero.

Definition at line 1903 of file shape_poly_set.cpp.

1905 {
1906  // Check if the segment is fully-contained. If so, its midpoint is a good-enough nearest point.
1907  if( containsSingle( aSegment.A, aPolygonIndex, 1 ) &&
1908  containsSingle( aSegment.B, aPolygonIndex, 1 ) )
1909  {
1910  if( aNearest )
1911  *aNearest = ( aSegment.A + aSegment.B ) / 2;
1912 
1913  return 0;
1914  }
1915 
1916  CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
1917  SEG::ecoord minDistance = (*iterator).SquaredDistance( aSegment );
1918 
1919  if( aNearest && minDistance == 0 )
1920  *aNearest = ( *iterator ).NearestPoint( aSegment );
1921 
1922  for( iterator++; iterator && minDistance > 0; iterator++ )
1923  {
1924  SEG::ecoord currentDistance = (*iterator).SquaredDistance( aSegment );
1925 
1926  if( currentDistance < minDistance )
1927  {
1928  if( aNearest )
1929  *aNearest = (*iterator).NearestPoint( aSegment );
1930 
1931  minDistance = currentDistance;
1932  }
1933  }
1934 
1935  // Return the maximum of minDistance and zero
1936  return minDistance < 0 ? 0 : minDistance;
1937 }
SEGMENT_ITERATOR_TEMPLATE< const SEG > CONST_SEGMENT_ITERATOR
VECTOR2I::extended_type ecoord
Definition: seg.h:43
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles() const
Return an iterator object, for the aOutline-th outline in the set (with holes).
VECTOR2I A
Definition: seg.h:48
bool containsSingle(const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
Check whether the point aP is inside the aSubpolyIndex-th polygon of the polyset.
VECTOR2I B
Definition: seg.h:49

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

◆ Subset()

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

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

Parameters
aFirstPolygonis the first polygon to be included in the returned set.
aLastPolygonis the last polygon to be excluded of the returned set.
Returns
a set containing the polygons between aFirstPolygon (included) and aLastPolygon (excluded).

Definition at line 308 of file shape_poly_set.cpp.

309 {
310  assert( aFirstPolygon >= 0 && aLastPolygon <= OutlineCount() );
311 
312  SHAPE_POLY_SET newPolySet;
313 
314  for( int index = aFirstPolygon; index < aLastPolygon; index++ )
315  newPolySet.m_polys.push_back( Polygon( index ) );
316 
317  return newPolySet;
318 }
int OutlineCount() const
Return the number of vertices in a given outline/hole.
Represent a set of closed polygons.
POLYGON & Polygon(int aIndex)

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

Referenced by UnitSet().

◆ TotalVertices()

int SHAPE_POLY_SET::TotalVertices ( ) const

Delete aIdx-th polygon from the set.

Definition at line 1840 of file shape_poly_set.cpp.

1841 {
1842  int c = 0;
1843 
1844  for( const POLYGON& poly : m_polys )
1845  {
1846  for( const SHAPE_LINE_CHAIN& path : poly )
1847  c += path.PointCount();
1848  }
1849 
1850  return c;
1851 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
Represent a polyline (an zero-thickness chain of connected line segments).

References m_polys, and path.

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

◆ TriangulatedPolyCount()

unsigned int SHAPE_POLY_SET::TriangulatedPolyCount ( ) const
inline

Return the number of outlines in the set.

Definition at line 642 of file shape_poly_set.h.

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

707  {
708  return m_triangulatedPolys[aIndex].get();
709  }
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys

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

◆ Unfracture()

void SHAPE_POLY_SET::Unfracture ( POLYGON_MODE  aFastMode)

Return true if the polygon set has any holes.

Definition at line 1241 of file shape_poly_set.cpp.

1242 {
1243  for( POLYGON& path : m_polys )
1245 
1246  Simplify( aFastMode ); // remove overlapping holes/degeneracy
1247 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
void unfractureSingle(POLYGON &path)
void Simplify(POLYGON_MODE aFastMode)

References m_polys, path, 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 1064 of file shape_poly_set.cpp.

1065 {
1066  assert( aPoly.size() == 1 );
1067 
1068  struct EDGE
1069  {
1070  int m_index = 0;
1071  SHAPE_LINE_CHAIN* m_poly = nullptr;
1072  bool m_duplicate = false;
1073 
1074  EDGE( SHAPE_LINE_CHAIN* aPolygon, int aIndex ) :
1075  m_index( aIndex ),
1076  m_poly( aPolygon )
1077  {}
1078 
1079  bool compareSegs( const SEG& s1, const SEG& s2 ) const
1080  {
1081  return (s1.A == s2.B && s1.B == s2.A);
1082  }
1083 
1084  bool operator==( const EDGE& aOther ) const
1085  {
1086  return compareSegs( m_poly->CSegment( m_index ),
1087  aOther.m_poly->CSegment( aOther.m_index ) );
1088  }
1089 
1090  bool operator!=( const EDGE& aOther ) const
1091  {
1092  return !compareSegs( m_poly->CSegment( m_index ),
1093  aOther.m_poly->CSegment( aOther.m_index ) );
1094  }
1095 
1096  struct HASH
1097  {
1098  std::size_t operator()( const EDGE& aEdge ) const
1099  {
1100  const SEG& a = aEdge.m_poly->CSegment( aEdge.m_index );
1101 
1102  return (std::size_t) ( a.A.x + a.B.x + a.A.y + a.B.y );
1103  }
1104  };
1105  };
1106 
1107  struct EDGE_LIST_ENTRY
1108  {
1109  int index;
1110  EDGE_LIST_ENTRY* next;
1111  };
1112 
1113  std::unordered_set<EDGE, EDGE::HASH> uniqueEdges;
1114 
1115  SHAPE_LINE_CHAIN lc = aPoly[0];
1116  lc.Simplify();
1117 
1118  auto edgeList = std::make_unique<EDGE_LIST_ENTRY[]>( lc.SegmentCount() );
1119 
1120  for( int i = 0; i < lc.SegmentCount(); i++ )
1121  {
1122  edgeList[i].index = i;
1123  edgeList[i].next = &edgeList[ (i != lc.SegmentCount() - 1) ? i + 1 : 0 ];
1124  }
1125 
1126  std::unordered_set<EDGE_LIST_ENTRY*> queue;
1127 
1128  for( int i = 0; i < lc.SegmentCount(); i++ )
1129  {
1130  EDGE e( &lc, i );
1131  uniqueEdges.insert( e );
1132  }
1133 
1134  for( int i = 0; i < lc.SegmentCount(); i++ )
1135  {
1136  EDGE e( &lc, i );
1137  auto it = uniqueEdges.find( e );
1138 
1139  if( it != uniqueEdges.end() && it->m_index != i )
1140  {
1141  int e1 = it->m_index;
1142  int e2 = i;
1143 
1144  if( e1 > e2 )
1145  std::swap( e1, e2 );
1146 
1147  int e1_prev = e1 - 1;
1148 
1149  if( e1_prev < 0 )
1150  e1_prev = lc.SegmentCount() - 1;
1151 
1152  int e2_prev = e2 - 1;
1153 
1154  if( e2_prev < 0 )
1155  e2_prev = lc.SegmentCount() - 1;
1156 
1157  int e1_next = e1 + 1;
1158 
1159  if( e1_next == lc.SegmentCount() )
1160  e1_next = 0;
1161 
1162  int e2_next = e2 + 1;
1163 
1164  if( e2_next == lc.SegmentCount() )
1165  e2_next = 0;
1166 
1167  edgeList[e1_prev].next = &edgeList[ e2_next ];
1168  edgeList[e2_prev].next = &edgeList[ e1_next ];
1169  edgeList[i].next = nullptr;
1170  edgeList[it->m_index].next = nullptr;
1171  }
1172  }
1173 
1174  for( int i = 0; i < lc.SegmentCount(); i++ )
1175  {
1176  if( edgeList[i].next )
1177  queue.insert( &edgeList[i] );
1178  }
1179 
1180  auto edgeBuf = std::make_unique<EDGE_LIST_ENTRY* []>( lc.SegmentCount() );
1181 
1182  int n = 0;
1183  int outline = -1;
1184 
1185  POLYGON result;
1186 
1187  while( queue.size() )
1188  {
1189  EDGE_LIST_ENTRY* e_first = *queue.begin();
1190  EDGE_LIST_ENTRY* e = e_first;
1191  int cnt = 0;
1192 
1193  do
1194  {
1195  edgeBuf[cnt++] = e;
1196  e = e->next;
1197  } while( e && e != e_first );
1198 
1199  SHAPE_LINE_CHAIN outl;
1200 
1201  for( int i = 0; i < cnt; i++ )
1202  {
1203  VECTOR2I p = lc.CPoint( edgeBuf[i]->index );
1204  outl.Append( p );
1205  queue.erase( edgeBuf[i] );
1206  }
1207 
1208  outl.SetClosed( true );
1209 
1210  bool cw = outl.Area() > 0.0;
1211 
1212  if( cw )
1213  outline = n;
1214 
1215  result.push_back( outl );
1216  n++;
1217  }
1218 
1219  if( outline > 0 )
1220  std::swap( result[0], result[outline] );
1221 
1222  aPoly = result;
1223 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
< represents a single polygon outline with holes.
CITER next(CITER it)
Definition: ptree.cpp:126
SHAPE_LINE_CHAIN & Simplify(bool aRemoveColinear=true)
Simplify the line chain by removing colinear adjacent segments and duplicate vertices.
Define a general 2D-vector/point.
Definition: vector2d.h:61
bool operator!=(const SYMBOL_LIB &aLibrary, const wxString &aName)
double Area(bool aAbsolute=true) const
Return the area of this chain.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
bool operator==(const SYMBOL_LIB &aLibrary, const wxString &aName)
Case insensitive library name comparison.
int SegmentCount() const
Return the number of segments in this line chain.
Definition: seg.h:40
const SEG CSegment(int aIndex) const
Return a constant copy of the aIndex segment in the line chain.
Represent a polyline (an zero-thickness chain of connected line segments).
VECTOR2I A
Definition: seg.h:48
VECTOR2I B
Definition: seg.h:49

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

Referenced by Unfracture().

◆ UnitSet()

SHAPE_POLY_SET SHAPE_POLY_SET::UnitSet ( int  aPolygonIndex)
inline

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

Definition at line 684 of file shape_poly_set.h.

References Subset().

Referenced by BOARD::NormalizeAreaPolygon().

◆ VertexCount()

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

Returns the number of holes in a given outline.

Definition at line 283 of file shape_poly_set.cpp.

284 {
285  if( m_polys.size() == 0 ) // Empty poly set
286  return 0;
287 
288  if( aOutline < 0 ) // Use last outline
289  aOutline += m_polys.size();
290 
291  int idx;
292 
293  if( aHole < 0 )
294  idx = 0;
295  else
296  idx = aHole + 1;
297 
298  if( aOutline >= (int) m_polys.size() ) // not existing outline
299  return 0;
300 
301  if( idx >= (int) m_polys[aOutline].size() ) // not existing hole
302  return 0;
303 
304  return m_polys[aOutline][idx].PointCount();
305 }

References m_polys.

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

Member Data Documentation

◆ m_hash

MD5_HASH SHAPE_POLY_SET::m_hash
private

◆ m_polys

◆ m_triangulatedPolys

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

◆ m_triangulationValid

bool SHAPE_POLY_SET::m_triangulationValid = false
private

◆ m_type

SHAPE_TYPE SHAPE_BASE::m_type
protectedinherited

< type of our shape

Definition at line 110 of file shape.h.

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

◆ MIN_PRECISION_IU

const int SHAPE::MIN_PRECISION_IU = 4
staticinherited

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

Definition at line 122 of file shape.h.

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


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