PNS::TOPOLOGY Class Reference

#include <pns_topology.h>

Public Types
typedef std::set< JOINT * >	JOINT_SET

Public Member Functions
	TOPOLOGY (NODE *aNode)
	~TOPOLOGY ()
bool	SimplifyLine (LINE *aLine)
ITEM *	NearestUnconnectedItem (JOINT *aStart, int *aAnchor=nullptr, int aKindMask=ITEM::ANY_T)
bool	NearestUnconnectedAnchorPoint (const LINE *aTrack, VECTOR2I &aPoint, LAYER_RANGE &aLayers)
bool	LeadingRatLine (const LINE *aTrack, SHAPE_LINE_CHAIN &aRatLine)
const JOINT_SET	ConnectedJoints (JOINT *aStart)
const ITEM_SET	ConnectedItems (JOINT *aStart, int aKindMask=ITEM::ANY_T)
const ITEM_SET	ConnectedItems (ITEM *aStart, int aKindMask=ITEM::ANY_T)
int64_t	ShortestConnectionLength (ITEM *aFrom, ITEM *aTo)
const ITEM_SET	AssembleTrivialPath (ITEM *aStart, std::pair< JOINT *, JOINT * > *aTerminalJoints=nullptr, bool aFollowLockedSegments=false)
	Assemble a trivial path between two joints given a starting item. More...
const ITEM_SET	AssembleTuningPath (ITEM *aStart, SOLID **aStartPad=nullptr, SOLID **aEndPad=nullptr)
	Like AssembleTrivialPath, but follows the track length algorithm, which discards segments that are fully inside pads, and truncates segments that cross into a pad (adding a straight- line segment from the intersection to the pad anchor). More...
const DIFF_PAIR	AssembleDiffPair (SEGMENT *aStart)
bool	AssembleDiffPair (ITEM *aStart, DIFF_PAIR &aPair)
const std::set< ITEM * >	AssembleCluster (ITEM *aStart, int aLayer)

Private Member Functions
bool	followTrivialPath (LINE *aLine, bool aLeft, ITEM_SET &aSet, std::set< ITEM * > &aVisited, JOINT **aTerminalJoint=nullptr)

Private Attributes
const int	DP_PARALLELITY_THRESHOLD = 5
NODE *	m_world

Detailed Description

Definition at line 39 of file pns_topology.h.

Member Typedef Documentation

JOINT_SET

typedef std::set<JOINT*> PNS::TOPOLOGY::JOINT_SET

Definition at line 42 of file pns_topology.h.

Constructor & Destructor Documentation

TOPOLOGY()

PNS::TOPOLOGY::TOPOLOGY ( NODE *  aNode )

inline

Definition at line 44 of file pns_topology.h.

 :
 m_world( aNode ) {};

~TOPOLOGY()

PNS::TOPOLOGY::~TOPOLOGY ( )

inline

Definition at line 47 of file pns_topology.h.

{};

Member Function Documentation

AssembleCluster()

const std::set< ITEM * > PNS::TOPOLOGY::AssembleCluster	(	ITEM *	aStart,
		int	aLayer
	)

Definition at line 533 of file pns_topology.cpp.

{
 std::set<ITEM*> visited;
 std::deque<ITEM*> pending;
 
 pending.push_back( aStart );
 
 while( !pending.empty() )
 {
 NODE::OBSTACLES obstacles;
 ITEM* top = pending.front();
 
 pending.pop_front();
 
 visited.insert( top );
 
 m_world->QueryColliding( top, obstacles, ITEM::ANY_T, -1, false, 0 ); // only query touching objects
 
 for( OBSTACLE& obs : obstacles )
 {
 bool trackOnTrack = ( obs.m_item->Net() != top->Net() ) && obs.m_item->OfKind( ITEM::SEGMENT_T ) && top->OfKind( ITEM::SEGMENT_T );
 
 if( trackOnTrack )
 continue;
 
 if( visited.find( obs.m_item ) == visited.end() &&
 obs.m_item->Layers().Overlaps( aLayer ) && !( obs.m_item->Marker() & MK_HEAD ) )
 {
 visited.insert( obs.m_item );
 pending.push_back( obs.m_item );
 }
 }
 }
 
 return visited;
}

