52static std::unordered_set<const NODE*> allocNodes;
65 allocNodes.insert(
this );
74 wxLogTrace( wxT(
"PNS" ), wxT(
"attempting to free a node that has kids." ) );
79 if( allocNodes.find(
this ) == allocNodes.end() )
81 wxLogTrace( wxT(
"PNS" ), wxT(
"attempting to free an already-free'd node." ) );
85 allocNodes.erase(
this );
90 std::vector<const ITEM*> toDelete;
96 if( item->BelongsTo(
this ) && item->OfKind(
ITEM::HOLE_T ) )
99 HOLE* hole =
static_cast<HOLE*
>( item );
107 toDelete.push_back( item );
111 for(
const ITEM* item : toDelete )
113 wxLogTrace( wxT(
"PNS" ), wxT(
"del item %p type %s" ), item, item->KindStr().c_str() );
159 JOINT_MAP::iterator j;
169 wxLogTrace( wxT(
"PNS" ), wxT(
"%d items, %d joints, %d overrides" ),
191 m_override( nullptr )
235 if(
m_item == aCandidate )
238 if(
visit( aCandidate ) )
264 assert( allocNodes.find(
this ) != allocNodes.end() );
279 return aObstacles.size();
290 for(
int i = 0; i < aLine->
CLine().SegmentCount(); i++ )
303 if( obstacleList.empty() )
327 std::vector<SHAPE_LINE_CHAIN::INTERSECTION> intersectingPts;
328 int layer = aLine->
Layer();
330 for(
const OBSTACLE& obstacle : obstacleList )
336 + aLine->
Width() / 2;
338 obstacleHull = obstacle.m_item->Hull( clearance, 0, layer );
343 obstacleHull.
Clear();
352 intersectingPts.clear();
355 for(
const auto& ip : intersectingPts )
359 updateNearest( ip, obstacle );
366 +
via.Diameter() / 2;
368 obstacleHull = obstacle.m_item->Hull( viaClearance, 0, layer );
373 obstacleHull.
Clear();
381 intersectingPts.clear();
385 updateNearest( ip, obstacle );
390 nearest = (*obstacleList.begin());
427 const LINE* line =
static_cast<const LINE*
>( aItemA );
536 aSolid->SetOwner(
this );
577 switch( aItem->
Kind() )
606 for(
size_t i = 0; i < l.
ArcCount(); i++ )
618 auto newarc = std::make_unique< ARC >( aLine, s );
619 aLine.
Link( newarc.get() );
620 Add( std::move( newarc ),
true );
643 std::unique_ptr<SEGMENT> newseg = std::make_unique<SEGMENT>( aLine, s );
644 aLine.
Link( newseg.get() );
645 Add( std::move( newseg ),
true );
663bool NODE::Add( std::unique_ptr< SEGMENT > aSegment,
bool aAllowRedundant )
665 if( aSegment->Seg().A == aSegment->Seg().B )
667 wxLogTrace( wxT(
"PNS" ),
668 wxT(
"attempting to add a segment with same end coordinates, ignoring." ) );
692bool NODE::Add( std::unique_ptr< ARC > aArc,
bool aAllowRedundant )
717 if( edgeExclusion->Collide( aPos ) )
785 std::vector<ITEM*> links( aJoint->
LinkList() );
797 auto range =
m_joints.equal_range( tag );
804 for(
auto f = range.first; f != range.second; ++f )
816 for(
ITEM* link : links )
847 add( aNewItem.release() );
893 switch( aItem->
Kind() )
919 LINE* l =
static_cast<LINE*
>( aItem );
934 via->Hole()->SetOwner(
via );
950 std::vector<LINKED_ITEM*>& segRefs = aLine.
Links();
967 bool& aGuardHit,
bool aStopAtLockedJoints,
bool aFollowLockedSegments )
969 bool prevReversed =
false;
973 for(
int count = 0 ; ; ++count )
975 const VECTOR2I p = aCurrent->
Anchor( aScanDirection ^ prevReversed );
980 aCorners[aPos] = jt->
Pos();
981 aSegments[aPos] = aCurrent;
982 aArcReversed[aPos] =
false;
986 if( ( aScanDirection && jt->
Pos() == aCurrent->
Anchor( 0 ) )
987 || ( !aScanDirection && jt->
Pos() == aCurrent->
Anchor( 1 ) ) )
988 aArcReversed[aPos] =
true;
991 aPos += ( aScanDirection ? 1 : -1 );
993 if( count && guard == p )
995 if( aPos >= 0 && aPos < aLimit )
996 aSegments[aPos] =
nullptr;
1004 if(
locked || !jt->
IsLineCorner( aFollowLockedSegments ) || aPos < 0 || aPos == aLimit )
1007 aCurrent = jt->
NextSegment( aCurrent, aFollowLockedSegments );
1009 prevReversed = ( aCurrent && jt->
Pos() == aCurrent->
Anchor( aScanDirection ) );
1015 bool aStopAtLockedJoints,
bool aFollowLockedSegments )
1017 const int MaxVerts = 1024 * 16;
1019 std::array<VECTOR2I, MaxVerts + 1> corners;
1020 std::array<LINKED_ITEM*, MaxVerts + 1> segs;
1021 std::array<bool, MaxVerts + 1> arcReversed;
1024 bool guardHit =
false;
1026 int i_start = MaxVerts / 2;
1027 int i_end = i_start + 1;
1034 followLine( aSeg,
false, i_start, MaxVerts, corners.data(), segs.data(), arcReversed.data(),
1035 guardHit, aStopAtLockedJoints, aFollowLockedSegments );
1039 followLine( aSeg,
true, i_end, MaxVerts, corners.data(), segs.data(), arcReversed.data(),
1040 guardHit, aStopAtLockedJoints, aFollowLockedSegments );
1046 bool originSet =
false;
1050 for(
int i = i_start + 1; i < i_end; i++ )
1058 if( li && prev_seg != li )
1062 const ARC* arc =
static_cast<const ARC*
>( li );
1067 ssize_t lastShape = nSegs ? line.
ArcIndex(
static_cast<ssize_t
>( nSegs ) - 1 ) : -1;
1075 if( li == aSeg && aOriginSegmentIndex && !originSet )
1079 *aOriginSegmentIndex = line.
PointCount() - 1;
1091 if( aOriginSegmentIndex && *aOriginSegmentIndex >= pl.
SegmentCount() )
1094 wxASSERT_MSG( pl.
SegmentCount() != 0,
"assembled line should never be empty" );
1119 JOINT j_start, j_end;
1126 if( id_end < id_start )
1127 std::swap( id_end, id_start );
1129 if( id_start >= 0 && id_end >= 0 )
1132 aLines.push_back( line );
1143 const SEGMENT* locked_seg =
nullptr;
1144 std::vector<VVIA*> vvias;
1148 JOINT joint = jointPair.second;
1153 int n_seg = 0, n_solid = 0, n_vias = 0;
1156 bool is_width_change =
false;
1157 bool is_locked =
false;
1169 else if(
const auto t = dyn_cast<const PNS::SEGMENT*>( item ) )
1173 if( prev_w >= 0 && w != prev_w )
1175 is_width_change =
true;
1178 max_w = std::max( w, max_w );
1181 is_locked = t->IsLocked();
1186 if( ( is_width_change || n_seg >= 3 || is_locked ) && n_solid == 0 && n_vias == 0 )
1197 locked_seg->
Seg().
B :
1198 locked_seg->
Seg().
A;
1205 for(
auto vvia : vvias )
1207 Add( ItemCast<VIA>( std::move( std::unique_ptr<VVIA>( vvia ) ) ) );
1221 if( f == end && !
isRoot() )
1232 if( f->second.Layers().Overlaps( aLayer ) )
1257 JOINT_MAP::iterator f =
m_joints.find( tag );
1259 std::pair<JOINT_MAP::iterator, JOINT_MAP::iterator> range;
1266 for( f = range.first; f != range.second; ++f )
1271 JOINT jt( aPos, aLayers, aNet );
1278 range =
m_joints.equal_range( tag );
1280 if( range.first ==
m_joints.end() )
1283 for( f = range.first; f != range.second; ++f )
1285 if( aLayers.
Overlaps( f->second.Layers() ) )
1287 jt.
Merge( f->second );
1301 wxLogTrace( wxT(
"PNS" ), wxT(
"joint layers %d-%d, net %d, pos %s, links: %d" ),
1332 std::unordered_set<SEGMENT*> all_segs;
1335 for( i = m_items.begin(); i != m_items.end(); i++ )
1338 all_segs.insert(
static_cast<SEGMENT*
>( *i ) );
1343 for( i =
m_root->m_items.begin(); i !=
m_root->m_items.end(); i++ )
1346 all_segs.insert(
static_cast<SEGMENT*
>(*i) );
1350 JOINT_MAP::iterator j;
1356 wxLogTrace( wxT(
"PNS" ), wxT(
"joint : %s, links : %d\n" ),
1357 j->second.GetPos().Format().c_str(), j->second.LinkCount() );
1358 JOINT::LINKED_ITEMS::const_iterator k;
1360 for( k = j->second.GetLinkList().begin(); k != j->second.GetLinkList().end(); ++k )
1362 const ITEM* m_item = *k;
1364 switch( m_item->GetKind() )
1369 wxLogTrace( wxT(
"PNS" ), wxT(
" -> seg %s %s\n" ),
1370 seg->GetSeg().A.
Format().c_str(),
1371 seg->GetSeg().B.
Format().c_str() );
1382 int lines_count = 0;
1384 while( !all_segs.empty() )
1386 SEGMENT* s = *all_segs.begin();
1389 LINE::LinkedSegments* seg_refs = l->GetLinkedSegments();
1393 wxLogTrace( wxT(
"PNS" ), wxT(
"Line: %s, net %d " ),
1394 l->GetLine().
Format().c_str(), l->GetNet() );
1397 for( std::vector<SEGMENT*>::iterator j = seg_refs->begin(); j != seg_refs->end(); ++j )
1399 wxLogTrace( wxT(
"PNS" ), wxT(
"%s " ), (*j)->GetSeg().A.Format().c_str() );
1401 if( j + 1 == seg_refs->end() )
1402 wxLogTrace( wxT(
"PNS" ), wxT(
"%s\n" ), (*j)->GetSeg().B.Format().c_str() );
1404 all_segs.erase( *j );
1410 wxLogTrace( wxT(
"PNS" ), wxT(
"Local joints: %d, lines : %d \n" ),
1428 aRemoved.push_back( item );
1431 aAdded.push_back( item );
1440 for(
NODE* node : kids )
1442 node->releaseChildren();
1453 std::vector<const ITEM*> cacheCheckItems;
1458 if( !item->BelongsTo(
this ) )
1508 for(
ITEM* item : *l_cur )
1510 if( item->OfKind( aKindMask ) && item->IsRoutable() )
1511 aItems.insert( item );
1521 for(
ITEM* item : *l_root )
1523 if( !
Overrides( item ) && item->OfKind( aKindMask ) && item->IsRoutable() )
1524 aItems.insert( item );
1535 item->SetRank( -1 );
1536 item->Mark( item->Marker() & ~aMarkerMask );
1543 std::vector<ITEM*> garbage;
1547 if( item->Marker() & aMarker )
1548 garbage.emplace_back( item );
1551 for(
ITEM* item : garbage )
1574 && ( (
A == a2 &&
B == b2 ) || (
A == b2 &&
B == a2 ) ) )
1603 ARC* seg2 =
static_cast<ARC*
>( item );
1609 && ( (
A == a2 &&
B == b2 ) || (
A == b2 &&
B == a2 ) ) )
1633 for( JOINT_MAP::value_type& j :
m_joints )
1635 if( !j.second.Layers().Overlaps( aLayerMask ) )
1638 if( aBox.
Contains( j.second.Pos() ) && j.second.LinkCount( aKindMask ) )
1640 aJoints.push_back( &j.second );
1650 if( !
Overrides( &j.second ) && j.second.Layers().Overlaps( aLayerMask ) )
1652 if( aBox.
Contains( j.second.Pos() ) && j.second.LinkCount( aKindMask ) )
1654 aJoints.push_back( &j.second );
1673 for(
ITEM* item : *l_cur )
1675 if( item->Parent() == aParent )
1686 std::vector<ITEM*> ret;
1690 if( item->Parent() == aParent )
1691 ret.push_back( item );
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
NETINFO_ITEM * GetNet() const
Return #NET_INFO object for a given item.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
virtual bool IsConnected() const
Returns information if the object is derived from BOARD_CONNECTED_ITEM.
coord_type GetTop() const
bool Contains(const Vec &aPoint) const
coord_type GetRight() const
coord_type GetLeft() const
coord_type GetBottom() const
@ ROUNDED_90
H/V with filleted corners.
@ MITERED_90
H/V only (90-degree corners)
Represent a contiguous set of PCB layers.
bool IsMultilayer() const
bool Overlaps(const LAYER_RANGE &aOther) const
virtual VECTOR2I Anchor(int n) const override
const SHAPE * Shape() const override
Return the geometrical shape of the item.
ITEM * ParentPadVia() const override
void Remove(ITEM *aItem)
Removes an item from the spatial index.
std::list< ITEM * > NET_ITEMS_LIST
int Size() const
Returns number of items stored in the index.
void Add(ITEM *aItem)
Adds item to the spatial index.
int Query(const ITEM *aItem, int aMinDistance, Visitor &aVisitor) const
Searches items in the index that are in proximity of aItem.
NET_ITEMS_LIST * GetItemsForNet(NET_HANDLE aNet)
Returns list of all items in a given net.
void Add(const LINE &aLine)
std::vector< ITEM * > & Items()
const std::vector< ITEM * > & CItems() const
Base class for PNS router board items.
void SetLayers(const LAYER_RANGE &aLayers)
virtual const std::string Format() const
virtual void Unmark(int aMarker=-1) const
virtual NET_HANDLE Net() const
PnsKind Kind() const
Return the type (kind) of the item.
void SetNet(NET_HANDLE aNet)
virtual void SetRank(int aRank)
virtual int Layer() const
virtual const SHAPE * Shape() const
Return the geometrical shape of the item.
const LAYER_RANGE & Layers() const
bool OfKind(int aKindMask) const
virtual VECTOR2I Anchor(int n) const
bool LayersOverlap(const ITEM *aOther) const
Return true if the set of layers spanned by aOther overlaps our layers.
virtual HOLE * Hole() const
bool Collide(const ITEM *aHead, const NODE *aNode, COLLISION_SEARCH_CONTEXT *aCtx=nullptr) const
Check for a collision (clearance violation) with between us and item aOther.
virtual bool HasHole() const
A 2D point on a given set of layers and belonging to a certain net, that links together a number of b...
const std::vector< ITEM * > & LinkList() const
NET_HANDLE Net() const override
int LinkCount(int aMask=-1) const
LINKED_ITEM * NextSegment(ITEM *aCurrent, bool aAllowLockedSegs=false) const
bool IsLineCorner(bool aAllowLockedSegs=false) const
Checks if a joint connects two segments of the same net, layer, and width.
void Lock(bool aLock=true)
void Link(ITEM *aItem)
Unlink a given board item from the joint (upon its removal from a NODE)
HASH_TAG m_tag
< hash tag for unordered_multimap
void Merge(const JOINT &aJoint)
bool Unlink(ITEM *aItem)
For trivial joints, return the segment adjacent to (aCurrent).
const VECTOR2I & Pos() const
Represents a track on a PCB, connecting two non-trivial joints (that is, vias, pads,...
const VECTOR2I & CPoint(int aIdx) const
void ClipVertexRange(int aStart, int aEnd)
Return the number of corners of angles specified by mask aAngles.
const SHAPE_LINE_CHAIN & CLine() const
SHAPE_LINE_CHAIN & Line()
void SetWidth(int aWidth)
Return line width.
int Width() const
Return true if the line is geometrically identical as line aOther.
virtual int Width() const
void Link(LINKED_ITEM *aLink)
Return the list of links from the owning node that constitute this line (or NULL if the line is not l...
bool IsLinked() const
Check if the segment aLink is a part of the line.
virtual void ClearLinks()
Return the number of segments that were assembled together to form this line.
Keep the router "world" - i.e.
NODE * Branch()
Create a lightweight copy (called branch) of self that tracks the changes (added/removed items) wrs t...
void RemoveByMarker(int aMarker)
NODE * m_root
root node of the whole hierarchy
SEGMENT * findRedundantSegment(const VECTOR2I &A, const VECTOR2I &B, const LAYER_RANGE &lr, NET_HANDLE aNet)
int FindLinesBetweenJoints(const JOINT &aA, const JOINT &aB, std::vector< LINE > &aLines)
Find the joints corresponding to the ends of line aLine.
std::vector< ITEM * > ITEM_VECTOR
int GetClearance(const ITEM *aA, const ITEM *aB, bool aUseClearanceEpsilon=true) const
Return the pre-set worst case clearance between any pair of items.
void followLine(LINKED_ITEM *aCurrent, bool aScanDirection, int &aPos, int aLimit, VECTOR2I *aCorners, LINKED_ITEM **aSegments, bool *aArcReversed, bool &aGuardHit, bool aStopAtLockedJoints, bool aFollowLockedSegments)
void addSolid(SOLID *aSeg)
void Replace(ITEM *aOldItem, std::unique_ptr< ITEM > aNewItem)
Replace an item with another one.
bool Overrides(ITEM *aItem) const
void removeSegmentIndex(SEGMENT *aSeg)
void rebuildJoint(const JOINT *aJoint, const ITEM *aItem)
void GetUpdatedItems(ITEM_VECTOR &aRemoved, ITEM_VECTOR &aAdded)
Return the list of items removed and added in this branch with respect to the root branch.
void addSegment(SEGMENT *aSeg)
std::vector< std::unique_ptr< SHAPE > > m_edgeExclusions
JOINT_MAP::value_type TagJointPair
bool QueryEdgeExclusions(const VECTOR2I &aPos) const
void doRemove(ITEM *aItem)
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Check if the item collides with anything else in the world, and if found, returns the obstacle.
const JOINT * FindJoint(const VECTOR2I &aPos, int aLayer, NET_HANDLE aNet) const
Search for a joint at a given position, layer and belonging to given net.
void addHole(HOLE *aHole)
std::optional< OBSTACLE > OPT_OBSTACLE
std::unordered_set< ITEM * > m_garbageItems
void Dump(bool aLong=false)
void FindLineEnds(const LINE &aLine, JOINT &aA, JOINT &aB)
Destroy all child nodes. Applicable only to the root node.
JOINT & touchJoint(const VECTOR2I &aPos, const LAYER_RANGE &aLayers, NET_HANDLE aNet)
Touch a joint and links it to an m_item.
RULE_RESOLVER * GetRuleResolver() const
Return the number of joints.
int QueryJoints(const BOX2I &aBox, std::vector< JOINT * > &aJoints, LAYER_RANGE aLayerMask=LAYER_RANGE::All(), int aKindMask=ITEM::ANY_T)
bool Add(std::unique_ptr< SEGMENT > aSegment, bool aAllowRedundant=false)
Add an item to the current node.
std::set< OBSTACLE > OBSTACLES
INDEX * m_index
Geometric/Net index of the items.
std::vector< ITEM * > FindItemsByZone(const ZONE *aParent)
std::unordered_set< ITEM * > m_override
hash of root's items that have been changed in this node
void AllItemsInNet(NET_HANDLE aNet, std::set< ITEM * > &aItems, int aKindMask=-1)
OPT_OBSTACLE NearestObstacle(const LINE *aLine, const COLLISION_SEARCH_OPTIONS &aOpts=COLLISION_SEARCH_OPTIONS())
Follow the line in search of an obstacle that is nearest to the starting to the line's starting point...
void LockJoint(const VECTOR2I &aPos, const ITEM *aItem, bool aLock)
void removeArcIndex(ARC *aVia)
void AddEdgeExclusion(std::unique_ptr< SHAPE > aShape)
int QueryColliding(const ITEM *aItem, OBSTACLES &aObstacles, const COLLISION_SEARCH_OPTIONS &aOpts=COLLISION_SEARCH_OPTIONS()) const
Find items colliding (closer than clearance) with the item aItem.
int m_maxClearance
worst case item-item clearance
void removeViaIndex(VIA *aVia)
void unlinkJoint(const VECTOR2I &aPos, const LAYER_RANGE &aLayers, NET_HANDLE aNet, ITEM *aWhere)
Helpers for adding/removing items.
void add(ITEM *aItem, bool aAllowRedundant=false)
void removeSolidIndex(SOLID *aSeg)
int m_depth
depth of the node (number of parent nodes in the inheritance chain)
std::set< NODE * > m_children
list of nodes branched from this one
ITEM * FindItemByParent(const BOARD_ITEM *aParent)
JOINT_MAP m_joints
hash table with the joints, linking the items.
ARC * findRedundantArc(const VECTOR2I &A, const VECTOR2I &B, const LAYER_RANGE &lr, NET_HANDLE aNet)
NODE * m_parent
node this node was branched from
void ClearRanks(int aMarkerMask=MK_HEAD|MK_VIOLATION)
void Remove(ARC *aArc)
Remove an item from this branch.
void Commit(NODE *aNode)
Apply the changes from a given branch (aNode) to the root branch.
RULE_RESOLVER * m_ruleResolver
Design rules resolver.
~NODE()
Return the expected clearance between items a and b.
void linkJoint(const VECTOR2I &aPos, const LAYER_RANGE &aLayers, NET_HANDLE aNet, ITEM *aWhere)
Unlink an item from a joint.
const LINE AssembleLine(LINKED_ITEM *aSeg, int *aOriginSegmentIndex=nullptr, bool aStopAtLockedJoints=false, bool aFollowLockedSegments=false)
Follow the joint map to assemble a line connecting two non-trivial joints starting from segment aSeg.
const ITEM_SET HitTest(const VECTOR2I &aPoint) const
Find all items that contain the point aPoint.
OBSTACLE_VISITOR(const ITEM *aItem)
const NODE * m_node
node we are searching in (either root or a branch)
const ITEM * m_item
the item we are looking for collisions with
bool visit(ITEM *aCandidate)
void SetWorld(const NODE *aNode, const NODE *aOverride=nullptr)
const NODE * m_override
node that overrides root entries
void SetOwner(const ITEM_OWNER *aOwner)
Set the node that owns this item.
bool BelongsTo(const ITEM_OWNER *aNode) const
const ITEM_OWNER * Owner() const
Return the owner of this item, or NULL if there's none.
virtual DEBUG_DECORATOR * GetDebugDecorator()=0
ROUTER_IFACE * GetInterface() const
ROUTING_SETTINGS & Settings()
static ROUTER * GetInstance()
DIRECTION_45::CORNER_MODE GetCornerMode() const
virtual void ClearCacheForItems(std::vector< const ITEM * > &aItems)
virtual int ClearanceEpsilon() const
virtual int Clearance(const ITEM *aA, const ITEM *aB, bool aUseClearanceEpsilon=true)=0
virtual const std::string Format() const override
virtual bool HasHole() const override
virtual HOLE * Hole() const override
const VECTOR2I & Pos() const
const VECTOR2I & Pos() const
virtual HOLE * Hole() const override
virtual bool HasHole() const override
SHAPE_ARC Reversed() const
const VECTOR2I & GetP1() const
const VECTOR2I & GetP0() const
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
const SHAPE_ARC & Arc(size_t aArc) const
int PointCount() const
Return the number of points (vertices) in this line chain.
ssize_t ArcIndex(size_t aSegment) const
Return the arc index for the given segment index.
void Clear()
Remove all points from the line chain.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
int SegmentCount() const
Return the number of segments in this line chain.
int PathLength(const VECTOR2I &aP, int aIndex=-1) const
Compute the walk path length from the beginning of the line chain and the point aP belonging to our l...
void RemoveDuplicatePoints()
Remove the duplicate points from the line chain.
const SEG CSegment(int aIndex) const
Return a constant copy of the aIndex segment in the line chain.
bool IsArcSegment(size_t aSegment) const
int Find(const VECTOR2I &aP, int aThreshold=0) const
Search for point aP.
const BOX2I BBox(int aClearance=0) const override
Compute a bounding box of the shape, with a margin of aClearance a collision.
virtual bool Collide(const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const
Check if the boundary of shape (this) lies closer to the point aP than aClearance,...
const std::string Format() const
Return the vector formatted as a string.
Handle a list of polygons defining a copper zone.
Push and Shove diff pair dimensions (gap) settings dialog.
void HullIntersection(const SHAPE_LINE_CHAIN &hull, const SHAPE_LINE_CHAIN &line, SHAPE_LINE_CHAIN::INTERSECTIONS &ips)
static std::vector< std::string > split(const std::string &aStr, const std::string &aDelim)
Split the input string into a vector of output strings.
const COLLISION_SEARCH_OPTIONS options
std::set< OBSTACLE > & obstacles
std::set< ITEM * > * m_restrictedSet
bool m_useClearanceEpsilon
bool operator()(ITEM *aItem) override
HIT_VISITOR(ITEM_SET &aTab, const VECTOR2I &aPoint)
< Joints are hashed by their position, layers and net.
bool operator()(ITEM *aCandidate) override
COLLISION_SEARCH_CONTEXT * m_ctx
DEFAULT_OBSTACLE_VISITOR(COLLISION_SEARCH_CONTEXT *aCtx, const ITEM *aItem)
virtual ~DEFAULT_OBSTACLE_VISITOR()
Hold an object colliding with another object, along with some useful data about the collision.
int m_distFirst
... and the distance thereof
int m_maxFanoutWidth
worst case (largest) width of the tracks connected to the item
ITEM * m_head
Line we search collisions against.
VECTOR2I m_ipFirst
First intersection between m_head and m_hull.
ITEM * m_item
Item found to be colliding with m_head.
Represent an intersection between two line segments.
VECTOR2I p
Point of intersection between our and their.
int index_their
index of the intersecting corner/segment in the 'their' (Intersect() method parameter) line.