KiCad PCB EDA Suite
SHAPE_POLY_SET Class Reference

SHAPE_POLY_SET. More...

#include <shape_poly_set.h>

Inheritance diagram for SHAPE_POLY_SET:
SHAPE

Classes

class  ITERATOR_TEMPLATE
 ITERATOR_TEMPLATE. More...
 
class  SEGMENT_ITERATOR_TEMPLATE
 SEGMENT_ITERATOR_TEMPLATE. More...
 
class  TRIANGULATED_POLYGON
 
struct  VERTEX_INDEX
 Struct VERTEX_INDEX. More...
 

Public Types

enum  POLYGON_MODE { PM_FAST = true, PM_STRICTLY_SIMPLE = false }
 operations on polygons use a aFastMode param if aFastMode is PM_FAST (true) the result can be a weak polygon if aFastMode is PM_STRICTLY_SIMPLE (false) (default) the result is (theorically) a strictly simple polygon, but calculations can be really significantly time consuming Most of time PM_FAST is preferable. More...
 
enum  CORNER_STRATEGY { ALLOW_ACUTE_CORNERS, CHOP_ACUTE_CORNERS, ROUND_ACUTE_CORNERS, ROUND_ALL_CORNERS }
 
typedef std::vector< SHAPE_LINE_CHAINPOLYGON
 

represents a single polygon outline with holes.

More...
 
typedef struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
 Struct VERTEX_INDEX. 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_POLY_SET &aOther, bool aDeepCopy=false)
 Copy constructor SHAPE_POLY_SET Performs a deep copy of aOther into this. More...
 
 ~SHAPE_POLY_SET ()
 