References PNS::ITEM::ANY_T, m_world, PNS::MK_HEAD, PNS::ITEM::Net(), PNS::ITEM::OfKind(), PNS::NODE::QueryColliding(), and PNS::ITEM::SEGMENT_T.

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

AssembleDiffPair() [1/2]

bool PNS::TOPOLOGY::AssembleDiffPair	(	ITEM *	aStart,
		DIFF_PAIR &	aPair
	)

Definition at line 459 of file pns_topology.cpp.

{
 int refNet = aStart->Net();
 int coupledNet = m_world->GetRuleResolver()->DpCoupledNet( refNet );
 
 if( coupledNet < 0 )
 return false;
 
 std::set<ITEM*> coupledItems;
 
 m_world->AllItemsInNet( coupledNet, coupledItems );
 
 SEGMENT* coupledSeg = nullptr, *refSeg;
 int minDist = std::numeric_limits<int>::max();
 
 if( ( refSeg = dyn_cast<SEGMENT*>( aStart ) ) != nullptr )
 {
 for( ITEM* item : coupledItems )
 {
 if( SEGMENT* s = dyn_cast<SEGMENT*>( item ) )
 {
 if( s->Layers().Start() == refSeg->Layers().Start() &&
 s->Width() == refSeg->Width() )
 {
 int dist = s->Seg().Distance( refSeg->Seg() );
 bool isParallel = refSeg->Seg().ApproxParallel( s->Seg(), DP_PARALLELITY_THRESHOLD );
 SEG p_clip, n_clip;
 
 bool isCoupled = commonParallelProjection( refSeg->Seg(), s->Seg(), p_clip,
 n_clip );
 
 if( isParallel && isCoupled && dist < minDist )
 {
 minDist = dist;
 coupledSeg = s;
 }
 }
 }
 }
 }
 else
 {
 return false;
 }
 
 if( !coupledSeg )
 return false;
 
 LINE lp = m_world->AssembleLine( refSeg );
 LINE ln = m_world->AssembleLine( coupledSeg );
 
 if( m_world->GetRuleResolver()->DpNetPolarity( refNet ) < 0 )
 {
 std::swap( lp, ln );
 }
 
 int gap = -1;
 
 if( refSeg->Seg().ApproxParallel( coupledSeg->Seg(), DP_PARALLELITY_THRESHOLD ) )
 {
 // Segments are parallel -> compute pair gap
 const VECTOR2I refDir = refSeg->Anchor( 1 ) - refSeg->Anchor( 0 );
 const VECTOR2I displacement = refSeg->Anchor( 1 ) - coupledSeg->Anchor( 1 );
 gap = (int) std::abs( refDir.Cross( displacement ) / refDir.EuclideanNorm() ) - lp.Width();
 }
 
 aPair = DIFF_PAIR( lp, ln );
 aPair.SetWidth( lp.Width() );
 aPair.SetLayers( lp.Layers() );
 aPair.SetGap( gap );
 
 return true;
}

References std::abs(), PNS::NODE::AllItemsInNet(), PNS::SEGMENT::Anchor(), PNS::NODE::AssembleLine(), PNS::commonParallelProjection(), VECTOR2< T >::Cross(), DP_PARALLELITY_THRESHOLD, PNS::RULE_RESOLVER::DpCoupledNet(), PNS::RULE_RESOLVER::DpNetPolarity(), VECTOR2< T >::EuclideanNorm(), PNS::NODE::GetRuleResolver(), PNS::ITEM::Layers(), m_world, PNS::ITEM::Net(), PNS::SEGMENT::Seg(), PNS::DIFF_PAIR::SetGap(), PNS::ITEM::SetLayers(), PNS::DIFF_PAIR::SetWidth(), and PNS::LINE::Width().

