KiCad PCB EDA Suite
PNS::JOINT Class Reference

A 2D point on a given set of layers and belonging to a certain net, that links together a number of board items. More...

#include <pns_joint.h>

Inheritance diagram for PNS::JOINT:
PNS::ITEM

Classes

struct  HASH_TAG
 
struct  JOINT_TAG_HASH
 

Public Types

typedef ITEM_SET::ENTRIES LINKED_ITEMS
 Joints are hashed by their position, layers and net. More...
 
enum  PnsKind {
  SOLID_T = 1 , LINE_T = 2 , JOINT_T = 4 , SEGMENT_T = 8 ,
  ARC_T = 16 , VIA_T = 32 , DIFF_PAIR_T = 64 , ANY_T = 0xff
}
 

Public Member Functions

 JOINT ()
 
 JOINT (const VECTOR2I &aPos, const LAYER_RANGE &aLayers, int aNet=-1)
 
 JOINT (const JOINT &aB)
 
ITEMClone () const override
 Return a deep copy of the item. More...
 
bool IsLineCorner (bool aAllowLockedSegs=false) const
 Checks if a joint connects two segments of the same net, layer, and width. More...
 
bool IsNonFanoutVia () const
 
bool IsStitchingVia () const
 
bool IsTraceWidthChange () const
 Link the joint to a given board item (when it's added to the NODE). More...
 
void Link (ITEM *aItem)
 Unlink a given board item from the joint (upon its removal from a NODE) More...
 
bool Unlink (ITEM *aItem)
 For trivial joints, return the segment adjacent to (aCurrent). More...
 
LINKED_ITEMNextSegment (ITEM *aCurrent, bool aAllowLockedSegs=false) const
 
VIAVia ()
 
const HASH_TAGTag () const
 trivial accessors More...
 
const VECTOR2IPos () const
 
int Net () const
 
const LINKED_ITEMSLinkList () const
 
const ITEM_SETCLinks () const
 
ITEM_SETLinks ()
 
int LinkCount (int aMask=-1) const
 
void Dump () const
 
bool operator== (const JOINT &rhs) const
 
void Merge (const JOINT &aJoint)
 
bool Overlaps (const JOINT &rhs) const
 
void Lock (bool aLock=true)
 
bool IsLocked () const
 
virtual const SHAPE_LINE_CHAIN Hull (int aClearance=0, int aWalkaroundThickness=0, int aLayer=-1) const
 
virtual const SHAPE_LINE_CHAIN HoleHull (int aClearance, int aWalkaroundThickness=0, int aLayer=-1) const
 
PnsKind Kind () const
 Return the type (kind) of the item. More...
 
bool OfKind (int aKindMask) const
 Return true if the item's type matches the mask aKindMask. More...
 
std::string KindStr () const
 Returns the kind of the item, as string. More...
 
void SetParent (BOARD_ITEM *aParent)
 
BOARD_ITEMParent () const
 
void SetNet (int aNet)
 
const LAYER_RANGELayers () const
 
void SetLayers (const LAYER_RANGE &aLayers)
 
void SetLayer (int aLayer)
 
virtual int Layer () const
 
bool LayersOverlap (const ITEM *aOther) const
 Return true if the set of layers spanned by aOther overlaps our layers. More...
 
NODEOwner () const
 Return the owner of this item, or NULL if there's none. More...
 
void SetOwner (NODE *aOwner)
 Set the node that owns this item. More...
 
bool BelongsTo (NODE *aNode) const
 
bool Collide (const ITEM *aOther, const NODE *aNode, bool aDifferentNetsOnly=true, int aOverrideClearance=-1) const
 Check for a collision (clearance violation) with between us and item aOther. More...
 
virtual const SHAPEShape () const
 Return the geometrical shape of the item. More...
 
virtual const SHAPEHole () const
 
virtual void Mark (int aMarker) const
 
virtual void Unmark (int aMarker=-1) const
 
virtual int Marker () const
 
virtual void SetRank (int aRank)
 
virtual int Rank () const
 
virtual VECTOR2I Anchor (int n) const
 
virtual int AnchorCount () const
 
void SetRoutable (bool aRoutable)
 
bool IsRoutable () const
 
void SetIsFreePad (bool aIsFreePad=true)
 
bool IsFreePad () const
 
bool IsVirtual () const
 
void SetIsCompoundShapePrimitive ()
 
bool IsCompoundShapePrimitive () const
 
virtual const std::string Format () const
 

Static Public Attributes

static const int UnusedNet = INT_MAX
 Supported item types. More...
 

Protected Attributes

PnsKind m_kind
 
BOARD_ITEMm_parent
 
NODEm_owner
 
LAYER_RANGE m_layers
 
bool m_movable
 
int m_net
 
int m_marker
 
int m_rank
 
bool m_routable
 
bool m_isVirtual
 
bool m_isFreePad
 
bool m_isCompoundShapePrimitive
 

Private Member Functions

bool collideSimple (const ITEM *aOther, const NODE *aNode, bool aDifferentNetsOnly, int aOverrideClearance) const
 

Private Attributes

HASH_TAG m_tag
 < hash tag for unordered_multimap More...
 
ITEM_SET m_linkedItems
 locked (non-movable) flag More...
 
bool m_locked
 

Detailed Description

A 2D point on a given set of layers and belonging to a certain net, that links together a number of board items.

A hash table of joints is used by the router to follow connectivity between the items.

Definition at line 42 of file pns_joint.h.

Member Typedef Documentation

◆ LINKED_ITEMS

Joints are hashed by their position, layers and net.

Linked items are, obviously, not hashed.

Definition at line 45 of file pns_joint.h.

Member Enumeration Documentation

◆ PnsKind

enum PNS::ITEM::PnsKind
inherited
Enumerator
SOLID_T 
LINE_T 
JOINT_T 
SEGMENT_T 
ARC_T 
VIA_T 
DIFF_PAIR_T 
ANY_T 

Definition at line 61 of file pns_item.h.

62 {
63 SOLID_T = 1,
64 LINE_T = 2,
65 JOINT_T = 4,
66 SEGMENT_T = 8,
67 ARC_T = 16,
68 VIA_T = 32,
69 DIFF_PAIR_T = 64,
70 ANY_T = 0xff
71 };
@ SOLID_T
Definition: pns_item.h:63
@ LINE_T
Definition: pns_item.h:64
@ SEGMENT_T
Definition: pns_item.h:66
@ DIFF_PAIR_T
Definition: pns_item.h:69
@ JOINT_T
Definition: pns_item.h:65

Constructor & Destructor Documentation

◆ JOINT() [1/3]

PNS::JOINT::JOINT ( )
inline

Definition at line 69 of file pns_joint.h.

69 :
70 ITEM( JOINT_T ), m_tag(), m_locked( false ) {}
ITEM(PnsKind aKind)
Definition: pns_item.h:73
HASH_TAG m_tag
< hash tag for unordered_multimap
Definition: pns_joint.h:302
bool m_locked
Definition: pns_joint.h:308

◆ JOINT() [2/3]

PNS::JOINT::JOINT ( const VECTOR2I aPos,
const LAYER_RANGE aLayers,
int  aNet = -1 
)
inline

Definition at line 72 of file pns_joint.h.

72 :
73 ITEM( JOINT_T )
74 {
75 m_tag.pos = aPos;
76 m_tag.net = aNet;
77 m_layers = aLayers;
78 m_locked = false;
79 }
LAYER_RANGE m_layers
Definition: pns_item.h:258

References PNS::ITEM::m_layers, m_locked, m_tag, PNS::JOINT::HASH_TAG::net, and PNS::JOINT::HASH_TAG::pos.

◆ JOINT() [3/3]

PNS::JOINT::JOINT ( const JOINT aB)
inline

Definition at line 81 of file pns_joint.h.

81 :
82 ITEM( JOINT_T )
83 {
84 m_layers = aB.m_layers;
85 m_tag.pos = aB.m_tag.pos;
86 m_tag.net = aB.m_tag.net;
87 m_linkedItems = aB.m_linkedItems;
88 m_layers = aB.m_layers;
89 m_locked = aB.m_locked;
90 }
ITEM_SET m_linkedItems
locked (non-movable) flag
Definition: pns_joint.h:305

References PNS::ITEM::m_layers, m_linkedItems, m_locked, m_tag, PNS::JOINT::HASH_TAG::net, and PNS::JOINT::HASH_TAG::pos.

Member Function Documentation

◆ Anchor()

◆ AnchorCount()

virtual int PNS::ITEM::AnchorCount ( ) const
inlinevirtualinherited

Reimplemented in PNS::ARC, PNS::SEGMENT, PNS::SOLID, and PNS::VIA.

Definition at line 224 of file pns_item.h.

225 {
226 return 0;
227 }

◆ BelongsTo()

bool PNS::ITEM::BelongsTo ( NODE aNode) const
inlineinherited
Returns
true if the item is owned by the node aNode.

Definition at line 183 of file pns_item.h.

184 {
185 return m_owner == aNode;
186 }
NODE * m_owner
Definition: pns_item.h:257

References PNS::ITEM::m_owner.

Referenced by PNS::NODE::doRemove().

◆ CLinks()

const ITEM_SET & PNS::JOINT::CLinks ( ) const
inline

Definition at line 246 of file pns_joint.h.

247 {
248 return m_linkedItems;
249 }

References m_linkedItems.

◆ Clone()

ITEM * PNS::JOINT::Clone ( ) const
inlineoverridevirtual

Return a deep copy of the item.

Implements PNS::ITEM.

Definition at line 92 of file pns_joint.h.

93 {
94 assert( false );
95 return nullptr;
96 }

◆ Collide()

bool PNS::ITEM::Collide ( const ITEM aOther,
const NODE aNode,
bool  aDifferentNetsOnly = true,
int  aOverrideClearance = -1 
) const
inherited

Check for a collision (clearance violation) with between us and item aOther.

Collision checking takes all PCB stuff into account (layers, nets, DRC rules). Optionally returns a minimum translation vector for force propagation algorithm.

Parameters
aOtheris the item to check collision against.
Returns
true, if a collision was found.

Definition at line 169 of file pns_item.cpp.

170{
171 if( collideSimple( aOther, aNode, aDifferentNetsOnly, aOverrideClearance ) )
172 return true;
173
174 // Special cases for "head" lines with vias attached at the end. Note that this does not
175 // support head-line-via to head-line-via collisions, but you can't route two independent
176 // tracks at once so it shouldn't come up.
177
178 if( m_kind == LINE_T )
179 {
180 const LINE* line = static_cast<const LINE*>( this );
181
182 if( line->EndsWithVia() && line->Via().collideSimple( aOther, aNode, aDifferentNetsOnly, aOverrideClearance ) )
183 return true;
184 }
185
186 if( aOther->m_kind == LINE_T )
187 {
188 const LINE* line = static_cast<const LINE*>( aOther );
189
190 if( line->EndsWithVia() && line->Via().collideSimple( this, aNode, aDifferentNetsOnly, aOverrideClearance ) )
191 return true;
192 }
193
194 return false;
195}
PnsKind m_kind
Definition: pns_item.h:254
bool collideSimple(const ITEM *aOther, const NODE *aNode, bool aDifferentNetsOnly, int aOverrideClearance) const
Definition: pns_item.cpp:32

References PNS::ITEM::collideSimple(), PNS::LINE::EndsWithVia(), PNS::ITEM::LINE_T, PNS::ITEM::m_kind, and PNS::LINE::Via().

Referenced by PNS::SHOVE::fixupViaCollisions(), PNS::SHOVE::onCollidingSolid(), PNS::NODE::DEFAULT_OBSTACLE_VISITOR::operator()(), PNS::OPTIMIZER::CACHE_VISITOR::operator()(), PNS::SHOVE::shoveLineFromLoneVia(), PNS::SHOVE::shoveLineToHullSet(), PNS::COMPONENT_DRAGGER::Start(), and PNS::verifyDpBypass().

◆ collideSimple()

bool PNS::ITEM::collideSimple ( const ITEM aOther,
const NODE aNode,
bool  aDifferentNetsOnly,
int  aOverrideClearance 
) const
privateinherited

Definition at line 32 of file pns_item.cpp.

33{
34 const ROUTER_IFACE* iface = ROUTER::GetInstance()->GetInterface();
35 const SHAPE* shapeA = Shape();
36 const SHAPE* holeA = Hole();
37 int lineWidthA = 0;
38 const SHAPE* shapeB = aOther->Shape();
39 const SHAPE* holeB = aOther->Hole();
40 int lineWidthB = 0;
41
42 // Sadly collision routines ignore SHAPE_POLY_LINE widths so we have to pass them in as part
43 // of the clearance value.
44 if( m_kind == LINE_T )
45 lineWidthA = static_cast<const LINE*>( this )->Width() / 2;
46
47 if( aOther->m_kind == LINE_T )
48 lineWidthB = static_cast<const LINE*>( aOther )->Width() / 2;
49
50 // same nets? no collision!
51 if( aDifferentNetsOnly && m_net == aOther->m_net && m_net >= 0 && aOther->m_net >= 0 )
52 return false;
53
54 // a pad associated with a "free" pin (NIC) doesn't have a net until it has been used
55 if( aDifferentNetsOnly && ( IsFreePad() || aOther->IsFreePad() ) )
56 return false;
57
58 // check if we are not on completely different layers first
59 if( !m_layers.Overlaps( aOther->m_layers ) )
60 return false;
61
62 auto checkKeepout =
63 []( const ZONE* aKeepout, const BOARD_ITEM* aOther )
64 {
65 if( aKeepout->GetDoNotAllowTracks() && aOther->IsType( { PCB_ARC_T, PCB_TRACE_T } ) )
66 return true;
67
68 if( aKeepout->GetDoNotAllowVias() && aOther->Type() == PCB_VIA_T )
69 return true;
70
71 if( aKeepout->GetDoNotAllowPads() && aOther->Type() == PCB_PAD_T )
72 return true;
73
74 // Incomplete test, but better than nothing:
75 if( aKeepout->GetDoNotAllowFootprints() && aOther->Type() == PCB_PAD_T )
76 {
77 return !aKeepout->GetParentFootprint()
78 || aKeepout->GetParentFootprint() != aOther->GetParentFootprint();
79 }
80
81 return false;
82 };
83
84 const ZONE* zoneA = dynamic_cast<ZONE*>( Parent() );
85 const ZONE* zoneB = dynamic_cast<ZONE*>( aOther->Parent() );
86
87 if( zoneA && aOther->Parent() && !checkKeepout( zoneA, aOther->Parent() ) )
88 return false;
89
90 if( zoneB && Parent() && !checkKeepout( zoneB, Parent() ) )
91 return false;
92
93 bool thisNotFlashed = !iface->IsFlashedOnLayer( this, aOther->Layer() );
94 bool otherNotFlashed = !iface->IsFlashedOnLayer( aOther, Layer() );
95
96 if( ( aNode->GetCollisionQueryScope() == NODE::CQS_ALL_RULES
97 || ( thisNotFlashed || otherNotFlashed ) )
98 && ( holeA || holeB ) )
99 {
100 int holeClearance = aNode->GetHoleClearance( this, aOther );
101
102 if( holeClearance >= 0 && holeA && holeA->Collide( shapeB, holeClearance + lineWidthB ) )
103 {
104 Mark( Marker() | MK_HOLE );
105 return true;
106 }
107
108 if( holeB && holeClearance >= 0 && holeB->Collide( shapeA, holeClearance + lineWidthA ) )
109 {
110 aOther->Mark( aOther->Marker() | MK_HOLE );
111 return true;
112 }
113
114 if( holeA && holeB )
115 {
116 int holeToHoleClearance = aNode->GetHoleToHoleClearance( this, aOther );
117
118 if( holeToHoleClearance >= 0 && holeA->Collide( holeB, holeToHoleClearance ) )
119 {
120 Mark( Marker() | MK_HOLE );
121 aOther->Mark( aOther->Marker() | MK_HOLE );
122 return true;
123 }
124 }
125 }
126
127 if( !aOther->Layers().IsMultilayer() && thisNotFlashed )
128 return false;
129
130 if( !Layers().IsMultilayer() && otherNotFlashed )
131 return false;
132
133 int clearance = aOverrideClearance >= 0 ? aOverrideClearance : aNode->GetClearance( this, aOther );
134
135 if( clearance >= 0 )
136 {
137 bool checkCastellation = ( m_parent && m_parent->GetLayer() == Edge_Cuts );
138 bool checkNetTie = aNode->GetRuleResolver()->IsInNetTie( this );
139
140 if( checkCastellation || checkNetTie )
141 {
142 // Slow method
143 int actual;
144 VECTOR2I pos;
145
146 if( shapeA->Collide( shapeB, clearance + lineWidthA, &actual, &pos ) )
147 {
148 if( checkCastellation && aNode->QueryEdgeExclusions( pos ) )
149 return false;
150
151 if( checkNetTie && aNode->GetRuleResolver()->IsNetTieExclusion( aOther, pos, this ) )
152 return false;
153
154 return true;
155 }
156 }
157 else
158 {
159 // Fast method
160 if( shapeA->Collide( shapeB, clearance + lineWidthA + lineWidthB ) )
161 return true;
162 }
163 }
164
165 return false;
166}
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:58
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition: board_item.h:180
BOARD_ITEM_CONTAINER * GetParentFootprint() const
Definition: board_item.cpp:239
bool Overlaps(const LAYER_RANGE &aOther) const
Definition: pns_layerset.h:67
BOARD_ITEM * Parent() const
Definition: pns_item.h:151
bool IsFreePad() const
Definition: pns_item.h:238
int m_net
Definition: pns_item.h:261
virtual const SHAPE * Hole() const
Definition: pns_item.h:207
virtual int Layer() const
Definition: pns_item.h:160
virtual const SHAPE * Shape() const
Return the geometrical shape of the item.
Definition: pns_item.h:202
const LAYER_RANGE & Layers() const
Definition: pns_item.h:156
virtual void Mark(int aMarker) const
Definition: pns_item.h:212
virtual int Marker() const
Definition: pns_item.h:214
BOARD_ITEM * m_parent
Definition: pns_item.h:256
@ CQS_ALL_RULES
check all rules
Definition: pns_node.h:162
ROUTER_IFACE * GetInterface() const
Definition: pns_router.h:211
static ROUTER * GetInstance()
Definition: pns_router.cpp:78
An abstract shape on 2D plane.
Definition: shape.h:123
virtual bool Collide(const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const
Check if the boundary of shape (this) lies closer to the point aP than aClearance,...
Definition: shape.h:178
Handle a list of polygons defining a copper zone.
Definition: zone.h:57
bool GetDoNotAllowVias() const
Definition: zone.h:699
bool GetDoNotAllowPads() const
Definition: zone.h:701
bool GetDoNotAllowTracks() const
Definition: zone.h:700
bool GetDoNotAllowFootprints() const
Definition: zone.h:702
@ Edge_Cuts
Definition: layer_ids.h:113
@ MK_HOLE
Definition: pns_item.h:45
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:102
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition: typeinfo.h:87
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:103
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:101

References SHAPE::Collide(), PNS::NODE::CQS_ALL_RULES, Edge_Cuts, PNS::NODE::GetClearance(), PNS::NODE::GetCollisionQueryScope(), ZONE::GetDoNotAllowFootprints(), ZONE::GetDoNotAllowPads(), ZONE::GetDoNotAllowTracks(), ZONE::GetDoNotAllowVias(), PNS::NODE::GetHoleClearance(), PNS::NODE::GetHoleToHoleClearance(), PNS::ROUTER::GetInstance(), PNS::ROUTER::GetInterface(), BOARD_ITEM::GetLayer(), BOARD_ITEM::GetParentFootprint(), PNS::NODE::GetRuleResolver(), PNS::ITEM::Hole(), PNS::ROUTER_IFACE::IsFlashedOnLayer(), PNS::ITEM::IsFreePad(), PNS::RULE_RESOLVER::IsInNetTie(), LAYER_RANGE::IsMultilayer(), PNS::RULE_RESOLVER::IsNetTieExclusion(), PNS::ITEM::Layer(), PNS::ITEM::Layers(), PNS::ITEM::LINE_T, PNS::ITEM::m_kind, PNS::ITEM::m_layers, PNS::ITEM::m_net, PNS::ITEM::m_parent, PNS::ITEM::Mark(), PNS::ITEM::Marker(), PNS::MK_HOLE, LAYER_RANGE::Overlaps(), PNS::ITEM::Parent(), PCB_ARC_T, PCB_PAD_T, PCB_TRACE_T, PCB_VIA_T, PNS::NODE::QueryEdgeExclusions(), and PNS::ITEM::Shape().

Referenced by PNS::ITEM::Collide().

◆ Dump()

void PNS::JOINT::Dump ( ) const

Definition at line 1277 of file pns_node.cpp.

1278{
1279 wxLogTrace( wxT( "PNS" ), wxT( "joint layers %d-%d, net %d, pos %s, links: %d" ),
1280 m_layers.Start(),
1281 m_layers.End(),
1282 m_tag.net,
1283 m_tag.pos.Format().c_str(),
1284 LinkCount() );
1285}
int Start() const
Definition: pns_layerset.h:82
int End() const
Definition: pns_layerset.h:87
int LinkCount(int aMask=-1) const
Definition: pns_joint.h:256
const std::string Format() const
Return the vector formatted as a string.
Definition: vector2d.h:408

References LAYER_RANGE::End(), VECTOR2< T >::Format(), LinkCount(), PNS::ITEM::m_layers, m_tag, PNS::JOINT::HASH_TAG::net, PNS::JOINT::HASH_TAG::pos, and LAYER_RANGE::Start().

◆ Format()

const std::string PNS::ITEM::Format ( ) const
virtualinherited

Reimplemented in PNS::SEGMENT, and PNS::VIA.

Definition at line 218 of file pns_item.cpp.

219{
220 std::stringstream ss;
221 ss << KindStr() << " ";
222 ss << "net " << m_net << " ";
223 ss << "layers " << m_layers.Start() << " " << m_layers.End();
224 return ss.str();
225}
std::string KindStr() const
Returns the kind of the item, as string.
Definition: pns_item.cpp:198

References LAYER_RANGE::End(), PNS::ITEM::KindStr(), PNS::ITEM::m_layers, PNS::ITEM::m_net, and LAYER_RANGE::Start().

Referenced by PNS::NODE::Dump(), PNS::SEGMENT::Format(), and PNS::VIA::Format().

◆ Hole()

virtual const SHAPE * PNS::ITEM::Hole ( ) const
inlinevirtualinherited

Reimplemented in PNS::SOLID, and PNS::VIA.

Definition at line 207 of file pns_item.h.

208 {
209 return nullptr;
210 }

Referenced by PNS::ITEM::collideSimple(), PNS::VIA::PushoutForce(), ROUTER_PREVIEW_ITEM::ROUTER_PREVIEW_ITEM(), and ROUTER_PREVIEW_ITEM::Update().

◆ HoleHull()

virtual const SHAPE_LINE_CHAIN PNS::ITEM::HoleHull ( int  aClearance,
int  aWalkaroundThickness = 0,
int  aLayer = -1 
) const
inlinevirtualinherited

Reimplemented in PNS::SOLID, and PNS::VIA.

Definition at line 123 of file pns_item.h.

125 {
126 return SHAPE_LINE_CHAIN();
127 }
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...

◆ Hull()

virtual const SHAPE_LINE_CHAIN PNS::ITEM::Hull ( int  aClearance = 0,
int  aWalkaroundThickness = 0,
int  aLayer = -1 
) const
inlinevirtualinherited

Reimplemented in PNS::ARC, PNS::SEGMENT, PNS::SOLID, and PNS::VIA.

Definition at line 117 of file pns_item.h.

119 {
120 return SHAPE_LINE_CHAIN();
121 }

◆ IsCompoundShapePrimitive()

bool PNS::ITEM::IsCompoundShapePrimitive ( ) const
inlineinherited

Definition at line 246 of file pns_item.h.

bool m_isCompoundShapePrimitive
Definition: pns_item.h:267

References PNS::ITEM::m_isCompoundShapePrimitive.

◆ IsFreePad()

bool PNS::ITEM::IsFreePad ( ) const
inlineinherited

Definition at line 238 of file pns_item.h.

238{ return m_isFreePad; }
bool m_isFreePad
Definition: pns_item.h:266

References PNS::ITEM::m_isFreePad.

Referenced by PNS::ITEM::collideSimple().

◆ IsLineCorner()

bool PNS::JOINT::IsLineCorner ( bool  aAllowLockedSegs = false) const
inline

Checks if a joint connects two segments of the same net, layer, and width.

Parameters
aAllowLockedSegswill consider joints between locked and unlocked segments as trivial
Returns
true if the joint is a trivial line corner

Definition at line 103 of file pns_joint.h.

104 {
105 if( m_linkedItems.Size() == 2 && m_linkedItems.Count( SEGMENT_T | ARC_T ) == 2 )
106 {
107 LINKED_ITEM* seg1 = static_cast<LINKED_ITEM*>( m_linkedItems[0] );
108 LINKED_ITEM* seg2 = static_cast<LINKED_ITEM*>( m_linkedItems[1] );
109
110 // joints between segments of different widths are not considered trivial.
111 return seg1->Width() == seg2->Width();
112 }
113 else if( m_linkedItems.Size() > 2 && m_linkedItems.Count( SEGMENT_T | ARC_T ) == 2 )
114 {
115 if( !aAllowLockedSegs )
116 {
117 return false;
118 }
119 // There will be multiple VVIAs on joints between two locked segments, because we
120 // naively add a VVIA to each end of a locked segment.
123 {
124 const LINKED_ITEM* seg1 = nullptr;
125 const LINKED_ITEM* seg2 = nullptr;
126 const VIA* via = nullptr;
127 bool hasNonVirtualVia = false;
128
129 for( const ITEM* item : m_linkedItems.CItems() )
130 {
131 if( item->Kind() == VIA_T )
132 {
133 via = static_cast<const VIA*>( item );
134
135 hasNonVirtualVia = !via->IsVirtual();
136 }
137 else if( item->Kind() == SEGMENT_T || item->Kind() == ARC_T )
138 {
139 if( !seg1 )
140 seg1 = static_cast<const LINKED_ITEM*>( item );
141 else
142 seg2 = static_cast<const LINKED_ITEM*>( item );
143 }
144 }
145
146 if( !via || hasNonVirtualVia )
147 return false;
148
149 assert ( seg1 && seg2 );
150
151 return seg1->Width() == seg2->Width();
152 }
153 }
154
155 return false;
156 }
int Size() const
Definition: pns_itemset.h:160
int Count(int aKindMask=-1) const
Definition: pns_itemset.h:114
const ENTRIES & CItems() const
Definition: pns_itemset.h:136
@ VIA
Normal via.
Definition: router_tool.cpp:89

References PNS::ITEM::ARC_T, PNS::ITEM_SET::CItems(), PNS::ITEM_SET::Count(), m_linkedItems, PNS::ITEM::SEGMENT_T, PNS::ITEM_SET::Size(), via, PNS::ITEM::VIA_T, and PNS::LINKED_ITEM::Width().

Referenced by PNS::NODE::followLine(), NextSegment(), and PNS::LINE_PLACER::simplifyNewLine().

◆ IsLocked()

bool PNS::JOINT::IsLocked ( ) const
inline

Definition at line 295 of file pns_joint.h.

296 {
297 return m_locked;
298 }

References m_locked.

Referenced by PNS::NODE::followLine(), Merge(), and PNS::SHOVE::pushOrShoveVia().

◆ IsNonFanoutVia()

bool PNS::JOINT::IsNonFanoutVia ( ) const
inline

Definition at line 158 of file pns_joint.h.

159 {
160 int vias = m_linkedItems.Count( VIA_T );
161 int segs = m_linkedItems.Count( SEGMENT_T );
162 segs += m_linkedItems.Count( ARC_T );
163
164 return ( m_linkedItems.Size() == 3 && vias == 1 && segs == 2 );
165 }

References PNS::ITEM::ARC_T, PNS::ITEM_SET::Count(), m_linkedItems, PNS::ITEM::SEGMENT_T, PNS::ITEM_SET::Size(), and PNS::ITEM::VIA_T.

Referenced by PNS::TOPOLOGY::AssembleTrivialPath(), and PNS::TOPOLOGY::followTrivialPath().

◆ IsRoutable()

bool PNS::ITEM::IsRoutable ( ) const
inlineinherited

Definition at line 235 of file pns_item.h.

235{ return m_routable; }
bool m_routable
Definition: pns_item.h:264

References PNS::ITEM::m_routable.

Referenced by PNS::NODE::addSolid(), and PNS::NODE::removeSolidIndex().

◆ IsStitchingVia()

bool PNS::JOINT::IsStitchingVia ( ) const
inline

Definition at line 167 of file pns_joint.h.

168 {
169 return ( m_linkedItems.Size() == 1 && m_linkedItems.Count( VIA_T ) == 1 );
170 }

References PNS::ITEM_SET::Count(), m_linkedItems, PNS::ITEM_SET::Size(), and PNS::ITEM::VIA_T.

Referenced by PNS::SHOVE::pushOrShoveVia().

◆ IsTraceWidthChange()

bool PNS::JOINT::IsTraceWidthChange ( ) const
inline

Link the joint to a given board item (when it's added to the NODE).

Definition at line 172 of file pns_joint.h.

References PNS::ITEM_SET::Count(), m_linkedItems, PNS::ITEM::SEGMENT_T, PNS::ITEM_SET::Size(), and PNS::SEGMENT::Width().

Referenced by PNS::TOPOLOGY::followTrivialPath().

◆ IsVirtual()

bool PNS::ITEM::IsVirtual ( ) const
inlineinherited

◆ Kind()

◆ KindStr()

std::string PNS::ITEM::KindStr ( ) const
inherited

Returns the kind of the item, as string.

Definition at line 198 of file pns_item.cpp.

199{
200 switch( m_kind )
201 {
202 case ARC_T: return "arc";
203 case LINE_T: return "line";
204 case SEGMENT_T: return "segment";
205 case VIA_T: return "via";
206 case JOINT_T: return "joint";
207 case SOLID_T: return "solid";
208 case DIFF_PAIR_T: return "diff-pair";
209 default: return "unknown";
210 }
211}

References PNS::ITEM::ARC_T, PNS::ITEM::DIFF_PAIR_T, PNS::ITEM::JOINT_T, PNS::ITEM::LINE_T, PNS::ITEM::m_kind, PNS::ITEM::SEGMENT_T, PNS::ITEM::SOLID_T, and PNS::ITEM::VIA_T.

Referenced by PNS::ITEM::Format(), PNS::TOOL_BASE::pickSingleItem(), and PNS::TOOL_BASE::updateEndItem().

◆ Layer()

◆ Layers()

const LAYER_RANGE & PNS::ITEM::Layers ( ) const
inlineinherited

Definition at line 156 of file pns_item.h.

156{ return m_layers; }

References PNS::ITEM::m_layers.

Referenced by PNS::INDEX::Add(), PNS::NODE::Add(), PNS::NODE::addArc(), PNS_KICAD_IFACE::AddItem(), PNS::NODE::addSegment(), PNS::NODE::addSolid(), PNS::NODE::addVia(), PNS::ARC::ARC(), PNS::TOPOLOGY::AssembleDiffPair(), PNS::NODE::AssembleLine(), PNS::KEEP_TOPOLOGY_CONSTRAINT::Check(), PNS_PCBNEW_RULE_RESOLVER::Clearance(), PNS::VIA::Clone(), PNS::ITEM::collideSimple(), comparePnsItems(), PNS::DP_MEANDER_PLACER::CurrentLayer(), PNS::MEANDER_PLACER::CurrentLayer(), PNS::DIFF_PAIR_PLACER::FindDpPrimitivePair(), PNS::NODE::FindJoint(), PNS::NODE::FindLinesBetweenJoints(), PNS::NODE::findRedundantArc(), PNS::NODE::findRedundantSegment(), PNS::NODE::FixupVirtualVias(), PNS::ROUTER::getNearestRatnestAnchor(), ROUTER_TOOL::getStartLayer(), PNS_PCBNEW_RULE_RESOLVER::HoleClearance(), PNS_PCBNEW_RULE_RESOLVER::HoleToHoleClearance(), PNS_KICAD_IFACE_BASE::IsFlashedOnLayer(), PNS::ITEM::Layer(), PNS::ITEM::LayersOverlap(), PNS::LINE::LINE(), PNS::NODE::LockJoint(), PNS::VIA::MakeHandle(), PNS::ROUTER::markViolations(), PNS::TOPOLOGY::NearestUnconnectedAnchorPoint(), PNS::SHOVE::onCollidingSolid(), LENGTH_TUNER_TOOL::performTuning(), PNS::TOOL_BASE::pickSingleItem(), PNS::INDEX::Query(), PNS::INDEX::Remove(), PNS::NODE::removeArcIndex(), PNS::NODE::removeSegmentIndex(), PNS::NODE::removeSolidIndex(), PNS::NODE::removeViaIndex(), PNS_LOG_PLAYER::ReplayLog(), PNS::SEGMENT::SEGMENT(), PNS::LINE_PLACER::SetLayer(), PNS::COMPONENT_DRAGGER::Start(), ROUTER_PREVIEW_ITEM::Update(), PNS::TOOL_BASE::updateEndItem(), PNS::DIFF_PAIR::updateLine(), PNS::TOOL_BASE::updateStartItem(), and PNS::VIA::VIA().

◆ LayersOverlap()

bool PNS::ITEM::LayersOverlap ( const ITEM aOther) const
inlineinherited

Return true if the set of layers spanned by aOther overlaps our layers.

Definition at line 165 of file pns_item.h.

166 {
167 return Layers().Overlaps( aOther->Layers() );
168 }

References PNS::ITEM::Layers(), and LAYER_RANGE::Overlaps().

Referenced by PNS::MEANDER_PLACER_BASE::lineLength(), PNS::SHOVE::onCollidingArc(), PNS::SHOVE::onCollidingSegment(), PNS::NODE::rebuildJoint(), and PNS::SHOVE::ShoveObstacleLine().

◆ Link()

void PNS::JOINT::Link ( ITEM aItem)
inline

Unlink a given board item from the joint (upon its removal from a NODE)

Returns
true if the joint became dangling after unlinking.

Definition at line 187 of file pns_joint.h.

References PNS::ITEM_SET::Add(), PNS::ITEM_SET::Contains(), and m_linkedItems.

Referenced by PNS::NODE::linkJoint().

◆ LinkCount()

int PNS::JOINT::LinkCount ( int  aMask = -1) const
inline

◆ LinkList()

◆ Links()

◆ Lock()

void PNS::JOINT::Lock ( bool  aLock = true)
inline

Definition at line 290 of file pns_joint.h.

291 {
292 m_locked = aLock;
293 }

References m_locked.

Referenced by PNS::NODE::LockJoint().

◆ Mark()

virtual void PNS::ITEM::Mark ( int  aMarker) const
inlinevirtualinherited

Reimplemented in PNS::LINE.

Definition at line 212 of file pns_item.h.

212{ m_marker = aMarker; }
int m_marker
Definition: pns_item.h:262

References PNS::ITEM::m_marker.

Referenced by PNS::ITEM::collideSimple(), and PNS::SHOVE::ShoveDraggingVia().

◆ Marker()

virtual int PNS::ITEM::Marker ( ) const
inlinevirtualinherited

◆ Merge()

void PNS::JOINT::Merge ( const JOINT aJoint)
inline

Definition at line 268 of file pns_joint.h.

269 {
270 if( !Overlaps( aJoint ) )
271 return;
272
273 m_layers.Merge( aJoint.m_layers );
274
275 if( aJoint.IsLocked() )
276 m_locked = true;
277
278 for( ITEM* item : aJoint.LinkList() )
279 {
280 m_linkedItems.Add( item );
281 }
282 }
void Merge(const LAYER_RANGE &aOther)
Definition: pns_layerset.h:92
void Add(const LINE &aLine)
Definition: pns_itemset.cpp:32
bool Overlaps(const JOINT &rhs) const
Definition: pns_joint.h:284

References PNS::ITEM_SET::Add(), IsLocked(), LinkList(), PNS::ITEM::m_layers, m_linkedItems, m_locked, LAYER_RANGE::Merge(), and Overlaps().

Referenced by PNS::NODE::touchJoint().

◆ Net()

int PNS::JOINT::Net ( ) const
inline

◆ NextSegment()

LINKED_ITEM * PNS::JOINT::NextSegment ( ITEM aCurrent,
bool  aAllowLockedSegs = false 
) const
inline

Definition at line 205 of file pns_joint.h.

206 {
207 if( !IsLineCorner( aAllowLockedSegs ) )
208 return nullptr;
209
210 return static_cast<LINKED_ITEM*>( m_linkedItems[m_linkedItems[0] == aCurrent ? 1 : 0] );
211 }
bool IsLineCorner(bool aAllowLockedSegs=false) const
Checks if a joint connects two segments of the same net, layer, and width.
Definition: pns_joint.h:103

References IsLineCorner(), and m_linkedItems.

Referenced by PNS::NODE::followLine().

◆ OfKind()

◆ operator==()

bool PNS::JOINT::operator== ( const JOINT rhs) const
inline

Definition at line 263 of file pns_joint.h.

264 {
265 return m_tag.pos == rhs.m_tag.pos && m_tag.net == rhs.m_tag.net;
266 }

References m_tag, PNS::JOINT::HASH_TAG::net, and PNS::JOINT::HASH_TAG::pos.

◆ Overlaps()

bool PNS::JOINT::Overlaps ( const JOINT rhs) const
inline

Definition at line 284 of file pns_joint.h.

285 {
286 return m_tag.pos == rhs.m_tag.pos &&
287 m_tag.net == rhs.m_tag.net && m_layers.Overlaps( rhs.m_layers );
288 }

References PNS::ITEM::m_layers, m_tag, PNS::JOINT::HASH_TAG::net, LAYER_RANGE::Overlaps(), and PNS::JOINT::HASH_TAG::pos.

Referenced by Merge().

◆ Owner()

NODE * PNS::ITEM::Owner ( ) const
inlineinherited

Return the owner of this item, or NULL if there's none.

Definition at line 173 of file pns_item.h.

173{ return m_owner; }

References PNS::ITEM::m_owner.

Referenced by PNS_KICAD_IFACE_BASE::inheritTrackWidth(), PNS::LINE_PLACER::Move(), and PNS::LINE_PLACER::rhShoveOnly().

◆ Parent()

◆ Pos()

◆ Rank()

virtual int PNS::ITEM::Rank ( ) const
inlinevirtualinherited

Reimplemented in PNS::LINE.

Definition at line 217 of file pns_item.h.

217{ return m_rank; }
int m_rank
Definition: pns_item.h:263

References PNS::ITEM::m_rank.

Referenced by PNS::ARC::ARC(), PNS::LINE::LINE(), PNS::SHOVE::onCollidingVia(), and PNS::SHOVE::shoveIteration().

◆ SetIsCompoundShapePrimitive()

void PNS::ITEM::SetIsCompoundShapePrimitive ( )
inlineinherited

Definition at line 245 of file pns_item.h.

References PNS::ITEM::m_isCompoundShapePrimitive.

◆ SetIsFreePad()

void PNS::ITEM::SetIsFreePad ( bool  aIsFreePad = true)
inlineinherited

Definition at line 237 of file pns_item.h.

237{ m_isFreePad = aIsFreePad; }

References PNS::ITEM::m_isFreePad.

◆ SetLayer()

◆ SetLayers()

void PNS::ITEM::SetLayers ( const LAYER_RANGE aLayers)
inlineinherited

◆ SetNet()

◆ SetOwner()

void PNS::ITEM::SetOwner ( NODE aOwner)
inlineinherited

Set the node that owns this item.

An item can belong to a single NODE or be unowned.

Definition at line 178 of file pns_item.h.

178{ m_owner = aOwner; }

References PNS::ITEM::m_owner.

Referenced by PNS::NODE::AssembleLine(), PNS::NODE::doRemove(), and PNS::NODE::Remove().

◆ SetParent()

void PNS::ITEM::SetParent ( BOARD_ITEM aParent)
inlineinherited

Definition at line 150 of file pns_item.h.

150{ m_parent = aParent; }

References PNS::ITEM::m_parent.

Referenced by PNS_KICAD_IFACE::AddItem().

◆ SetRank()

virtual void PNS::ITEM::SetRank ( int  aRank)
inlinevirtualinherited

Reimplemented in PNS::LINE.

Definition at line 216 of file pns_item.h.

216{ m_rank = aRank; }

References PNS::ITEM::m_rank.

Referenced by PNS::NODE::Commit(), and PNS::SHOVE::ShoveDraggingVia().

◆ SetRoutable()

void PNS::ITEM::SetRoutable ( bool  aRoutable)
inlineinherited

Definition at line 234 of file pns_item.h.

234{ m_routable = aRoutable; }

References PNS::ITEM::m_routable.

◆ Shape()

virtual const SHAPE * PNS::ITEM::Shape ( ) const
inlinevirtualinherited

◆ Tag()

const HASH_TAG & PNS::JOINT::Tag ( ) const
inline

trivial accessors

Definition at line 226 of file pns_joint.h.

227 {
228 return m_tag;
229 }

References m_tag.

◆ Unlink()

bool PNS::JOINT::Unlink ( ITEM aItem)
inline

For trivial joints, return the segment adjacent to (aCurrent).

For non-trival ones, return NULL, indicating the end of line.

Definition at line 197 of file pns_joint.h.

References PNS::ITEM_SET::Erase(), m_linkedItems, and PNS::ITEM_SET::Size().

Referenced by PNS::NODE::unlinkJoint().

◆ Unmark()

virtual void PNS::ITEM::Unmark ( int  aMarker = -1) const
inlinevirtualinherited

Reimplemented in PNS::LINE.

Definition at line 213 of file pns_item.h.

213{ m_marker &= ~aMarker; }

References PNS::ITEM::m_marker.

Referenced by PNS::NODE::Commit(), and PNS::DRAGGER::Start().

◆ Via()

VIA * PNS::JOINT::Via ( )
inline

Definition at line 213 of file pns_joint.h.

214 {
215 for( ITEM* item : m_linkedItems.Items() )
216 {
217 if( item->OfKind( VIA_T ) )
218 return static_cast<VIA*>( item );
219 }
220
221 return nullptr;
222 }
ENTRIES & Items()
Definition: pns_itemset.h:135

References PNS::ITEM_SET::Items(), m_linkedItems, and PNS::ITEM::VIA_T.

Referenced by PNS::SHOVE::fixupViaCollisions().

Member Data Documentation

◆ m_isCompoundShapePrimitive

bool PNS::ITEM::m_isCompoundShapePrimitive
protectedinherited

◆ m_isFreePad

bool PNS::ITEM::m_isFreePad
protectedinherited

Definition at line 266 of file pns_item.h.

Referenced by PNS::ITEM::IsFreePad(), PNS::ITEM::ITEM(), and PNS::ITEM::SetIsFreePad().

◆ m_isVirtual

bool PNS::ITEM::m_isVirtual
protectedinherited

◆ m_kind

PnsKind PNS::ITEM::m_kind
protectedinherited

◆ m_layers

◆ m_linkedItems

ITEM_SET PNS::JOINT::m_linkedItems
private

◆ m_locked

bool PNS::JOINT::m_locked
private

Definition at line 308 of file pns_joint.h.

Referenced by IsLocked(), JOINT(), Lock(), and Merge().

◆ m_marker

◆ m_movable

bool PNS::ITEM::m_movable
protectedinherited

◆ m_net

◆ m_owner

NODE* PNS::ITEM::m_owner
protectedinherited

◆ m_parent

BOARD_ITEM* PNS::ITEM::m_parent
protectedinherited

◆ m_rank

◆ m_routable

bool PNS::ITEM::m_routable
protectedinherited

Definition at line 264 of file pns_item.h.

Referenced by PNS::ITEM::IsRoutable(), PNS::ITEM::ITEM(), and PNS::ITEM::SetRoutable().

◆ m_tag

HASH_TAG PNS::JOINT::m_tag
private

< hash tag for unordered_multimap

list of items linked to this joint

Definition at line 302 of file pns_joint.h.

Referenced by Dump(), JOINT(), Net(), operator==(), Overlaps(), Pos(), and Tag().

◆ UnusedNet

const int PNS::ITEM::UnusedNet = INT_MAX
staticinherited

Supported item types.

Definition at line 58 of file pns_item.h.

Referenced by PNS::ITEM::ITEM().


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