Represents a track on a PCB, connecting two non-trivial joints (that is, vias, pads, junctions between multiple traces or two traces different widths and combinations of these). More...

#include <pns_line.h>

Inheritance diagram for PNS::LINE:

Public Types
typedef std::vector< LINKED_ITEM * >	LINKS

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
	LINE ()
	Makes an empty line. More...

	LINE (const LINE &aOther)

	LINE (const LINE &aBase, const SHAPE_LINE_CHAIN &aLine)
	Copy properties (net, layers, etc.) from a base line and replaces the shape by another. More...

	LINE (const VIA &aVia)
	Construct a LINE for a lone VIA (ie a stitching via). More...

	~LINE ()

virtual LINE *	Clone () const override
	Return a deep copy of the item. More...

LINE &	operator= (const LINE &aOther)

bool	IsLinkedChecked () const
	Assign a shape to the line (a polyline/line chain). More...

void	SetShape (const SHAPE_LINE_CHAIN &aLine)
	Return the shape of the line. More...

const SHAPE *	Shape () const override
	Modifiable accessor to the underlying shape. More...

SHAPE_LINE_CHAIN &	Line ()

const SHAPE_LINE_CHAIN &	CLine () const

int	SegmentCount () const

int	PointCount () const

int	ArcCount () const

int	ShapeCount () const
	Return the aIdx-th point of the line. More...

const VECTOR2I &	CPoint (int aIdx) const

const SEG	CSegment (int aIdx) const
	Set line width. More...

void	SetWidth (int aWidth)
	Return line width. More...

int	Width () const
	Return true if the line is geometrically identical as line aOther. More...

bool	CompareGeometry (const LINE &aOther)
	Reverse the point/vertex order. More...

void	Reverse ()
	Clip the line to the nearest obstacle, traversing from the line's start vertex (0). More...

const LINE	ClipToNearestObstacle (NODE *aNode) const
	Clip the line to a given range of vertices. More...

void	ClipVertexRange (int aStart, int aEnd)
	Return the number of corners of angles specified by mask aAngles. More...

int	CountCorners (int aAngles) const

bool	Walkaround (SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN &aPre, SHAPE_LINE_CHAIN &aWalk, SHAPE_LINE_CHAIN &aPost, bool aCw) const
	Calculate a line tightly wrapping a convex hull of an obstacle object (aObstacle). More...

bool	Walkaround (const SHAPE_LINE_CHAIN &aObstacle, SHAPE_LINE_CHAIN &aPath, bool aCw) const
	Print out all linked segments. More...

void	ShowLinks () const

bool	EndsWithVia () const

void	AppendVia (const VIA &aVia)

void	RemoveVia ()

const VIA &	Via () const

void	SetViaDiameter (int aDiameter)

void	SetViaDrill (int aDrill)

virtual void	Mark (int aMarker) const override

virtual void	Unmark (int aMarker=-1) const override

virtual int	Marker () const override

void	SetBlockingObstacle (ITEM *aObstacle)

ITEM *	GetBlockingObstacle () const

void	DragSegment (const VECTOR2I &aP, int aIndex, bool aFreeAngle=false)

void	DragCorner (const VECTOR2I &aP, int aIndex, bool aFreeAngle=false)

void	SetRank (int aRank) override

int	Rank () const override

bool	HasLoops () const

bool	HasLockedSegments () const

void	Clear ()

OPT_BOX2I	ChangedArea (const LINE *aOther) const

void	SetSnapThreshhold (int aThreshhold)

int	GetSnapThreshhold () 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 linked). More...

LINKS &	Links ()

const LINKS &	Links () const

bool	IsLinked () const
	Check if the segment aLink is a part of the line. More...

bool	ContainsLink (const LINKED_ITEM *aItem) const

LINKED_ITEM *	GetLink (int aIndex) const
	Erase the linking information. Used to detach the line from the owning node. More...

virtual void	ClearLinks ()
	Return the number of segments that were assembled together to form this line. More...

int	LinkCount () 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_ITEM *	Parent () const

void	SetNet (int aNet)

int	Net () const

const LAYER_RANGE &	Layers () 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...

NODE *	Owner () 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 SHAPE *	Hole () const

virtual VECTOR2I	Anchor (int n) const

virtual int	AnchorCount () const

bool	IsLocked () 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 Member Functions
static bool	ClassOf (const ITEM *aItem)

Static Public Attributes
static const int	UnusedNet = INT_MAX
	Supported item types. More...

Protected Member Functions
void	copyLinks (const LINK_HOLDER *aParent)
	< Copy m_links from the line aParent. More...

Protected Attributes
LINKS	m_links

PnsKind	m_kind

BOARD_ITEM *	m_parent

NODE *	m_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
void	dragSegment45 (const VECTOR2I &aP, int aIndex)

void	dragCorner45 (const VECTOR2I &aP, int aIndex)

void	dragSegmentFree (const VECTOR2I &aP, int aIndex)

void	dragCornerFree (const VECTOR2I &aP, int aIndex)

VECTOR2I	snapToNeighbourSegments (const SHAPE_LINE_CHAIN &aPath, const VECTOR2I &aP, int aIndex) const

VECTOR2I	snapDraggedCorner (const SHAPE_LINE_CHAIN &aPath, const VECTOR2I &aP, int aIndex) const

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

Private Attributes
SHAPE_LINE_CHAIN	m_line
	The actual shape of the line. More...

int	m_width
	Our width. More...

int	m_snapThreshhold
	Width to smooth out jagged segments. More...

bool	m_hasVia
	Optional via at the end point. More...

VIA	m_via

ITEM *	m_blockingObstacle
	For mark obstacle mode. More...

Detailed Description

Represents a track on a PCB, connecting two non-trivial joints (that is, vias, pads, junctions between multiple traces or two traces different widths and combinations of these).

PNS_LINEs are NOT stored in the model (NODE). Instead, they are assembled on-the-fly, based on a via/pad/segment that belongs to/starts/ends them.

PNS_LINEs can be either loose (consisting of segments that do not belong to any NODE) or owned (with segments taken from a NODE) - these are returned by #NODE::AssembleLine and friends.

A LINE may have a VIA attached at its end (i.e. the last point) - this is used by via dragging/force propagation stuff.

Definition at line 60 of file pns_line.h.

Member Typedef Documentation

◆ LINKS

typedef std::vector<LINKED_ITEM*> PNS::LINK_HOLDER::LINKS

inherited

Definition at line 36 of file pns_link_holder.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.

 {
 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
 };

Constructor & Destructor Documentation

◆ LINE() [1/4]

PNS::LINE::LINE ( )

inline

Makes an empty line.

Definition at line 66 of file pns_line.h.

 :
 LINK_HOLDER( LINE_T ),
 m_blockingObstacle( nullptr )
 {
 m_hasVia = false;
 m_width = 1; // Dummy value
 m_snapThreshhold = 0;
 }

References m_hasVia, m_snapThreshhold, and m_width.

Referenced by Clone().

◆ LINE() [2/4]

PNS::LINE::LINE ( const LINE & aOther )

Definition at line 36 of file pns_line.cpp.

 : LINK_HOLDER( aOther ),
 m_line( aOther.m_line ),
 m_width( aOther.m_width ),
 m_snapThreshhold( aOther.m_snapThreshhold )
{
 m_net = aOther.m_net;
 m_movable = aOther.m_movable;
 m_layers = aOther.m_layers;
 m_via = aOther.m_via;
 m_hasVia = aOther.m_hasVia;
 m_marker = aOther.m_marker;
 m_rank = aOther.m_rank;
 m_blockingObstacle = aOther.m_blockingObstacle;
 
 copyLinks( &aOther );
}

References PNS::LINK_HOLDER::copyLinks(), m_blockingObstacle, m_hasVia, PNS::ITEM::m_layers, PNS::ITEM::m_marker, PNS::ITEM::m_movable, PNS::ITEM::m_net, PNS::ITEM::m_rank, and m_via.

◆ LINE() [3/4]

PNS::LINE::LINE	(	const LINE &	aBase,
		const SHAPE_LINE_CHAIN &	aLine
	)

inline

Copy properties (net, layers, etc.) from a base line and replaces the shape by another.

Definition at line 80 of file pns_line.h.

 :
 LINK_HOLDER( aBase ),
 m_line( aLine ),
 m_width( aBase.m_width ),
 m_snapThreshhold( aBase.m_snapThreshhold ),
 m_blockingObstacle( nullptr )
 {
 m_net = aBase.m_net;
 m_layers = aBase.m_layers;
 m_hasVia = false;
 }

References m_hasVia, PNS::ITEM::m_layers, and PNS::ITEM::m_net.

◆ LINE() [4/4]

PNS::LINE::LINE ( const VIA & aVia )

inline

Construct a LINE for a lone VIA (ie a stitching via).

Definition at line 95 of file pns_line.h.

 :
 LINK_HOLDER( LINE_T ),
 m_blockingObstacle( nullptr )
 {
 m_hasVia = true;
 m_via = aVia;
 m_width = aVia.Diameter();
 m_net = aVia.Net();
 m_layers = aVia.Layers();
 m_rank = aVia.Rank();
 m_snapThreshhold = 0;
 }

References PNS::VIA::Diameter(), PNS::ITEM::Layers(), m_hasVia, PNS::ITEM::m_layers, PNS::ITEM::m_net, PNS::ITEM::m_rank, m_snapThreshhold, m_via, m_width, PNS::ITEM::Net(), and PNS::ITEM::Rank().

◆ ~LINE()

PNS::LINE::~LINE ( )

Definition at line 55 of file pns_line.cpp.

56{

57}

Member Function Documentation

◆ Anchor()

virtual VECTOR2I PNS::ITEM::Anchor ( int n ) const

inlinevirtualinherited

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

Definition at line 219 of file pns_item.h.

 {
 return VECTOR2I();
 }

Referenced by PNS::DP_PRIMITIVE_PAIR::anchorDirection(), PNS::DP_PRIMITIVE_PAIR::CursorOrientation(), PNS::DP_PRIMITIVE_PAIR::DP_PRIMITIVE_PAIR(), PNS::NODE::followLine(), PNS::getDanglingAnchor(), PNS::ROUTER::getNearestRatnestAnchor(), PNS::TOPOLOGY::NearestUnconnectedAnchorPoint(), PNS::TOOL_BASE::pickSingleItem(), and PNS::TOOL_BASE::snapToItem().

◆ 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.

 {
 return 0;
 }

◆ AppendVia()

void PNS::LINE::AppendVia ( const VIA & aVia )

Definition at line 1031 of file pns_line.cpp.

{
 if( m_line.PointCount() > 1 && aVia.Pos() == m_line.CPoint( 0 ) )
 {
 Reverse();
 }
 
 m_hasVia = true;
 m_via = aVia;
 m_via.SetNet( m_net );
}

References SHAPE_LINE_CHAIN::CPoint(), m_hasVia, m_line, PNS::ITEM::m_net, m_via, SHAPE_LINE_CHAIN::PointCount(), PNS::VIA::Pos(), Reverse(), and PNS::ITEM::SetNet().