AssembleDiffPair() [2/2]

const DIFF_PAIR PNS::TOPOLOGY::AssembleDiffPair

(

SEGMENT *

aStart

)

Referenced by PNS::DP_MEANDER_PLACER::Start(), and PNS::MEANDER_SKEW_PLACER::Start().

AssembleTrivialPath()

const ITEM_SET PNS::TOPOLOGY::AssembleTrivialPath	(	ITEM *	aStart,
		std::pair< JOINT *, JOINT * > *	aTerminalJoints = nullptr,
		bool	aFollowLockedSegments = false
	)

Assemble a trivial path between two joints given a starting item.

Parameters

aStart	is the item to assemble from.
aTerminalJoints	will be filled with the start and end points of the assembled path.
aFollowLockedSegments	if true will assemble a path including locked segments

Returns

a set of items in the path.

Definition at line 265 of file pns_topology.cpp.

{
 ITEM_SET path;
 std::set<ITEM*> visited;
 LINKED_ITEM* seg = nullptr;
 
 if( aStart->Kind() == ITEM::VIA_T )
 {
 VIA* via = static_cast<VIA*>( aStart );
 JOINT* jt = m_world->FindJoint( via->Pos(), via );
 
 if( !jt->IsNonFanoutVia() )
 return ITEM_SET();
 
 for( const ITEM_SET::ENTRY& entry : jt->Links().Items() )
 {
 if( entry.item->OfKind( ITEM::SEGMENT_T | ITEM::ARC_T ) )
 {
 seg = static_cast<LINKED_ITEM*>( entry.item );
 break;
 }
 }
 }
 else if( aStart->OfKind( ITEM::SEGMENT_T | ITEM::ARC_T ) )
 {
 seg = static_cast<LINKED_ITEM*>( aStart );
 }
 
 if( !seg )
 return ITEM_SET();
 
 // Assemble a line following through locked segments
 // TODO: consider if we want to allow tuning lines with different widths in the future
 LINE l = m_world->AssembleLine( seg, nullptr, false, true );
 
 path.Add( l );
 
 JOINT* jointA = nullptr;
 JOINT* jointB = nullptr;
 
 followTrivialPath( &l, false, path, visited, &jointB );
 followTrivialPath( &l, true, path, visited, &jointA );
 
 if( aTerminalJoints )
 {
 wxASSERT( jointA && jointB );
 *aTerminalJoints = std::make_pair( jointA, jointB );
 }
 
 return path;
}

References PNS::ITEM::ARC_T, PNS::NODE::AssembleLine(), PNS::NODE::FindJoint(), followTrivialPath(), PNS::JOINT::IsNonFanoutVia(), PNS::ITEM_SET::Items(), PNS::ITEM::Kind(), PNS::JOINT::Links(), m_world, PNS::ITEM::OfKind(), path, PNS::ITEM::SEGMENT_T, via, and PNS::ITEM::VIA_T.

Referenced by AssembleTuningPath(), and PNS::MEANDER_SKEW_PLACER::Start().

AssembleTuningPath()

const ITEM_SET PNS::TOPOLOGY::AssembleTuningPath	(	ITEM *	aStart,
		SOLID **	aStartPad = nullptr,
		SOLID **	aEndPad = nullptr
	)

Like AssembleTrivialPath, but follows the track length algorithm, which discards segments that are fully inside pads, and truncates segments that cross into a pad (adding a straight- line segment from the intersection to the pad anchor).

Note

When changing this, sync with BOARD::GetTrackLength()

Parameters

aStart	is the item to assemble a path from.
aStartPad	will be filled with the starting pad of the path, if found.
aEndPad	will be filled with the ending pad of the path, if found.

Returns

an item set containing all the items in the path.

Definition at line 320 of file pns_topology.cpp.