bool GetRelativeIndices (int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
 Function GetRelativeIndices. More...
 
bool GetGlobalIndex (VERTEX_INDEX aRelativeIndices, int &aGlobalIdx)
 Function GetGlobalIndex computes the global index of a vertex from the relative indices of polygon, contour and vertex. More...
 
SHAPEClone () const override
 Function Clone() More...
 
int NewOutline ()
 

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

More...
 
int NewHole (int aOutline=-1)
 

Creates a new hole in a given outline

More...
 
int AddOutline (const SHAPE_LINE_CHAIN &aOutline)
 

Adds a new outline to the set and returns its index

More...
 
int AddHole (const SHAPE_LINE_CHAIN &aHole, int aOutline=-1)
 

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

More...
 
int Append (int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
 

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

More...
 
void Append (const SHAPE_POLY_SET &aSet)
 

Merges polygons from two sets.

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

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

More...
 
void InsertVertex (int aGlobalIndex, VECTOR2I aNewVertex)
 Function InsertVertex Adds a vertex in the globally indexed position aGlobalIndex. More...
 
const VECTOR2ICVertex (int aIndex, int aOutline, int aHole) const
 

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

More...
 
const VECTOR2ICVertex (int aGlobalIndex) const
 

Returns the aGlobalIndex-th vertex in the poly set

More...
 
const VECTOR2ICVertex (VERTEX_INDEX aIndex) const
 

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

More...
 
bool GetNeighbourIndexes (int aGlobalIndex, int *aPrevious, int *aNext)
 Returns the global indexes of the previous and the next corner of the aGlobalIndex-th corner of a contour in the polygon set. More...
 
bool IsPolygonSelfIntersecting (int aPolygonIndex) const
 Function IsPolygonSelfIntersecting. More...
 
bool IsSelfIntersecting () const
 Function IsSelfIntersecting Checks whether any of the polygons in the set is self intersecting. More...
 
unsigned int TriangulatedPolyCount () const
 

Returns the number of triangulated polygons

More...
 
int OutlineCount () const
 

Returns the number of outlines in the set

More...
 
int VertexCount (int aOutline=-1, int aHole=-1) const
 

Returns the number of vertices in a given outline/hole

More...
 
int HoleCount (int aOutline) const
 

Returns the number of holes in a given outline

More...
 
SHAPE_LINE_CHAINOutline (int aIndex)
 

Returns the reference to aIndex-th outline in the set

More...
 
SHAPE_POLY_SET Subset (int aFirstPolygon, int aLastPolygon)
 Function Subset returns a subset of the polygons in this set, the ones between aFirstPolygon and aLastPolygon. More...
 
SHAPE_POLY_SET UnitSet (int aPolygonIndex)
 
SHAPE_LINE_CHAINHole (int aOutline, int aHole)
 

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

More...
 
POLYGONPolygon (int aIndex)
 

Returns the aIndex-th subpolygon in the set

More...
 
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)
 Function Iterate returns an object to iterate through the points of the polygons between aFirst and aLast. More...
 
ITERATOR Iterate (int aOutline)
 Function Iterate. More...
 
ITERATOR IterateWithHoles (int aOutline)
 Function IterateWithHoles. More...
 
ITERATOR Iterate ()
 Function Iterate. More...
 
ITERATOR IterateWithHoles ()
 Function IterateWithHoles. More...
 
CONST_ITERATOR CIterate (int aFirst, int aLast, bool aIterateHoles=false) const
 
CONST_ITERATOR CIterate (int aOutline) const
 
CONST_ITERATOR CIterateWithHoles (int aOutline) const
 
CONST_ITERATOR CIterate () const
 
CONST_ITERATOR CIterateWithHoles () const
 
ITERATOR IterateFromVertexWithHoles (int aGlobalIdx)
 
SEGMENT_ITERATOR IterateSegments (int aFirst, int aLast, bool aIterateHoles=false)
 

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

without holes (default: without) More...

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

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

without holes (default: without) More...

 
SEGMENT_ITERATOR IterateSegments (int aPolygonIdx)
 

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

More...
 
CONST_SEGMENT_ITERATOR CIterateSegments (int aPolygonIdx) const
 

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

More...
 
SEGMENT_ITERATOR IterateSegments ()
 

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

More...
 
SEGMENT_ITERATOR IterateSegmentsWithHoles ()
 

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

More...
 
SEGMENT_ITERATOR IterateSegmentsWithHoles (int aOutline)
 

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

More...
 
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles (int aOutline) const
 

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

More...
 
void BooleanAdd (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 

Performs boolean polyset union For aFastMode meaning, see function booleanOp

More...
 
void BooleanSubtract (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 

Performs boolean polyset difference For aFastMode meaning, see function booleanOp

More...
 
void BooleanIntersection (const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
 

Performs boolean polyset intersection For aFastMode meaning, see function booleanOp

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

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

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

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

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

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

More...
 
void Inflate (int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
 Performs outline inflation/deflation. More...
 
void Deflate (int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
 
void InflateWithLinkedHoles (int aFactor, int aCircleSegmentsCount, POLYGON_MODE aFastMode)
 Performs outline inflation/deflation, using round corners. More...
 
void Fracture (POLYGON_MODE aFastMode)
 

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

More...
 
void Unfracture (POLYGON_MODE aFastMode)
 

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

More...
 
bool HasHoles () const
 

Returns true if the polygon set has any holes.

More...
 
bool HasTouchingHoles () const
 

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

More...
 
void Simplify (POLYGON_MODE aFastMode)
 

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

More...
 
int NormalizeAreaOutlines ()
 Function NormalizeAreaOutlines Convert a self-intersecting polygon to one (or more) non self-intersecting polygon(s) Removes null segments. More...
 
const std::string Format () const override
 
bool Parse (std::stringstream &aStream) override
 
void Move (const VECTOR2I &aVector) override
 
void Mirror (bool aX=true, bool aY=false, const VECTOR2I &aRef={ 0, 0 })
 Mirrors the line points about y or x (or both) More...
 
void Rotate (double aAngle, const VECTOR2I &aCenter={ 0, 0 })
 Function Rotate rotates all vertices by a given angle. More...
 
bool IsSolid () const override
 
const BOX2I BBox (int aClearance=0) const override
 Function BBox() More...
 
bool PointOnEdge (const VECTOR2I &aP) const
 Function PointOnEdge() More...
 
bool Collide (const VECTOR2I &aP, int aClearance=0) const override
 Function Collide Checks whether the point aP collides with the inside of the polygon set; if the point lies on an edge or on a corner of any of the polygons, there is no collision: the edges does not belong to the polygon itself. More...
 
bool Collide (const SEG &aSeg, int aClearance=0) const override
 Function Collide Checks whether the segment aSeg collides with the inside of the polygon set; if the segment touches an edge or a corner of any of the polygons, there is no collision: the edges do not belong to the polygon itself. More...
 
bool CollideVertex (const VECTOR2I &aPoint, VERTEX_INDEX &aClosestVertex, int aClearance=0)
 Function CollideVertex Checks whether aPoint collides with any vertex of any of the contours of the polygon. More...
 
bool CollideEdge (const VECTOR2I &aPoint, VERTEX_INDEX &aClosestVertex, int aClearance=0)
 Function CollideEdge Checks whether aPoint collides with any edge of any of the contours of the polygon. More...
 
void BuildBBoxCaches ()
 Constructs BBoxCaches for Contains(), below. More...
 
bool Contains (const VECTOR2I &aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=false) const
 Returns true if a given subpolygon contains the point aP. More...
 
bool IsEmpty () const
 

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

More...
 
void RemoveVertex (int aGlobalIndex)
 Function RemoveVertex deletes the aGlobalIndex-th vertex. More...
 
void RemoveVertex (VERTEX_INDEX aRelativeIndices)
 Function RemoveVertex deletes the vertex indexed by aIndex (index of polygon, contour and vertex). More...
 
void RemoveAllContours ()
 

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

More...
 
void RemoveContour (int aContourIdx, int aPolygonIdx=-1)
 Function RemoveContour deletes the aContourIdx-th contour of the aPolygonIdx-th polygon in the set. More...
 
int RemoveNullSegments ()
 Function RemoveNullSegments looks for null segments; ie, segments whose ends are exactly the same and deletes them. More...
 
void SetVertex (const VERTEX_INDEX &aIndex, const VECTOR2I &aPos)
 Function SetVertex Accessor function to set the position of a specific point. More...
 
void SetVertex (int aGlobalIndex, const VECTOR2I &aPos)
 Sets the vertex based on the global index. More...
 
int TotalVertices () const
 

Returns total number of vertices stored in the set.

More...
 
void DeletePolygon (int aIdx)
 

Deletes aIdx-th polygon from the set

More...
 
POLYGON ChamferPolygon (unsigned int aDistance, int aIndex, std::set< VECTOR2I > *aPreserveCorners)
 Function Chamfer returns a chamfered version of the aIndex-th polygon. More...
 
POLYGON FilletPolygon (unsigned int aRadius, int aErrorMax, int aIndex, std::set< VECTOR2I > *aPreserveCorners=nullptr)
 Function Fillet returns a filleted version of the aIndex-th polygon. More...
 
SHAPE_POLY_SET Chamfer (int aDistance, std::set< VECTOR2I > *aPreserveCorners=nullptr)
 Function Chamfer returns a chamfered version of the polygon set. More...
 
SHAPE_POLY_SET Fillet (int aRadius, int aErrorMax, std::set< VECTOR2I > *aPreserveCorners=nullptr)
 Function Fillet returns a filleted version of the polygon set. More...
 
int DistanceToPolygon (VECTOR2I aPoint, int aIndex)
 Function DistanceToPolygon computes the minimum distance between the aIndex-th polygon and aPoint. More...
 
int DistanceToPolygon (const SEG &aSegment, int aIndex, int aSegmentWidth=0)
 Function DistanceToPolygon computes the minimum distance between the aIndex-th polygon and aSegment with a possible width. More...
 
int Distance (VECTOR2I aPoint)
 Function DistanceToPolygon computes the minimum distance between aPoint and all the polygons in the set. More...
 
int Distance (const SEG &aSegment, int aSegmentWidth=0)
 Function DistanceToPolygon computes the minimum distance between aSegment and all the polygons in the set. More...
 
bool IsVertexInHole (int aGlobalIdx)
 Function IsVertexInHole. More...
 
SHAPE_POLY_SEToperator= (const SHAPE_POLY_SET &)
 
void CacheTriangulation ()
 
bool IsTriangulationUpToDate () const
 
MD5_HASH GetHash () const
 
SHAPE_TYPE Type () const
 Function Type() More...
 
virtual bool Collide (const SHAPE *aShape, int aClearance, VECTOR2I &aMTV) const
 Function Collide() More...
 
virtual bool Collide (const SHAPE *aShape, int aClearance=0) const
 
virtual VECTOR2I Centre () const
 Function Centre() More...
 
FACETNewFacet ()
 
SGNODECalcShape (SGNODE *aParent, SGNODE *aColor, WRL1_ORDER aVertexOrder, float aCreaseLimit=0.74317, bool isVRML2=false)
 

Protected Types

typedef VECTOR2I::extended_type ecoord
 

Protected Attributes

SHAPE_TYPE m_type
 

type of our shape

More...
 

Private Types

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

Private Member Functions

void fractureSingle (POLYGON &paths)
 
void unfractureSingle (POLYGON &path)
 
void importTree (ClipperLib::PolyTree *tree)
 
void booleanOp (ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
 Function booleanOp this is the engine to execute all polygon boolean transforms (AND, OR, ... More...
 
void booleanOp (ClipperLib::ClipType aType, const SHAPE_POLY_SET &aShape, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
 
bool pointInPolygon (const VECTOR2I &aP, const SHAPE_LINE_CHAIN &aPath, bool aIgnoreEdges, bool aUseBBoxCaches=false) const
 
bool containsSingle (const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
 containsSingle function Checks whether the point aP is inside the aSubpolyIndex-th polygon of the polyset. More...
 
POLYGON chamferFilletPolygon (CORNER_MODE aMode, unsigned int aDistance, int aIndex, int aErrorMax, std::set< VECTOR2I > *aPreserveCorners)
 Function chamferFilletPolygon Returns the camfered or filleted version of the aIndex-th polygon in the set, depending on the aMode selected. More...
 
bool hasTouchingHoles (const POLYGON &aPoly) const
 

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

More...
 
MD5_HASH checksum () const
 

Private Attributes

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

Detailed Description

SHAPE_POLY_SET.

Represents a set of closed polygons. Polygons may be nonconvex, self-intersecting and have holes. Provides boolean operations (using Clipper library as the backend).

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

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

TODO: add convex partitioning & spatial index

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

◆ POLYSET

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

Definition at line 1280 of file shape_poly_set.h.

◆ SEGMENT_ITERATOR

◆ VERTEX_INDEX

Struct VERTEX_INDEX.

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

Member Enumeration Documentation

◆ CORNER_MODE

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

Enumerator
CHAMFERED 
FILLETED 

Definition at line 1252 of file shape_poly_set.h.

◆ CORNER_STRATEGY

Enumerator
ALLOW_ACUTE_CORNERS 
CHOP_ACUTE_CORNERS 
ROUND_ACUTE_CORNERS 
ROUND_ALL_CORNERS 

Definition at line 868 of file shape_poly_set.h.

◆ POLYGON_MODE

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

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

Enumerator
PM_FAST 
PM_STRICTLY_SIMPLE 

Definition at line 835 of file shape_poly_set.h.

Constructor & Destructor Documentation

◆ SHAPE_POLY_SET() [1/2]

SHAPE_POLY_SET::SHAPE_POLY_SET ( )

Definition at line 57 of file shape_poly_set.cpp.

57  :
59 {
60 }
SHAPE(SHAPE_TYPE aType)
Constructor.
Definition: shape.h:72
simple polygon
Definition: shape.h:50

Referenced by Clone(), and Collide().

◆ SHAPE_POLY_SET() [2/2]

SHAPE_POLY_SET::SHAPE_POLY_SET ( const SHAPE_POLY_SET aOther,
bool  aDeepCopy = false 
)

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

Parameters
aOtheris the SHAPE_POLY_SET object that will be copied.
aDeepCopyif true, make new copies of the triangulated unique_ptr vector

Definition at line 63 of file shape_poly_set.cpp.

63  :
64  SHAPE( SH_POLY_SET ), m_polys( aOther.m_polys )
65 {
66  if( aOther.IsTriangulationUpToDate() )
67  {
68  for( unsigned i = 0; i < aOther.TriangulatedPolyCount(); i++ )
69  m_triangulatedPolys.push_back(
70  std::make_unique<TRIANGULATED_POLYGON>( *aOther.TriangulatedPolygon( i ) ) );
71 
72  m_hash = aOther.GetHash();
73  m_triangulationValid = true;
74  }
75 }
SHAPE(SHAPE_TYPE aType)
Constructor.
Definition: shape.h:72
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
bool IsTriangulationUpToDate() const
MD5_HASH GetHash() const
simple polygon
Definition: shape.h:50
unsigned int TriangulatedPolyCount() const
Returns the number of triangulated polygons
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 78 of file shape_poly_set.cpp.

79 {
80 }

Member Function Documentation

◆ AddHole()

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

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

Definition at line 423 of file shape_poly_set.cpp.

424 {
425  assert( m_polys.size() );
426 
427  if( aOutline < 0 )
428  aOutline += m_polys.size();
429 
430  POLYGON& poly = m_polys[aOutline];
431 
432  assert( poly.size() );
433 
434  poly.push_back( aHole );
435 
436  return poly.size() - 1;
437 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.

References m_polys.

Referenced by ZONE_CONTAINER::AddPolygon(), KI_TEST::BuildHollowSquare(), and KI_TEST::CommonTestData::CommonTestData().

◆ AddOutline()

int SHAPE_POLY_SET::AddOutline ( const SHAPE_LINE_CHAIN aOutline)

◆ Append() [1/3]

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

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

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

Parameters
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
int - the number of corners of the selected contour after the addition.

Definition at line 201 of file shape_poly_set.cpp.

202 {
203  assert( m_polys.size() );
204 
205  if( aOutline < 0 )
206  aOutline += m_polys.size();
207 
208  int idx;
209 
210  if( aHole < 0 )
211  idx = 0;
212  else
213  idx = aHole + 1;
214 
215  assert( aOutline < (int) m_polys.size() );
216  assert( idx < (int) m_polys[aOutline].size() );
217 
218  m_polys[aOutline][idx].Append( x, y, aAllowDuplication );
219 
220  return m_polys[aOutline][idx].PointCount();
221 }

References m_polys.

Referenced by AR_AUTOPLACER::addFpBody(), addHoleToPolygon(), ZONE_FILLER::addKnockout(), AR_AUTOPLACER::addPad(), D_PAD::AddPrimitive(), addRect(), Append(), ZONE_CONTAINER::AppendCorner(), BuildBoardPolygonOutlines(), D_PAD::buildCustomPadPolygon(), CINFO3D_VISU::buildPadShapePolygon(), D_PAD::BuildPadShapePolygon(), DRC::checkClearancePadToPad(), DRC::checkClearanceSegmToPad(), ConvertOutlineToPolygon(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), CINFO3D_VISU::createNewPadWithClearance(), BITMAPCONV_INFO::createOutputData(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), GERBER_FILE_IMAGE::Execute_G_Command(), fillArcPOLY(), MODULE::GetBoundingPoly(), getRectangleAlongCentreLine(), ZONE_CONTAINER::initDataFromSrcInCopyCtor(), InsertVertex(), EAGLE_PLUGIN::loadPolygon(), LEGACY_PLUGIN::loadZONE_CONTAINER(), ZONE_CONTAINER::operator=(), PCB_PARSER::parseZONE_CONTAINER(), DXF_PLOTTER::PlotPoly(), PlotStandardLayer(), D_PAD::PrintShape(), DRC_COURTYARD_OVERLAP::RunDRC(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), DRAWSEGMENT::SetPolyPoints(), WS_DATA_ITEM_POLYGONS::SyncDrawItems(), PNS_KICAD_IFACE::syncPad(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon(), TransformOvalToPolygon(), TransformRingToPolygon(), TransformRoundChamferedRectToPolygon(), TransformSegmentToPolygon(), DRAWSEGMENT::TransformShapeWithClearanceToPolygon(), D_PAD::TransformShapeWithClearanceToPolygon(), and ZONE_CONTAINER::TransformSolidAreasShapesToPolygonSet().

◆ Append() [2/3]

void SHAPE_POLY_SET::Append ( const SHAPE_POLY_SET aSet)

Merges polygons from two sets.

Definition at line 1289 of file shape_poly_set.cpp.

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

References m_polys.

◆ Append() [3/3]

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

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

Definition at line 1295 of file shape_poly_set.cpp.

1296 {
1297  Append( aP.x, aP.y, aOutline, aHole );
1298 }
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)

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

◆ BBox()

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

Function BBox()

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

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

1134 {
1135  BOX2I bb;
1136 
1137  for( unsigned i = 0; i < m_polys.size(); i++ )
1138  {
1139  if( i == 0 )
1140  bb = m_polys[i][0].BBox();
1141  else
1142  bb.Merge( m_polys[i][0].BBox() );
1143  }
1144 
1145  bb.Inflate( aClearance );
1146  return bb;
1147 }
BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated c...
Definition: box2.h:42
BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Function Merge modifies the position and size of the rectangle in order to contain aRect.
Definition: box2.h:385
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:301
const BOX2I BBox(int aClearance=0) const override
Function BBox()

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

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BOARD::CombineAllAreasInNet(), APERTURE_MACRO::GetApertureMacroShape(), D_PAD::GetBestAnchorPosition(), WS_DRAW_ITEM_POLYPOLYGONS::GetBoundingBox(), GERBER_DRAW_ITEM::GetBoundingBox(), BOARD::TestAreaIntersection(), KIGFX::PREVIEW::POLYGON_ITEM::ViewBBox(), and KIGFX::PREVIEW::CENTRELINE_RECT_ITEM::ViewBBox().

◆ BooleanAdd() [1/2]

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

Performs boolean polyset union For aFastMode meaning, see function booleanOp

Definition at line 476 of file shape_poly_set.cpp.

477 {
478  booleanOp( ctUnion, b, aFastMode );
479 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...

References booleanOp().

Referenced by D_PAD::buildCustomPadPolygon(), BOARD::CombineAreas(), DXF_PLOTTER::PlotPoly(), PlotSilkScreen(), PlotSolderMaskLayer(), C3D_RENDER_OGL_LEGACY::reload(), and TransformRoundChamferedRectToPolygon().

◆ BooleanAdd() [2/2]

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

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

Definition at line 494 of file shape_poly_set.cpp.

497 {
498  booleanOp( ctUnion, a, b, aFastMode );
499 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...

References booleanOp().

◆ BooleanIntersection() [1/2]

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

Performs boolean polyset intersection For aFastMode meaning, see function booleanOp

Definition at line 488 of file shape_poly_set.cpp.

489 {
490  booleanOp( ctIntersection, b, aFastMode );
491 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...

References booleanOp().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), ZONE_FILLER::computeRawFilledArea(), Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(), ZONE_FILLER::fillSingleZone(), DRC_COURTYARD_OVERLAP::RunDRC(), and TransformOvalToPolygon().

◆ BooleanIntersection() [2/2]

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

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

Definition at line 510 of file shape_poly_set.cpp.

513 {
514  booleanOp( ctIntersection, a, b, aFastMode );
515 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...

References booleanOp().

◆ booleanOp() [1/2]

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

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

and polygon simplification (merging overlaping polygons)

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

Definition at line 440 of file shape_poly_set.cpp.

442 {
443  booleanOp( aType, *this, aOtherShape, aFastMode );
444 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...

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

451 {
452  Clipper c;
453 
454  c.StrictlySimple( aFastMode == PM_STRICTLY_SIMPLE );
455 
456  for( auto poly : aShape.m_polys )
457  {
458  for( size_t i = 0 ; i < poly.size(); i++ )
459  c.AddPath( poly[i].convertToClipper( i == 0 ), ptSubject, true );
460  }
461 
462  for( auto poly : aOtherShape.m_polys )
463  {
464  for( size_t i = 0; i < poly.size(); i++ )
465  c.AddPath( poly[i].convertToClipper( i == 0 ), ptClip, true );
466  }
467 
468  PolyTree solution;
469 
470  c.Execute( aType, solution, pftNonZero, pftNonZero );
471 
472  importTree( &solution );
473 }
void importTree(ClipperLib::PolyTree *tree)

References importTree(), m_polys, and PM_STRICTLY_SIMPLE.

◆ BooleanSubtract() [1/2]

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

Performs boolean polyset difference For aFastMode meaning, see function booleanOp

Definition at line 482 of file shape_poly_set.cpp.

483 {
484  booleanOp( ctDifference, b, aFastMode );
485 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...

References booleanOp().

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), addHoleToPolygon(), ZONE_FILLER::computeRawFilledArea(), MODULE::CoverageRatio(), BITMAPCONV_INFO::createOutputData(), C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), AR_AUTOPLACER::genModuleOnRoutingMatrix(), APERTURE_MACRO::GetApertureMacroShape(), ZONE_FILLER::knockoutThermalReliefs(), NormalizeAreaOutlines(), ZONE_CREATE_HELPER::performZoneCutout(), AR_AUTOPLACER::testModuleByPolygon(), and TransformRoundChamferedRectToPolygon().

◆ BooleanSubtract() [2/2]

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

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

Definition at line 502 of file shape_poly_set.cpp.

505 {
506  booleanOp( ctDifference, a, b, aFastMode );
507 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...

References booleanOp().

◆ BuildBBoxCaches()

void SHAPE_POLY_SET::BuildBBoxCaches ( )

Constructs BBoxCaches for Contains(), below.

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

Definition at line 1369 of file shape_poly_set.cpp.

1370 {
1371  for( int polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
1372  {
1373  Outline( polygonIdx ).GenerateBBoxCache();
1374 
1375  for( int holeIdx = 0; holeIdx < HoleCount( polygonIdx ); holeIdx++ )
1376  Hole( polygonIdx, holeIdx ).GenerateBBoxCache();
1377  }
1378 }
int OutlineCount() const
Returns the number of outlines in the set
SHAPE_LINE_CHAIN & Hole(int aOutline, int aHole)
Returns the reference to aHole-th hole in the aIndex-th outline
SHAPE_LINE_CHAIN & Outline(int aIndex)
Returns the reference to aIndex-th outline in the set
int HoleCount(int aOutline) const
Returns the number of holes in a given outline

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

Referenced by ZONE_FILLER::computeRawFilledArea().

◆ CacheTriangulation()

void SHAPE_POLY_SET::CacheTriangulation ( )

Definition at line 1858 of file shape_poly_set.cpp.

1859 {
1860  bool recalculate = !m_hash.IsValid();
1861  MD5_HASH hash;
1862 
1863  if( !m_triangulationValid )
1864  recalculate = true;
1865 
1866  if( !recalculate )
1867  {
1868  hash = checksum();
1869 
1870  if( m_hash != hash )
1871  {
1872  m_hash = hash;
1873  recalculate = true;
1874  }
1875  }
1876 
1877  if( !recalculate )
1878  return;
1879 
1880  SHAPE_POLY_SET tmpSet = *this;
1881 
1882  if( tmpSet.HasHoles() )
1883  tmpSet.Fracture( PM_FAST );
1884 
1885  m_triangulatedPolys.clear();
1886  m_triangulationValid = true;
1887 
1888  while( tmpSet.OutlineCount() > 0 )
1889  {
1890  m_triangulatedPolys.push_back( std::make_unique<TRIANGULATED_POLYGON>() );
1891  PolygonTriangulation tess( *m_triangulatedPolys.back() );
1892 
1893  // If the tesselation fails, we re-fracture the polygon, which will
1894  // first simplify the system before fracturing and removing the holes
1895  // This may result in multiple, disjoint polygons.
1896  if( !tess.TesselatePolygon( tmpSet.Polygon( 0 ).front() ) )
1897  {
1898  tmpSet.Fracture( PM_FAST );
1899  m_triangulationValid = false;
1900  continue;
1901  }
1902 
1903  tmpSet.DeletePolygon( 0 );
1904  m_triangulationValid = true;
1905  }
1906 
1907  if( m_triangulationValid )
1908  m_hash = checksum();
1909 }
int OutlineCount() const
Returns the number of outlines in the set
bool HasHoles() const
Returns true if the polygon set has any holes.
MD5_HASH checksum() const
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys
void DeletePolygon(int aIdx)
Deletes aIdx-th polygon from the set
SHAPE_POLY_SET.
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...
POLYGON & Polygon(int aIndex)
Returns the aIndex-th subpolygon in the set
bool IsValid() const
Definition: md5_hash.h:24

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

Referenced by ZONE_CONTAINER::CacheTriangulation(), Convert_shape_line_polygon_to_triangles(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), polygon_triangulation_main(), and PNS_KICAD_IFACE::syncZone().

◆ CalcShape()

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

Definition at line 713 of file wrlfacet.cpp.

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

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

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

◆ Centre()

virtual VECTOR2I SHAPE::Centre ( ) const
inlinevirtualinherited

Function Centre()

Computes a center-of-mass of the shape

Returns
the center-of-mass point

Definition at line 153 of file shape.h.

154  {
155  return BBox( 0 ).Centre(); // if nothing better is available....
156  }
virtual const BOX2I BBox(int aClearance=0) const =0
Function BBox()
Vec Centre() const
Definition: box2.h:78

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

Referenced by PNS_PCBNEW_RULE_RESOLVER::CollideHoles().

◆ Chamfer()

SHAPE_POLY_SET SHAPE_POLY_SET::Chamfer ( int  aDistance,
std::set< VECTOR2I > *  aPreserveCorners = nullptr 
)

Function Chamfer returns a chamfered version of the polygon set.

Parameters
aDistanceis the chamfering distance.
aPreserveCornersan optional set of corners which should not be chamfered.
Returns
SHAPE_POLY_SET - A set containing the chamfered version of this set.

Definition at line 1632 of file shape_poly_set.cpp.

1633 {
1634  SHAPE_POLY_SET chamfered;
1635 
1636  for( unsigned int idx = 0; idx < m_polys.size(); idx++ )
1637  chamfered.m_polys.push_back( ChamferPolygon( aDistance, idx, aPreserveCorners ) );
1638 
1639  return chamfered;
1640 }
SHAPE_POLY_SET.
POLYGON ChamferPolygon(unsigned int aDistance, int aIndex, std::set< VECTOR2I > *aPreserveCorners)
Function Chamfer returns a chamfered version of the aIndex-th polygon.

References ChamferPolygon(), and m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), and ZONE_CONTAINER::BuildSmoothedPoly().

◆ chamferFilletPolygon()

SHAPE_POLY_SET::POLYGON SHAPE_POLY_SET::chamferFilletPolygon ( CORNER_MODE  aMode,
unsigned int  aDistance,
int  aIndex,
int  aErrorMax,
std::set< VECTOR2I > *  aPreserveCorners 
)
private

Function chamferFilletPolygon Returns the camfered 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.
aPreserveCornersan optional set of corners which should be skipped.
Returns
POLYGON - the chamfered/filleted version of the polygon.

Definition at line 1655 of file shape_poly_set.cpp.

1658 {
1659  // Null segments create serious issues in calculations. Remove them:
1661 
1662  SHAPE_POLY_SET::POLYGON currentPoly = Polygon( aIndex );
1663  SHAPE_POLY_SET::POLYGON newPoly;
1664 
1665  // If the chamfering distance is zero, then the polygon remain intact.
1666  if( aDistance == 0 )
1667  {
1668  return currentPoly;
1669  }
1670 
1671  // Iterate through all the contours (outline and holes) of the polygon.
1672  for( SHAPE_LINE_CHAIN& currContour : currentPoly )
1673  {
1674  // Generate a new contour in the new polygon
1675  SHAPE_LINE_CHAIN newContour;
1676 
1677  // Iterate through the vertices of the contour
1678  for( int currVertex = 0; currVertex < currContour.PointCount(); currVertex++ )
1679  {
1680  // Current vertex
1681  int x1 = currContour.CPoint( currVertex ).x;
1682  int y1 = currContour.CPoint( currVertex ).y;
1683 
1684  if( aPreserveCorners && aPreserveCorners->count( VECTOR2I( x1, y1 ) ) > 0 )
1685  {
1686  newContour.Append( x1, y1 );
1687  continue;
1688  }
1689 
1690  // Indices for previous and next vertices.
1691  int prevVertex;
1692  int nextVertex;
1693 
1694  // Previous and next vertices indices computation. Necessary to manage the edge cases.
1695 
1696  // Previous vertex is the last one if the current vertex is the first one
1697  prevVertex = currVertex == 0 ? currContour.PointCount() - 1 : currVertex - 1;
1698 
1699  // next vertex is the first one if the current vertex is the last one.
1700  nextVertex = currVertex == currContour.PointCount() - 1 ? 0 : currVertex + 1;
1701 
1702  // Previous vertex computation
1703  double xa = currContour.CPoint( prevVertex ).x - x1;
1704  double ya = currContour.CPoint( prevVertex ).y - y1;
1705 
1706  // Next vertex computation
1707  double xb = currContour.CPoint( nextVertex ).x - x1;
1708  double yb = currContour.CPoint( nextVertex ).y - y1;
1709 
1710  // Compute the new distances
1711  double lena = hypot( xa, ya );
1712  double lenb = hypot( xb, yb );
1713 
1714  // Make the final computations depending on the mode selected, chamfered or filleted.
1715  if( aMode == CORNER_MODE::CHAMFERED )
1716  {
1717  double distance = aDistance;
1718 
1719  // Chamfer one half of an edge at most
1720  if( 0.5 * lena < distance )
1721  distance = 0.5 * lena;
1722 
1723  if( 0.5 * lenb < distance )
1724  distance = 0.5 * lenb;
1725 
1726  int nx1 = KiROUND( distance * xa / lena );
1727  int ny1 = KiROUND( distance * ya / lena );
1728 
1729  newContour.Append( x1 + nx1, y1 + ny1 );
1730 
1731  int nx2 = KiROUND( distance * xb / lenb );
1732  int ny2 = KiROUND( distance * yb / lenb );
1733 
1734  newContour.Append( x1 + nx2, y1 + ny2 );
1735  }
1736  else // CORNER_MODE = FILLETED
1737  {
1738  double cosine = ( xa * xb + ya * yb ) / ( lena * lenb );
1739 
1740  double radius = aDistance;
1741  double denom = sqrt( 2.0 / ( 1 + cosine ) - 1 );
1742 
1743  // Do nothing in case of parallel edges
1744  if( std::isinf( denom ) )
1745  continue;
1746 
1747  // Limit rounding distance to one half of an edge
1748  if( 0.5 * lena * denom < radius )
1749  radius = 0.5 * lena * denom;
1750 
1751  if( 0.5 * lenb * denom < radius )
1752  radius = 0.5 * lenb * denom;
1753 
1754  // Calculate fillet arc absolute center point (xc, yx)
1755  double k = radius / sqrt( .5 * ( 1 - cosine ) );
1756  double lenab = sqrt( ( xa / lena + xb / lenb ) * ( xa / lena + xb / lenb ) +
1757  ( ya / lena + yb / lenb ) * ( ya / lena + yb / lenb ) );
1758  double xc = x1 + k * ( xa / lena + xb / lenb ) / lenab;
1759  double yc = y1 + k * ( ya / lena + yb / lenb ) / lenab;
1760 
1761  // Calculate arc start and end vectors
1762  k = radius / sqrt( 2 / ( 1 + cosine ) - 1 );
1763  double xs = x1 + k * xa / lena - xc;
1764  double ys = y1 + k * ya / lena - yc;
1765  double xe = x1 + k * xb / lenb - xc;
1766  double ye = y1 + k * yb / lenb - yc;
1767 
1768  // Cosine of arc angle
1769  double argument = ( xs * xe + ys * ye ) / ( radius * radius );
1770 
1771  // Make sure the argument is in [-1,1], interval in which the acos function is
1772  // defined
1773  if( argument < -1 )
1774  argument = -1;
1775  else if( argument > 1 )
1776  argument = 1;
1777 
1778  double arcAngle = acos( argument );
1779  double arcAngleDegrees = arcAngle * 180.0 / M_PI;
1780  int segments = GetArcToSegmentCount( radius, aErrorMax, arcAngleDegrees );
1781 
1782  double deltaAngle = arcAngle / segments;
1783  double startAngle = atan2( -ys, xs );
1784 
1785  // Flip arc for inner corners
1786  if( xa * yb - ya * xb <= 0 )
1787  deltaAngle *= -1;
1788 
1789  double nx = xc + xs;
1790  double ny = yc + ys;
1791 
1792  newContour.Append( KiROUND( nx ), KiROUND( ny ) );
1793 
1794  // Store the previous added corner to make a sanity check
1795  int prevX = KiROUND( nx );
1796  int prevY = KiROUND( ny );
1797 
1798  for( int j = 0; j < segments; j++ )
1799  {
1800  nx = xc + cos( startAngle + ( j + 1 ) * deltaAngle ) * radius;
1801  ny = yc - sin( startAngle + ( j + 1 ) * deltaAngle ) * radius;
1802 
1803  // Sanity check: the rounding can produce repeated corners; do not add them.
1804  if( KiROUND( nx ) != prevX || KiROUND( ny ) != prevY )
1805  {
1806  newContour.Append( KiROUND( nx ), KiROUND( ny ) );
1807  prevX = KiROUND( nx );
1808  prevY = KiROUND( ny );
1809  }
1810  }
1811  }
1812  }
1813 
1814  // Close the current contour and add it the new polygon
1815  newContour.SetClosed( true );
1816  newPoly.push_back( newContour );
1817  }
1818 
1819  return newPoly;
1820 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
void Append(int aX, int aY, bool aAllowDuplication=false)
Function Append()
const VECTOR2I & CPoint(int aIndex) const
Function Point()
void SetClosed(bool aClosed)
Function SetClosed()
int RemoveNullSegments()
Function RemoveNullSegments looks for null segments; ie, segments whose ends are exactly the same and...
SHAPE_LINE_CHAIN.
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)
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:61
POLYGON & Polygon(int aIndex)
Returns the aIndex-th subpolygon in the set
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,
std::set< VECTOR2I > *  aPreserveCorners 
)

Function Chamfer returns a chamfered version of the aIndex-th polygon.

Parameters
aDistanceis the chamfering distance.
aIndexis the index of the polygon to be chamfered.
aPreserveCornersan optional set of corners which should not be chamfered.
Returns
POLYGON - A polygon containing the chamfered version of the aIndex-th polygon.

Definition at line 1507 of file shape_poly_set.cpp.

1509 {
1510  return chamferFilletPolygon( CHAMFERED, aDistance, aIndex, 0, aPreserveCorners );
1511 }
POLYGON chamferFilletPolygon(CORNER_MODE aMode, unsigned int aDistance, int aIndex, int aErrorMax, std::set< VECTOR2I > *aPreserveCorners)
Function chamferFilletPolygon Returns the camfered or filleted version of the aIndex-th polygon in th...

References CHAMFERED, and chamferFilletPolygon().

Referenced by Chamfer().

◆ checksum()

MD5_HASH SHAPE_POLY_SET::checksum ( ) const
private

Definition at line 1912 of file shape_poly_set.cpp.

1913 {
1914  MD5_HASH hash;
1915 
1916  hash.Hash( m_polys.size() );
1917 
1918  for( const auto& outline : m_polys )
1919  {
1920  hash.Hash( outline.size() );
1921 
1922  for( const auto& lc : outline )
1923  {
1924  hash.Hash( lc.PointCount() );
1925 
1926  for( int i = 0; i < lc.PointCount(); i++ )
1927  {
1928  hash.Hash( lc.CPoint( i ).x );
1929  hash.Hash( lc.CPoint( i ).y );
1930  }
1931  }
1932  }
1933 
1934  hash.Finalize();
1935 
1936  return hash;
1937 }
void Hash(uint8_t *data, uint32_t length)
Definition: md5_hash.cpp:66
void Finalize()
Definition: md5_hash.cpp:76

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

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

◆ CHole()

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

◆ CIterate() [1/3]

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

Definition at line 706 of file shape_poly_set.h.

707  {
708  CONST_ITERATOR iter;
709 
710  iter.m_poly = const_cast<SHAPE_POLY_SET*>( this );
711  iter.m_currentPolygon = aFirst;
712  iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
713  iter.m_currentContour = 0;
714  iter.m_currentVertex = 0;
715  iter.m_iterateHoles = aIterateHoles;
716 
717  return iter;
718  }
int OutlineCount() const
Returns the number of outlines in the set
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 D_PAD::AddPrimitive(), DRAWSEGMENT::BuildPolyPointsList(), ConvertOutlineToPolygon(), PCB_IO::format(), DRAWSEGMENT::GetBoundingBox(), ZONE_CONTAINER::GetColinearCorners(), EDGE_MODULE::Print(), and PNS_KICAD_IFACE::syncPad().

◆ CIterate() [2/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( int  aOutline) const
inline

Definition at line 720 of file shape_poly_set.h.

721  {
722  return CIterate( aOutline, aOutline );
723  }
CONST_ITERATOR CIterate() const

References CIterate().

◆ CIterate() [3/3]

CONST_ITERATOR SHAPE_POLY_SET::CIterate ( ) const
inline

Definition at line 730 of file shape_poly_set.h.

731  {
732  return CIterate( 0, OutlineCount() - 1 );
733  }
int OutlineCount() const
Returns the number of outlines in the set
CONST_ITERATOR CIterate() const

References OutlineCount().

Referenced by CIterate(), and CIterateWithHoles().

◆ CIterateSegments() [1/2]

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

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

without holes (default: without)

Definition at line 777 of file shape_poly_set.h.

779  {
781 
782  iter.m_poly = const_cast<SHAPE_POLY_SET*>( this );
783  iter.m_currentPolygon = aFirst;
784  iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
785  iter.m_currentContour = 0;
786  iter.m_currentSegment = 0;
787  iter.m_iterateHoles = aIterateHoles;
788 
789  return iter;
790  }
int OutlineCount() const
Returns the number of outlines in the set
SEGMENT_ITERATOR_TEMPLATE< const SEG > CONST_SEGMENT_ITERATOR

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

Referenced by CIterateSegments(), CIterateSegmentsWithHoles(), and BRDITEMS_PLOTTER::PlotDrawSegment().

◆ CIterateSegments() [2/2]

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegments ( int  aPolygonIdx) const
inline

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

Definition at line 799 of file shape_poly_set.h.

800  {
801  return CIterateSegments( aPolygonIdx, aPolygonIdx );
802  }
CONST_SEGMENT_ITERATOR CIterateSegments(int aFirst, int aLast, bool aIterateHoles=false) const
Returns an iterator object, for iterating between aFirst and aLast outline, with or without holes (de...

References CIterateSegments().

◆ CIterateSegmentsWithHoles()

CONST_SEGMENT_ITERATOR SHAPE_POLY_SET::CIterateSegmentsWithHoles ( int  aOutline) const
inline

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

Definition at line 823 of file shape_poly_set.h.

824  {
825  return CIterateSegments( aOutline, aOutline, true );
826  }
CONST_SEGMENT_ITERATOR CIterateSegments(int aFirst, int aLast, bool aIterateHoles=false) const
Returns an iterator object, for iterating between aFirst and aLast outline, with or without holes (de...

References CIterateSegments().

Referenced by IsPolygonSelfIntersecting().

◆ CIterateWithHoles() [1/2]

CONST_ITERATOR SHAPE_POLY_SET::CIterateWithHoles ( int  aOutline) const
inline

Definition at line 725 of file shape_poly_set.h.

726  {
727  return CIterate( aOutline, aOutline, true );
728  }
CONST_ITERATOR CIterate() const

References CIterate().

Referenced by EDIT_POINTS_FACTORY::buildForPolyOutline(), ZONE_CONTAINER::CIterateWithHoles(), and GRID_HELPER::computeAnchors().

◆ CIterateWithHoles() [2/2]

CONST_ITERATOR SHAPE_POLY_SET::CIterateWithHoles ( ) const
inline

Definition at line 735 of file shape_poly_set.h.

736  {
737  return CIterate( 0, OutlineCount() - 1, true );
738  }
int OutlineCount() const
Returns the number of outlines in the set
CONST_ITERATOR CIterate() const

References CIterate(), and OutlineCount().

◆ Clone()

SHAPE * SHAPE_POLY_SET::Clone ( ) const
overridevirtual

Function Clone()

Returns a dynamically allocated copy of the shape

Return values
copyof the shape

Reimplemented from SHAPE.

Definition at line 83 of file shape_poly_set.cpp.

84 {
85  return new SHAPE_POLY_SET( *this );
86 }

References SHAPE_POLY_SET().

◆ Collide() [1/4]

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

Function Collide()

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

Parameters
aShapeshape to check collision against
aClearanceminimum clearance
aMTVminimum translation vector
Returns
true, if there is a collision.

Definition at line 549 of file shape_collisions.cpp.

550 {
551  return CollideShapes( this, aShape, aClearance, true, aMTV );
552 }
bool CollideShapes(const SHAPE *aA, const SHAPE *aB, int aClearance, bool aNeedMTV, VECTOR2I &aMTV)

References CollideShapes().

◆ Collide() [2/4]

bool SHAPE::Collide ( const SHAPE aShape,
int  aClearance = 0 
) const
virtualinherited

Definition at line 555 of file shape_collisions.cpp.

556 {
557  VECTOR2I dummy;
558 
559  return CollideShapes( this, aShape, aClearance, false, dummy );
560 }
VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
static LIB_PART * dummy()
Used to draw a dummy shape when a LIB_PART is not found in library.
bool CollideShapes(const SHAPE *aA, const SHAPE *aB, int aClearance, bool aNeedMTV, VECTOR2I &aMTV)

References CollideShapes(), and dummy().

◆ Collide() [3/4]

bool SHAPE_POLY_SET::Collide ( const VECTOR2I aP,
int  aClearance = 0 
) const
overridevirtual

Function Collide Checks whether the point aP collides with the inside of the polygon set; if the point lies on an edge or on a corner of any of the polygons, there is no collision: the edges does not belong to the polygon itself.

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.
Returns
bool - true if the point aP collides with the polygon; false in any other case.

Reimplemented from SHAPE.

Definition at line 1198 of file shape_poly_set.cpp.

1199 {
1200  SHAPE_POLY_SET polySet = SHAPE_POLY_SET( *this );
1201 
1202  // Inflate the polygon if necessary.
1203  if( aClearance > 0 )
1204  {
1205  // fixme: the number of arc segments should not be hardcoded
1206  polySet.Inflate( aClearance, 8 );
1207  }
1208 
1209  // There is a collision if and only if the point is inside of the polygon.
1210  return polySet.Contains( aP );
1211 }
bool Contains(const VECTOR2I &aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=false) const
Returns true if a given subpolygon contains the point aP.
void Inflate(int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
Performs outline inflation/deflation.
SHAPE_POLY_SET.

References Contains(), Inflate(), and SHAPE_POLY_SET().

Referenced by WS_DRAW_ITEM_POLYPOLYGONS::HitTest(), DRAWSEGMENT::HitTest(), and MODULE::HitTestAccurate().

◆ Collide() [4/4]

bool SHAPE_POLY_SET::Collide ( const SEG aSeg,
int  aClearance = 0 
) const
overridevirtual

Function Collide Checks whether the segment aSeg collides with the inside of the polygon set; if the segment touches an edge or a corner of any of the polygons, there is no collision: the edges do not belong to the polygon itself.

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.
Returns
bool - true if the segment aSeg collides with the polygon; false in any other case.

Implements SHAPE.

Definition at line 1167 of file shape_poly_set.cpp.

1168 {
1169 
1170  SHAPE_POLY_SET polySet = SHAPE_POLY_SET( *this );
1171 
1172  // Inflate the polygon if necessary.
1173  if( aClearance > 0 )
1174  {
1175  // fixme: the number of arc segments should not be hardcoded
1176  polySet.Inflate( aClearance, 8 );
1177  }
1178 
1179  // We are going to check to see if the segment crosses an external
1180  // boundary. However, if the full segment is inside the polyset, this
1181  // will not be true. So we first test to see if one of the points is
1182  // inside. If true, then we collide
1183  if( polySet.Contains( aSeg.A ) )
1184  return true;
1185 
1186  for( SEGMENT_ITERATOR it = ( (SHAPE_POLY_SET*) this )->IterateSegmentsWithHoles(); it; it++ )
1187  {
1188  SEG polygonEdge = *it;
1189 
1190  if( polygonEdge.Intersect( aSeg, true ) )
1191  return true;
1192  }
1193 
1194  return false;
1195 }
OPT_VECTOR2I Intersect(const SEG &aSeg, bool aIgnoreEndpoints=false, bool aLines=false) const
Function Intersect()
Definition: seg.cpp:144
SEGMENT_ITERATOR_TEMPLATE< SEG > SEGMENT_ITERATOR
bool Contains(const VECTOR2I &aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=false) const
Returns true if a given subpolygon contains the point aP.
void Inflate(int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
Performs outline inflation/deflation.
SHAPE_POLY_SET.
Definition: seg.h:39
VECTOR2I A
Definition: seg.h:47

References SEG::A, Contains(), Inflate(), SEG::Intersect(), and SHAPE_POLY_SET().

◆ CollideEdge()

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

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

1341 {
1342  // Shows whether there was a collision
1343  bool collision = false;
1344 
1345  SEGMENT_ITERATOR iterator;
1346 
1347  for( iterator = IterateSegmentsWithHoles(); iterator; iterator++ )
1348  {
1349  SEG currentSegment = *iterator;
1350  int distance = currentSegment.Distance( aPoint );
1351 
1352  // Check for collisions
1353  if( distance <= aClearance )
1354  {
1355  collision = true;
1356 
1357  // Update aClearance to look for closer edges
1358  aClearance = distance;
1359 
1360  // Store the indices that identify the vertex
1361  aClosestVertex = iterator.GetIndex();
1362  }
1363  }
1364 
1365  return collision;
1366 }
int Distance(const SEG &aSeg) const
Function Distance()
Definition: seg.h:202
SEGMENT_ITERATOR IterateSegmentsWithHoles()
Returns an iterator object, for all outlines in the set (with holes)
SEGMENT_ITERATOR_TEMPLATE< SEG > SEGMENT_ITERATOR
Definition: seg.h:39
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)

References SEG::Distance(), distance(), SHAPE_POLY_SET::SEGMENT_ITERATOR_TEMPLATE< T >::GetIndex(), and IterateSegmentsWithHoles().

Referenced by DRAWSEGMENT::HitTest(), and ZONE_CONTAINER::HitTestForEdge().

◆ CollideVertex()

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

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

1303 {
1304  // Shows whether there was a collision
1305  bool collision = false;
1306 
1307  // Difference vector between each vertex and aPoint.
1308  VECTOR2D delta;
1309  double distance, clearance;
1310 
1311  // Convert clearance to double for precission when comparing distances
1312  clearance = aClearance;
1313 
1314  for( ITERATOR iterator = IterateWithHoles(); iterator; iterator++ )
1315  {
1316  // Get the difference vector between current vertex and aPoint
1317  delta = *iterator - aPoint;
1318 
1319  // Compute distance
1320  distance = delta.EuclideanNorm();
1321 
1322  // Check for collisions
1323  if( distance <= clearance )
1324  {
1325  collision = true;
1326 
1327  // Update aClearance to look for closer vertices
1328  clearance = distance;
1329 
1330  // Store the indices that identify the vertex
1331  aClosestVertex = iterator.GetIndex();
1332  }
1333  }
1334 
1335  return collision;
1336 }
ITERATOR_TEMPLATE< VECTOR2I > ITERATOR
ITERATOR IterateWithHoles()
Function IterateWithHoles.
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)
T EuclideanNorm() const
Destructor.
Definition: vector2d.h:299

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

Referenced by ZONE_CONTAINER::HitTestForCorner().

◆ Contains()

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

Returns true if a given subpolygon contains the point aP.

Parameters
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 point

Definition at line 1381 of file shape_poly_set.cpp.

1383 {
1384  if( m_polys.empty() )
1385  return false;
1386 
1387  // If there is a polygon specified, check the condition against that polygon
1388  if( aSubpolyIndex >= 0 )
1389  return containsSingle( aP, aSubpolyIndex, aAccuracy, aUseBBoxCaches );
1390 
1391  // In any other case, check it against all polygons in the set
1392  for( int polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
1393  {
1394  if( containsSingle( aP, polygonIdx, aAccuracy, aUseBBoxCaches ) )
1395  return true;
1396  }
1397 
1398  return false;
1399 }
int OutlineCount() const
Returns the number of outlines in the set
bool containsSingle(const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
containsSingle function Checks whether the point aP is inside the aSubpolyIndex-th polygon of the pol...

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

Referenced by Collide(), ZONE_FILLER::computeRawFilledArea(), ZONE_FILLER::Fill(), D_PAD::GetBestAnchorPosition(), GERBER_DRAW_ITEM::HitTest(), ZONE_CONTAINER::HitTestFilledArea(), and BOARD::TestAreaIntersection().

◆ containsSingle()

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

containsSingle function Checks whether the point aP is inside the aSubpolyIndex-th polygon of the polyset.

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

Parameters
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
bool - true if aP is inside aSubpolyIndex-th polygon; false in any other case.

Definition at line 1437 of file shape_poly_set.cpp.

1439 {
1440  // Check that the point is inside the outline
1441  if( m_polys[aSubpolyIndex][0].PointInside( aP, aAccuracy ) )
1442  {
1443  // Check that the point is not in any of the holes
1444  for( int holeIdx = 0; holeIdx < HoleCount( aSubpolyIndex ); holeIdx++ )
1445  {
1446  const SHAPE_LINE_CHAIN& hole = CHole( aSubpolyIndex, holeIdx );
1447 
1448  // If the point is inside a hole it is outside of the polygon. Do not use aAccuracy
1449  // here as it's meaning would be inverted.
1450  if( hole.PointInside( aP, 1, aUseBBoxCaches ) )
1451  return false;
1452  }
1453 
1454  return true;
1455  }
1456 
1457  return false;
1458 }
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
int HoleCount(int aOutline) const
Returns the number of holes in a given outline
SHAPE_LINE_CHAIN.
bool PointInside(const VECTOR2I &aPt, int aAccuracy=0, bool aUseBBoxCache=false) const
Function PointInside()

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

Referenced by Contains(), and DistanceToPolygon().

◆ COutline()

◆ CPolygon()

◆ CVertex() [1/3]

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

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

Definition at line 286 of file shape_poly_set.cpp.

287 {
288  if( aOutline < 0 )
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  assert( aOutline < (int) m_polys.size() );
299  assert( idx < (int) m_polys[aOutline].size() );
300 
301  return m_polys[aOutline][idx].CPoint( aIndex );
302 }

References m_polys.

Referenced by POINT_EDITOR::addCorner(), CVertex(), D_CODE::DrawFlashedPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), GERBER_FILE_IMAGE::Execute_G_Command(), findVertex(), ZONE_CONTAINER::GetCornerPosition(), DRAWSEGMENT::GetPosition(), ZONE_CONTAINER::Hatch(), DRAWSEGMENT::HitTest(), ZONE_CONTAINER::HitTest(), ZONE_CONTAINER::MoveEdge(), DRC_COURTYARD_OVERLAP::RunDRC(), ZONE_CONTAINER::SetCornerPosition(), POINT_EDITOR::updateItem(), and POINT_EDITOR::updatePoints().

◆ CVertex() [2/3]

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

Returns the aGlobalIndex-th vertex in the poly set

Definition at line 305 of file shape_poly_set.cpp.

306 {
308 
309  // Assure the passed index references a legal position; abort otherwise
310  if( !GetRelativeIndices( aGlobalIndex, &index ) )
311  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
312 
313  return m_polys[index.m_polygon][index.m_contour].CPoint( index.m_vertex );
314 }
Struct VERTEX_INDEX.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Function GetRelativeIndices.

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

◆ CVertex() [3/3]

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

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

Definition at line 317 of file shape_poly_set.cpp.

318 {
319  return CVertex( index.m_vertex, index.m_polygon, index.m_contour - 1 );
320 }
const VECTOR2I & CVertex(int aIndex, int aOutline, int aHole) const
Returns the index-th vertex in a given hole outline within a given outline

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

893  {
894  Inflate( -aAmount, aCircleSegmentsCount, aCornerStrategy );
895  }
void Inflate(int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
Performs outline inflation/deflation.

References Inflate().

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

◆ DeletePolygon()

void SHAPE_POLY_SET::DeletePolygon ( int  aIdx)

Deletes aIdx-th polygon from the set

Definition at line 1283 of file shape_poly_set.cpp.

1284 {
1285  m_polys.erase( m_polys.begin() + aIdx );
1286 }

References m_polys.

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

◆ Distance() [1/2]

int SHAPE_POLY_SET::Distance ( VECTOR2I  aPoint)

Function DistanceToPolygon computes the minimum distance between aPoint and all the polygons in the set.

Parameters
aPointis the point whose distance to the set has to be measured.
Returns
int - The minimum distance 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 1583 of file shape_poly_set.cpp.

1584 {
1585  int currentDistance;
1586  int minDistance = DistanceToPolygon( aPoint, 0 );
1587 
1588  // Iterate through all the polygons and get the minimum distance.
1589  for( unsigned int polygonIdx = 1; polygonIdx < m_polys.size(); polygonIdx++ )
1590  {
1591  currentDistance = DistanceToPolygon( aPoint, polygonIdx );
1592 
1593  if( currentDistance < minDistance )
1594  minDistance = currentDistance;
1595  }
1596 
1597  return minDistance;
1598 }
int DistanceToPolygon(VECTOR2I aPoint, int aIndex)
Function DistanceToPolygon computes the minimum distance between the aIndex-th polygon and aPoint.

References DistanceToPolygon(), and m_polys.

Referenced by BOOST_AUTO_TEST_CASE(), DRC_MARKER_FACTORY::NewMarker(), DRC::testCopperDrawItem(), and DRC::testCopperTextItem().

◆ Distance() [2/2]

int SHAPE_POLY_SET::Distance ( const SEG aSegment,
int  aSegmentWidth = 0 
)

Function DistanceToPolygon computes the minimum distance between aSegment and all the polygons in the set.

Parameters
aSegmentis the segment whose distance to the polygon set has to be measured.
aSegmentWidthis the width of the segment; defaults to zero.
Returns
int - The minimum distance between aSegment and all the polygons in the set. If the point is contained in the polygon, the distance is zero.

Definition at line 1601 of file shape_poly_set.cpp.

1602 {
1603  int currentDistance;
1604  int minDistance = DistanceToPolygon( aSegment, 0, aSegmentWidth );
1605 
1606  // Iterate through all the polygons and get the minimum distance.
1607  for( unsigned int polygonIdx = 1; polygonIdx < m_polys.size(); polygonIdx++ )
1608  {
1609  currentDistance = DistanceToPolygon( aSegment, polygonIdx, aSegmentWidth );
1610 
1611  if( currentDistance < minDistance )
1612  minDistance = currentDistance;
1613  }
1614 
1615  return minDistance;
1616 }
int DistanceToPolygon(VECTOR2I aPoint, int aIndex)
Function DistanceToPolygon computes the minimum distance between the aIndex-th polygon and aPoint.

References DistanceToPolygon(), and m_polys.

◆ DistanceToPolygon() [1/2]

int SHAPE_POLY_SET::DistanceToPolygon ( VECTOR2I  aPoint,
int  aIndex 
)

Function DistanceToPolygon computes 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 distace to aPoint has to be measured.
Returns
int - The minimum distance between aPoint and all the segments of the aIndex-th polygon. If the point is contained in the polygon, the distance is zero.

Definition at line 1522 of file shape_poly_set.cpp.

1523 {
1524  // We calculate the min dist between the segment and each outline segment. However, if the
1525  // segment to test is inside the outline, and does not cross any edge, it can be seen outside
1526  // the polygon. Therefore test if a segment end is inside (testing only one end is enough).
1527  // Use an accuracy of "1" to say that we don't care if it's exactly on the edge or not.
1528  if( containsSingle( aPoint, aPolygonIndex, 1 ) )
1529  return 0;
1530 
1531  SEGMENT_ITERATOR iterator = IterateSegmentsWithHoles( aPolygonIndex );
1532 
1533  SEG polygonEdge = *iterator;
1534  int minDistance = polygonEdge.Distance( aPoint );
1535 
1536  for( iterator++; iterator && minDistance > 0; iterator++ )
1537  {
1538  polygonEdge = *iterator;
1539 
1540  int currentDistance = polygonEdge.Distance( aPoint );
1541 
1542  if( currentDistance < minDistance )
1543  minDistance = currentDistance;
1544  }
1545 
1546  return minDistance;
1547 }
int Distance(const SEG &aSeg) const
Function Distance()
Definition: seg.h:202
SEGMENT_ITERATOR IterateSegmentsWithHoles()
Returns an iterator object, for all outlines in the set (with holes)
SEGMENT_ITERATOR_TEMPLATE< SEG > SEGMENT_ITERATOR
Definition: seg.h:39
bool containsSingle(const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
containsSingle function Checks whether the point aP is inside the aSubpolyIndex-th polygon of the pol...

References containsSingle(), SEG::Distance(), and IterateSegmentsWithHoles().

Referenced by Distance().

◆ DistanceToPolygon() [2/2]

int SHAPE_POLY_SET::DistanceToPolygon ( const SEG aSegment,
int  aIndex,
int  aSegmentWidth = 0 
)

Function DistanceToPolygon computes 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 distace to aPoint has to be measured.
aSegmentWidthis the width of the segment; defaults to zero.
Returns
int - The minimum distance between aSegment and all the segments of the aIndex-th polygon. If the point is contained in the polygon, the distance is zero.

Definition at line 1550 of file shape_poly_set.cpp.

1551 {
1552  // We calculate the min dist between the segment and each outline segment. However, if the
1553  // segment to test is inside the outline, and does not cross any edge, it can be seen outside
1554  // the polygon. Therefore test if a segment end is inside (testing only one end is enough).
1555  // Use an accuracy of "1" to say that we don't care if it's exactly on the edge or not.
1556  if( containsSingle( aSegment.A, aPolygonIndex, 1 ) )
1557  return 0;
1558 
1559  SEGMENT_ITERATOR iterator = IterateSegmentsWithHoles( aPolygonIndex );
1560 
1561  SEG polygonEdge = *iterator;
1562  int minDistance = polygonEdge.Distance( aSegment );
1563 
1564  for( iterator++; iterator && minDistance > 0; iterator++ )
1565  {
1566  polygonEdge = *iterator;
1567 
1568  int currentDistance = polygonEdge.Distance( aSegment );
1569 
1570  if( currentDistance < minDistance )
1571  minDistance = currentDistance;
1572  }
1573 
1574  // Take into account the width of the segment
1575  if( aSegmentWidth > 0 )
1576  minDistance -= aSegmentWidth / 2;
1577 
1578  // Return the maximum of minDistance and zero
1579  return minDistance < 0 ? 0 : minDistance;
1580 }
int Distance(const SEG &aSeg) const
Function Distance()
Definition: seg.h:202
SEGMENT_ITERATOR IterateSegmentsWithHoles()
Returns an iterator object, for all outlines in the set (with holes)
SEGMENT_ITERATOR_TEMPLATE< SEG > SEGMENT_ITERATOR
Definition: seg.h:39
VECTOR2I A
Definition: seg.h:47
bool containsSingle(const VECTOR2I &aP, int aSubpolyIndex, int aAccuracy, bool aUseBBoxCaches=false) const
containsSingle function Checks whether the point aP is inside the aSubpolyIndex-th polygon of the pol...

References SEG::A, containsSingle(), SEG::Distance(), and IterateSegmentsWithHoles().

◆ Fillet()

SHAPE_POLY_SET SHAPE_POLY_SET::Fillet ( int  aRadius,
int  aErrorMax,
std::set< VECTOR2I > *  aPreserveCorners = nullptr 
)

Function Fillet returns a filleted version of the polygon set.

Parameters
aRadiusis the fillet radius.
aErrorMaxis the maximum allowable deviation of the polygon from the circle
aPreserveCornersan optional set of corners which should not be filleted.
Returns
SHAPE_POLY_SET - A set containing the filleted version of this set.

Definition at line 1643 of file shape_poly_set.cpp.

1645 {
1646  SHAPE_POLY_SET filleted;
1647 
1648  for( size_t idx = 0; idx < m_polys.size(); idx++ )
1649  filleted.m_polys.push_back( FilletPolygon( aRadius, aErrorMax, idx, aPreserveCorners ) );
1650 
1651  return filleted;
1652 }
SHAPE_POLY_SET.
POLYGON FilletPolygon(unsigned int aRadius, int aErrorMax, int aIndex, std::set< VECTOR2I > *aPreserveCorners=nullptr)
Function Fillet returns a filleted version of the aIndex-th polygon.

References FilletPolygon(), and m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), and ZONE_CONTAINER::BuildSmoothedPoly().

◆ FilletPolygon()

SHAPE_POLY_SET::POLYGON SHAPE_POLY_SET::FilletPolygon ( unsigned int  aRadius,
int  aErrorMax,
int  aIndex,
std::set< VECTOR2I > *  aPreserveCorners = nullptr 
)

Function Fillet returns 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
aPreserveCornersan optional set of corners which should not be filleted.
Returns
POLYGON - A polygon containing the filleted version of the aIndex-th polygon.

Definition at line 1514 of file shape_poly_set.cpp.

1517 {
1518  return chamferFilletPolygon( FILLETED, aRadius, aIndex, aErrorMax, aPreserveCorners );
1519 }
POLYGON chamferFilletPolygon(CORNER_MODE aMode, unsigned int aDistance, int aIndex, int aErrorMax, std::set< VECTOR2I > *aPreserveCorners)
Function chamferFilletPolygon Returns the camfered or filleted version of the aIndex-th polygon in th...

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

1050 {
1051  std::stringstream ss;
1052 
1053  ss << "polyset " << m_polys.size() << "\n";
1054 
1055  for( unsigned i = 0; i < m_polys.size(); i++ )
1056  {
1057  ss << "poly " << m_polys[i].size() << "\n";
1058 
1059  for( unsigned j = 0; j < m_polys[i].size(); j++ )
1060  {
1061  ss << m_polys[i][j].PointCount() << "\n";
1062 
1063  for( int v = 0; v < m_polys[i][j].PointCount(); v++ )
1064  ss << m_polys[i][j].CPoint( v ).x << " " << m_polys[i][j].CPoint( v ).y << "\n";
1065  }
1066 
1067  ss << "\n";
1068  }
1069 
1070  return ss.str();
1071 }

References m_polys.

◆ Fracture()

void SHAPE_POLY_SET::Fracture ( POLYGON_MODE  aFastMode)

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

Definition at line 810 of file shape_poly_set.cpp.

811 {
812  Simplify( aFastMode ); // remove overlapping holes/degeneracy
813 
814  for( POLYGON& paths : m_polys )
815  {
816  fractureSingle( paths );
817  }
818 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
void fractureSingle(POLYGON &paths)
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...

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

Referenced by addHoleToPolygon(), D_PAD::AddPrimitive(), D_PAD::buildCustomPadPolygon(), CacheTriangulation(), ZONE_FILLER::computeRawFilledArea(), MODULE::CoverageRatio(), BITMAPCONV_INFO::createOutputData(), AR_AUTOPLACER::drawPlacementRoutingMatrix(), export_vrml_polygon(), AR_AUTOPLACER::fillMatrix(), ZONE_FILLER::fillSingleZone(), APERTURE_MACRO::GetApertureMacroShape(), InflateWithLinkedHoles(), EAGLE_PLUGIN::loadPolygon(), BRDITEMS_PLOTTER::Plot_1_EdgeModule(), BRDITEMS_PLOTTER::PlotDrawSegment(), DXF_PLOTTER::PlotPoly(), PlotSilkScreen(), PlotSolderMaskLayer(), PlotStandardLayer(), C3D_RENDER_RAYTRACING::reload(), ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon(), TransformRingToPolygon(), D_PAD::TransformShapeWithClearanceToPolygon(), and GBR_TO_PCB_EXPORTER::writePcbPolygonItem().

◆ fractureSingle()

void SHAPE_POLY_SET::fractureSingle ( POLYGON paths)
private

Definition at line 706 of file shape_poly_set.cpp.

707 {
708  FractureEdgeSet edges;
709  FractureEdgeSet border_edges;
710  FractureEdge* root = NULL;
711 
712  bool first = true;
713 
714  if( paths.size() == 1 )
715  return;
716 
717  int num_unconnected = 0;
718 
719  for( const SHAPE_LINE_CHAIN& path : paths )
720  {
721  const std::vector<VECTOR2I>& points = path.CPoints();
722  int pointCount = points.size();
723 
724  FractureEdge* prev = NULL, * first_edge = NULL;
725 
726  int x_min = std::numeric_limits<int>::max();
727 
728  for( const VECTOR2I& p : points )
729  {
730  if( p.x < x_min )
731  x_min = p.x;
732  }
733 
734  for( int i = 0; i < pointCount; i++ )
735  {
736  // Do not use path.CPoint() here; open-coding it using the local variables "points"
737  // and "pointCount" gives a non-trivial performance boost to zone fill times.
738  FractureEdge* fe = new FractureEdge( first, points[ i ],
739  points[ i+1 == pointCount ? 0 : i+1 ] );
740 
741  if( !root )
742  root = fe;
743 
744  if( !first_edge )
745  first_edge = fe;
746 
747  if( prev )
748  prev->m_next = fe;
749 
750  if( i == pointCount - 1 )
751  fe->m_next = first_edge;
752 
753  prev = fe;
754  edges.push_back( fe );
755 
756  if( !first )
757  {
758  if( fe->m_p1.x == x_min )
759  border_edges.push_back( fe );
760  }
761 
762  if( !fe->m_connected )
763  num_unconnected++;
764  }
765 
766  first = false; // first path is always the outline
767  }
768 
769  // keep connecting holes to the main outline, until there's no holes left...
770  while( num_unconnected > 0 )
771  {
772  int x_min = std::numeric_limits<int>::max();
773 
774  FractureEdge* smallestX = NULL;
775 
776  // find the left-most hole edge and merge with the outline
777  for( FractureEdge* border_edge : border_edges )
778  {
779  int xt = border_edge->m_p1.x;
780 
781  if( ( xt < x_min ) && !border_edge->m_connected )
782  {
783  x_min = xt;
784  smallestX = border_edge;
785  }
786  }
787 
788  num_unconnected -= processEdge( edges, smallestX );
789  }
790 
791  paths.clear();
792  SHAPE_LINE_CHAIN newPath;
793 
794  newPath.SetClosed( true );
795 
796  FractureEdge* e;
797 
798  for( e = root; e->m_next != root; e = e->m_next )
799  newPath.Append( e->m_p1 );
800 
801  newPath.Append( e->m_p1 );
802 
803  for( FractureEdge* edge : edges )
804  delete edge;
805 
806  paths.push_back( std::move( newPath ) );
807 }
static int processEdge(FractureEdgeSet &edges, FractureEdge *edge)
void Append(int aX, int aY, bool aAllowDuplication=false)
Function Append()
void SetClosed(bool aClosed)
Function SetClosed()
#define NULL
SHAPE_LINE_CHAIN.
FractureEdge * m_next
std::vector< FractureEdge * > FractureEdgeSet

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

Referenced by Fracture().

◆ GetGlobalIndex()

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

Function GetGlobalIndex computes the global index of a vertex from the relative indices of polygon, contour and vertex.

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

Definition at line 129 of file shape_poly_set.cpp.

131 {
132  int selectedVertex = aRelativeIndices.m_vertex;
133  unsigned int selectedContour = aRelativeIndices.m_contour;
134  unsigned int selectedPolygon = aRelativeIndices.m_polygon;
135 
136  // Check whether the vertex indices make sense in this poly set
137  if( selectedPolygon < m_polys.size() && selectedContour < m_polys[selectedPolygon].size()
138  && selectedVertex < m_polys[selectedPolygon][selectedContour].PointCount() )
139  {
140  POLYGON currentPolygon;
141 
142  aGlobalIdx = 0;
143 
144  for( unsigned int polygonIdx = 0; polygonIdx < selectedPolygon; polygonIdx++ )
145  {
146  currentPolygon = Polygon( polygonIdx );
147 
148  for( unsigned int contourIdx = 0; contourIdx < currentPolygon.size(); contourIdx++ )
149  {
150  aGlobalIdx += currentPolygon[contourIdx].PointCount();
151  }
152  }
153 
154  currentPolygon = Polygon( selectedPolygon );
155 
156  for( unsigned int contourIdx = 0; contourIdx < selectedContour; contourIdx++ )
157  {
158  aGlobalIdx += currentPolygon[contourIdx].PointCount();
159  }
160 
161  aGlobalIdx += selectedVertex;
162 
163  return true;
164  }
165  else
166  {
167  return false;
168  }
169 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
POLYGON & Polygon(int aIndex)
Returns the aIndex-th subpolygon in the set

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_CONTAINER::GetSelectedCorner().

◆ GetHash()

MD5_HASH SHAPE_POLY_SET::GetHash ( ) const

Definition at line 1835 of file shape_poly_set.cpp.

1836 {
1837  if( !m_hash.IsValid() )
1838  return checksum();
1839 
1840  return m_hash;
1841 }
MD5_HASH checksum() const
bool IsValid() const
Definition: md5_hash.h:24

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

Referenced by ZONE_CONTAINER::BuildHashValue(), and SHAPE_POLY_SET().

◆ GetNeighbourIndexes()

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

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

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

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

Definition at line 323 of file shape_poly_set.cpp.

324 {
326 
327  // If the edge does not exist, throw an exception, it is an illegal access memory error
328  if( !GetRelativeIndices( aGlobalIndex, &index ) )
329  return false;
330 
331  // Calculate the previous and next index of aGlobalIndex, corresponding to
332  // the same contour;
333  VERTEX_INDEX inext = index;
334  int lastpoint = m_polys[index.m_polygon][index.m_contour].SegmentCount();
335 
336  if( index.m_vertex == 0 )
337  {
338  index.m_vertex = lastpoint;
339  inext.m_vertex = 1;
340  }
341  else if( index.m_vertex == lastpoint )
342  {
343  index.m_vertex--;
344  inext.m_vertex = 0;
345  }
346  else
347  {
348  inext.m_vertex++;
349  index.m_vertex--;
350  }
351 
352  if( aPrevious )
353  {
354  int previous;
355  GetGlobalIndex( index, previous );
356  *aPrevious = previous;
357  }
358 
359  if( aNext )
360  {
361  int next;
362  GetGlobalIndex( inext, next );
363  *aNext = next;
364  }
365 
366  return true;
367 }
CITER next(CITER it)
Definition: ptree.cpp:130
Struct VERTEX_INDEX.
struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
Struct VERTEX_INDEX.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Function GetRelativeIndices.
bool GetGlobalIndex(VERTEX_INDEX aRelativeIndices, int &aGlobalIdx)
Function GetGlobalIndex computes the global index of a vertex from the relative indices of polygon,...

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_CONTAINER::MoveEdge().

◆ GetRelativeIndices()

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

Function GetRelativeIndices.

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

Parameters
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
bool - true if the global index is correct and the information in aRelativeIndices is valid; false otherwise.

Definition at line 89 of file shape_poly_set.cpp.

91 {
92  int polygonIdx = 0;
93  unsigned int contourIdx = 0;
94  int vertexIdx = 0;
95 
96  int currentGlobalIdx = 0;
97 
98  for( polygonIdx = 0; polygonIdx < OutlineCount(); polygonIdx++ )
99  {
100  const POLYGON currentPolygon = CPolygon( polygonIdx );
101 
102  for( contourIdx = 0; contourIdx < currentPolygon.size(); contourIdx++ )
103  {
104  SHAPE_LINE_CHAIN currentContour = currentPolygon[contourIdx];
105  int totalPoints = currentContour.PointCount();
106 
107  for( vertexIdx = 0; vertexIdx < totalPoints; vertexIdx++ )
108  {
109  // Check if the current vertex is the globally indexed as aGlobalIdx
110  if( currentGlobalIdx == aGlobalIdx )
111  {
112  aRelativeIndices->m_polygon = polygonIdx;
113  aRelativeIndices->m_contour = contourIdx;
114  aRelativeIndices->m_vertex = vertexIdx;
115 
116  return true;
117  }
118 
119  // Advance
120  currentGlobalIdx++;
121  }
122  }
123  }
124 
125  return false;
126 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
const POLYGON & CPolygon(int aIndex) const
int OutlineCount() const
Returns the number of outlines in the set
int PointCount() const
Function PointCount()
SHAPE_LINE_CHAIN.

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_CONTAINER::GetCornerPosition(), GetNeighbourIndexes(), InsertVertex(), IsVertexInHole(), IterateFromVertexWithHoles(), RemoveVertex(), ZONE_CONTAINER::SetCornerPosition(), ZONE_CONTAINER::SetSelectedCorner(), and SetVertex().

◆ HasHoles()

bool SHAPE_POLY_SET::HasHoles ( ) const

Returns true if the polygon set has any holes.

Definition at line 982 of file shape_poly_set.cpp.

983 {
984  // Iterate through all the polygons on the set
985  for( const POLYGON& paths : m_polys )
986  {
987  // If any of them has more than one contour, it is a hole.
988  if( paths.size() > 1 )
989  return true;
990  }
991 
992  // Return false if and only if every polygon has just one outline, without holes.
993  return false;
994 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.

References m_polys.

Referenced by CacheTriangulation().

◆ HasTouchingHoles()

bool SHAPE_POLY_SET::HasTouchingHoles ( ) const

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

Definition at line 1940 of file shape_poly_set.cpp.

1941 {
1942  for( int i = 0; i < OutlineCount(); i++ )
1943  {
1944  if( hasTouchingHoles( CPolygon( i ) ) )
1945  {
1946  return true;
1947  }
1948  }
1949 
1950  return false;
1951 }
const POLYGON & CPolygon(int aIndex) const
int OutlineCount() const
Returns the number of outlines in the set
bool hasTouchingHoles(const POLYGON &aPoly) const
Returns true if the polygon set has any holes that touch share a vertex.

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

◆ hasTouchingHoles()

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

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

Definition at line 1954 of file shape_poly_set.cpp.

1955 {
1956  std::set< long long > ptHashes;
1957 
1958  for( const auto& lc : aPoly )
1959  {
1960  for( const VECTOR2I& pt : lc.CPoints() )
1961  {
1962  const long long ptHash = (long long) pt.x << 32 | pt.y;
1963 
1964  if( ptHashes.count( ptHash ) > 0 )
1965  {
1966  return true;
1967  }
1968 
1969  ptHashes.insert( ptHash );
1970  }
1971  }
1972 
1973  return false;
1974 }

Referenced by HasTouchingHoles().

◆ Hole()

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

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

Definition at line 603 of file shape_poly_set.h.

604  {
605  return m_polys[aOutline][aHole + 1];
606  }

References m_polys.

Referenced by BuildBBoxCaches(), Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(), export_vrml_board(), DSN::SPECCTRA_DB::fillBOUNDARY(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), and TransformRingToPolygon().

◆ HoleCount()

int SHAPE_POLY_SET::HoleCount ( int  aOutline) const
inline

Returns the number of holes in a given outline

Definition at line 570 of file shape_poly_set.h.

571  {
572  if( ( aOutline < 0 ) || (aOutline >= (int)m_polys.size()) || (m_polys[aOutline].size() < 2) )
573  return 0;
574 
575  // the first polygon in m_polys[aOutline] is the main contour,
576  // only others are holes:
577  return m_polys[aOutline].size() - 1;
578  }

References m_polys.

Referenced by CINFO3D_VISU::AddSolidAreasShapesToContainer(), CLAYER_TRIANGLES::AddToMiddleContourns(), ZONE_CONTAINER::AppendCorner(), BuildBBoxCaches(), containsSingle(), Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(), KIGFX::PCB_PAINTER::draw(), export_vrml_board(), DSN::SPECCTRA_DB::fillBOUNDARY(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), PlotLayerOutlines(), and HYPERLYNX_EXPORTER::writeNetObjects().

◆ importTree()

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

Definition at line 581 of file shape_poly_set.cpp.

582 {
583  m_polys.clear();
584 
585  for( PolyNode* n = tree->GetFirst(); n; n = n->GetNext() )
586  {
587  if( !n->IsHole() )
588  {
589  POLYGON paths;
590  paths.reserve( n->Childs.size() + 1 );
591  paths.push_back( n->Contour );
592 
593  for( unsigned int i = 0; i < n->Childs.size(); i++ )
594  paths.push_back( n->Childs[i]->Contour );
595 
596  m_polys.push_back( paths );
597  }
598  }
599 }
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  aCircleSegmentsCount,
CORNER_STRATEGY  aCornerStrategy = ROUND_ALL_CORNERS 
)

Performs outline inflation/deflation.

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

Parameters
aAmount- number of units to offset edges
aCircleSegmentsCount- number of segments per 360° to use in curve approx
aCornerStrategy- ALLOW_ACUTE_CORNERS to preserve all angles, CHOP_ACUTE_CORNERS to chop angles less than 90°, ROUND_ACUTE_CORNERS to round off angles less than 90°, ROUND_ALL_CORNERS to round regardless of angles

Definition at line 527 of file shape_poly_set.cpp.

529 {
530  // A static table to avoid repetitive calculations of the coefficient
531  // 1.0 - cos( M_PI / aCircleSegmentsCount )
532  // aCircleSegmentsCount is most of time <= 64 and usually 8, 12, 16, 32
533  #define SEG_CNT_MAX 64
534  static double arc_tolerance_factor[SEG_CNT_MAX + 1];
535 
536  ClipperOffset c;
537 
538  // N.B. see the Clipper documentation for jtSquare/jtMiter/jtRound. They are poorly named
539  // and are not what you'd think they are.
540  // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/JoinType.htm
541  JoinType joinType = aCornerStrategy == ROUND_ALL_CORNERS ? jtRound : jtMiter;
542  double miterLimit = aCornerStrategy == ALLOW_ACUTE_CORNERS ? 10 : 1.5;
543  JoinType miterFallback = aCornerStrategy == ROUND_ACUTE_CORNERS ? jtRound : jtSquare;
544 
545  for( const POLYGON& poly : m_polys )
546  {
547  for( size_t i = 0; i < poly.size(); i++ )
548  c.AddPath( poly[i].convertToClipper( i == 0 ), joinType, etClosedPolygon );
549  }
550 
551  PolyTree solution;
552 
553  // Calculate the arc tolerance (arc error) from the seg count by circle. The seg count is
554  // nn = M_PI / acos(1.0 - c.ArcTolerance / abs(aAmount))
555  // http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Classes/ClipperOffset/Properties/ArcTolerance.htm
556 
557  if( aCircleSegmentsCount < 6 ) // avoid incorrect aCircleSegmentsCount values
558  aCircleSegmentsCount = 6;
559 
560  double coeff;
561 
562  if( aCircleSegmentsCount > SEG_CNT_MAX || arc_tolerance_factor[aCircleSegmentsCount] == 0 )
563  {
564  coeff = 1.0 - cos( M_PI / aCircleSegmentsCount );
565 
566  if( aCircleSegmentsCount <= SEG_CNT_MAX )
567  arc_tolerance_factor[aCircleSegmentsCount] = coeff;
568  }
569  else
570  coeff = arc_tolerance_factor[aCircleSegmentsCount];
571 
572  c.ArcTolerance = std::abs( aAmount ) * coeff;
573  c.MiterLimit = miterLimit;
574  c.MiterFallback = miterFallback;
575  c.Execute( solution, aAmount );
576 
577  importTree( &solution );
578 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
#define SEG_CNT_MAX
void importTree(ClipperLib::PolyTree *tree)

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

Referenced by D_PAD::buildCustomPadPolygon(), CINFO3D_VISU::buildPadShapePolygon(), Collide(), ZONE_FILLER::computeRawFilledArea(), CINFO3D_VISU::createNewPadWithClearance(), Deflate(), export_vrml_polygon(), GERBER_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadRoundRect(), MODULE::GetBoundingPoly(), InflateWithLinkedHoles(), EAGLE_PLUGIN::loadPolygon(), EAGLE_PLUGIN::packagePolygon(), ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon(), TransformRoundChamferedRectToPolygon(), and D_PAD::TransformShapeWithClearanceToPolygon().

◆ InflateWithLinkedHoles()

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

Performs outline inflation/deflation, using round corners.

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

Definition at line 518 of file shape_poly_set.cpp.

520 {
521  Simplify( aFastMode );
522  Inflate( aFactor, aCircleSegmentsCount );
523  Fracture( aFastMode );
524 }
void Inflate(int aAmount, int aCircleSegmentsCount, CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)
Performs outline inflation/deflation.
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
void Fracture(POLYGON_MODE aFastMode)
Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the oute...

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

Referenced by PlotStandardLayer(), and D_PAD::PrintShape().

◆ InsertVertex()

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

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

Parameters
aGlobalIndexis the global index of the position in which teh new vertex will be inserted.
aNewVertexis the new inserted vertex.

Definition at line 224 of file shape_poly_set.cpp.

225 {
226  VERTEX_INDEX index;
227 
228  if( aGlobalIndex < 0 )
229  aGlobalIndex = 0;
230 
231  if( aGlobalIndex >= TotalVertices() )
232  {
233  Append( aNewVertex );
234  }
235  else
236  {
237  // Assure the position to be inserted exists; throw an exception otherwise
238  if( GetRelativeIndices( aGlobalIndex, &index ) )
239  m_polys[index.m_polygon][index.m_contour].Insert( index.m_vertex, aNewVertex );
240  else
241  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
242  }
243 }
int TotalVertices() const
Returns total number of vertices stored in the set.
struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
Struct VERTEX_INDEX.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Function GetRelativeIndices.
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)

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 POINT_EDITOR::addCorner().

◆ IsEmpty()

◆ IsPolygonSelfIntersecting()

bool SHAPE_POLY_SET::IsPolygonSelfIntersecting ( int  aPolygonIndex) const

Function IsPolygonSelfIntersecting.

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

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

Definition at line 370 of file shape_poly_set.cpp.

371 {
372  CONST_SEGMENT_ITERATOR iterator = CIterateSegmentsWithHoles( aPolygonIndex );
373  CONST_SEGMENT_ITERATOR innerIterator;
374 
375  for( iterator = CIterateSegmentsWithHoles( aPolygonIndex ); iterator; iterator++ )
376  {
377  SEG firstSegment = *iterator;
378 
379  // Iterate through all remaining segments.
380  innerIterator = iterator;
381 
382  // Start in the next segment, we don't want to check collision between a segment and itself
383  for( innerIterator++; innerIterator; innerIterator++ )
384  {
385  SEG secondSegment = *innerIterator;
386 
387  // Check whether the two segments built collide, only when they are not adjacent.
388  if( !iterator.IsAdjacent( innerIterator ) && firstSegment.Collide( secondSegment, 0 ) )
389  return true;
390  }
391  }
392 
393  return false;
394 }
SEGMENT_ITERATOR_TEMPLATE< const SEG > CONST_SEGMENT_ITERATOR
CONST_SEGMENT_ITERATOR CIterateSegmentsWithHoles(int aOutline) const
Returns an iterator object, for the aOutline-th outline in the set (with holes)
Definition: seg.h:39
bool Collide(const SEG &aSeg, int aClearance) const
Definition: seg.cpp:179

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

Referenced by IsSelfIntersecting().

◆ IsSelfIntersecting()

bool SHAPE_POLY_SET::IsSelfIntersecting ( ) const

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

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

Definition at line 397 of file shape_poly_set.cpp.

398 {
399  for( unsigned int polygon = 0; polygon < m_polys.size(); polygon++ )
400  {
401  if( IsPolygonSelfIntersecting( polygon ) )
402  return true;
403  }
404 
405  return false;
406 }
bool IsPolygonSelfIntersecting(int aPolygonIndex) const
Function IsPolygonSelfIntersecting.

References IsPolygonSelfIntersecting(), and m_polys.

Referenced by BOARD::NormalizeAreaPolygon(), and POINT_EDITOR::validatePolygon().

◆ IsSolid()

bool SHAPE_POLY_SET::IsSolid ( ) const
inlineoverridevirtual

Implements SHAPE.

Definition at line 959 of file shape_poly_set.h.

960  {
961  return true;
962  }

◆ IsTriangulationUpToDate()

bool SHAPE_POLY_SET::IsTriangulationUpToDate ( ) const

Definition at line 1844 of file shape_poly_set.cpp.

1845 {
1846  if( !m_triangulationValid )
1847  return false;
1848 
1849  if( !m_hash.IsValid() )
1850  return false;
1851 
1852  auto hash = checksum();
1853 
1854  return hash == m_hash;
1855 }
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(), SHAPE_POLY_SET(), and PNS_KICAD_IFACE::syncZone().

◆ IsVertexInHole()

bool SHAPE_POLY_SET::IsVertexInHole ( int  aGlobalIdx)

Function IsVertexInHole.

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

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

Definition at line 1619 of file shape_poly_set.cpp.

1620 {
1621  VERTEX_INDEX index;
1622 
1623  // Get the polygon and contour where the vertex is. If the vertex does not exist, return false
1624  if( !GetRelativeIndices( aGlobalIdx, &index ) )
1625  return false;
1626 
1627  // The contour is a hole if its index is greater than zero
1628  return index.m_contour > 0;
1629 }
struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
Struct VERTEX_INDEX.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Function GetRelativeIndices.

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

◆ Iterate() [1/3]

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

Function Iterate returns an object to iterate through the points of the polygons between aFirst and aLast.

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

650  {
651  ITERATOR iter;
652 
653  iter.m_poly = this;
654  iter.m_currentPolygon = aFirst;
655  iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
656  iter.m_currentContour = 0;
657  iter.m_currentVertex = 0;
658  iter.m_iterateHoles = aIterateHoles;
659 
660  return iter;
661  }
int OutlineCount() const
Returns the number of outlines in the set
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 POINT_EDITOR::addCorner(), D_CODE::ConvertShapeToPolygon(), and ZONE_CONTAINER::Iterate().

◆ Iterate() [2/3]

ITERATOR SHAPE_POLY_SET::Iterate ( int  aOutline)
inline

Function Iterate.

Parameters
aOutlinethe index of the polygon to be iterated.
Returns
ITERATOR - an iterator object to visit all points in the main outline of the aOutline-th polygon, without visiting the points in the holes.

Definition at line 669 of file shape_poly_set.h.

670  {
671  return Iterate( aOutline, aOutline );
672  }
ITERATOR Iterate()
Function Iterate.

References Iterate().

◆ Iterate() [3/3]

ITERATOR SHAPE_POLY_SET::Iterate ( )
inline

Function Iterate.

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

Definition at line 690 of file shape_poly_set.h.

691  {
692  return Iterate( 0, OutlineCount() - 1 );
693  }
int OutlineCount() const
Returns the number of outlines in the set
ITERATOR Iterate()
Function Iterate.

References OutlineCount().

Referenced by Iterate(), and IterateWithHoles().

◆ IterateFromVertexWithHoles()

ITERATOR SHAPE_POLY_SET::IterateFromVertexWithHoles ( int  aGlobalIdx)
inline

Definition at line 740 of file shape_poly_set.h.

741  {
742  // Build iterator
743  ITERATOR iter = IterateWithHoles();
744 
745  // Get the relative indices of the globally indexed vertex
746  VERTEX_INDEX indices;
747 
748  if( !GetRelativeIndices( aGlobalIdx, &indices ) )
749  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
750 
751  // Adjust where the iterator is pointing
752  iter.m_currentPolygon = indices.m_polygon;
753  iter.m_currentContour = indices.m_contour;
754  iter.m_currentVertex = indices.m_vertex;
755 
756  return iter;
757  }
struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
Struct VERTEX_INDEX.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Function GetRelativeIndices.
ITERATOR_TEMPLATE< VECTOR2I > ITERATOR
ITERATOR IterateWithHoles()
Function IterateWithHoles.

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

◆ IterateSegments() [1/3]

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

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

without holes (default: without)

Definition at line 761 of file shape_poly_set.h.

762  {
763  SEGMENT_ITERATOR iter;
764 
765  iter.m_poly = this;
766  iter.m_currentPolygon = aFirst;
767  iter.m_lastPolygon = aLast < 0 ? OutlineCount() - 1 : aLast;
768  iter.m_currentContour = 0;
769  iter.m_currentSegment = 0;
770  iter.m_iterateHoles = aIterateHoles;
771 
772  return iter;
773  }
int OutlineCount() const
Returns the number of outlines in the set
SEGMENT_ITERATOR_TEMPLATE< SEG > SEGMENT_ITERATOR

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

Referenced by TestConcaveSquareFillet(), and TestSquareFillet().

◆ IterateSegments() [2/3]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegments ( int  aPolygonIdx)
inline

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

Definition at line 793 of file shape_poly_set.h.

794  {
795  return IterateSegments( aPolygonIdx, aPolygonIdx );
796  }
SEGMENT_ITERATOR IterateSegments()
Returns an iterator object, for all outlines in the set (no holes)

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

806  {
807  return IterateSegments( 0, OutlineCount() - 1 );
808  }
int OutlineCount() const
Returns the number of outlines in the set
SEGMENT_ITERATOR IterateSegments()
Returns an iterator object, for all outlines in the set (no holes)

References OutlineCount().

Referenced by IterateSegments(), and IterateSegmentsWithHoles().

◆ IterateSegmentsWithHoles() [1/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( )
inline

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

Definition at line 811 of file shape_poly_set.h.

812  {
813  return IterateSegments( 0, OutlineCount() - 1, true );
814  }
int OutlineCount() const
Returns the number of outlines in the set
SEGMENT_ITERATOR IterateSegments()
Returns an iterator object, for all outlines in the set (no holes)

References IterateSegments(), and OutlineCount().

Referenced by CollideEdge(), ConvertOutlineToPolygon(), DistanceToPolygon(), DRC::doTrackDrc(), ZONE_CONTAINER::Hatch(), ZONE_CONTAINER::Print(), and BOARD::TestAreaIntersection().

◆ IterateSegmentsWithHoles() [2/2]

SEGMENT_ITERATOR SHAPE_POLY_SET::IterateSegmentsWithHoles ( int  aOutline)
inline

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

Definition at line 817 of file shape_poly_set.h.

818  {
819  return IterateSegments( aOutline, aOutline, true );
820  }
SEGMENT_ITERATOR IterateSegments()
Returns an iterator object, for all outlines in the set (no holes)

References IterateSegments().

◆ IterateWithHoles() [1/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( int  aOutline)
inline

Function IterateWithHoles.

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

Definition at line 680 of file shape_poly_set.h.

681  {
682  return Iterate( aOutline, aOutline, true );
683  }
ITERATOR Iterate()
Function Iterate.

References Iterate().

Referenced by findVertex(), ZONE_CONTAINER::Hatch(), ZONE_CONTAINER::IterateWithHoles(), and BOARD::TestAreaIntersection().

◆ IterateWithHoles() [2/2]

ITERATOR SHAPE_POLY_SET::IterateWithHoles ( )
inline

Function IterateWithHoles.

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

Definition at line 700 of file shape_poly_set.h.

701  {
702  return Iterate( 0, OutlineCount() - 1, true );
703  }
int OutlineCount() const
Returns the number of outlines in the set
ITERATOR Iterate()
Function Iterate.

References Iterate(), and OutlineCount().

Referenced by CollideVertex(), IterateFromVertexWithHoles(), and RemoveNullSegments().

◆ Mirror()

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

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

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

1472 {
1473  for( POLYGON& poly : m_polys )
1474  {
1475  for( SHAPE_LINE_CHAIN& path : poly )
1476  {
1477  path.Mirror( aX, aY, aRef );
1478  }
1479  }
1480 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
SHAPE_LINE_CHAIN.

References m_polys.

Referenced by GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), EDGE_MODULE::Flip(), DRAWSEGMENT::Flip(), D_PAD::FlipPrimitives(), EDGE_MODULE::Mirror(), and ZONE_CONTAINER::Mirror().

◆ Move()

void SHAPE_POLY_SET::Move ( const VECTOR2I aVector)
overridevirtual

◆ NewFacet()

FACET * SHAPE::NewFacet ( )
inherited

Definition at line 705 of file wrlfacet.cpp.

706 {
707  FACET* fp = new FACET;
708  facets.push_back( fp );
709  return fp;
710 }
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)

Creates a new hole in a given outline

Definition at line 184 of file shape_poly_set.cpp.

185 {
186  SHAPE_LINE_CHAIN empty_path;
187 
188  empty_path.SetClosed( true );
189 
190  // Default outline is the last one
191  if( aOutline < 0 )
192  aOutline += m_polys.size();
193 
194  // Add hole to the selected outline
195  m_polys[aOutline].push_back( empty_path );
196 
197  return m_polys.back().size() - 2;
198 }
void SetClosed(bool aClosed)
Function SetClosed()
SHAPE_LINE_CHAIN.

References m_polys, and SHAPE_LINE_CHAIN::SetClosed().

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

◆ NewOutline()

int SHAPE_POLY_SET::NewOutline ( )

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

Definition at line 172 of file shape_poly_set.cpp.

173 {
174  SHAPE_LINE_CHAIN empty_path;
175  POLYGON poly;
176 
177  empty_path.SetClosed( true );
178  poly.push_back( empty_path );
179  m_polys.push_back( poly );
180  return m_polys.size() - 1;
181 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
void SetClosed(bool aClosed)
Function SetClosed()
SHAPE_LINE_CHAIN.

References m_polys, and SHAPE_LINE_CHAIN::SetClosed().

Referenced by AR_AUTOPLACER::addFpBody(), addHoleToPolygon(), ZONE_FILLER::addKnockout(), AR_AUTOPLACER::addPad(), addRect(), ZONE_CONTAINER::AppendCorner(), BuildBoardPolygonOutlines(), D_PAD::buildCustomPadPolygon(), D_PAD::BuildPadShapePolygon(), KI_TEST::CommonTestData::CommonTestData(), ConvertOutlineToPolygon(), GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), D_CODE::ConvertShapeToPolygon(), BITMAPCONV_INFO::createOutputData(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), fillArcPOLY(), MODULE::GetBoundingPoly(), getRectangleAlongCentreLine(), EAGLE_PLUGIN::loadPolygon(), LEGACY_PLUGIN::loadZONE_CONTAINER(), PCB_PARSER::parseZONE_CONTAINER(), DXF_PLOTTER::PlotPoly(), KIGFX::PREVIEW::POLYGON_ITEM::SetPoints(), DRAWSEGMENT::SetPolyPoints(), WS_DATA_ITEM_POLYGONS::SyncDrawItems(), EDA_TEXT::TransformBoundingBoxWithClearanceToPolygon(), TransformCircleToPolygon(), TransformOvalToPolygon(), TransformRoundChamferedRectToPolygon(), TransformSegmentToPolygon(), DRAWSEGMENT::TransformShapeWithClearanceToPolygon(), and D_PAD::TransformShapeWithClearanceToPolygon().

◆ NormalizeAreaOutlines()

int SHAPE_POLY_SET::NormalizeAreaOutlines ( )

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

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

Definition at line 1016 of file shape_poly_set.cpp.

1017 {
1018  // We are expecting only one main outline, but this main outline can have holes
1019  // if holes: combine holes and remove them from the main outline.
1020  // Note also we are using SHAPE_POLY_SET::PM_STRICTLY_SIMPLE in polygon
1021  // calculations, but it is not mandatory. It is used mainly
1022  // because there is usually only very few vertices in area outlines
1023  SHAPE_POLY_SET::POLYGON& outline = Polygon( 0 );
1024  SHAPE_POLY_SET holesBuffer;
1025 
1026  // Move holes stored in outline to holesBuffer:
1027  // The first SHAPE_LINE_CHAIN is the main outline, others are holes
1028  while( outline.size() > 1 )
1029  {
1030  holesBuffer.AddOutline( outline.back() );
1031  outline.pop_back();
1032  }
1033 
1035 
1036  // If any hole, substract it to main outline
1037  if( holesBuffer.OutlineCount() )
1038  {
1039  holesBuffer.Simplify( SHAPE_POLY_SET::PM_FAST );
1041  }
1042 
1044 
1045  return OutlineCount();
1046 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
int OutlineCount() const
Returns the number of outlines in the set
SHAPE_POLY_SET.
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...
int RemoveNullSegments()
Function RemoveNullSegments looks for null segments; ie, segments whose ends are exactly the same and...
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new outline to the set and returns its index
void BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Performs boolean polyset difference For aFastMode meaning, see function booleanOp
POLYGON & Polygon(int aIndex)
Returns the aIndex-th subpolygon in the set

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

1824 {
1825  static_cast<SHAPE&>(*this) = aOther;
1826  m_polys = aOther.m_polys;
1827 
1828  // reset poly cache:
1829  m_hash = MD5_HASH{};
1830  m_triangulationValid = false;
1831  m_triangulatedPolys.clear();
1832  return *this;
1833 }
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys

References m_hash, m_polys, m_triangulatedPolys, and m_triangulationValid.

◆ Outline()

SHAPE_LINE_CHAIN& SHAPE_POLY_SET::Outline ( int  aIndex)
inline

Returns the reference to aIndex-th outline in the set

Definition at line 581 of file shape_poly_set.h.

582  {
583  return m_polys[aIndex][0];
584  }

References m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), BuildBBoxCaches(), GRID_HELPER::computeAnchors(), Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(), BITMAPCONV_INFO::createOutputData(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), KIGFX::WS_PAINTER::draw(), APERTURE_MACRO::DrawApertureMacroShape(), export_vrml_padshape(), DSN::SPECCTRA_DB::fillBOUNDARY(), AR_AUTOPLACER::fillMatrix(), HPGL_PLOTTER::FlashPadCustom(), PSLIKE_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), DXF_PLOTTER::FlashPadCustom(), HPGL_PLOTTER::FlashPadRoundRect(), PSLIKE_PLOTTER::FlashPadRoundRect(), GERBER_PLOTTER::FlashPadRoundRect(), DXF_PLOTTER::FlashPadRoundRect(), PCB_IO::format(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), DRAWSEGMENT::GetMsgPanelInfo(), DSN::SPECCTRA_DB::makePADSTACK(), D_PAD::MirrorXPrimitives(), BOARD::NormalizeAreaPolygon(), BRDITEMS_PLOTTER::Plot_1_EdgeModule(), BRDITEMS_PLOTTER::PlotFilledAreas(), PlotWorkSheet(), polygonArea(), DRAWSEGMENT::Print(), GERBER_DRAW_ITEM::PrintGerberPoly(), D_PAD::PrintShape(), WS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem(), POINT_EDITOR::removeCorner(), POINT_EDITOR::removeCornerCondition(), PNS_KICAD_IFACE::syncPad(), GBR_TO_PCB_EXPORTER::writePcbPolygonItem(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

◆ OutlineCount()

int SHAPE_POLY_SET::OutlineCount ( ) const
inline

Returns the number of outlines in the set

Definition at line 564 of file shape_poly_set.h.

564 { return m_polys.size(); }

References m_polys.

Referenced by POINT_EDITOR::addCorner(), ZONE_FILLER::addHatchFillTypeOnZone(), ZONE_CONTAINER::AddPolygon(), CINFO3D_VISU::AddSolidAreasShapesToContainer(), CLAYER_TRIANGLES::AddToMiddleContourns(), ZONE_CONTAINER::AppendCorner(), D_PAD::boundingRadius(), BuildBBoxCaches(), BuildBoardPolygonOutlines(), BuildConvexHull(), D_PAD::buildCustomPadPolygon(), DRAWSEGMENT::BuildPolyPointsList(), CacheTriangulation(), DRC::checkClearancePadToPad(), CIterate(), CIterateSegments(), CIterateWithHoles(), BOARD::CombineAreas(), Contains(), Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(), BITMAPCONV_INFO::createOutputData(), PLACEFILE_GERBER_WRITER::CreatePlaceFile(), D_PAD::CustomShapeAsPolygonToBoardPosition(), KIGFX::WS_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), APERTURE_MACRO::DrawApertureMacroShape(), D_CODE::DrawFlashedPolygon(), D_CODE::DrawFlashedShape(), KIGFX::GERBVIEW_PAINTER::drawFlashedShape(), AR_AUTOPLACER::drawPlacementRoutingMatrix(), KIGFX::CAIRO_GAL_BASE::DrawPolygon(), KIGFX::OPENGL_GAL::DrawPolygon(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), GERBER_FILE_IMAGE::Execute_DCODE_Command(), export_vrml_board(), export_vrml_padshape(), export_vrml_zones(), fillArcPOLY(), DSN::SPECCTRA_DB::fillBOUNDARY(), GEOM_TEST::FilletPolySet(), HPGL_PLOTTER::FlashPadCustom(), PSLIKE_PLOTTER::FlashPadCustom(), GERBER_PLOTTER::FlashPadCustom(), DXF_PLOTTER::FlashPadCustom(), C3D_RENDER_OGL_LEGACY::generate_3D_Vias_and_Pads(), C3D_RENDER_OGL_LEGACY::generate_holes_display_list(), APERTURE_MACRO::GetApertureMacroShape(), GERBER_DRAW_ITEM::GetBoundingBox(), D_PAD::GetBoundingBox(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), GetRelativeIndices(), HasTouchingHoles(), WS_DRAW_ITEM_POLYPOLYGONS::HitTest(), D_PAD::HitTest(), Iterate(), IterateSegments(), IterateSegmentsWithHoles(), IterateWithHoles(), D_PAD::MergePrimitivesAsPolygon(), D_PAD::MirrorXPrimitives(), NormalizeAreaOutlines(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::operator bool(), BRDITEMS_PLOTTER::Plot_1_EdgeModule(), BRDITEMS_PLOTTER::PlotFilledAreas(), PlotLayerOutlines(), BRDITEMS_PLOTTER::PlotPad(), DXF_PLOTTER::PlotPoly(), PlotWorkSheet(), polygon_triangulation_main(), polygonArea(), DRAWSEGMENT::Print(), GERBER_DRAW_ITEM::Print(), ZONE_CONTAINER::PrintFilledArea(), D_PAD::PrintShape(), WS_DRAW_ITEM_POLYPOLYGONS::PrintWsItem(), C3D_RENDER_OGL_LEGACY::reload(), C3D_RENDER_RAYTRACING::reload(), DRC_COURTYARD_OVERLAP::RunDRC(), Subset(), PNS_KICAD_IFACE::syncZone(), TestConcaveSquareFillet(), AR_AUTOPLACER::testModuleByPolygon(), TestSquareFillet(), ZONE_CONTAINER::TransformSolidAreasShapesToPolygonSet(), HYPERLYNX_EXPORTER::writeBoardInfo(), HYPERLYNX_EXPORTER::writeNetObjects(), GBR_TO_PCB_EXPORTER::writePcbPolygonItem(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

◆ Parse()

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

Reimplemented from SHAPE.

Definition at line 1074 of file shape_poly_set.cpp.

1075 {
1076  std::string tmp;
1077 
1078  aStream >> tmp;
1079 
1080  if( tmp != "polyset" )
1081  return false;
1082 
1083  aStream >> tmp;
1084 
1085  int n_polys = atoi( tmp.c_str() );
1086 
1087  if( n_polys < 0 )
1088  return false;
1089 
1090  for( int i = 0; i < n_polys; i++ )
1091  {
1092  POLYGON paths;
1093 
1094  aStream >> tmp;
1095 
1096  if( tmp != "poly" )
1097  return false;
1098 
1099  aStream >> tmp;
1100  int n_outlines = atoi( tmp.c_str() );
1101 
1102  if( n_outlines < 0 )
1103  return false;
1104 
1105  for( int j = 0; j < n_outlines; j++ )
1106  {
1107  SHAPE_LINE_CHAIN outline;
1108 
1109  outline.SetClosed( true );
1110 
1111  aStream >> tmp;
1112  int n_vertices = atoi( tmp.c_str() );
1113 
1114  for( int v = 0; v < n_vertices; v++ )
1115  {
1116  VECTOR2I p;
1117 
1118  aStream >> tmp; p.x = atoi( tmp.c_str() );
1119  aStream >> tmp; p.y = atoi( tmp.c_str() );
1120  outline.Append( p );
1121  }
1122 
1123  paths.push_back( outline );
1124  }
1125 
1126  m_polys.push_back( paths );
1127  }
1128 
1129  return true;
1130 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
void Append(int aX, int aY, bool aAllowDuplication=false)
Function Append()
void SetClosed(bool aClosed)
Function SetClosed()
SHAPE_LINE_CHAIN.

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

◆ pointInPolygon()

bool SHAPE_POLY_SET::pointInPolygon ( const VECTOR2I aP,
const SHAPE_LINE_CHAIN aPath,
bool  aIgnoreEdges,
bool  aUseBBoxCaches = false 
) const
private

◆ PointOnEdge()

bool SHAPE_POLY_SET::PointOnEdge ( const VECTOR2I aP) const

Function PointOnEdge()

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

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

Definition at line 1150 of file shape_poly_set.cpp.

1151 {
1152  // Iterate through all the polygons in the set
1153  for( const POLYGON& polygon : m_polys )
1154  {
1155  // Iterate through all the line chains in the polygon
1156  for( const SHAPE_LINE_CHAIN& lineChain : polygon )
1157  {
1158  if( lineChain.PointOnEdge( aP ) )
1159  return true;
1160  }
1161  }
1162 
1163  return false;
1164 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
SHAPE_LINE_CHAIN.

References m_polys.

◆ Polygon() [1/2]

◆ Polygon() [2/2]

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

Definition at line 614 of file shape_poly_set.h.

615  {
616  return m_polys[aIndex];
617  }

References m_polys.

◆ RemoveAllContours()

◆ RemoveContour()

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

Function RemoveContour deletes the aContourIdx-th contour of the aPolygonIdx-th polygon in the set.

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

1221 {
1222  // Default polygon is the last one
1223  if( aPolygonIdx < 0 )
1224  aPolygonIdx += m_polys.size();
1225 
1226  m_polys[aPolygonIdx].erase( m_polys[aPolygonIdx].begin() + aContourIdx );
1227 }

References m_polys.

Referenced by POINT_EDITOR::removeCorner().

◆ RemoveNullSegments()

int SHAPE_POLY_SET::RemoveNullSegments ( )

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

Returns
int - the number of deleted segments.

Definition at line 1230 of file shape_poly_set.cpp.

1231 {
1232  int removed = 0;
1233 
1234  ITERATOR iterator = IterateWithHoles();
1235 
1236  VECTOR2I contourStart = *iterator;
1237  VECTOR2I segmentStart, segmentEnd;
1238 
1239  VERTEX_INDEX indexStart;
1240 
1241  while( iterator )
1242  {
1243  // Obtain first point and its index
1244  segmentStart = *iterator;
1245  indexStart = iterator.GetIndex();
1246 
1247  // Obtain last point
1248  if( iterator.IsEndContour() )
1249  {
1250  segmentEnd = contourStart;
1251 
1252  // Advance
1253  iterator++;
1254 
1255  if( iterator )
1256  contourStart = *iterator;
1257  }
1258  else
1259  {
1260  // Advance
1261  iterator++;
1262 
1263  if( iterator )
1264  segmentEnd = *iterator;
1265  }
1266 
1267  // Remove segment start if both points are equal
1268  if( segmentStart == segmentEnd )
1269  {
1270  RemoveVertex( indexStart );
1271  removed++;
1272 
1273  // Advance the iterator one position, as there is one vertex less.
1274  if( iterator )
1275  iterator++;
1276  }
1277  }
1278 
1279  return removed;
1280 }
struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
Struct VERTEX_INDEX.
ITERATOR_TEMPLATE< VECTOR2I > ITERATOR
ITERATOR IterateWithHoles()
Function IterateWithHoles.
void RemoveVertex(int aGlobalIndex)
Function RemoveVertex deletes 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)

Function RemoveVertex deletes the aGlobalIndex-th vertex.

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

Definition at line 1402 of file shape_poly_set.cpp.

1403 {
1404  VERTEX_INDEX index;
1405 
1406  // Assure the to be removed vertex exists, abort otherwise
1407  if( GetRelativeIndices( aGlobalIndex, &index ) )
1408  RemoveVertex( index );
1409  else
1410  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
1411 }
struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
Struct VERTEX_INDEX.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Function GetRelativeIndices.
void RemoveVertex(int aGlobalIndex)
Function RemoveVertex deletes the aGlobalIndex-th vertex.

References GetRelativeIndices().

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

◆ RemoveVertex() [2/2]

void SHAPE_POLY_SET::RemoveVertex ( VERTEX_INDEX  aRelativeIndices)

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

Parameters
aRelativeIndicesis the set of relative indices of the to-be-removed vertex.

Definition at line 1414 of file shape_poly_set.cpp.

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

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

Function Rotate rotates all vertices by a given angle.

Parameters
aCenteris the rotation center
aAnglerotation angle in radians

Definition at line 1483 of file shape_poly_set.cpp.

1484 {
1485  for( POLYGON& poly : m_polys )
1486  {
1487  for( SHAPE_LINE_CHAIN& path : poly )
1488  path.Rotate( aAngle, aCenter );
1489  }
1490 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
SHAPE_LINE_CHAIN.

References m_polys.

Referenced by ZONE_FILLER::addHatchFillTypeOnZone(), DRC::checkClearanceSegmToPad(), D_CODE::ConvertShapeToPolygon(), D_PAD::CustomShapeAsPolygonToBoardPosition(), export_vrml_polygon(), MODULE::GetBoundingPoly(), DRAWSEGMENT::Rotate(), ZONE_CONTAINER::Rotate(), TransformOvalToPolygon(), and TransformRoundChamferedRectToPolygon().

◆ SetVertex() [1/2]

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

Function SetVertex Accessor function to set the position of a specific point.

Parameters
aIndexVERTEX_INDEX of the point to move
aPosdestination position of the specified point

Definition at line 1431 of file shape_poly_set.cpp.

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

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_CONTAINER::MoveEdge(), ZONE_CONTAINER::SetCornerPosition(), SetVertex(), and POINT_EDITOR::updateItem().

◆ SetVertex() [2/2]

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

Sets the vertex based on the global index.

Throws if the index doesn't exist

Parameters
aGlobalIndexglobal index of the to-be-moved vertex
aPosNew position on the vertex

Definition at line 1420 of file shape_poly_set.cpp.

1421 {
1422  VERTEX_INDEX index;
1423 
1424  if( GetRelativeIndices( aGlobalIndex, &index ) )
1425  SetVertex( index, aPos );
1426  else
1427  throw( std::out_of_range( "aGlobalIndex-th vertex does not exist" ) );
1428 }
struct SHAPE_POLY_SET::VERTEX_INDEX VERTEX_INDEX
Struct VERTEX_INDEX.
void SetVertex(const VERTEX_INDEX &aIndex, const VECTOR2I &aPos)
Function SetVertex Accessor function to set the position of a specific point.
bool GetRelativeIndices(int aGlobalIdx, VERTEX_INDEX *aRelativeIndices) const
Function GetRelativeIndices.

References GetRelativeIndices(), and SetVertex().

◆ Simplify()

void SHAPE_POLY_SET::Simplify ( POLYGON_MODE  aFastMode)

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

Definition at line 1008 of file shape_poly_set.cpp.

1009 {
1011 
1012  booleanOp( ctUnion, empty, aFastMode );
1013 }
void booleanOp(ClipperLib::ClipType aType, const SHAPE_POLY_SET &aOtherShape, POLYGON_MODE aFastMode)
Function booleanOp this is the engine to execute all polygon boolean transforms (AND,...
SHAPE_POLY_SET.
static bool empty(const wxTextEntryBase *aCtrl)

References booleanOp(), and empty().

Referenced by CINFO3D_VISU::AddShapeWithClearanceToContainer(), ZONE_FILLER::buildCopperItemClearances(), D_PAD::buildCustomPadPolygon(), BOARD::CombineAreas(), ZONE_FILLER::computeRawFilledArea(), MODULE::CoverageRatio(), CINFO3D_VISU::createLayers(), BITMAPCONV_INFO::createOutputData(), Fracture(), BOARD::GetBoardPolygonOutlines(), InflateWithLinkedHoles(), ZONE_FILLER::knockoutThermalReliefs(), NormalizeAreaOutlines(), PlotLayerOutlines(), ZONE_CONTAINER::TransformShapeWithClearanceToPolygon(), D_PAD::TransformShapeWithClearanceToPolygon(), Unfracture(), HYPERLYNX_EXPORTER::writeNetObjects(), GBR_TO_PCB_EXPORTER::writePcbPolygonItem(), and GBR_TO_PCB_EXPORTER::writePcbZoneItem().

◆ Subset()

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

Function Subset returns a subset of the polygons in this set, the ones between aFirstPolygon and aLastPolygon.

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

Definition at line 271 of file shape_poly_set.cpp.

272 {
273  assert( aFirstPolygon >= 0 && aLastPolygon <= OutlineCount() );
274 
275  SHAPE_POLY_SET newPolySet;
276 
277  for( int index = aFirstPolygon; index < aLastPolygon; index++ )
278  {
279  newPolySet.m_polys.push_back( Polygon( index ) );
280  }
281 
282  return newPolySet;
283 }
int OutlineCount() const
Returns the number of outlines in the set
SHAPE_POLY_SET.
POLYGON & Polygon(int aIndex)
Returns the aIndex-th subpolygon in the set

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

Referenced by UnitSet().

◆ TotalVertices()

int SHAPE_POLY_SET::TotalVertices ( ) const

Returns total number of vertices stored in the set.

Definition at line 1493 of file shape_poly_set.cpp.

1494 {
1495  int c = 0;
1496 
1497  for( const POLYGON& poly : m_polys )
1498  {
1499  for( const SHAPE_LINE_CHAIN& path : poly )
1500  c += path.PointCount();
1501  }
1502 
1503  return c;
1504 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
SHAPE_LINE_CHAIN.

References m_polys.

Referenced by EDIT_POINTS_FACTORY::buildForPolyOutline(), ZONE_CONTAINER::GetMsgPanelInfo(), ZONE_CONTAINER::GetNumCorners(), DRAWSEGMENT::HitTest(), ZONE_CONTAINER::HitTest(), InsertVertex(), POINT_EDITOR::updateItem(), and POINT_EDITOR::updatePoints().

◆ TriangulatedPolyCount()

unsigned int SHAPE_POLY_SET::TriangulatedPolyCount ( ) const
inline

Returns the number of triangulated polygons

Definition at line 561 of file shape_poly_set.h.

561 { return m_triangulatedPolys.size(); }
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys

References m_triangulatedPolys.

Referenced by Convert_shape_line_polygon_to_triangles(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), and SHAPE_POLY_SET().

◆ TriangulatedPolygon()

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

Definition at line 619 of file shape_poly_set.h.

620  {
621  return m_triangulatedPolys[aIndex].get();
622  }
std::vector< std::unique_ptr< TRIANGULATED_POLYGON > > m_triangulatedPolys

References m_triangulatedPolys.

Referenced by Convert_shape_line_polygon_to_triangles(), KIGFX::OPENGL_GAL::drawTriangulatedPolyset(), SHAPE_POLY_SET(), and PNS_KICAD_IFACE::syncZone().

◆ Type()

SHAPE_TYPE SHAPE::Type ( ) const
inlineinherited

Function Type()

Returns the type of the shape.

Return values
thetype

Definition at line 85 of file shape.h.

86  {
87  return m_type;
88  }
SHAPE_TYPE m_type
type of our shape
Definition: shape.h:168

References SHAPE::m_type.

Referenced by PNS::DP_GATEWAYS::BuildFromPrimitivePair(), CollideShapes(), PNS::OPTIMIZER::computeBreakouts(), PNS::LOGGER::dumpShape(), PNS::SOLID::Hull(), ROUTER_PREVIEW_ITEM::ViewDraw(), and SHAPE_FILE_IO::Write().

◆ Unfracture()

void SHAPE_POLY_SET::Unfracture ( POLYGON_MODE  aFastMode)

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

Definition at line 997 of file shape_poly_set.cpp.

998 {
999  for( POLYGON& path : m_polys )
1000  {
1001  unfractureSingle( path );
1002  }
1003 
1004  Simplify( aFastMode ); // remove overlapping holes/degeneracy
1005 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
void unfractureSingle(POLYGON &path)
void Simplify(POLYGON_MODE aFastMode)
Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) For aFast...

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

Referenced by PlotStandardLayer(), and polygon_triangulation_main().

◆ unfractureSingle()

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

Definition at line 821 of file shape_poly_set.cpp.

822 {
823  assert( aPoly.size() == 1 );
824 
825  struct EDGE
826  {
827  int m_index = 0;
828  SHAPE_LINE_CHAIN* m_poly = nullptr;
829  bool m_duplicate = false;
830 
831  EDGE( SHAPE_LINE_CHAIN* aPolygon, int aIndex ) :
832  m_index( aIndex ),
833  m_poly( aPolygon )
834  {}
835 
836  bool compareSegs( const SEG& s1, const SEG& s2 ) const
837  {
838  return (s1.A == s2.B && s1.B == s2.A);
839  }
840 
841  bool operator==( const EDGE& aOther ) const
842  {
843  return compareSegs( m_poly->CSegment( m_index ),
844  aOther.m_poly->CSegment( aOther.m_index ) );
845  }
846 
847  bool operator!=( const EDGE& aOther ) const
848  {
849  return !compareSegs( m_poly->CSegment( m_index ),
850  aOther.m_poly->CSegment( aOther.m_index ) );
851  }
852 
853  struct HASH
854  {
855  std::size_t operator()( const EDGE& aEdge ) const
856  {
857  const auto& a = aEdge.m_poly->CSegment( aEdge.m_index );
858 
859  return (std::size_t) ( a.A.x + a.B.x + a.A.y + a.B.y );
860  }
861  };
862  };
863 
864  struct EDGE_LIST_ENTRY
865  {
866  int index;
867  EDGE_LIST_ENTRY* next;
868  };
869 
870  std::unordered_set<EDGE, EDGE::HASH> uniqueEdges;
871 
872  auto lc = aPoly[0];
873  lc.Simplify();
874 
875  auto edgeList = std::make_unique<EDGE_LIST_ENTRY []>( lc.SegmentCount() );
876 
877  for( int i = 0; i < lc.SegmentCount(); i++ )
878  {
879  edgeList[i].index = i;
880  edgeList[i].next = &edgeList[ (i != lc.SegmentCount() - 1) ? i + 1 : 0 ];
881  }
882 
883  std::unordered_set<EDGE_LIST_ENTRY*> queue;
884 
885  for( int i = 0; i < lc.SegmentCount(); i++ )
886  {
887  EDGE e( &lc, i );
888  uniqueEdges.insert( e );
889  }
890 
891  for( int i = 0; i < lc.SegmentCount(); i++ )
892  {
893  EDGE e( &lc, i );
894  auto it = uniqueEdges.find( e );
895 
896  if( it != uniqueEdges.end() && it->m_index != i )
897  {
898  int e1 = it->m_index;
899  int e2 = i;
900 
901  if( e1 > e2 )
902  std::swap( e1, e2 );
903 
904  int e1_prev = e1 - 1;
905 
906  if( e1_prev < 0 )
907  e1_prev = lc.SegmentCount() - 1;
908 
909  int e2_prev = e2 - 1;
910 
911  if( e2_prev < 0 )
912  e2_prev = lc.SegmentCount() - 1;
913 
914  int e1_next = e1 + 1;
915 
916  if( e1_next == lc.SegmentCount() )
917  e1_next = 0;
918 
919  int e2_next = e2 + 1;
920 
921  if( e2_next == lc.SegmentCount() )
922  e2_next = 0;
923 
924  edgeList[e1_prev].next = &edgeList[ e2_next ];
925  edgeList[e2_prev].next = &edgeList[ e1_next ];
926  edgeList[i].next = nullptr;
927  edgeList[it->m_index].next = nullptr;
928  }
929  }
930 
931  for( int i = 0; i < lc.SegmentCount(); i++ )
932  {
933  if( edgeList[i].next )
934  queue.insert( &edgeList[i] );
935  }
936 
937  auto edgeBuf = std::make_unique<EDGE_LIST_ENTRY* []>( lc.SegmentCount() );
938 
939  int n = 0;
940  int outline = -1;
941 
942  POLYGON result;
943 
944  while( queue.size() )
945  {
946  auto e_first = (*queue.begin() );
947  auto e = e_first;
948  int cnt = 0;
949 
950  do {
951  edgeBuf[cnt++] = e;
952  e = e->next;
953  } while( e && e != e_first );
954 
955  SHAPE_LINE_CHAIN outl;
956 
957  for( int i = 0; i < cnt; i++ )
958  {
959  auto p = lc.CPoint( edgeBuf[i]->index );
960  outl.Append( p );
961  queue.erase( edgeBuf[i] );
962  }
963 
964  outl.SetClosed( true );
965 
966  bool cw = outl.Area() > 0.0;
967 
968  if( cw )
969  outline = n;
970 
971  result.push_back( outl );
972  n++;
973  }
974 
975  if( outline > 0 )
976  std::swap( result[0], result[outline] );
977 
978  aPoly = result;
979 }
std::vector< SHAPE_LINE_CHAIN > POLYGON
represents a single polygon outline with holes.
CITER next(CITER it)
Definition: ptree.cpp:130
bool operator==(const PART_LIB &aLibrary, const wxString &aName)
Case insensitive library name comparison.
void Append(int aX, int aY, bool aAllowDuplication=false)
Function Append()
const VECTOR2I & CPoint(int aIndex) const
Function Point()
void SetClosed(bool aClosed)
Function SetClosed()
double Area() const
Definition: seg.h:39
const SEG CSegment(int aIndex) const
Function CSegment()
SHAPE_LINE_CHAIN.
VECTOR2I A
Definition: seg.h:47
bool operator!=(const PART_LIB &aLibrary, const wxString &aName)
VECTOR2I B
Definition: seg.h:48

References SEG::A, SHAPE_LINE_CHAIN::Append(), SHAPE_LINE_CHAIN::Area(), SEG::B, SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::CSegment(), next(), operator!=(), operator==(), and SHAPE_LINE_CHAIN::SetClosed().

Referenced by Unfracture().

◆ UnitSet()

SHAPE_POLY_SET SHAPE_POLY_SET::UnitSet ( int  aPolygonIndex)
inline

Definition at line 597 of file shape_poly_set.h.

598  {
599  return Subset( aPolygonIndex, aPolygonIndex + 1 );
600  }
SHAPE_POLY_SET Subset(int aFirstPolygon, int aLastPolygon)
Function Subset returns a subset of the polygons in this set, the ones between aFirstPolygon and aLas...

References Subset().

Referenced by BOARD::NormalizeAreaPolygon().

◆ VertexCount()

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

Returns the number of vertices in a given outline/hole

Definition at line 246 of file shape_poly_set.cpp.

247 {
248  if( m_polys.size() == 0 ) // Empty poly set
249  return 0;
250 
251  if( aOutline < 0 ) // Use last outline
252  aOutline += m_polys.size();
253 
254  int idx;
255 
256  if( aHole < 0 )
257  idx = 0;
258  else
259  idx = aHole + 1;
260 
261  if( aOutline >= (int) m_polys.size() ) // not existing outline
262  return 0;
263 
264  if( idx >= (int) m_polys[aOutline].size() ) // not existing hole
265  return 0;
266 
267  return m_polys[aOutline][idx].PointCount();
268 }

References m_polys.

Referenced by D_CODE::DrawFlashedPolygon(), and DRAWSEGMENT::GetPointCount().

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::m_type
protectedinherited

type of our shape

Definition at line 168 of file shape.h.

Referenced by SHAPE::Type().


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