Referenced by PNS::LINE_PLACER::buildInitialLine(), PNS::SHOVE::onReverseCollidingVia(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkBase(), PNS::LINE_PLACER::rhWalkOnly(), and PNS::DIFF_PAIR::updateLine().

◆ ArcCount()

int PNS::LINE::ArcCount ( ) const

inline

Definition at line 146 of file pns_line.h.

146{ return m_line.ArcCount(); }

SHAPE_LINE_CHAIN::ArcCount

size_t ArcCount() const

Definition: shape_line_chain.h:787

References SHAPE_LINE_CHAIN::ArcCount(), and m_line.

Referenced by PNS::OPTIMIZER::Optimize().

◆ 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.

 {
 return m_owner == aNode;
 }

References PNS::ITEM::m_owner.

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

◆ ChangedArea()

OPT_BOX2I PNS::LINE::ChangedArea ( const LINE * aOther ) const

Definition at line 1152 of file pns_line.cpp.

{
 BOX2I area;
 bool areaDefined = false;
 
 int i_start = -1;
 int i_end_self = -1, i_end_other = -1;
 
 SHAPE_LINE_CHAIN self( m_line );
 self.Simplify();
 SHAPE_LINE_CHAIN other( aOther->m_line );
 other.Simplify();
 
 int np_self = self.PointCount();
 int np_other = other.PointCount();
 
 int n = std::min( np_self, np_other );
 
 for( int i = 0; i < n; i++ )
 {
 const VECTOR2I p1 = self.CPoint( i );
 const VECTOR2I p2 = other.CPoint( i );
 
 if( p1 != p2 )
 {
 if( i != n - 1 )
 {
 SEG s = self.CSegment( i );
 
 if( !s.Contains( p2 ) )
 {
 i_start = i;
 break;
 }
 }
 else
 {
 i_start = i;
 break;
 }
 }
 }
 
 for( int i = 0; i < n; i++ )
 {
 const VECTOR2I p1 = self.CPoint( np_self - 1 - i );
 const VECTOR2I p2 = other.CPoint( np_other - 1 - i );
 
 if( p1 != p2 )
 {
 i_end_self = np_self - 1 - i;
 i_end_other = np_other - 1 - i;
 break;
 }
 }
 
 if( i_start < 0 )
 i_start = n;
 
 if( i_end_self < 0 )
 i_end_self = np_self - 1;
 
 if( i_end_other < 0 )
 i_end_other = np_other - 1;
 
 for( int i = i_start; i <= i_end_self; i++ )
 extendBox( area, areaDefined, self.CPoint( i ) );
 
 for( int i = i_start; i <= i_end_other; i++ )
 extendBox( area, areaDefined, other.CPoint( i ) );
 
 if( areaDefined )
 {
 area.Inflate( std::max( Width(), aOther->Width() ) );
 return area;
 }
 
 return OPT_BOX2I();
}

References SEG::Contains(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::CSegment(), PNS::extendBox(), BOX2< Vec >::Inflate(), m_line, SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN::Simplify(), and Width().

Referenced by PNS::ChangedArea(), and PNS::DRAGGER::optimizeAndUpdateDraggedLine().

◆ ClassOf()

static bool PNS::LINE::ClassOf ( const ITEM * aItem )

inlinestatic

Definition at line 110 of file pns_line.h.

 {
 return aItem && LINE_T == aItem->Kind();
 }

References PNS::ITEM::Kind(), and PNS::ITEM::LINE_T.

◆ Clear()

void PNS::LINE::Clear ( )

Definition at line 1244 of file pns_line.cpp.

{
 m_hasVia = false;
 m_line.Clear();
}

References SHAPE_LINE_CHAIN::Clear(), m_hasVia, and m_line.

Referenced by PNS::LINE_PLACER::rhWalkBase(), PNS::LINE_PLACER::routeStep(), and PNS::LINE_PLACER::splitHeadTail().

◆ ClearLinks()

virtual void PNS::LINK_HOLDER::ClearLinks ( )

inlinevirtualinherited

Return the number of segments that were assembled together to form this line.

Reimplemented in PNS::DIFF_PAIR.

Definition at line 69 of file pns_link_holder.h.

References PNS::LINK_HOLDER::m_links.

Referenced by PNS::DIFF_PAIR::ClearLinks(), PNS::COMPONENT_DRAGGER::Drag(), PNS::DRAGGER::dragMarkObstacles(), PNS::DRAGGER::dragShove(), PNS::DRAGGER::dragViaMarkObstacles(), PNS::DRAGGER::dragViaWalkaround(), PNS::SHOVE::onCollidingSolid(), PNS::SHOVE::onReverseCollidingVia(), PNS::OPTIMIZER::Optimize(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::NODE::Remove(), PNS::WALKAROUND::Route(), PNS::SHOVE::ShoveLines(), PNS::SHOVE::ShoveMultiLines(), and PNS::SHOVE::ShoveObstacleLine().

◆ CLine()

const SHAPE_LINE_CHAIN & PNS::LINE::CLine ( ) const

inline

Definition at line 142 of file pns_line.h.

142{ return m_line; }

References m_line.

◆ ClipToNearestObstacle()

const LINE PNS::LINE::ClipToNearestObstacle ( NODE * aNode ) const

Clip the line to a given range of vertices.

Definition at line 551 of file pns_line.cpp.

{
 const int IterationLimit = 5;
 int i;
 LINE l( *this );
 
 for( i = 0; i < IterationLimit; i++ )
 {
 NODE::OPT_OBSTACLE obs = aNode->NearestObstacle( &l );
 
 if( obs )
 {
 l.RemoveVia();
 VECTOR2I collisionPoint = obs->m_ipFirst;
 int segIdx = l.Line().NearestSegment( collisionPoint );
 
 if( l.Line().IsArcSegment( segIdx ) )
 {
 // Don't clip at arcs, start again
  l.Line().Clear();
 }
 else
 {
 SEG nearestSegment = l.Line().CSegment( segIdx );
 VECTOR2I nearestPt = nearestSegment.NearestPoint( collisionPoint );
 int p = l.Line().Split( nearestPt );
 l.Line().Remove( p + 1, -1 );
 }
 }
 else
 {
 break;
 }
 }
 
 if( i == IterationLimit )
 l.Line().Clear();
 
 return l;
}

References SHAPE_LINE_CHAIN::Clear(), SHAPE_LINE_CHAIN::CSegment(), SHAPE_LINE_CHAIN::IsArcSegment(), Line(), PNS::NODE::NearestObstacle(), SEG::NearestPoint(), SHAPE_LINE_CHAIN::NearestSegment(), SHAPE_LINE_CHAIN::Remove(), RemoveVia(), and SHAPE_LINE_CHAIN::Split().

◆ ClipVertexRange()

void PNS::LINE::ClipVertexRange	(	int	aStart,
		int	aEnd
	)

Return the number of corners of angles specified by mask aAngles.

We need to figure out which joints to keep after the clip operation, because arcs will have multiple vertices. It is assumed that anything calling this method will have determined the vertex range to clip based on joints, meaning we will never clip in the middle of an arc. Clipping in the middle of an arc would break this and various other things...

Definition at line 1074 of file pns_line.cpp.

{
 int firstLink = 0;
 int lastLink = std::max( 0, static_cast<int>( m_links.size() ) - 1 );
 int linkIdx = 0;
 
 int numPoints = static_cast<int>( m_line.PointCount() );
 
 for( int i = 0; i >= 0 && i < m_line.PointCount(); i = m_line.NextShape( i ) )
 {
 if( i <= aStart )
 firstLink = linkIdx;
 
 if( i < 0 || i >= aEnd - 1 || linkIdx >= lastLink )
 {
 lastLink = linkIdx;
 break;
 }
 
 linkIdx++;
 }
 
 wxASSERT( lastLink >= firstLink );
 
 m_line = m_line.Slice( aStart, aEnd );
 
 if( IsLinked() )
 {
 wxASSERT( m_links.size() < INT_MAX );
 wxASSERT( static_cast<int>( m_links.size() ) >= ( lastLink - firstLink ) );
 
 // Note: The range includes aEnd, but we have n-1 segments.
 std::rotate(
 m_links.begin(),
 m_links.begin() + firstLink,
 m_links.begin() + lastLink
 );
 
 m_links.resize( lastLink - firstLink + 1 );
 }
}

References PNS::LINK_HOLDER::IsLinked(), m_line, PNS::LINK_HOLDER::m_links, SHAPE_LINE_CHAIN::NextShape(), SHAPE_LINE_CHAIN::PointCount(), and SHAPE_LINE_CHAIN::Slice().

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

◆ Clone()

LINE * PNS::LINE::Clone ( ) const

overridevirtual

Return a deep copy of the item.

Implements PNS::ITEM.

Definition at line 81 of file pns_line.cpp.

{
 LINE* l = new LINE( *this );
 
 return l;
}

References LINE().

Referenced by PNS::ITEM_SET::Add(), PNS::ITEM_SET::Prepend(), and PNS::SHOVE::replaceLine().

◆ 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

aOther is the item to check collision against.

Returns: true, if a collision was found.

Definition at line 169 of file pns_item.cpp.

{
 if( collideSimple( aOther, aNode, aDifferentNetsOnly, aOverrideClearance ) )
 return true;
 
 // Special cases for "head" lines with vias attached at the end. Note that this does not
 // support head-line-via to head-line-via collisions, but you can't route two independent
 // tracks at once so it shouldn't come up.
 
 if( m_kind == LINE_T )
 {
 const LINE* line = static_cast<const LINE*>( this );
 
 if( line->EndsWithVia() && line->Via().collideSimple( aOther, aNode, aDifferentNetsOnly, aOverrideClearance ) )
 return true;
 }
 
 if( aOther->m_kind == LINE_T )
 {
 const LINE* line = static_cast<const LINE*>( aOther );
 
 if( line->EndsWithVia() && line->Via().collideSimple( this, aNode, aDifferentNetsOnly, aOverrideClearance ) )
 return true;
 }
 
 return false;
}

References PNS::ITEM::collideSimple(), EndsWithVia(), PNS::ITEM::LINE_T, PNS::ITEM::m_kind, and 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.

{
 const ROUTER_IFACE* iface = ROUTER::GetInstance()->GetInterface();
 const SHAPE* shapeA = Shape();
 const SHAPE* holeA = Hole();
 int lineWidthA = 0;
 const SHAPE* shapeB = aOther->Shape();
 const SHAPE* holeB = aOther->Hole();
 int lineWidthB = 0;
 
 // Sadly collision routines ignore SHAPE_POLY_LINE widths so we have to pass them in as part
 // of the clearance value.
 if( m_kind == LINE_T )
 lineWidthA = static_cast<const LINE*>( this )->Width() / 2;
 
 if( aOther->m_kind == LINE_T )
 lineWidthB = static_cast<const LINE*>( aOther )->Width() / 2;
 
 // same nets? no collision!
 if( aDifferentNetsOnly && m_net == aOther->m_net && m_net >= 0 && aOther->m_net >= 0 )
 return false;
 
 // a pad associated with a "free" pin (NIC) doesn't have a net until it has been used
 if( aDifferentNetsOnly && ( IsFreePad() || aOther->IsFreePad() ) )
 return false;
 
 // check if we are not on completely different layers first
 if( !m_layers.Overlaps( aOther->m_layers ) )
 return false;
 
 auto checkKeepout =
 []( const ZONE* aKeepout, const BOARD_ITEM* aOther )
 {
 if( aKeepout->GetDoNotAllowTracks() && aOther->IsType( { PCB_ARC_T, PCB_TRACE_T } ) )
 return true;
 
 if( aKeepout->GetDoNotAllowVias() && aOther->Type() == PCB_VIA_T )
 return true;
 
 if( aKeepout->GetDoNotAllowPads() && aOther->Type() == PCB_PAD_T )
 return true;
 
 // Incomplete test, but better than nothing:
 if( aKeepout->GetDoNotAllowFootprints() && aOther->Type() == PCB_PAD_T )
 {
 return !aKeepout->GetParentFootprint()
 || aKeepout->GetParentFootprint() != aOther->GetParentFootprint();
 }
 
 return false;
 };
 
 const ZONE* zoneA = dynamic_cast<ZONE*>( Parent() );
 const ZONE* zoneB = dynamic_cast<ZONE*>( aOther->Parent() );
 
 if( zoneA && aOther->Parent() && !checkKeepout( zoneA, aOther->Parent() ) )
 return false;
 
 if( zoneB && Parent() && !checkKeepout( zoneB, Parent() ) )
 return false;
 
 bool thisNotFlashed = !iface->IsFlashedOnLayer( this, aOther->Layer() );
 bool otherNotFlashed = !iface->IsFlashedOnLayer( aOther, Layer() );
 
 if( ( aNode->GetCollisionQueryScope() == NODE::CQS_ALL_RULES
 || ( thisNotFlashed || otherNotFlashed ) )
 && ( holeA || holeB ) )
 {
 int holeClearance = aNode->GetHoleClearance( this, aOther );
 
 if( holeClearance >= 0 && holeA && holeA->Collide( shapeB, holeClearance + lineWidthB ) )
 {
 Mark( Marker() | MK_HOLE );
 return true;
 }
 
 if( holeB && holeClearance >= 0 && holeB->Collide( shapeA, holeClearance + lineWidthA ) )
 {
 aOther->Mark( aOther->Marker() | MK_HOLE );
 return true;
 }
 
 if( holeA && holeB )
 {
 int holeToHoleClearance = aNode->GetHoleToHoleClearance( this, aOther );
 
 if( holeToHoleClearance >= 0 && holeA->Collide( holeB, holeToHoleClearance ) )
 {
 Mark( Marker() | MK_HOLE );
 aOther->Mark( aOther->Marker() | MK_HOLE );
 return true;
 }
 }
 }
 
 if( !aOther->Layers().IsMultilayer() && thisNotFlashed )
 return false;
 
 if( !Layers().IsMultilayer() && otherNotFlashed )
 return false;
 
 int clearance = aOverrideClearance >= 0 ? aOverrideClearance : aNode->GetClearance( this, aOther );
 
 if( clearance >= 0 )
 {
 bool checkCastellation = ( m_parent && m_parent->GetLayer() == Edge_Cuts );
 bool checkNetTie = aNode->GetRuleResolver()->IsInNetTie( this );
 
 if( checkCastellation || checkNetTie )
 {
 // Slow method
 int actual;
 VECTOR2I pos;
 
 if( shapeA->Collide( shapeB, clearance + lineWidthA, &actual, &pos ) )
 {
 if( checkCastellation && aNode->QueryEdgeExclusions( pos ) )
 return false;
 
 if( checkNetTie && aNode->GetRuleResolver()->IsNetTieExclusion( aOther, pos, this ) )
 return false;
 
 return true;
 }
 }
 else
 {
 // Fast method
 if( shapeA->Collide( shapeB, clearance + lineWidthA + lineWidthB ) )
 return true;
 }
 }
 
 return false;
}

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

◆ CompareGeometry()

bool PNS::LINE::CompareGeometry ( const LINE & aOther )

Reverse the point/vertex order.

Definition at line 1017 of file pns_line.cpp.

{
 return m_line.CompareGeometry( aOther.m_line );
}

References SHAPE_LINE_CHAIN::CompareGeometry(), and m_line.

◆ ContainsLink()

bool PNS::LINK_HOLDER::ContainsLink ( const LINKED_ITEM * aItem ) const

inlineinherited

Definition at line 58 of file pns_link_holder.h.

 {
 return alg::contains( m_links, aItem );
 }

References alg::contains(), and PNS::LINK_HOLDER::m_links.

◆ copyLinks()

void PNS::LINK_HOLDER::copyLinks ( const LINK_HOLDER * aParent )

inlineprotectedinherited

< Copy m_links from the line aParent.

List of segments in the owning NODE (ITEM::m_owner) that constitute this line, or NULL if the line is not a part of any node.

Definition at line 98 of file pns_link_holder.h.

References PNS::LINK_HOLDER::m_links.

Referenced by LINE(), and operator=().

◆ CountCorners()

int PNS::LINE::CountCorners ( int aAngles ) const

Definition at line 135 of file pns_line.cpp.

{
 int count = 0;
 
 for( int i = 0; i < m_line.SegmentCount() - 1; i++ )
 {
 const SEG seg1 = m_line.CSegment( i );
 const SEG seg2 = m_line.CSegment( i + 1 );
 
 const DIRECTION_45 dir1( seg1 );
 const DIRECTION_45 dir2( seg2 );
 
 DIRECTION_45::AngleType a = dir1.Angle( dir2 );
 
 if( a & aAngles )
 count++;
 }
 
 return count;
}

References DIRECTION_45::Angle(), SHAPE_LINE_CHAIN::CSegment(), m_line, and SHAPE_LINE_CHAIN::SegmentCount().

Referenced by PNS::CORNER_COUNT_LIMIT_CONSTRAINT::Check(), PNS::LINE_PLACER::mergeHead(), PNS::OPTIMIZER::Optimize(), and PNS::OPTIMIZER::smartPadsSingle().

◆ CPoint()

const VECTOR2I & PNS::LINE::CPoint ( int aIdx ) const

inline

◆ CSegment()

const SEG PNS::LINE::CSegment ( int aIdx ) const

inline

Set line width.

Definition at line 151 of file pns_line.h.

References SHAPE_LINE_CHAIN::CSegment(), and m_line.

Referenced by PNS::DIFF_PAIR::EndingPrimitives(), PNS::LINE_PLACER::FixRoute(), PNS::OPTIMIZER::mergeStep(), PNS::LINE_PLACER::optimizeTailHeadTransition(), and PNS::SHOVE::ShoveObstacleLine().

◆ DragCorner()

void PNS::LINE::DragCorner	(	const VECTOR2I &	aP,
		int	aIndex,
		bool	aFreeAngle = `false`
	)

Definition at line 734 of file pns_line.cpp.

{
 wxCHECK_RET( aIndex >= 0, wxT( "Negative index passed to LINE::DragCorner" ) );
 
 if( aFreeAngle )
 {
 dragCornerFree( aP, aIndex );
 }
 else
 {
 dragCorner45( aP, aIndex );
 }
}

References dragCorner45(), and dragCornerFree().

Referenced by PNS::COMPONENT_DRAGGER::Drag(), PNS::DRAGGER::dragMarkObstacles(), PNS::DRAGGER::dragShove(), PNS::DRAGGER::dragViaMarkObstacles(), PNS::DRAGGER::dragViaWalkaround(), and PNS::DRAGGER::dragWalkaround().

◆ dragCorner45()

void PNS::LINE::dragCorner45	(	const VECTOR2I &	aP,
		int	aIndex
	)

private

Definition at line 677 of file pns_line.cpp.

{
 SHAPE_LINE_CHAIN path;
 
 int width = m_line.Width();
 VECTOR2I snapped = snapDraggedCorner( m_line, aP, aIndex );
 
 if( aIndex == 0 )
 path = dragCornerInternal( m_line.Reverse(), snapped ).Reverse();
 else if( aIndex == m_line.SegmentCount() )
 path = dragCornerInternal( m_line, snapped );
 else
 {
 // Are we next to an arc? Insert a new point so we slice correctly
 if( m_line.IsPtOnArc( static_cast<size_t>( aIndex ) + 1 ) )
 m_line.Insert( aIndex + 1, m_line.CPoint( aIndex + 1 ) );
 
 // fixme: awkward behaviour for "outwards" drags
 path = dragCornerInternal( m_line.Slice( 0, aIndex ), snapped );
 SHAPE_LINE_CHAIN path_rev =
 dragCornerInternal( m_line.Slice( aIndex, -1 ).Reverse(), snapped ).Reverse();
 path.Append( path_rev );
 }
 
 path.Simplify();
 path.SetWidth( width );
 m_line = path;
}

References SHAPE_LINE_CHAIN::CPoint(), PNS::dragCornerInternal(), SHAPE_LINE_CHAIN::Insert(), SHAPE_LINE_CHAIN::IsPtOnArc(), m_line, path, SHAPE_LINE_CHAIN::Reverse(), SHAPE_LINE_CHAIN::SegmentCount(), SHAPE_LINE_CHAIN::Slice(), snapDraggedCorner(), and SHAPE_LINE_CHAIN::Width().

Referenced by DragCorner().

◆ dragCornerFree()

void PNS::LINE::dragCornerFree	(	const VECTOR2I &	aP,
		int	aIndex
	)

private

Definition at line 707 of file pns_line.cpp.

{
 ssize_t idx = static_cast<ssize_t>( aIndex );
 ssize_t numpts = static_cast<ssize_t>( m_line.PointCount() );
 
 // If we're asked to drag the end of an arc, insert a new vertex to drag instead
 if( m_line.IsPtOnArc( idx ) )
 {
 if( idx == 0 || ( idx > 0 && !m_line.IsPtOnArc( idx - 1 ) ) )
 {
 m_line.Insert( idx, m_line.GetPoint( idx ) );
 }
 else if( ( idx == numpts - 1 ) || ( idx < numpts - 1 && !m_line.IsArcSegment( idx ) ) )
 {
 idx++;
 m_line.Insert( idx, m_line.GetPoint( idx ) );
 }
 else
 {
 wxASSERT_MSG( false, wxT( "Attempt to dragCornerFree in the middle of an arc!" ) );
 }
 }
 
 m_line.SetPoint( idx, aP );
 m_line.Simplify();
}

References SHAPE_LINE_CHAIN::GetPoint(), SHAPE_LINE_CHAIN::Insert(), SHAPE_LINE_CHAIN::IsArcSegment(), SHAPE_LINE_CHAIN::IsPtOnArc(), m_line, SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN::SetPoint(), and SHAPE_LINE_CHAIN::Simplify().

Referenced by DragCorner().

◆ DragSegment()

void PNS::LINE::DragSegment	(	const VECTOR2I &	aP,
		int	aIndex,
		bool	aFreeAngle = `false`
	)

Definition at line 748 of file pns_line.cpp.

{
 if( aFreeAngle )
 {
 assert( false );
 }
 else
 {
 dragSegment45( aP, aIndex );
 }
}

References dragSegment45().

Referenced by PNS::DRAGGER::dragMarkObstacles(), PNS::DRAGGER::dragShove(), and PNS::DRAGGER::dragWalkaround().

◆ dragSegment45()

void PNS::LINE::dragSegment45	(	const VECTOR2I &	aP,
		int	aIndex
	)

private

Definition at line 847 of file pns_line.cpp.

{
 SHAPE_LINE_CHAIN path( m_line );
 VECTOR2I target( aP );
 
 wxASSERT( aIndex < m_line.PointCount() );
 
 SEG guideA[2], guideB[2];
 int index = aIndex;
 
 target = snapToNeighbourSegments( path, aP, aIndex );
 
 // We require a valid s_prev and s_next. If we are at the start or end of the line, we insert
 // a new point at the start or end so there is a zero-length segment for prev or next (we will
 // resize it as part of the drag operation). If we are next to an arc, we do this also, as we
 // cannot drag away one of the arc's points.
 
 if( index == 0 || path.IsPtOnArc( index ) )
 {
 path.Insert( index > 0 ? index + 1 : 0, path.CPoint( index ) );
 index++;
 }
 
 if( index == path.SegmentCount() - 1 )
 {
 path.Insert( path.PointCount() - 1, path.CPoint( -1 ) );
 }
 else if( path.IsPtOnArc( index + 1 ) )
 {
 path.Insert( index + 1, path.CPoint( index + 1 ) );
 }
 
 SEG dragged = path.CSegment( index );
 DIRECTION_45 drag_dir( dragged );
 
 SEG s_prev = path.CSegment( index - 1 );
 SEG s_next = path.CSegment( index + 1 );
 
 DIRECTION_45 dir_prev( s_prev );
 DIRECTION_45 dir_next( s_next );
 
 if( dir_prev == drag_dir )
 {
 dir_prev = dir_prev.Left();
 path.Insert( index, path.CPoint( index ) );
 index++;
 }
 else if( dir_prev == DIRECTION_45::UNDEFINED )
 {
 dir_prev = drag_dir.Left();
 }
 
 if( dir_next == drag_dir )
 {
 dir_next = dir_next.Right();
 path.Insert( index + 1, path.CPoint( index + 1 ) );
 }
 else if( dir_next == DIRECTION_45::UNDEFINED )
 {
 dir_next = drag_dir.Right();
 }
 
 s_prev = path.CSegment( index - 1 );
 s_next = path.CSegment( index + 1 );
 dragged = path.CSegment( index );
 
 if( aIndex == 0 )
 {
 guideA[0] = SEG( dragged.A, dragged.A + drag_dir.Right().ToVector() );
 guideA[1] = SEG( dragged.A, dragged.A + drag_dir.Left().ToVector() );
 }
 else
 {
 if( dir_prev.Angle( drag_dir )
 & ( DIRECTION_45::ANG_OBTUSE | DIRECTION_45::ANG_HALF_FULL ) )
 {
 guideA[0] = SEG( s_prev.A, s_prev.A + drag_dir.Left().ToVector() );
 guideA[1] = SEG( s_prev.A, s_prev.A + drag_dir.Right().ToVector() );
 }
 else
 guideA[0] = guideA[1] = SEG( dragged.A, dragged.A + dir_prev.ToVector() );
 }
 
 if( aIndex == m_line.SegmentCount() - 1 )
 {
 guideB[0] = SEG( dragged.B, dragged.B + drag_dir.Right().ToVector() );
 guideB[1] = SEG( dragged.B, dragged.B + drag_dir.Left().ToVector() );
 }
 else
 {
 if( dir_next.Angle( drag_dir )
 & ( DIRECTION_45::ANG_OBTUSE | DIRECTION_45::ANG_HALF_FULL ) )
 {
 guideB[0] = SEG( s_next.B, s_next.B + drag_dir.Left().ToVector() );
 guideB[1] = SEG( s_next.B, s_next.B + drag_dir.Right().ToVector() );
 }
 else
 guideB[0] = guideB[1] = SEG( dragged.B, dragged.B + dir_next.ToVector() );
 }
 
 SEG s_current( target, target + drag_dir.ToVector() );
 
 int best_len = INT_MAX;
 SHAPE_LINE_CHAIN best;
 
 for( int i = 0; i < 2; i++ )
 {
 for( int j = 0; j < 2; j++ )
 {
 OPT_VECTOR2I ip1 = s_current.IntersectLines( guideA[i] );
 OPT_VECTOR2I ip2 = s_current.IntersectLines( guideB[j] );
 
 SHAPE_LINE_CHAIN np;
 
 if( !ip1 || !ip2 )
 continue;
 
 SEG s1( s_prev.A, *ip1 );
 SEG s2( *ip1, *ip2 );
 SEG s3( *ip2, s_next.B );
 
 OPT_VECTOR2I ip;
 
 if( ( ip = s1.Intersect( s_next ) ) )
 {
 np.Append( s1.A );
 np.Append( *ip );
 np.Append( s_next.B );
 }
 else if( ( ip = s3.Intersect( s_prev ) ) )
 {
 np.Append( s_prev.A );
 np.Append( *ip );
 np.Append( s3.B );
 }
 else if( ( ip = s1.Intersect( s3 ) ) )
 {
 np.Append( s_prev.A );
 np.Append( *ip );
 np.Append( s_next.B );
 }
 else
 {
 np.Append( s_prev.A );
 np.Append( *ip1 );
 np.Append( *ip2 );
 np.Append( s_next.B );
 }
 
 if( np.Length() < best_len )
 {
 best_len = np.Length();
 best = np;
 }
 }
 }
 
 if( m_line.PointCount() == 1 )
 m_line = best;
 else if( aIndex == 0 )
 m_line.Replace( 0, 1, best );
 else if( aIndex == m_line.SegmentCount() - 1 )
 m_line.Replace( -2, -1, best );
 else
 m_line.Replace( aIndex, aIndex + 1, best );
 
 m_line.Simplify();
}

References SEG::A, DIRECTION_45::ANG_HALF_FULL, DIRECTION_45::ANG_OBTUSE, DIRECTION_45::Angle(), SHAPE_LINE_CHAIN::Append(), SEG::B, SEG::Intersect(), SEG::IntersectLines(), DIRECTION_45::Left(), SHAPE_LINE_CHAIN::Length(), m_line, path, SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN::Replace(), DIRECTION_45::Right(), SHAPE_LINE_CHAIN::SegmentCount(), SHAPE_LINE_CHAIN::Simplify(), snapToNeighbourSegments(), DIRECTION_45::ToVector(), and DIRECTION_45::UNDEFINED.

Referenced by DragSegment().

◆ dragSegmentFree()

void PNS::LINE::dragSegmentFree	(	const VECTOR2I &	aP,
		int	aIndex
	)

private

◆ EndsWithVia()

bool PNS::LINE::EndsWithVia ( ) const

inline

◆ 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.

{
 std::stringstream ss;
 ss << KindStr() << " ";
 ss << "net " << m_net << " ";
 ss << "layers " << m_layers.Start() << " " << m_layers.End();
 return ss.str();
}

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

◆ GetBlockingObstacle()

ITEM * PNS::LINE::GetBlockingObstacle ( ) const

inline

Definition at line 209 of file pns_line.h.

209{ return m_blockingObstacle; }

References m_blockingObstacle.

Referenced by PNS::ROUTER::markViolations().

◆ GetLink()

LINKED_ITEM * PNS::LINK_HOLDER::GetLink ( int aIndex ) const

inlineinherited

Erase the linking information. Used to detach the line from the owning node.

Definition at line 63 of file pns_link_holder.h.

References PNS::LINK_HOLDER::m_links.

Referenced by PNS::LINE_PLACER::removeLoops(), PNS::TOPOLOGY::SimplifyLine(), PNS::DP_MEANDER_PLACER::Start(), and PNS::MEANDER_SKEW_PLACER::Start().

◆ GetSnapThreshhold()

int PNS::LINE::GetSnapThreshhold ( ) const

inline

Definition at line 229 of file pns_line.h.

 {
 return m_snapThreshhold;
 }

References m_snapThreshhold.

◆ HasLockedSegments()

bool PNS::LINE::HasLockedSegments ( ) const

Definition at line 1233 of file pns_line.cpp.

{
 for( const auto seg : m_links )
 {
 if( seg->Marker() & MK_LOCKED )
 return true;
 }
 return false;
}

References PNS::LINK_HOLDER::m_links, and PNS::MK_LOCKED.

Referenced by PNS::SHOVE::onCollidingArc(), and PNS::SHOVE::onCollidingSegment().

◆ HasLoops()

bool PNS::LINE::HasLoops ( ) const

Definition at line 1123 of file pns_line.cpp.

{
 for( int i = 0; i < PointCount(); i++ )
 {
 for( int j = i + 2; j < PointCount(); j++ )
 {
 if( CPoint( i ) == CPoint( j ) )
 return true;
 }
 }
 
 return false;
}

References CPoint(), and PointCount().

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

◆ 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.

 {
 return nullptr;
 }

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.

 {
 return SHAPE_LINE_CHAIN();
 }

◆ 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.

 {
 return SHAPE_LINE_CHAIN();
 }

◆ IsCompoundShapePrimitive()

bool PNS::ITEM::IsCompoundShapePrimitive ( ) const

inlineinherited

Definition at line 246 of file pns_item.h.

246{ return m_isCompoundShapePrimitive; }

PNS::ITEM::m_isCompoundShapePrimitive

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

PNS::ITEM::m_isFreePad

bool m_isFreePad

Definition: pns_item.h:266

References PNS::ITEM::m_isFreePad.

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

◆ IsLinked()

bool PNS::LINK_HOLDER::IsLinked ( ) const

inlineinherited

Check if the segment aLink is a part of the line.

Definition at line 52 of file pns_link_holder.h.

References PNS::LINK_HOLDER::m_links.

Referenced by PNS::NODE::Add(), ClipVertexRange(), PNS::TOPOLOGY::followTrivialPath(), IsLinkedChecked(), PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), Rank(), PNS::OPTIMIZER::removeCachedSegments(), PNS::LINK_HOLDER::ShowLinks(), and PNS::TOPOLOGY::SimplifyLine().

◆ IsLinkedChecked()

bool PNS::LINE::IsLinkedChecked ( ) const

inline

Assign a shape to the line (a polyline/line chain).

Definition at line 120 of file pns_line.h.

References PNS::LINK_HOLDER::IsLinked(), PNS::LINK_HOLDER::LinkCount(), and ShapeCount().

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

◆ IsLocked()

bool PNS::ITEM::IsLocked ( ) const

inlineinherited

Definition at line 229 of file pns_item.h.

 {
 return Marker() & MK_LOCKED;
 }

References PNS::ITEM::Marker(), and PNS::MK_LOCKED.

Referenced by ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::performDragging(), and PNS::SHOVE::pushOrShoveVia().

◆ IsRoutable()

bool PNS::ITEM::IsRoutable ( ) const

inlineinherited

Definition at line 235 of file pns_item.h.

235{ return m_routable; }

PNS::ITEM::m_routable

bool m_routable

Definition: pns_item.h:264

References PNS::ITEM::m_routable.

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

◆ IsVirtual()

bool PNS::ITEM::IsVirtual ( ) const

inlineinherited

Definition at line 240 of file pns_item.h.

 {
 return m_isVirtual;
 }

References PNS::ITEM::m_isVirtual.

Referenced by PNS_KICAD_IFACE::DisplayItem(), PNS::NODE::GetClearance(), PNS::NODE::GetHoleClearance(), PNS::NODE::GetHoleToHoleClearance(), and PNS::NODE::QueryColliding().

◆ Kind()

PnsKind PNS::ITEM::Kind ( ) const

inlineinherited

Return the type (kind) of the item.

Definition at line 132 of file pns_item.h.

 {
 return m_kind;
 }

References PNS::ITEM::m_kind.

Referenced by PNS_KICAD_IFACE::AddItem(), PNS::NODE::AssembleLine(), PNS::TOPOLOGY::AssembleTrivialPath(), PNS::OPTIMIZER::CacheRemove(), PNS::NODE::CheckColliding(), PNS::ARC::ClassOf(), PNS::DIFF_PAIR::ClassOf(), ClassOf(), PNS::SEGMENT::ClassOf(), PNS::SOLID::ClassOf(), PNS::VIA::ClassOf(), comparePnsItems(), PNS::OPTIMIZER::computeBreakouts(), PNS::DIFF_PAIR_PLACER::FindDpPrimitivePair(), PNS::NODE::followLine(), PNS::getDanglingAnchor(), PNS::MEANDER_PLACER_BASE::getSnappedStartPoint(), PNS_PCBNEW_RULE_RESOLVER::holeRadius(), PNS_KICAD_IFACE_BASE::inheritTrackWidth(), PNS::OPTIMIZER::CACHE_VISITOR::operator()(), ROUTER_TOOL::performDragging(), PNS_PCBNEW_RULE_RESOLVER::QueryConstraint(), PNS::NODE::Remove(), PNS::SHOVE::shoveIteration(), PNS::OPTIMIZER::smartPadsSingle(), PNS::TOOL_BASE::snapToItem(), PNS::LINE_PLACER::Start(), PNS::DRAGGER::Start(), ROUTER_PREVIEW_ITEM::Update(), PNS_KICAD_IFACE::UpdateItem(), and PNS::LINE_PLACER::UpdateSizes().

◆ 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.

{
 switch( m_kind )
 {
 case ARC_T: return "arc";
 case LINE_T: return "line";
 case SEGMENT_T: return "segment";
 case VIA_T: return "via";
 case JOINT_T: return "joint";
 case SOLID_T: return "solid";
 case DIFF_PAIR_T: return "diff-pair";
 default: return "unknown";
 }
}

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

virtual int PNS::ITEM::Layer ( ) const

inlinevirtualinherited

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

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

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

◆ Line()

SHAPE_LINE_CHAIN & PNS::LINE::Line ( )

inline

Definition at line 141 of file pns_line.h.

141{ return m_line; }

References m_line.

◆ Link()

void PNS::LINK_HOLDER::Link ( LINKED_ITEM * aLink )

inlineinherited

Return the list of links from the owning node that constitute this line (or NULL if the line is not linked).

Definition at line 42 of file pns_link_holder.h.

References PNS::LINK_HOLDER::m_links.

Referenced by PNS::NODE::Add(), and PNS::NODE::AssembleLine().

◆ LinkCount()

int PNS::LINK_HOLDER::LinkCount ( ) const

inlineinherited

Definition at line 75 of file pns_link_holder.h.

 {
 return m_links.size();
 }

References PNS::LINK_HOLDER::m_links.

Referenced by IsLinkedChecked(), and PNS::LINE_PLACER::removeLoops().

◆ Links() [1/2]

LINKS & PNS::LINK_HOLDER::Links ( )

inlineinherited

Definition at line 49 of file pns_link_holder.h.

49{ return m_links; }

References PNS::LINK_HOLDER::m_links.

Referenced by PNS::SHOVE::findRootLine(), PNS::TOPOLOGY::followTrivialPath(), PNS::SHOVE::popLineStack(), PNS::NODE::Remove(), PNS::OPTIMIZER::removeCachedSegments(), PNS::SHOVE::replaceLine(), PNS::SHOVE::ShoveObstacleLine(), PNS::COMPONENT_DRAGGER::Start(), and PNS::SHOVE::unwindLineStack().

◆ Links() [2/2]

const LINKS & PNS::LINK_HOLDER::Links ( ) const

inlineinherited

Definition at line 50 of file pns_link_holder.h.

50{ return m_links; }

References PNS::LINK_HOLDER::m_links.

◆ Mark()

void PNS::LINE::Mark ( int aMarker ) const

overridevirtual

Reimplemented from PNS::ITEM.

Definition at line 89 of file pns_line.cpp.

{
 m_marker = aMarker;
 
 for( const LINKED_ITEM* s : m_links )
 s->Mark( aMarker );
 
}

References PNS::LINK_HOLDER::m_links, and PNS::ITEM::m_marker.

Referenced by PNS::SHOVE::onCollidingSolid(), PNS::SHOVE::ShoveLines(), PNS::SHOVE::ShoveMultiLines(), and PNS::SHOVE::ShoveObstacleLine().

◆ Marker()

int PNS::LINE::Marker ( ) const

overridevirtual

Reimplemented from PNS::ITEM.

Definition at line 108 of file pns_line.cpp.

{
 int marker = m_marker;
 
 for( auto s : m_links )
 {
 marker |= s->Marker();
 }
 
 return marker;
}

References PNS::LINK_HOLDER::m_links, and PNS::ITEM::m_marker.

Referenced by PNS::ARC::ARC(), PNS::SHOVE::onCollidingArc(), PNS::SHOVE::onCollidingLine(), PNS::SHOVE::onCollidingSegment(), PNS::SHOVE::onCollidingSolid(), PNS::SEGMENT::SEGMENT(), PNS::SHOVE::shoveLineToHullSet(), and PNS::SHOVE::ShoveObstacleLine().

◆ Net()

int PNS::ITEM::Net ( ) const

inlineinherited

Definition at line 154 of file pns_item.h.

154{ return m_net; }

References PNS::ITEM::m_net.

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::AssembleCluster(), PNS::TOPOLOGY::AssembleDiffPair(), PNS::NODE::AssembleLine(), PNS::LINE_PLACER::buildInitialLine(), PNS::KEEP_TOPOLOGY_CONSTRAINT::Check(), PNS::VIA::Clone(), comparePnsItems(), PNS::DRAGGER::CurrentNets(), PNS::MEANDER_PLACER::CurrentNets(), PNS::DIFF_PAIR::DIFF_PAIR(), PNS::OPTIMIZER::fanoutCleanup(), PNS::DIFF_PAIR_PLACER::FindDpPrimitivePair(), PNS::NODE::FindJoint(), PNS::NODE::findRedundantArc(), PNS::NODE::findRedundantSegment(), PNS::LINE_PLACER::FixRoute(), ROUTER_TOOL::InlineDrag(), PNS_PCBNEW_RULE_RESOLVER::IsDiffPair(), PNS_PCBNEW_RULE_RESOLVER::IsNetTieExclusion(), PNS::ROUTER::isStartingPointRoutable(), LINE(), PNS::NODE::LockJoint(), PNS::VIA::MakeHandle(), PNS::MEANDER_SKEW_PLACER::origPathLength(), ROUTER_TOOL::performDragging(), LENGTH_TUNER_TOOL::performTuning(), ROUTER_TOOL::prepareInteractive(), PNS_PCBNEW_RULE_RESOLVER::QueryConstraint(), PNS::NODE::rebuildJoint(), PNS::INDEX::Remove(), PNS::NODE::removeArcIndex(), PNS::NODE::removeSegmentIndex(), PNS::NODE::removeSolidIndex(), PNS::NODE::removeViaIndex(), PNS::OPTIMIZER::runSmartPads(), PNS::SEGMENT::SEGMENT(), PNS::SHOVE::ShoveObstacleLine(), PNS::DIFF_PAIR_PLACER::Start(), PNS::LINE_PLACER::Start(), PNS::MEANDER_SKEW_PLACER::Start(), and PNS::VIA::VIA().

◆ OfKind()

bool PNS::ITEM::OfKind ( int aKindMask ) const

inlineinherited

Return true if the item's type matches the mask aKindMask.

Definition at line 140 of file pns_item.h.

 {
 return ( aKindMask & m_kind ) != 0;
 }

References PNS::ITEM::m_kind.

Referenced by PNS::DP_PRIMITIVE_PAIR::anchorDirection(), PNS::TOPOLOGY::AssembleCluster(), PNS::TOPOLOGY::AssembleTrivialPath(), ROUTER_TOOL::breakTrack(), PNS::DP_GATEWAYS::BuildFromPrimitivePair(), PNS::ChangedArea(), PNS::TOOL_BASE::checkSnap(), PNS::DP_PRIMITIVE_PAIR::CursorOrientation(), PNS::DP_PRIMITIVE_PAIR::Directional(), PNS_KICAD_IFACE::DisplayItem(), PNS::OPTIMIZER::fanoutCleanup(), PNS::SHOVE::fixupViaCollisions(), PNS::MEANDER_PLACER_BASE::lineLength(), PNS::SHOVE::onCollidingVia(), PNS::NODE::DEFAULT_OBSTACLE_VISITOR::operator()(), PNS_KICAD_IFACE::RemoveItem(), PNS::LINE_PLACER::SetLayer(), PNS::SHOVE::shoveIteration(), PNS::LINE_PLACER::simplifyNewLine(), PNS::LINE_PLACER::SplitAdjacentSegments(), PNS::DP_MEANDER_PLACER::Start(), PNS::MEANDER_PLACER::Start(), PNS::MEANDER_SKEW_PLACER::Start(), and PNS::SHOVE::unwindLineStack().

◆ operator=()

LINE & PNS::LINE::operator= ( const LINE & aOther )

Definition at line 60 of file pns_line.cpp.

{
 m_line = aOther.m_line;
 m_width = aOther.m_width;
 m_net = aOther.m_net;
 m_movable = aOther.m_movable;
 m_layers = aOther.m_layers;
 m_via = aOther.m_via;
 m_hasVia = aOther.m_hasVia;
 m_marker = aOther.m_marker;
 m_rank = aOther.m_rank;
 m_owner = aOther.m_owner;
 m_snapThreshhold = aOther.m_snapThreshhold;
 m_blockingObstacle = aOther.m_blockingObstacle;
 
 copyLinks( &aOther );
 
 return *this;
}

References PNS::LINK_HOLDER::copyLinks(), m_blockingObstacle, m_hasVia, PNS::ITEM::m_layers, m_line, PNS::ITEM::m_marker, PNS::ITEM::m_movable, PNS::ITEM::m_net, PNS::ITEM::m_owner, PNS::ITEM::m_rank, m_snapThreshhold, m_via, and m_width.

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

BOARD_ITEM * PNS::ITEM::Parent ( ) const

inlineinherited

◆ PointCount()

int PNS::LINE::PointCount ( ) const

inline

Definition at line 145 of file pns_line.h.

145{ return m_line.PointCount(); }

References m_line, and SHAPE_LINE_CHAIN::PointCount().

Referenced by PNS::LINE_PLACER::buildInitialLine(), PNS::OPTIMIZER::fanoutCleanup(), HasLoops(), PNS::LINE_PLACER::Move(), PNS::TOPOLOGY::NearestUnconnectedAnchorPoint(), PNS::OPTIMIZER::removeCachedSegments(), PNS::WALKAROUND::Route(), PNS::LINE_PLACER::route(), PNS::TOPOLOGY::SimplifyLine(), PNS::LINE_PLACER::simplifyNewLine(), PNS::LINE_PLACER::splitHeadTail(), and PNS::DRAGGER::startDragSegment().

◆ Rank()

int PNS::LINE::Rank ( ) const

overridevirtual

Reimplemented from PNS::ITEM.

Definition at line 1054 of file pns_line.cpp.

{
 int min_rank = INT_MAX;
 
 if( IsLinked() )
 {
 for( const LINKED_ITEM* item : m_links )
 min_rank = std::min( min_rank, item->Rank() );
 }
 else
 {
 min_rank = m_rank;
 }
 
 int rank = ( min_rank == INT_MAX ) ? -1 : min_rank;
 
 return rank;
}

References PNS::LINK_HOLDER::IsLinked(), PNS::LINK_HOLDER::m_links, and PNS::ITEM::m_rank.

Referenced by PNS::ARC::ARC(), PNS::SHOVE::onCollidingArc(), PNS::SHOVE::onCollidingLine(), PNS::SHOVE::onCollidingSegment(), PNS::SHOVE::onCollidingSolid(), PNS::SHOVE::onReverseCollidingVia(), PNS::SEGMENT::SEGMENT(), and PNS::SHOVE::shoveIteration().

◆ RemoveVia()

void PNS::LINE::RemoveVia ( )

inline

Definition at line 197 of file pns_line.h.

197{ m_hasVia = false; }

References m_hasVia.

Referenced by ClipToNearestObstacle(), PNS::LINE_PLACER::FixRoute(), PNS::LINE_PLACER::initPlacement(), PNS::SHOVE::onReverseCollidingVia(), PNS::DIFF_PAIR::RemoveVias(), PNS::LINE_PLACER::SetLayer(), PNS::LINE_PLACER::splitHeadTail(), PNS::LINE_PLACER::ToggleVia(), and PNS::LINE_PLACER::UnfixRoute().

◆ Reverse()

void PNS::LINE::Reverse ( )

Clip the line to the nearest obstacle, traversing from the line's start vertex (0).

Returns the clipped line.

Definition at line 1023 of file pns_line.cpp.

{
 m_line = m_line.Reverse();
 
 std::reverse( m_links.begin(), m_links.end() );
}

References m_line, PNS::LINK_HOLDER::m_links, and SHAPE_LINE_CHAIN::Reverse().

Referenced by AppendVia(), PNS::DRAGGER::findViaFanoutByHandle(), and PNS::TOPOLOGY::followTrivialPath().

◆ SegmentCount()

int PNS::LINE::SegmentCount ( ) const

inline

◆ SetBlockingObstacle()

void PNS::LINE::SetBlockingObstacle ( ITEM * aObstacle )

inline

Definition at line 208 of file pns_line.h.

208{ m_blockingObstacle = aObstacle; }

References m_blockingObstacle.

Referenced by PNS::LINE_PLACER::rhMarkObstacles().

◆ SetIsCompoundShapePrimitive()

void PNS::ITEM::SetIsCompoundShapePrimitive ( )

inlineinherited

Definition at line 245 of file pns_item.h.

245{ m_isCompoundShapePrimitive = true; }

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

void PNS::ITEM::SetLayer ( int aLayer )

inlineinherited

Definition at line 159 of file pns_item.h.

159{ m_layers = LAYER_RANGE( aLayer, aLayer ); }

LAYER_RANGE

Represent a contiguous set of PCB layers.

Definition: pns_layerset.h:32

References PNS::ITEM::m_layers.

Referenced by PNS::LINE_PLACER::buildInitialLine(), PNS::LINE_PLACER::FixRoute(), PNS::LINE_PLACER::initPlacement(), PNS::ROUTER::isStartingPointRoutable(), PNS::DIFF_PAIR_PLACER::propagateDpHeadForces(), PNS::DIFF_PAIR_PLACER::routeHead(), PNS::LINE_PLACER::SetLayer(), PNS::LINE_PLACER::UnfixRoute(), and PNS::DIFF_PAIR::updateLine().

◆ SetLayers()

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

inlineinherited

Definition at line 157 of file pns_item.h.

157{ m_layers = aLayers; }

References PNS::ITEM::m_layers.

Referenced by PNS::TOPOLOGY::AssembleDiffPair(), PNS::NODE::AssembleLine(), PNS::VIA::Clone(), parseCommonPnsProps(), and PNS::VIA::VIA().

◆ SetNet()

void PNS::ITEM::SetNet ( int aNet )

inlineinherited

Definition at line 153 of file pns_item.h.

153{ m_net = aNet; }

References PNS::ITEM::m_net.

Referenced by AppendVia(), PNS::NODE::AssembleLine(), PNS::LINE_PLACER::buildInitialLine(), PNS::VIA::Clone(), PNS::LINE_PLACER::FixRoute(), PNS::LINE_PLACER::initPlacement(), PNS::ROUTER::isStartingPointRoutable(), PNS::DIFF_PAIR_PLACER::makeVia(), parseCommonPnsProps(), PNS::DIFF_PAIR::updateLine(), and PNS::VIA::VIA().

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

void PNS::LINE::SetRank ( int aRank )

overridevirtual

Reimplemented from PNS::ITEM.

Definition at line 1044 of file pns_line.cpp.

{
 m_rank = aRank;
 
 for( auto s : m_links )
 s->SetRank( aRank );
 
}

References PNS::LINK_HOLDER::m_links, and PNS::ITEM::m_rank.

Referenced by PNS::SHOVE::onCollidingArc(), PNS::SHOVE::onCollidingLine(), PNS::SHOVE::onCollidingSegment(), PNS::SHOVE::onCollidingSolid(), PNS::SHOVE::onReverseCollidingVia(), PNS::SHOVE::ShoveLines(), and PNS::SHOVE::ShoveMultiLines().

◆ 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.

◆ SetShape()

void PNS::LINE::SetShape ( const SHAPE_LINE_CHAIN & aLine )

inline

◆ SetSnapThreshhold()

void PNS::LINE::SetSnapThreshhold ( int aThreshhold )

inline

Definition at line 224 of file pns_line.h.

 {
 m_snapThreshhold = aThreshhold;
 }

References m_snapThreshhold.

Referenced by PNS::DRAGGER::dragMarkObstacles(), PNS::DRAGGER::dragShove(), and PNS::DRAGGER::dragWalkaround().

◆ SetViaDiameter()

void PNS::LINE::SetViaDiameter ( int aDiameter )

inline

Definition at line 201 of file pns_line.h.

201{ m_via.SetDiameter( aDiameter ); }

PNS::VIA::SetDiameter

void SetDiameter(int aDiameter)

Definition: pns_via.h:114

References m_via, and PNS::VIA::SetDiameter().

Referenced by PNS::LINE_PLACER::UpdateSizes().

◆ SetViaDrill()

void PNS::LINE::SetViaDrill ( int aDrill )

inline

Definition at line 202 of file pns_line.h.

202{ m_via.SetDrill( aDrill ); }

PNS::VIA::SetDrill

void SetDrill(int aDrill)

Definition: pns_via.h:122

References m_via, and PNS::VIA::SetDrill().

Referenced by PNS::LINE_PLACER::UpdateSizes().

◆ SetWidth()

void PNS::LINE::SetWidth ( int aWidth )

inline

Return line width.

Definition at line 154 of file pns_line.h.

References m_line, m_width, and SHAPE_LINE_CHAIN::SetWidth().

Referenced by PNS::NODE::AssembleLine(), PNS::LINE_PLACER::initPlacement(), PNS::ROUTER::isStartingPointRoutable(), PNS::DIFF_PAIR::updateLine(), and PNS::LINE_PLACER::UpdateSizes().

◆ Shape()

const SHAPE * PNS::LINE::Shape ( ) const

inlineoverridevirtual

Modifiable accessor to the underlying shape.

Reimplemented from PNS::ITEM.

Definition at line 138 of file pns_line.h.

References m_line.

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

◆ ShapeCount()

int PNS::LINE::ShapeCount ( ) const

inline

Return the aIdx-th point of the line.

Definition at line 147 of file pns_line.h.

References m_line, and SHAPE_LINE_CHAIN::ShapeCount().

Referenced by IsLinkedChecked(), and PNS::LINE_PLACER::routeStep().

◆ ShowLinks()

void PNS::LINE::ShowLinks ( ) const

◆ snapDraggedCorner()

VECTOR2I PNS::LINE::snapDraggedCorner	(	const SHAPE_LINE_CHAIN &	aPath,
		const VECTOR2I &	aP,
		int	aIndex
	)		const

private

Definition at line 760 of file pns_line.cpp.

{
 int s_start = std::max( aIndex - 2, 0 );
 int s_end = std::min( aIndex + 2, aPath.SegmentCount() - 1 );
 
 int i, j;
 int best_dist = INT_MAX;
 VECTOR2I best_snap = aP;
 
 if( m_snapThreshhold <= 0 )
 return aP;
 
 for( i = s_start; i <= s_end; i++ )
 {
  const SEG& a = aPath.CSegment( i );
 
 for( j = s_start; j < i; j++ )
 {
 const SEG& b = aPath.CSegment( j );
 
 if( !( DIRECTION_45( a ).IsObtuse( DIRECTION_45( b ) ) ) )
 continue;
 
 OPT_VECTOR2I ip = a.IntersectLines( b );
 
 if( ip )
 {
 int dist = ( *ip - aP ).EuclideanNorm();
 
 if( dist < m_snapThreshhold && dist < best_dist )
 {
 best_dist = dist;
 best_snap = *ip;
 }
 }
 }
 }
 
 return best_snap;
}

References SHAPE_LINE_CHAIN::CSegment(), EuclideanNorm(), SEG::IntersectLines(), m_snapThreshhold, and SHAPE_LINE_CHAIN::SegmentCount().

Referenced by dragCorner45().

◆ snapToNeighbourSegments()

VECTOR2I PNS::LINE::snapToNeighbourSegments	(	const SHAPE_LINE_CHAIN &	aPath,
		const VECTOR2I &	aP,
		int	aIndex
	)		const

private

Definition at line 802 of file pns_line.cpp.

{
 VECTOR2I snap_p[2];
 DIRECTION_45 dragDir( aPath.CSegment( aIndex ) );
 int snap_d[2] = { -1, -1 };
 
 if( m_snapThreshhold == 0 )
 return aP;
 
 if( aIndex >= 2 )
 {
 SEG s = aPath.CSegment( aIndex - 2 );
 
 if( DIRECTION_45( s ) == dragDir )
 snap_d[0] = s.LineDistance( aP );
 
 snap_p[0] = s.A;
 }
 
 if( aIndex < aPath.SegmentCount() - 2 )
 {
 SEG s = aPath.CSegment( aIndex + 2 );
 
 if( DIRECTION_45( s ) == dragDir )
 snap_d[1] = s.LineDistance( aP );
 
 snap_p[1] = s.A;
 }
 
 VECTOR2I best = aP;
 int minDist = INT_MAX;
 
 for( int i = 0; i < 2; i++ )
 {
 if( snap_d[i] >= 0 && snap_d[i] < minDist && snap_d[i] <= m_snapThreshhold )
 {
 minDist = snap_d[i];
 best = snap_p[i];
 }
 }
 
 return best;
}

References SEG::A, SHAPE_LINE_CHAIN::CSegment(), SEG::LineDistance(), m_snapThreshhold, and SHAPE_LINE_CHAIN::SegmentCount().

Referenced by dragSegment45().

◆ Unmark()

void PNS::LINE::Unmark ( int aMarker = -1 ) const

overridevirtual

Reimplemented from PNS::ITEM.

Definition at line 99 of file pns_line.cpp.

{
 for( const LINKED_ITEM* s : m_links )
 s->Unmark( aMarker );
 
 m_marker = 0;
}

References PNS::LINK_HOLDER::m_links, and PNS::ITEM::m_marker.

Referenced by PNS::COMPONENT_DRAGGER::Drag(), PNS::DRAGGER::dragShove(), PNS::SHOVE::onCollidingSolid(), and PNS::DRAGGER::optimizeAndUpdateDraggedLine().

◆ Via()

const VIA & PNS::LINE::Via ( ) const

inline

◆ Walkaround() [1/2]

bool PNS::LINE::Walkaround	(	const SHAPE_LINE_CHAIN &	aObstacle,
		SHAPE_LINE_CHAIN &	aPath,
		bool	aCw
	)		const

Print out all linked segments.

Definition at line 171 of file pns_line.cpp.

{
 const SHAPE_LINE_CHAIN& line( CLine() );
 
 if( line.SegmentCount() < 1 )
 {
 return false;
 }
 
 const auto pFirst = line.CPoint(0);
 
 bool inFirst = aObstacle.PointInside( pFirst ) && !aObstacle.PointOnEdge( pFirst );
 
 // We can't really walk around if the beginning of the path lies inside the obstacle hull.
 // Double check if it's not on the hull itself as this triggers many unroutable corner cases.
 if( inFirst )
 {
 return false;
 }
 
 enum VERTEX_TYPE { INSIDE = 0, OUTSIDE, ON_EDGE };
 
 // Represents an entry in directed graph of hull/path vertices. Scanning this graph
 // starting from the path's first point results (if possible) with a correct walkaround path
 struct VERTEX
 {
 // vertex classification (inside/outside/exactly on the hull)
 VERTEX_TYPE type;
 // true = vertex coming from the hull primitive
 bool isHull;
 // position
 VECTOR2I pos;
 // list of neighboring vertices
 std::vector<VERTEX*> neighbours;
 // index of this vertex in path (pnew)
 int indexp = -1;
 // index of this vertex in the hull (hnew)
 int indexh = -1;
 // visited indicator (for BFS search)
 bool visited = false;
 };
 
 SHAPE_LINE_CHAIN::INTERSECTIONS ips;
 
 HullIntersection( aObstacle, line, ips );
 
 SHAPE_LINE_CHAIN pnew( CLine() ), hnew( aObstacle );
 
 std::vector<VERTEX> vts;
 
 auto findVertex = [&]( VECTOR2I pos) -> VERTEX*
 {
 for( VERTEX& v : vts )
 {
 if(v.pos == pos )
 return &v;
 }
 
 return nullptr;
 };
 
 
 // corner case for loopy tracks: insert the end loop point back into the hull
 if( auto isect = pnew.SelfIntersecting() )
 {
 if( isect->p != pnew.CPoint( -1 ) )
 {
 pnew.Split( isect->p );
 }
 }
 
 // insert all intersections found into the new hull/path SLCs
 for( auto& ip : ips )
 {
 if( pnew.Find( ip.p, 1 ) < 0)
 {
 pnew.Split(ip.p);
 }
 
 if( hnew.Find( ip.p, 1 ) < 0 )
 {
 hnew.Split(ip.p);
 }
 }
 
 for( int i = 0; i < pnew.PointCount(); i++ )
 {
 auto p = pnew.CPoint(i);
 bool onEdge = hnew.PointOnEdge( p );
 
 if ( !onEdge )
 continue;
 
 int idx = hnew.Find( p );
 
 if(idx < 0 )
 {
 hnew.Split(p);
 }
 }
 
 #ifdef TOM_EXTRA_DEBUG
 for( auto& ip : ips )
 {
 printf("Chk: %d %d\n", pnew.Find( ip.p ), hnew.Find(ip.p) );
 }
 #endif
 
 // we assume the default orientation of the hulls is clockwise, so just reverse the vertex
 // order if the caller wants a counter-clockwise walkaround
 if ( !aCw )
 hnew = hnew.Reverse();
 
 vts.reserve( 2 * ( hnew.PointCount() + pnew.PointCount() ) );
 
 // create a graph of hull/path vertices and classify them (inside/on edge/outside the hull)
 for( int i = 0; i < pnew.PointCount(); i++ )
 {
 auto p = pnew.CPoint(i);
 bool onEdge = hnew.PointOnEdge( p );
 bool inside = hnew.PointInside( p );
 
 #ifdef TOM_EXTRA_DEBUG
 printf("pnew %d inside %d onedge %d\n", i, !!inside, !!onEdge );
 #endif
 
 VERTEX v;
 
 v.indexp = i;
 v.isHull = false;
 v.pos = p;
 v.type = inside && !onEdge ? INSIDE : onEdge ? ON_EDGE : OUTSIDE;
 vts.push_back( v );
 }
 
 #ifdef TOM_EXTRA_DEBUG
 g_pnew = pnew;
 g_hnew = hnew;
 #endif
 
 // each path vertex neighbour list points for sure to the next vertex in the path
 for( int i = 0; i < pnew.PointCount() - 1; i++ )
 {
 vts[i].neighbours.push_back( &vts[ i+1 ] );
 }
 
 // each path vertex neighbour list points for sure to the next vertex in the path
 for( int i = 1; i < pnew.PointCount() ; i++ )
 {
 vts[i].neighbours.push_back( &vts[ i-1 ] );
 }
 
 // insert hull vertices into the graph
 for( int i = 0; i < hnew.PointCount(); i++ )
 {
 auto hp = hnew.CPoint( i );
 auto vn = findVertex( hp );
 
 // if vertex already present (it's very likely that in recursive shoving hull and path vertices will overlap)
 // just mark it as a path vertex that also belongs to the hull
 if( vn )
 {
 vn->isHull = true;
 vn->indexh = i;
 }
 else // new hull vertex
 {
 VERTEX v;
 v.pos = hp;
 v.type = ON_EDGE;
 v.indexh = i;
 v.isHull = true;
 vts.push_back( v );
 }
 }
 
 // go around the hull and fix up the neighbour link lists
 for( int i = 0; i < hnew.PointCount(); i++ )
 {
 auto vc = findVertex( hnew.CPoint(i ) );
 auto vnext = findVertex( hnew.CPoint( i+1 ) );
 
 if(vc && vnext)
 vc->neighbours.push_back(vnext);
 }
 
 // In the case that the initial path ends *inside* the current obstacle (i.e. the mouse cursor
 // is somewhere inside the hull for the current obstacle) we want to end the walkaround at the
 // point closest to the cursor
 bool inLast = aObstacle.PointInside( CPoint( -1 ) ) && !aObstacle.PointOnEdge( CPoint( -1 ) );
 bool appendV = true;
 int lastDst = INT_MAX;
 
 int i = 0;
#ifdef TOM_EXTRA_DEBUG
 for(auto &v: vts)
 {
 if( v.indexh < 0 && v.type == ON_EDGE )
 {
 v.type = OUTSIDE; // hack
 }
 printf("V %d pos %d %d ip %d ih %d type %d\n", i++, v.pos.x, v.pos.y, v.indexp, v.indexh, v.type );
 }
#endif
 // vts[0] = start point
 VERTEX* v = &vts[0], *v_prev = nullptr;
 SHAPE_LINE_CHAIN out;
 
 int iterLimit = 1000;
 
 // keep scanning the graph until we reach the end point of the path
 while( v->indexp != ( pnew.PointCount() - 1 ) )
 {
 iterLimit--;
 
 // I'm not 100% sure this algorithm doesn't have bugs that may cause it to freeze,
 // so here's a temporary iteration limit
 if( iterLimit == 0 )
 {
 return false;
 }
 
 if( v->visited )
 {
 // loop found? stop walking
 break;
 }
#ifdef TOM_EXTRA_DEBUG
 printf("---\nvisit ip %d ih %d type %d outs %d neig %d\n", v->indexp, v->indexh, v->type, out.PointCount(), v->neighbours.size() );
#endif
 out.Append( v->pos );
 
 VERTEX* v_next = nullptr;
 
 if( v->type == OUTSIDE )
 {
 // current vertex is outside? first look for any vertex further down the path
 // that is not inside the hull
 out.Append( v->pos );
 VERTEX* v_next_fallback = nullptr;
 for( auto vn : v->neighbours )
 {
 if( areNeighbours( vn->indexp , v->indexp, pnew.PointCount() ) &&
 vn->type != INSIDE )
 {
 if( !vn->visited )
 {
 v_next = vn;
 break;
 }
 else if( vn != v_prev )
 v_next_fallback = vn;
 }
 }
 
 if( !v_next )
 v_next = v_next_fallback;
 
 // such a vertex must always be present, if not, bummer.
 if( !v_next )
 {
 #ifdef TOM_EXTRA_DEBUG
 printf("FAIL VN fallback %p\n", v_next_fallback );
 #endif
 return false;
 }
 
 }
 else if( v->type == ON_EDGE )
 {
 // look first for the first vertex outside the hull
 for( VERTEX* vn : v->neighbours )
 {
#ifdef TOM_EXTRA_DEBUG
 printf( "- OUT scan ip %d ih %d type %d\n", vn->indexp, vn->indexh, vn->type );
#endif
 
 if( vn->type == OUTSIDE && !vn->visited )
 {
 v_next = vn;
 break;
 }
 }
 
 // no outside vertices found? continue traversing the hull
 if( !v_next )
 {
 for( VERTEX* vn : v->neighbours )
 {
 #ifdef TOM_EXTRA_DEBUG
 printf("- scan ip %d ih %d type %d\n", vn->indexp, vn->indexh, vn->type );
 #endif
 if( vn->type == ON_EDGE && !vn->isHull &&
 areNeighbours( vn->indexp, v->indexp, pnew.PointCount() ) &&
 ( vn->indexh == ( ( v->indexh + 1 ) % hnew.PointCount() ) ) )
 {
 v_next = vn;
 break;
 }
 }
 }
 
 // still nothing found? try to find the next (index-wise) point on the hull. I guess
 // we should never reach this part of the code, but who really knows?
 if( !v_next )
 {
#ifdef TOM_EXTRA_DEBUG
 printf("still no v_next\n");
#endif
 for( VERTEX* vn : v->neighbours )
 {
 if( vn->type == ON_EDGE )
 {
 if( vn->indexh == ( ( v->indexh + 1 ) % hnew.PointCount() ) )
 {
 v_next = vn;
 break;
 }
 }
 }
 
 if( v_next )
 {
 for( auto &v : vts )
 {
 if( v.isHull )
 v.visited = false;
 }
 }
 
#ifdef TOM_EXTRA_DEBUG
 printf("v_next %p\n", v_next);
#endif
 
 // Did we get the next hull point but the end of the line is inside? Instead of walking
 // around the hull some more (which will just end up taking us back to the start), lets
 // just project the normal of the endpoint onto this next segment and call it quits.
 if( inLast && v_next )
 {
 int d = ( v_next->pos - CPoint( -1 ) ).SquaredEuclideanNorm();
 
 if( d < lastDst )
 {
 lastDst = d;
 }
 else
 {
 VECTOR2I proj = SEG( v->pos, v_next->pos ).NearestPoint( CPoint( -1 ) );
 out.Append( proj );
 appendV = false;
 break;
 }
 }
 }
 }
 
 v->visited = true;
 v_prev = v;
 v = v_next;
 
 if( !v )
 {
 return false;
 }
 }
 
 if( appendV )
 out.Append( v->pos );
 
 aPath = out;
 
 return true;
}

References SHAPE_LINE_CHAIN::Append(), PNS::areNeighbours(), CLine(), CPoint(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::Find(), findVertex(), PNS::HullIntersection(), SEG::NearestPoint(), OUTSIDE, SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN_BASE::PointInside(), SHAPE_LINE_CHAIN_BASE::PointOnEdge(), SHAPE_LINE_CHAIN::Reverse(), SHAPE_LINE_CHAIN::SegmentCount(), and SHAPE_LINE_CHAIN::Split().

◆ Walkaround() [2/2]

bool PNS::LINE::Walkaround	(	SHAPE_LINE_CHAIN	aObstacle,
		SHAPE_LINE_CHAIN &	aPre,
		SHAPE_LINE_CHAIN &	aWalk,
		SHAPE_LINE_CHAIN &	aPost,
		bool	aCw
	)		const

Calculate a line tightly wrapping a convex hull of an obstacle object (aObstacle).

Parameters

aPrePath	is the path from origin to the obstacle.
aWalkaroundPath	is the path around the obstacle.
aPostPath	is the path from obstacle till the end.
aCW	determines whether to walk around in clockwise or counter-clockwise direction.

Referenced by PNS::SHOVE::shoveLineFromLoneVia(), PNS::SHOVE::shoveLineToHullSet(), and PNS::WALKAROUND::singleStep().

◆ Width()

int PNS::LINE::Width ( ) const

inline

Return true if the line is geometrically identical as line aOther.

Definition at line 161 of file pns_line.h.

References m_width.

Referenced by PNS::TOPOLOGY::AssembleDiffPair(), ChangedArea(), PNS::MEANDER_PLACER::doMove(), PNS::DRAGGER::dragMarkObstacles(), PNS::DRAGGER::dragShove(), PNS::DRAGGER::dragWalkaround(), PNS::OPTIMIZER::fanoutCleanup(), PNS::LINE_PLACER::FixRoute(), PNS::NODE::NearestObstacle(), PNS::SHOVE::onCollidingVia(), PNS::LINE_PLACER::rhMarkObstacles(), PNS::SHOVE::shoveIteration(), PNS::SHOVE::shoveLineFromLoneVia(), PNS::SHOVE::shoveLineToHullSet(), PNS::SHOVE::ShoveObstacleLine(), PNS::OPTIMIZER::smartPadsSingle(), PNS::LINE_PLACER::Start(), PNS::MEANDER_PLACER::Start(), and PNS::MEANDER_SKEW_PLACER::Start().

Member Data Documentation

◆ m_blockingObstacle

ITEM* PNS::LINE::m_blockingObstacle

private

For mark obstacle mode.

Definition at line 255 of file pns_line.h.

Referenced by GetBlockingObstacle(), LINE(), operator=(), and SetBlockingObstacle().

◆ m_hasVia

bool PNS::LINE::m_hasVia

private

Optional via at the end point.

Definition at line 252 of file pns_line.h.

Referenced by AppendVia(), Clear(), EndsWithVia(), LINE(), operator=(), RemoveVia(), and SetShape().

◆ m_isCompoundShapePrimitive

bool PNS::ITEM::m_isCompoundShapePrimitive

protectedinherited

Definition at line 267 of file pns_item.h.

Referenced by PNS::ITEM::IsCompoundShapePrimitive(), PNS::ITEM::ITEM(), and PNS::ITEM::SetIsCompoundShapePrimitive().

◆ 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

Definition at line 265 of file pns_item.h.

Referenced by PNS::VIA::Clone(), PNS::ITEM::IsVirtual(), PNS::ITEM::ITEM(), PNS::VIA::VIA(), and PNS::VVIA::VVIA().

◆ m_kind

PnsKind PNS::ITEM::m_kind

protectedinherited

Definition at line 254 of file pns_item.h.

Referenced by PNS::ITEM::Collide(), PNS::ITEM::collideSimple(), PNS::ITEM::ITEM(), PNS::ITEM::Kind(), PNS::ITEM::KindStr(), and PNS::ITEM::OfKind().

◆ m_layers

LAYER_RANGE PNS::ITEM::m_layers

protectedinherited

Definition at line 258 of file pns_item.h.

Referenced by PNS::ARC::ARC(), PNS::ARC::Clone(), PNS::SEGMENT::Clone(), PNS::ITEM::collideSimple(), PNS::JOINT::Dump(), PNS::ITEM::Format(), PNS::ITEM::ITEM(), PNS::JOINT::JOINT(), PNS::ITEM::Layers(), LINE(), PNS::JOINT::Merge(), operator=(), PNS::JOINT::Overlaps(), PNS::SEGMENT::SEGMENT(), PNS::ITEM::SetLayer(), and PNS::ITEM::SetLayers().

◆ m_line

SHAPE_LINE_CHAIN PNS::LINE::m_line

private

The actual shape of the line.

Definition at line 246 of file pns_line.h.

Referenced by AppendVia(), ArcCount(), ChangedArea(), Clear(), CLine(), ClipVertexRange(), CompareGeometry(), CountCorners(), CPoint(), CSegment(), dragCorner45(), dragCornerFree(), dragSegment45(), Line(), operator=(), PointCount(), Reverse(), SegmentCount(), SetShape(), SetWidth(), Shape(), and ShapeCount().

◆ m_links

LINKS PNS::LINK_HOLDER::m_links

protectedinherited

◆ m_marker

int PNS::ITEM::m_marker

mutableprotectedinherited

Definition at line 262 of file pns_item.h.

Referenced by PNS::ARC::ARC(), PNS::ARC::Clone(), PNS::SEGMENT::Clone(), PNS::VIA::Clone(), PNS::ITEM::ITEM(), LINE(), PNS::ITEM::Mark(), Mark(), PNS::ITEM::Marker(), Marker(), operator=(), PNS::SEGMENT::SEGMENT(), PNS::ITEM::Unmark(), Unmark(), and PNS::VIA::VIA().

◆ m_movable

bool PNS::ITEM::m_movable

protectedinherited

Definition at line 260 of file pns_item.h.

Referenced by PNS::ITEM::ITEM(), LINE(), operator=(), and PNS::SOLID::SOLID().

◆ m_net

int PNS::ITEM::m_net

protectedinherited

Definition at line 261 of file pns_item.h.

Referenced by AppendVia(), PNS::ARC::ARC(), PNS::ARC::Clone(), PNS::SEGMENT::Clone(), PNS::ITEM::collideSimple(), PNS::ITEM::Format(), PNS::ITEM::ITEM(), LINE(), PNS::ITEM::Net(), operator=(), PNS::SEGMENT::SEGMENT(), and PNS::ITEM::SetNet().

◆ m_owner

NODE* PNS::ITEM::m_owner

protectedinherited

Definition at line 257 of file pns_item.h.

Referenced by PNS::ITEM::BelongsTo(), PNS::ITEM::ITEM(), operator=(), PNS::ITEM::Owner(), and PNS::ITEM::SetOwner().

◆ m_parent

BOARD_ITEM* PNS::ITEM::m_parent

protectedinherited

Definition at line 256 of file pns_item.h.

Referenced by PNS::VIA::Clone(), PNS::ITEM::collideSimple(), PNS::ITEM::ITEM(), PNS::ITEM::Parent(), and PNS::ITEM::SetParent().

◆ m_rank

int PNS::ITEM::m_rank

protectedinherited

Definition at line 263 of file pns_item.h.

Referenced by PNS::ARC::ARC(), PNS::ARC::Clone(), PNS::SEGMENT::Clone(), PNS::VIA::Clone(), PNS::ITEM::ITEM(), LINE(), operator=(), PNS::ITEM::Rank(), Rank(), PNS::SEGMENT::SEGMENT(), PNS::ITEM::SetRank(), SetRank(), and PNS::VIA::VIA().

◆ 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_snapThreshhold

int PNS::LINE::m_snapThreshhold

private

Width to smooth out jagged segments.

Definition at line 250 of file pns_line.h.

Referenced by GetSnapThreshhold(), LINE(), operator=(), SetSnapThreshhold(), snapDraggedCorner(), and snapToNeighbourSegments().

◆ m_via

VIA PNS::LINE::m_via

private

Definition at line 253 of file pns_line.h.

Referenced by AppendVia(), LINE(), operator=(), SetShape(), SetViaDiameter(), SetViaDrill(), and Via().

◆ m_width

int PNS::LINE::m_width

private

Our width.

Definition at line 247 of file pns_line.h.

Referenced by LINE(), operator=(), SetShape(), SetWidth(), and Width().

◆ 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:

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ LINKS

Member Enumeration Documentation

◆ PnsKind

Constructor & Destructor Documentation

◆ LINE() [1/4]

◆ LINE() [2/4]

◆ LINE() [3/4]

◆ LINE() [4/4]

◆ ~LINE()

Member Function Documentation

◆ Anchor()

◆ AnchorCount()

◆ AppendVia()

◆ ArcCount()

◆ BelongsTo()

◆ ChangedArea()

◆ ClassOf()

◆ Clear()

◆ ClearLinks()

◆ CLine()

◆ ClipToNearestObstacle()

◆ ClipVertexRange()

◆ Clone()

◆ Collide()

◆ collideSimple()

◆ CompareGeometry()

◆ ContainsLink()

◆ copyLinks()

◆ CountCorners()

◆ CPoint()

◆ CSegment()

◆ DragCorner()

◆ dragCorner45()

◆ dragCornerFree()

◆ DragSegment()

◆ dragSegment45()

◆ dragSegmentFree()

◆ EndsWithVia()

◆ Format()

◆ GetBlockingObstacle()

◆ GetLink()

◆ GetSnapThreshhold()

◆ HasLockedSegments()

◆ HasLoops()

◆ Hole()

◆ HoleHull()

◆ Hull()

◆ IsCompoundShapePrimitive()

◆ IsFreePad()

◆ IsLinked()

◆ IsLinkedChecked()

◆ IsLocked()

◆ IsRoutable()

◆ IsVirtual()

◆ Kind()

◆ KindStr()

◆ Layer()

◆ Layers()

◆ LayersOverlap()

◆ Line()

◆ Link()

◆ LinkCount()

◆ Links() [1/2]

◆ Links() [2/2]

◆ Mark()

◆ Marker()

◆ Net()

◆ OfKind()

◆ operator=()

◆ Owner()