{
 std::pair<JOINT*, JOINT*> joints;
 ITEM_SET initialPath = AssembleTrivialPath( aStart, &joints, true );
 
 PAD* padA = nullptr;
 PAD* padB = nullptr;
 
 auto getPadFromJoint =
 []( JOINT* aJoint, PAD** aTargetPad, SOLID** aTargetSolid )
 {
 for( ITEM* item : aJoint->LinkList() )
 {
 if( item->OfKind( ITEM::SOLID_T ) )
 {
 BOARD_ITEM* bi = static_cast<SOLID*>( item )->Parent();
 
 if( bi->Type() == PCB_PAD_T )
 {
 *aTargetPad = static_cast<PAD*>( bi );
 
 if( aTargetSolid )
 *aTargetSolid = static_cast<SOLID*>( item );
 }
 
 break;
 }
 }
 };
 
 if( joints.first )
 getPadFromJoint( joints.first, &padA, aStartPad );
 
 if( joints.second )
 getPadFromJoint( joints.second, &padB, aEndPad );
 
 if( !padA && !padB )
 return initialPath;
 
 auto clipLineToPad =
 []( SHAPE_LINE_CHAIN& aLine, PAD* aPad, bool aForward = true )
 {
 const std::shared_ptr<SHAPE_POLY_SET>& shape = aPad->GetEffectivePolygon();
 
  int start = aForward ? 0 : aLine.PointCount() - 1;
 int delta = aForward ? 1 : -1;
 
 // Skip the "first" (or last) vertex, we already know it's contained in the pad
 int clip = start;
 
 for( int vertex = start + delta;
 aForward ? vertex < aLine.PointCount() : vertex >= 0;
 vertex += delta )
 {
 SEG seg( aLine.GetPoint( vertex ), aLine.GetPoint( vertex - delta ) );
 
 bool containsA = shape->Contains( seg.A );
 bool containsB = shape->Contains( seg.B );
 
 if( containsA && containsB )
 {
 // Whole segment is inside: clip out this segment
 clip = vertex;
 }
 else if( containsB )
 {
 // Only one point inside: Find the intersection
 VECTOR2I loc;
 
 if( shape->Collide( seg, 0, nullptr, &loc ) )
 {
 aLine.Replace( vertex - delta, vertex - delta, loc );
 }
 }
 }
 
 if( !aForward && clip < start )
 aLine.Remove( clip + 1, start );
 else if( clip > start )
 aLine.Remove( start, clip - 1 );
 
 // Now connect the dots
 aLine.Insert( aForward ? 0 : aLine.PointCount(), aPad->GetPosition() );
 };
 
 auto processPad =
 [&]( JOINT* aJoint, PAD* aPad )
 {
 const std::shared_ptr<SHAPE_POLY_SET>& shape = aPad->GetEffectivePolygon();
 
 for( int idx = 0; idx < initialPath.Size(); idx++ )
 {
 if( initialPath[idx]->Kind() != ITEM::LINE_T )
 continue;
 
 LINE* line = static_cast<LINE*>( initialPath[idx] );
 
 if( !aPad->FlashLayer( line->Layer() ) )
 continue;
 
 const std::vector<VECTOR2I>& points = line->CLine().CPoints();
 
 if( points.front() != aJoint->Pos() && points.back() != aJoint->Pos() )
 continue;
 
 SHAPE_LINE_CHAIN& slc = line->Line();
 
 if( shape->Contains( slc.CPoint( 0 ) ) )
 clipLineToPad( slc, aPad, true );
 else if( shape->Contains( slc.CPoint( -1 ) ) )
 clipLineToPad( slc, aPad, false );
 }
 };
 
 if( padA )
 processPad( joints.first, padA );
 
 if( padB )
 processPad( joints.second, padB );
 
 return initialPath;
}

References SEG::A, AssembleTrivialPath(), SEG::B, PNS::LINE::CLine(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::CPoints(), delta, SHAPE_LINE_CHAIN::GetPoint(), SHAPE_LINE_CHAIN::Insert(), PNS::ITEM::Layer(), PNS::LINE::Line(), PNS::ITEM::LINE_T, PNS::JOINT::LinkList(), PCB_PAD_T, SHAPE_LINE_CHAIN::PointCount(), PNS::JOINT::Pos(), SHAPE_LINE_CHAIN::Remove(), SHAPE_LINE_CHAIN::Replace(), PNS::ITEM_SET::Size(), PNS::ITEM::SOLID_T, and EDA_ITEM::Type().

Referenced by PNS::DP_MEANDER_PLACER::Start(), PNS::MEANDER_PLACER::Start(), and PNS::MEANDER_SKEW_PLACER::Start().

ConnectedItems() [1/2]

const ITEM_SET PNS::TOPOLOGY::ConnectedItems	(	ITEM *	aStart,
		int	aKindMask = ITEM::ANY_T
	)

Definition at line 450 of file pns_topology.cpp.

{
 return ITEM_SET();
}

ConnectedItems() [2/2]

const ITEM_SET PNS::TOPOLOGY::ConnectedItems	(	JOINT *	aStart,
		int	aKindMask = ITEM::ANY_T
	)

Definition at line 444 of file pns_topology.cpp.

{
 return ITEM_SET();
}

ConnectedJoints()

const TOPOLOGY::JOINT_SET PNS::TOPOLOGY::ConnectedJoints

(

JOINT *

aStart

)

Definition at line 62 of file pns_topology.cpp.

{
 std::deque<JOINT*> searchQueue;
 JOINT_SET processed;
 
 searchQueue.push_back( aStart );
 processed.insert( aStart );
 
 while( !searchQueue.empty() )
 {
 JOINT* current = searchQueue.front();
 searchQueue.pop_front();
 
 for( ITEM* item : current->LinkList() )
 {
 if( item->OfKind( ITEM::SEGMENT_T | ITEM::ARC_T ) )
 {
 JOINT* a = m_world->FindJoint( item->Anchor( 0 ), item );;
 JOINT* b = m_world->FindJoint( item->Anchor( 1 ), item );;
 JOINT* next = ( *a == *current ) ? b : a;
 
 if( processed.find( next ) == processed.end() )
 {
 processed.insert( next );
 searchQueue.push_back( next );
 }
 }
 }
 }
 
 return processed;
}

References PNS::ITEM::ARC_T, PNS::NODE::FindJoint(), PNS::JOINT::LinkList(), m_world, next(), and PNS::ITEM::SEGMENT_T.

Referenced by NearestUnconnectedItem().

followTrivialPath()

bool PNS::TOPOLOGY::followTrivialPath ( LINE *  aLine, bool  aLeft, ITEM_SET &  aSet, std::set< ITEM * > &  aVisited, JOINT **  aTerminalJoint = nullptr  )

private

Definition at line 197 of file pns_topology.cpp.

{
 assert( aLine->IsLinked() );
 
 VECTOR2I anchor = aLeft ? aLine->CPoint( 0 ) : aLine->CPoint( -1 );
 LINKED_ITEM* last = aLeft ? aLine->Links().front() : aLine->Links().back();
 JOINT* jt = m_world->FindJoint( anchor, aLine );
 
 assert( jt != nullptr );
 
 aVisited.insert( last );
 
 if( jt->IsNonFanoutVia() || jt->IsTraceWidthChange() )
 {
 ITEM* via = nullptr;
 SEGMENT* next_seg = nullptr;
 
 for( ITEM* link : jt->Links().Items() )
 {
 if( link->OfKind( ITEM::VIA_T ) )
 via = link;
 else if( aVisited.find( link ) == aVisited.end() )
 next_seg = static_cast<SEGMENT*>( link );
 }
 
 if( !next_seg )
 {
 if( aTerminalJoint )
 *aTerminalJoint = jt;
 
 return false;
 }
 
 LINE l = m_world->AssembleLine( next_seg );
 
 VECTOR2I nextAnchor = ( aLeft ? l.CLine().CPoint( -1 ) : l.CLine().CPoint( 0 ) );
 
 if( nextAnchor != anchor )
 {
 l.Reverse();
 }
 
 if( aLeft )
 {
 if( via )
 aSet.Prepend( via );
 
 aSet.Prepend( l );
 }
 else
 {
 if( via )
 aSet.Add( via );
 
 aSet.Add( l );
 }
 
 return followTrivialPath( &l, aLeft, aSet, aVisited, aTerminalJoint );
 }
 
 if( aTerminalJoint )
 *aTerminalJoint = jt;
 
 return false;
}

References PNS::ITEM_SET::Add(), anchor, PNS::NODE::AssembleLine(), PNS::LINE::CLine(), PNS::LINE::CPoint(), SHAPE_LINE_CHAIN::CPoint(), PNS::NODE::FindJoint(), followTrivialPath(), PNS::LINK_HOLDER::IsLinked(), PNS::JOINT::IsNonFanoutVia(), PNS::JOINT::IsTraceWidthChange(), PNS::ITEM_SET::Items(), PNS::JOINT::Links(), PNS::LINK_HOLDER::Links(), m_world, PNS::ITEM_SET::Prepend(), PNS::LINE::Reverse(), via, and PNS::ITEM::VIA_T.

Referenced by AssembleTrivialPath(), and followTrivialPath().

LeadingRatLine()

bool PNS::TOPOLOGY::LeadingRatLine	(	const LINE *	aTrack,
		SHAPE_LINE_CHAIN &	aRatLine
	)

Definition at line 138 of file pns_topology.cpp.

{
 VECTOR2I end;
 // Ratline doesn't care about the layer
 LAYER_RANGE layers;
 
 if( !NearestUnconnectedAnchorPoint( aTrack, end, layers ) )
 return false;
 
 aRatLine.Clear();
 aRatLine.Append( aTrack->CPoint( -1 ) );
 aRatLine.Append( end );
 return true;
}

References SHAPE_LINE_CHAIN::Append(), SHAPE_LINE_CHAIN::Clear(), PNS::LINE::CPoint(), and NearestUnconnectedAnchorPoint().

Referenced by PNS::DIFF_PAIR_PLACER::updateLeadingRatLine(), and PNS::LINE_PLACER::updateLeadingRatLine().

NearestUnconnectedAnchorPoint()

bool PNS::TOPOLOGY::NearestUnconnectedAnchorPoint	(	const LINE *	aTrack,
		VECTOR2I &	aPoint,
		LAYER_RANGE &	aLayers
	)

Definition at line 96 of file pns_topology.cpp.

{
 LINE track( *aTrack );
 VECTOR2I end;
 
 if( !track.PointCount() )
 return false;
 
 std::unique_ptr<NODE> tmpNode( m_world->Branch() );
 tmpNode->Add( track );
 
 JOINT* jt = tmpNode->FindJoint( track.CPoint( -1 ), &track );
 
 if( !jt || jt->Net() <= 0 )
 return false;
 
 if( ( !track.EndsWithVia() && jt->LinkCount() >= 2 )
 || ( track.EndsWithVia() && jt->LinkCount() >= 3 ) ) // we got something connected
 {
 end = jt->Pos();
 aLayers = jt->Layers();
 }
 else
 {
 int anchor;
 
 TOPOLOGY topo( tmpNode.get() );
 ITEM* it = topo.NearestUnconnectedItem( jt, &anchor );
 
 if( !it )
 return false;
 
 end = it->Anchor( anchor );
 aLayers = it->Layers();
 }
 
 aPoint = end;
 return true;
}

References anchor, PNS::ITEM::Anchor(), PNS::NODE::Branch(), PNS::LINE::CPoint(), PNS::LINE::EndsWithVia(), PNS::ITEM::Layers(), PNS::JOINT::LinkCount(), m_world, NearestUnconnectedItem(), PNS::JOINT::Net(), PNS::LINE::PointCount(), and PNS::JOINT::Pos().

Referenced by PNS::ROUTER::getNearestRatnestAnchor(), and LeadingRatLine().

NearestUnconnectedItem()

ITEM * PNS::TOPOLOGY::NearestUnconnectedItem	(	JOINT *	aStart,
		int *	aAnchor = nullptr,
		int	aKindMask = ITEM::ANY_T
	)

Definition at line 154 of file pns_topology.cpp.

{
 std::set<ITEM*> disconnected;
 
 m_world->AllItemsInNet( aStart->Net(), disconnected );
 
 for( const JOINT* jt : ConnectedJoints( aStart ) )
 {
 for( ITEM* link : jt->LinkList() )
 {
 if( disconnected.find( link ) != disconnected.end() )
 disconnected.erase( link );
 }
 }
 
 int best_dist = INT_MAX;
 ITEM* best = nullptr;
 
 for( ITEM* item : disconnected )
 {
 if( item->OfKind( aKindMask ) )
 {
 for( int i = 0; i < item->AnchorCount(); i++ )
 {
 VECTOR2I p = item->Anchor( i );
 int d = ( p - aStart->Pos() ).EuclideanNorm();
 
 if( d < best_dist )
 {
 best_dist = d;
 best = item;
 
 if( aAnchor )
 *aAnchor = i;
 }
 }
 }
 }
 
 return best;
}

References PNS::NODE::AllItemsInNet(), ConnectedJoints(), EuclideanNorm(), m_world, PNS::JOINT::Net(), and PNS::JOINT::Pos().

Referenced by PNS::ROUTER::getNearestRatnestAnchor(), and NearestUnconnectedAnchorPoint().

ShortestConnectionLength()

int64_t PNS::TOPOLOGY::ShortestConnectionLength	(	ITEM *	aFrom,
		ITEM *	aTo
	)

SimplifyLine()

bool PNS::TOPOLOGY::SimplifyLine

(

LINE *

aLine

)

Definition at line 38 of file pns_topology.cpp.

{
 if( !aLine->IsLinked() || !aLine->SegmentCount() )
 return false;
 
 LINKED_ITEM* root = aLine->GetLink( 0 );
 LINE l = m_world->AssembleLine( root );
 SHAPE_LINE_CHAIN simplified( l.CLine() );
 
 simplified.Simplify();
 
 if( simplified.PointCount() != l.PointCount() )
 {
  m_world->Remove( l );
 LINE lnew( l );
 lnew.SetShape( simplified );
 m_world->Add( lnew );
 return true;
 }
 
 return false;
}

References PNS::NODE::Add(), PNS::NODE::AssembleLine(), PNS::LINE::CLine(), PNS::LINK_HOLDER::GetLink(), PNS::LINK_HOLDER::IsLinked(), m_world, SHAPE_LINE_CHAIN::PointCount(), PNS::LINE::PointCount(), PNS::NODE::Remove(), PNS::LINE::SegmentCount(), PNS::LINE::SetShape(), and SHAPE_LINE_CHAIN::Simplify().

Referenced by PNS::DIFF_PAIR_PLACER::FixRoute().

Member Data Documentation

DP_PARALLELITY_THRESHOLD

const int PNS::TOPOLOGY::DP_PARALLELITY_THRESHOLD = 5

private

Definition at line 96 of file pns_topology.h.

Referenced by AssembleDiffPair().

m_world

NODE* PNS::TOPOLOGY::m_world

private

Definition at line 101 of file pns_topology.h.

Referenced by AssembleCluster(), AssembleDiffPair(), AssembleTrivialPath(), ConnectedJoints(), followTrivialPath(), NearestUnconnectedAnchorPoint(), NearestUnconnectedItem(), and SimplifyLine().

---

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

• pns_topology.h
• pns_topology.cpp