KiCad PCB EDA Suite
PNS::DIFF_PAIR_PLACER Class Reference

Single track placement algorithm. More...

#include <pns_diff_pair_placer.h>

Inheritance diagram for PNS::DIFF_PAIR_PLACER:
PNS::PLACEMENT_ALGO PNS::ALGO_BASE

Public Member Functions

 DIFF_PAIR_PLACER (ROUTER *aRouter)
 
 ~DIFF_PAIR_PLACER ()
 
bool Start (const VECTOR2I &aP, ITEM *aStartItem) override
 Start routing a single track at point aP, taking item aStartItem as anchor (unless NULL). More...
 
bool Move (const VECTOR2I &aP, ITEM *aEndItem) override
 Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL). More...
 
bool FixRoute (const VECTOR2I &aP, ITEM *aEndItem, bool aForceFinish) override
 Commit the currently routed track to the parent node, taking aP as the final end point and aEndItem as the final anchor (if provided). More...
 
bool CommitPlacement () override
 
bool AbortPlacement () override
 
bool HasPlacedAnything () const override
 
bool ToggleVia (bool aEnabled) override
 Enable/disable a via at the end of currently routed trace. More...
 
bool SetLayer (int aLayer) override
 Set the current routing layer. More...
 
const ITEM_SET Traces () override
 Return the complete routed line, as a single-member ITEM_SET. More...
 
const VECTOR2ICurrentEnd () const override
 Return the current end of the line being placed. More...
 
const std::vector< int > CurrentNets () const override
 Return the net code of currently routed track. More...
 
int CurrentLayer () const override
 Return the layer of currently routed track. More...
 
NODECurrentNode (bool aLoopsRemoved=false) const override
 Return the most recent world state. More...
 
void FlipPosture () override
 Toggle the current posture (straight/diagonal) of the trace head. More...
 
void UpdateSizes (const SIZES_SETTINGS &aSizes) override
 Perform on-the-fly update of the width, via diameter & drill size from a settings class. More...
 
bool IsPlacingVia () const override
 Function IsPlacingVia() More...
 
void SetOrthoMode (bool aOrthoMode) override
 Function SetOrthoMode() More...
 
void GetModifiedNets (std::vector< int > &aNets) const override
 Function GetModifiedNets. More...
 
virtual bool UnfixRoute ()
 
ROUTERRouter () const
 Return current router settings. More...
 
ROUTING_SETTINGSSettings () const
 Return the logger object, allowing to dump geometry to a file. More...
 
virtual LOGGERLogger ()
 
void SetLogger (LOGGER *aLogger)
 
void SetDebugDecorator (DEBUG_DECORATOR *aDecorator)
 Assign a debug decorator allowing this algo to draw extra graphics for visual debugging. More...
 
DEBUG_DECORATORDbg () const
 
const BOX2IVisibleViewArea () const
 

Static Public Member Functions

static bool FindDpPrimitivePair (NODE *aWorld, const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
 

Protected Attributes

DEBUG_DECORATORm_debugDecorator
 
ROUTERm_router
 
LOGGERm_logger
 

Private Types

enum  State { RT_START = 0, RT_ROUTE = 1, RT_FINISH = 2 }
 

Private Member Functions

int viaGap () const
 
int gap () const
 
bool route (const VECTOR2I &aP)
 Re-route the current track to point aP. More...
 
void updateLeadingRatLine ()
 Draw the "leading" ratsnest line, which connects the end of currently routed track and the nearest yet unrouted item. More...
 
void setWorld (NODE *aWorld)
 Set the board to route. More...
 
void initPlacement ()
 Initialize placement of a new line with given parameters. More...
 
void setInitialDirection (const DIRECTION_45 &aDirection)
 Set preferred direction of the very first track segment to be laid. More...
 
bool routeHead (const VECTOR2I &aP)
 
bool tryWalkDp (NODE *aNode, DIFF_PAIR &aPair, bool aSolidsOnly)
 route step, walk around mode More...
 
bool rhWalkOnly (const VECTOR2I &aP)
 route step, shove mode More...
 
bool rhShoveOnly (const VECTOR2I &aP)
 route step, mark obstacles mode More...
 
bool rhMarkObstacles (const VECTOR2I &aP)
 
const VIA makeVia (const VECTOR2I &aP, int aNet)
 
bool attemptWalk (NODE *aNode, DIFF_PAIR *aCurrent, DIFF_PAIR &aWalk, bool aPFirst, bool aWindCw, bool aSolidsOnly)
 
bool propagateDpHeadForces (const VECTOR2I &aP, VECTOR2I &aNewP)
 

Private Attributes

State m_state
 
bool m_chainedPlacement
 
bool m_initialDiagonal
 
bool m_startDiagonal
 
bool m_fitOk
 
int m_netP
 
int m_netN
 
DP_PRIMITIVE_PAIR m_start
 
OPT< DP_PRIMITIVE_PAIRm_prevPair
 current algorithm iteration More...
 
int m_iteration
 pointer to world to search colliding items More...
 
NODEm_world
 current routing start point (end of tail, beginning of head) More...
 
VECTOR2I m_p_start
 The shove engine. More...
 
SHOVEm_shove
 Current world state. More...
 
NODEm_currentNode
 Postprocessed world state (including marked collisions & removed loops) More...
 
NODEm_lastNode
 
SIZES_SETTINGS m_sizes
 Are we placing a via? More...
 
bool m_placingVia
 current via diameter More...
 
int m_viaDiameter
 current via drill More...
 
int m_viaDrill
 current track width More...
 
int m_currentWidth
 
int m_currentNet
 
int m_currentLayer
 
bool m_startsOnVia
 
bool m_orthoMode
 
bool m_snapOnTarget
 
VECTOR2I m_currentEnd
 
VECTOR2I m_currentStart
 
DIFF_PAIR m_currentTrace
 
ITEMm_currentEndItem
 
PNS_MODE m_currentMode
 
bool m_idle
 

Detailed Description

Single track placement algorithm.

Interactively routes a track and applies shove and walk around algorithms when needed.

Definition at line 55 of file pns_diff_pair_placer.h.

Member Enumeration Documentation

◆ State

Enumerator
RT_START 
RT_ROUTE 
RT_FINISH 

Definition at line 212 of file pns_diff_pair_placer.h.

Constructor & Destructor Documentation

◆ DIFF_PAIR_PLACER()

PNS::DIFF_PAIR_PLACER::DIFF_PAIR_PLACER ( ROUTER aRouter)

Definition at line 38 of file pns_diff_pair_placer.cpp.

38  :
39  PLACEMENT_ALGO( aRouter )
40 {
41  m_state = RT_START;
42  m_chainedPlacement = false;
43  m_initialDiagonal = false;
44  m_startDiagonal = false;
45  m_fitOk = false;
46  m_netP = 0;
47  m_netN = 0;
48  m_iteration = 0;
49  m_world = NULL;
50  m_shove = NULL;
52  m_lastNode = NULL;
53  m_placingVia = false;
54  m_viaDiameter = 0;
55  m_viaDrill = 0;
56  m_currentWidth = 0;
57  m_currentNet = 0;
58  m_currentLayer = 0;
59  m_startsOnVia = false;
60  m_orthoMode = false;
61  m_snapOnTarget = false;
64  m_idle = true;
65 }
int m_iteration
pointer to world to search colliding items
SHOVE * m_shove
Current world state.
int m_viaDiameter
current via drill
NODE * m_world
current routing start point (end of tail, beginning of head)
int m_viaDrill
current track width
#define NULL
bool m_placingVia
current via diameter
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
Ignore collisions, mark obstacles.
PLACEMENT_ALGO(ROUTER *aRouter)

References m_chainedPlacement, m_currentEndItem, m_currentLayer, m_currentMode, m_currentNet, m_currentNode, m_currentWidth, m_fitOk, m_idle, m_initialDiagonal, m_iteration, m_lastNode, m_netN, m_netP, m_orthoMode, m_placingVia, m_shove, m_snapOnTarget, m_startDiagonal, m_startsOnVia, m_state, m_viaDiameter, m_viaDrill, m_world, NULL, PNS::RM_MarkObstacles, and RT_START.

◆ ~DIFF_PAIR_PLACER()

PNS::DIFF_PAIR_PLACER::~DIFF_PAIR_PLACER ( )

Definition at line 67 of file pns_diff_pair_placer.cpp.

68 {
69  if( m_shove )
70  delete m_shove;
71 }
SHOVE * m_shove
Current world state.

References m_shove.

Member Function Documentation

◆ AbortPlacement()

bool PNS::DIFF_PAIR_PLACER::AbortPlacement ( )
overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 786 of file pns_diff_pair_placer.cpp.

787 {
789  return true;
790 }
NODE * m_world
current routing start point (end of tail, beginning of head)
void KillChildren()
Definition: pns_node.cpp:1292

References PNS::NODE::KillChildren(), and m_world.

◆ attemptWalk()

bool PNS::DIFF_PAIR_PLACER::attemptWalk ( NODE aNode,
DIFF_PAIR aCurrent,
DIFF_PAIR aWalk,
bool  aPFirst,
bool  aWindCw,
bool  aSolidsOnly 
)
private

Definition at line 161 of file pns_diff_pair_placer.cpp.

163 {
164  WALKAROUND walkaround( aNode, Router() );
166 
167  walkaround.SetSolidsOnly( aSolidsOnly );
168  walkaround.SetIterationLimit( Settings().WalkaroundIterationLimit() );
169 
170  SHOVE shove( aNode, Router() );
171  LINE walkP, walkN;
172 
173  aWalk = *aCurrent;
174 
175  int iter = 0;
176 
177  DIFF_PAIR cur( *aCurrent );
178 
179  bool currentIsP = aPFirst;
180 
181  int mask = aSolidsOnly ? ITEM::SOLID_T : ITEM::ANY_T;
182 
183  do
184  {
185  LINE preWalk = ( currentIsP ? cur.PLine() : cur.NLine() );
186  LINE preShove = ( currentIsP ? cur.NLine() : cur.PLine() );
187  LINE postWalk;
188 
189  if( !aNode->CheckColliding ( &preWalk, mask ) )
190  {
191  currentIsP = !currentIsP;
192 
193  if( !aNode->CheckColliding( &preShove, mask ) )
194  break;
195  else
196  continue;
197  }
198 
199  wf1 = walkaround.Route( preWalk, postWalk, false );
200 
201  if( wf1 != WALKAROUND::DONE )
202  return false;
203 
204  LINE postShove( preShove );
205 
206  shove.ForceClearance( true, cur.Gap() - 2 * PNS_HULL_MARGIN );
207 
209 
210  sh1 = shove.ShoveObstacleLine( postWalk, preShove, postShove );
211 
212  if( sh1 != SHOVE::SH_OK )
213  return false;
214 
215  postWalk.Line().Simplify();
216  postShove.Line().Simplify();
217 
218  cur.SetShape( postWalk.CLine(), postShove.CLine(), !currentIsP );
219 
220  currentIsP = !currentIsP;
221 
222  if( !aNode->CheckColliding( &postShove, mask ) )
223  break;
224 
225  iter++;
226  }
227  while( iter < 3 );
228 
229  if( iter == 3 )
230  return false;
231 
232  aWalk.SetShape( cur.CP(), cur.CN() );
233 
234  return true;
235 }
ROUTER * Router() const
Return current router settings.
Definition: pns_algo_base.h:54
#define PNS_HULL_MARGIN
Definition: pns_line.h:44
ROUTING_SETTINGS & Settings() const
Return the logger object, allowing to dump geometry to a file.

References PNS::ITEM::ANY_T, PNS::NODE::CheckColliding(), PNS::LINE::CLine(), PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), PNS::WALKAROUND::DONE, PNS::SHOVE::ForceClearance(), PNS::DIFF_PAIR::Gap(), PNS::LINE::Line(), PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), PNS_HULL_MARGIN, PNS::WALKAROUND::Route(), PNS::ALGO_BASE::Router(), PNS::WALKAROUND::SetIterationLimit(), PNS::DIFF_PAIR::SetShape(), PNS::WALKAROUND::SetSolidsOnly(), PNS::ALGO_BASE::Settings(), PNS::SHOVE::SH_OK, PNS::SHOVE::ShoveObstacleLine(), SHAPE_LINE_CHAIN::Simplify(), and PNS::ITEM::SOLID_T.

Referenced by tryWalkDp().

◆ CommitPlacement()

bool PNS::DIFF_PAIR_PLACER::CommitPlacement ( )
overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 800 of file pns_diff_pair_placer.cpp.

801 {
802  if( m_lastNode )
804 
805  m_lastNode = NULL;
807  return true;
808 }
ROUTER * Router() const
Return current router settings.
Definition: pns_algo_base.h:54
void CommitRouting()
Definition: pns_router.cpp:655
#define NULL
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)

References PNS::ROUTER::CommitRouting(), m_currentNode, m_lastNode, NULL, and PNS::ALGO_BASE::Router().

Referenced by FixRoute().

◆ CurrentEnd()

const VECTOR2I& PNS::DIFF_PAIR_PLACER::CurrentEnd ( ) const
inlineoverridevirtual

Return the current end of the line being placed.

It may not be equal to the cursor position due to collisions.

Implements PNS::PLACEMENT_ALGO.

Definition at line 113 of file pns_diff_pair_placer.h.

114  {
115  return m_currentEnd;
116  }

References m_currentEnd.

◆ CurrentLayer()

int PNS::DIFF_PAIR_PLACER::CurrentLayer ( ) const
inlineoverridevirtual

Return the layer of currently routed track.

Implements PNS::PLACEMENT_ALGO.

Definition at line 126 of file pns_diff_pair_placer.h.

127  {
128  return m_currentLayer;
129  }

References m_currentLayer.

◆ CurrentNets()

const std::vector< int > PNS::DIFF_PAIR_PLACER::CurrentNets ( ) const
overridevirtual

Return the net code of currently routed track.

Implements PNS::PLACEMENT_ALGO.

Definition at line 831 of file pns_diff_pair_placer.cpp.

832 {
833  std::vector<int> rv;
834  rv.push_back( m_netP );
835  rv.push_back( m_netN );
836  return rv;
837 }

References m_netN, and m_netP.

◆ CurrentNode()

NODE * PNS::DIFF_PAIR_PLACER::CurrentNode ( bool  aLoopsRemoved = false) const
overridevirtual

Return the most recent world state.

Implements PNS::PLACEMENT_ALGO.

Definition at line 372 of file pns_diff_pair_placer.cpp.

373 {
374  if( m_lastNode )
375  return m_lastNode;
376 
377  return m_currentNode;
378 }
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)

References m_currentNode, and m_lastNode.

◆ Dbg()

◆ FindDpPrimitivePair()

bool PNS::DIFF_PAIR_PLACER::FindDpPrimitivePair ( NODE aWorld,
const VECTOR2I aP,
ITEM aItem,
DP_PRIMITIVE_PAIR aPair,
wxString *  aErrorMsg = nullptr 
)
static

Definition at line 437 of file pns_diff_pair_placer.cpp.

439 {
440  int netP, netN;
441 
442  wxLogTrace( "PNS", "world %p", aWorld );
443 
444  bool result = aWorld->GetRuleResolver()->DpNetPair( aItem, netP, netN );
445 
446  if( !result )
447  {
448  if( aErrorMsg )
449  {
450  *aErrorMsg = _( "Unable to find complementary differential pair "
451  "nets. Make sure the names of the nets belonging "
452  "to a differential pair end with either _N/_P or +/-." );
453  }
454  return false;
455  }
456 
457  int refNet = aItem->Net();
458  int coupledNet = ( refNet == netP ) ? netN : netP;
459 
460  wxLogTrace( "PNS", "result %d", !!result );
461 
462  OPT_VECTOR2I refAnchor = getDanglingAnchor( aWorld, aItem );
463  ITEM* primRef = aItem;
464 
465  wxLogTrace( "PNS", "refAnchor %p", aItem );
466 
467  if( !refAnchor )
468  {
469  if( aErrorMsg )
470  {
471  *aErrorMsg = _( "Can't find a suitable starting point. If starting "
472  "from an existing differential pair make sure you are "
473  "at the end." );
474  }
475  return false;
476  }
477 
478  std::set<ITEM*> coupledItems;
479 
480  aWorld->AllItemsInNet( coupledNet, coupledItems );
481  double bestDist = std::numeric_limits<double>::max();
482  bool found = false;
483 
484  for( ITEM* item : coupledItems )
485  {
486  if( item->Kind() == aItem->Kind() )
487  {
488  OPT_VECTOR2I anchor = getDanglingAnchor( aWorld, item );
489  if( !anchor )
490  continue;
491 
492  double dist = ( *anchor - *refAnchor ).EuclideanNorm();
493 
494  bool shapeMatches = true;
495 
496  if( item->OfKind( ITEM::SOLID_T ) && item->Layers() != aItem->Layers() )
497  {
498  shapeMatches = false;
499  }
500 
501  if( dist < bestDist && shapeMatches )
502  {
503  found = true;
504  bestDist = dist;
505 
506  if( refNet != netP )
507  {
508  aPair = DP_PRIMITIVE_PAIR ( item, primRef );
509  aPair.SetAnchors( *anchor, *refAnchor );
510  }
511  else
512  {
513  aPair = DP_PRIMITIVE_PAIR( primRef, item );
514  aPair.SetAnchors( *refAnchor, *anchor );
515  }
516  }
517  }
518  }
519 
520  if( !found )
521  {
522  if( aErrorMsg )
523  {
524  *aErrorMsg = wxString::Format( _( "Can't find a suitable starting point "
525  "for coupled net \"%s\"." ),
526  aWorld->GetRuleResolver()->NetName( coupledNet ) );
527  }
528  return false;
529  }
530 
531  return true;
532 }
double EuclideanNorm(const wxPoint &vector)
Euclidean norm of a 2D vector.
Definition: trigo.h:148
OPT< VECTOR2I > OPT_VECTOR2I
Definition: seg.h:39
OPT_VECTOR2I getDanglingAnchor(NODE *aNode, ITEM *aItem)
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
#define _(s)
Definition: 3d_actions.cpp:33

References _, PNS::NODE::AllItemsInNet(), PNS::RULE_RESOLVER::DpNetPair(), EuclideanNorm(), Format(), PNS::getDanglingAnchor(), PNS::NODE::GetRuleResolver(), PNS::ITEM::Kind(), PNS::ITEM::Layers(), PNS::ITEM::Net(), PNS::RULE_RESOLVER::NetName(), PNS::DP_PRIMITIVE_PAIR::SetAnchors(), and PNS::ITEM::SOLID_T.

Referenced by PNS::ROUTER::isStartingPointRoutable(), routeHead(), and Start().

◆ FixRoute()

bool PNS::DIFF_PAIR_PLACER::FixRoute ( const VECTOR2I aP,
ITEM aEndItem,
bool  aForceFinish 
)
overridevirtual

Commit the currently routed track to the parent node, taking aP as the final end point and aEndItem as the final anchor (if provided).

Returns
true if route has been committed. May return false if the routing result is violating design rules. In such cases, the track is only committed if #Settings.CanViolateDRC() is on.

Implements PNS::PLACEMENT_ALGO.

Definition at line 720 of file pns_diff_pair_placer.cpp.

721 {
722  if( !m_fitOk && !Settings().CanViolateDRC() )
723  return false;
724 
725  if( m_currentTrace.CP().SegmentCount() < 1 ||
726  m_currentTrace.CN().SegmentCount() < 1 )
727  return false;
728 
729  if( m_currentTrace.CP().SegmentCount() > 1 )
730  m_initialDiagonal = !DIRECTION_45( m_currentTrace.CP().CSegment( -2 ) ).IsDiagonal();
731 
732  TOPOLOGY topo( m_lastNode );
733 
734  if( !m_snapOnTarget && !m_currentTrace.EndsWithVias() && !aForceFinish )
735  {
738 
739  if( newP.SegmentCount() > 1 && newN.SegmentCount() > 1 )
740  {
741  newP.Remove( -1, -1 );
742  newN.Remove( -1, -1 );
743  }
744 
745  m_currentTrace.SetShape( newP, newN );
746  }
747 
749  {
752  m_chainedPlacement = false;
753  }
754  else
755  {
756  m_chainedPlacement = !m_snapOnTarget && !aForceFinish;
757  }
758 
759  LINE lineP( m_currentTrace.PLine() );
760  LINE lineN( m_currentTrace.NLine() );
761 
762  m_lastNode->Add( lineP );
763  m_lastNode->Add( lineN );
764 
765  topo.SimplifyLine( &lineP );
766  topo.SimplifyLine( &lineN );
767 
769 
770  CommitPlacement();
771  m_placingVia = false;
772 
773  if( m_snapOnTarget || aForceFinish )
774  {
775  m_idle = true;
776  return true;
777  }
778  else
779  {
780  initPlacement();
781  return false;
782  }
783 }
void SetShape(const SHAPE_LINE_CHAIN &aP, const SHAPE_LINE_CHAIN &aN, bool aSwapLanes=false)
bool EndsWithVias() const
const SHAPE_LINE_CHAIN & CN() const
ROUTING_SETTINGS & Settings() const
Return the logger object, allowing to dump geometry to a file.
Represent route directions & corner angles in a 45-degree metric.
Definition: direction45.h:36
bool m_placingVia
current via diameter
void Remove(int aStartIndex, int aEndIndex)
Function Remove()
int SegmentCount() const
Function SegmentCount()
const SHAPE_LINE_CHAIN & CP() const
const SEG CSegment(int aIndex) const
Function CSegment()
std::unique_ptr< typename std::remove_const< T >::type > Clone(const T &aItem)
Definition: pns_item.h:257
SHAPE_LINE_CHAIN.
void initPlacement()
Initialize placement of a new line with given parameters.
OPT< DP_PRIMITIVE_PAIR > m_prevPair
current algorithm iteration
const VIA & Via() const
Definition: pns_line.h:196
bool Add(std::unique_ptr< SEGMENT > aSegment, bool aAllowRedundant=false)
Add an item to the current node.
Definition: pns_node.cpp:615
DP_PRIMITIVE_PAIR EndingPrimitives()

References PNS::NODE::Add(), PNS::Clone(), PNS::DIFF_PAIR::CN(), CommitPlacement(), PNS::DIFF_PAIR::CP(), SHAPE_LINE_CHAIN::CSegment(), PNS::DIFF_PAIR::EndingPrimitives(), PNS::DIFF_PAIR::EndsWithVias(), initPlacement(), m_chainedPlacement, m_currentTrace, m_fitOk, m_idle, m_initialDiagonal, m_lastNode, m_placingVia, m_prevPair, m_snapOnTarget, PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), SHAPE_LINE_CHAIN::Remove(), SHAPE_LINE_CHAIN::SegmentCount(), PNS::DIFF_PAIR::SetShape(), PNS::ALGO_BASE::Settings(), PNS::TOPOLOGY::SimplifyLine(), and PNS::LINE::Via().

◆ FlipPosture()

void PNS::DIFF_PAIR_PLACER::FlipPosture ( )
overridevirtual

Toggle the current posture (straight/diagonal) of the trace head.

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 363 of file pns_diff_pair_placer.cpp.

364 {
366 
367  if( !m_idle )
368  Move( m_currentEnd, NULL );
369 }
#define NULL
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL).

References m_currentEnd, m_idle, m_startDiagonal, Move(), and NULL.

◆ gap()

int PNS::DIFF_PAIR_PLACER::gap ( ) const
private

Definition at line 542 of file pns_diff_pair_placer.cpp.

543 {
545 }
SIZES_SETTINGS m_sizes
Are we placing a via?

References PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), and m_sizes.

Referenced by routeHead().

◆ GetModifiedNets()

void PNS::DIFF_PAIR_PLACER::GetModifiedNets ( std::vector< int > &  aNets) const
overridevirtual

Function GetModifiedNets.

Returns the net codes of all currently routed trace(s)

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 811 of file pns_diff_pair_placer.cpp.

812 {
813  aNets.push_back( m_netP );
814  aNets.push_back( m_netN );
815 }

References m_netN, and m_netP.

◆ HasPlacedAnything()

bool PNS::DIFF_PAIR_PLACER::HasPlacedAnything ( ) const
overridevirtual

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 793 of file pns_diff_pair_placer.cpp.

794 {
795  return m_currentTrace.CP().SegmentCount() > 0 ||
797 }
const SHAPE_LINE_CHAIN & CN() const
int SegmentCount() const
Function SegmentCount()
const SHAPE_LINE_CHAIN & CP() const

References PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), m_currentTrace, and SHAPE_LINE_CHAIN::SegmentCount().

◆ initPlacement()

void PNS::DIFF_PAIR_PLACER::initPlacement ( )
private

Initialize placement of a new line with given parameters.

Definition at line 572 of file pns_diff_pair_placer.cpp.

573 {
574  m_idle = false;
575  m_orthoMode = false;
578 
579  NODE* world = Router()->GetWorld();
580 
581  world->KillChildren();
582  NODE* rootNode = world->Branch();
583 
584  setWorld( rootNode );
585 
586  m_lastNode = NULL;
587  m_currentNode = rootNode;
589 
590  if( m_shove )
591  delete m_shove;
592 
593  m_shove = NULL;
594 
596  {
597  m_shove = new SHOVE( m_currentNode, Router() );
598  }
599 }
ROUTER * Router() const
Return current router settings.
Definition: pns_algo_base.h:54
SHOVE * m_shove
Current world state.
ROUTING_SETTINGS & Settings() const
Return the logger object, allowing to dump geometry to a file.
void KillChildren()
Definition: pns_node.cpp:1292
#define NULL
PNS_MODE Mode() const
Set the routing mode.
Guess what's better, try to make least mess on the PCB.
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
void setWorld(NODE *aWorld)
Set the board to route.
NODE * GetWorld() const
Definition: pns_router.h:158

References PNS::NODE::Branch(), PNS::ROUTER::GetWorld(), PNS::NODE::KillChildren(), m_currentEndItem, m_currentMode, m_currentNode, m_idle, m_initialDiagonal, m_lastNode, m_orthoMode, m_shove, m_startDiagonal, PNS::ROUTING_SETTINGS::Mode(), NULL, PNS::RM_Shove, PNS::RM_Smart, PNS::ALGO_BASE::Router(), PNS::ALGO_BASE::Settings(), and setWorld().

Referenced by FixRoute(), SetLayer(), and Start().

◆ IsPlacingVia()

bool PNS::DIFF_PAIR_PLACER::IsPlacingVia ( ) const
inlineoverridevirtual

Function IsPlacingVia()

Returns true if the placer is placing a via (or more vias).

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 148 of file pns_diff_pair_placer.h.

148 { return m_placingVia; }
bool m_placingVia
current via diameter

References m_placingVia.

◆ Logger()

LOGGER * PNS::ALGO_BASE::Logger ( )
virtualinherited

Reimplemented in PNS::SHOVE.

Definition at line 34 of file pns_algo_base.cpp.

35 {
36  return NULL;
37 }
#define NULL

References NULL.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::DRAGGER::Start(), and PNS::DRAGGER::tryWalkaround().

◆ makeVia()

const VIA PNS::DIFF_PAIR_PLACER::makeVia ( const VECTOR2I aP,
int  aNet 
)
private

Definition at line 79 of file pns_diff_pair_placer.cpp.

80 {
82 
83  VIA v( aP, layers, m_sizes.ViaDiameter(), m_sizes.ViaDrill(), -1, m_sizes.ViaType() );
84  v.SetNet( aNet );
85 
86  return v;
87 }
SIZES_SETTINGS m_sizes
Are we placing a via?
Definition: track.h:343
VIATYPE ViaType() const
void SetNet(NETINFO_ITEM *aNetInfo)
Set a NET_INFO object for the item.
Represent a contiguous set of PCB layers.
Definition: pns_layerset.h:31

References PNS::SIZES_SETTINGS::GetLayerBottom(), PNS::SIZES_SETTINGS::GetLayerTop(), m_sizes, PNS::ITEM::SetNet(), PNS::SIZES_SETTINGS::ViaDiameter(), PNS::SIZES_SETTINGS::ViaDrill(), and PNS::SIZES_SETTINGS::ViaType().

Referenced by propagateDpHeadForces(), and routeHead().

◆ Move()

bool PNS::DIFF_PAIR_PLACER::Move ( const VECTOR2I aP,
ITEM aEndItem 
)
overridevirtual

Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL).

Implements PNS::PLACEMENT_ALGO.

Definition at line 680 of file pns_diff_pair_placer.cpp.

681 {
682  m_currentEndItem = aEndItem;
683  m_fitOk = false;
684 
685  delete m_lastNode;
686  m_lastNode = NULL;
687 
688  bool retval = route( aP );
689 
690  NODE* latestNode = m_currentNode;
691  m_lastNode = latestNode->Branch();
692 
693  assert( m_lastNode != NULL );
694  m_currentEnd = aP;
695 
697 
698  return retval;
699 }
bool route(const VECTOR2I &aP)
Re-route the current track to point aP.
NODE * Branch()
Create a lightweight copy (called branch) of self that tracks the changes (added/removed items) wrs t...
Definition: pns_node.cpp:124
#define NULL
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
void updateLeadingRatLine()
Draw the "leading" ratsnest line, which connects the end of currently routed track and the nearest ye...

References PNS::NODE::Branch(), m_currentEnd, m_currentEndItem, m_currentNode, m_fitOk, m_lastNode, NULL, route(), and updateLeadingRatLine().

Referenced by FlipPosture(), SetLayer(), SetOrthoMode(), and ToggleVia().

◆ propagateDpHeadForces()

bool PNS::DIFF_PAIR_PLACER::propagateDpHeadForces ( const VECTOR2I aP,
VECTOR2I aNewP 
)
private

Definition at line 124 of file pns_diff_pair_placer.cpp.

125 {
126  VIA virtHead = makeVia( aP, -1 );
127 
128  if( m_placingVia )
129  virtHead.SetDiameter( viaGap() + 2 * virtHead.Diameter() );
130  else
131  {
132  virtHead.SetLayer( m_currentLayer );
133  virtHead.SetDiameter( m_sizes.DiffPairGap() + 2 * m_sizes.DiffPairWidth() );
134  }
135 
136  VECTOR2I lead( 0, 0 );// = aP - m_currentStart ;
137  VECTOR2I force;
138  bool solidsOnly = true;
139 
141  {
142  aNewP = aP;
143  return true;
144  }
145  else if( m_currentMode == RM_Walkaround )
146  {
147  solidsOnly = false;
148  }
149 
150  // fixme: I'm too lazy to do it well. Circular approximaton will do for the moment.
151  if( virtHead.PushoutForce( m_currentNode, lead, force, solidsOnly, 40 ) )
152  {
153  aNewP = aP + force;
154  return true;
155  }
156 
157  return false;
158 }
SIZES_SETTINGS m_sizes
Are we placing a via?
Definition: track.h:343
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
Definition: board_item.h:194
const VIA makeVia(const VECTOR2I &aP, int aNet)
bool m_placingVia
current via diameter
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
Ignore collisions, mark obstacles.
Only walk around.

References PNS::VIA::Diameter(), PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), m_currentLayer, m_currentMode, m_currentNode, m_placingVia, m_sizes, makeVia(), PNS::VIA::PushoutForce(), PNS::RM_MarkObstacles, PNS::RM_Walkaround, PNS::VIA::SetDiameter(), PNS::ITEM::SetLayer(), and viaGap().

Referenced by routeHead().

◆ rhMarkObstacles()

bool PNS::DIFF_PAIR_PLACER::rhMarkObstacles ( const VECTOR2I aP)
private

Definition at line 110 of file pns_diff_pair_placer.cpp.

111 {
112  if( !routeHead( aP ) )
113  return false;
114 
115  bool collP = static_cast<bool>( m_currentNode->CheckColliding( &m_currentTrace.PLine() ) );
116  bool collN = static_cast<bool>( m_currentNode->CheckColliding( &m_currentTrace.NLine() ) );
117 
118  m_fitOk = !( collP || collN ) ;
119 
120  return m_fitOk;
121 }
bool routeHead(const VECTOR2I &aP)
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Check if the item collides with anything else in the world, and if found, returns the obstacle.
Definition: pns_node.cpp:427

References PNS::NODE::CheckColliding(), m_currentNode, m_currentTrace, m_fitOk, PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), and routeHead().

Referenced by route().

◆ rhShoveOnly()

bool PNS::DIFF_PAIR_PLACER::rhShoveOnly ( const VECTOR2I aP)
private

route step, mark obstacles mode

Definition at line 312 of file pns_diff_pair_placer.cpp.

313 {
315 
316  bool ok = routeHead( aP );
317 
318  m_fitOk = false;
319 
320  if( !ok )
321  return false;
322 
323  if( !tryWalkDp( m_currentNode, m_currentTrace, true ) )
324  return false;
325 
326  LINE pLine( m_currentTrace.PLine() );
327  LINE nLine( m_currentTrace.NLine() );
328  ITEM_SET head;
329 
330  head.Add( &pLine );
331  head.Add( &nLine );
332 
333  SHOVE::SHOVE_STATUS status = m_shove->ShoveMultiLines( head );
334 
336 
337  if( status == SHOVE::SH_OK )
338  {
340 
343  {
344  m_fitOk = true;
345  }
346  }
347 
348  return m_fitOk;
349 }
SHOVE * m_shove
Current world state.
bool routeHead(const VECTOR2I &aP)
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Check if the item collides with anything else in the world, and if found, returns the obstacle.
Definition: pns_node.cpp:427
bool tryWalkDp(NODE *aNode, DIFF_PAIR &aPair, bool aSolidsOnly)
route step, walk around mode
SHOVE_STATUS ShoveMultiLines(const ITEM_SET &aHeadSet)
Definition: pns_shove.cpp:1413
NODE * CurrentNode()
Definition: pns_shove.cpp:1664

References PNS::ITEM_SET::Add(), PNS::NODE::CheckColliding(), PNS::SHOVE::CurrentNode(), m_currentNode, m_currentTrace, m_fitOk, m_shove, PNS::DIFF_PAIR::NLine(), PNS::DIFF_PAIR::PLine(), routeHead(), PNS::SHOVE::SH_OK, PNS::SHOVE::ShoveMultiLines(), and tryWalkDp().

Referenced by route().

◆ rhWalkOnly()

bool PNS::DIFF_PAIR_PLACER::rhWalkOnly ( const VECTOR2I aP)
private

route step, shove mode

Definition at line 283 of file pns_diff_pair_placer.cpp.

284 {
285  if( !routeHead ( aP ) )
286  return false;
287 
289 
290  return m_fitOk;
291 }
bool routeHead(const VECTOR2I &aP)
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
bool tryWalkDp(NODE *aNode, DIFF_PAIR &aPair, bool aSolidsOnly)
route step, walk around mode

References m_currentNode, m_currentTrace, m_fitOk, routeHead(), and tryWalkDp().

Referenced by route().

◆ route()

bool PNS::DIFF_PAIR_PLACER::route ( const VECTOR2I aP)
private

Re-route the current track to point aP.

Returns true, when routing has completed successfully (i.e. the trace end has reached point aP), and false if the trace was stuck somewhere on the way. May call routeStep() repetitively due to mouse smoothing.

Parameters
aPis the ending point of current route.
Returns
true if the routing is complete.

Definition at line 294 of file pns_diff_pair_placer.cpp.

295 {
296  switch( m_currentMode )
297  {
298  case RM_MarkObstacles:
299  return rhMarkObstacles( aP );
300  case RM_Walkaround:
301  return rhWalkOnly( aP );
302  case RM_Shove:
303  return rhShoveOnly( aP );
304  default:
305  break;
306  }
307 
308  return false;
309 }
bool rhWalkOnly(const VECTOR2I &aP)
route step, shove mode
bool rhShoveOnly(const VECTOR2I &aP)
route step, mark obstacles mode
Ignore collisions, mark obstacles.
Only walk around.
bool rhMarkObstacles(const VECTOR2I &aP)

References m_currentMode, rhMarkObstacles(), rhShoveOnly(), rhWalkOnly(), PNS::RM_MarkObstacles, PNS::RM_Shove, and PNS::RM_Walkaround.

Referenced by Move().

◆ routeHead()

bool PNS::DIFF_PAIR_PLACER::routeHead ( const VECTOR2I aP)
private

Definition at line 602 of file pns_diff_pair_placer.cpp.

603 {
604  m_fitOk = false;
605 
606  DP_GATEWAYS gwsEntry( gap() );
607  DP_GATEWAYS gwsTarget( gap() );
608 
609  if( !m_prevPair )
611 
612  gwsEntry.BuildFromPrimitivePair( *m_prevPair, m_startDiagonal );
613 
614  DP_PRIMITIVE_PAIR target;
615 
617  {
618  gwsTarget.BuildFromPrimitivePair( target, m_startDiagonal );
619  m_snapOnTarget = true;
620  }
621  else
622  {
623  VECTOR2I fp;
624 
625  if( !propagateDpHeadForces( aP, fp ) )
626  return false;
627 
628  VECTOR2I midp, dirV;
629  m_prevPair->CursorOrientation( fp, midp, dirV );
630 
631  VECTOR2I fpProj = SEG( midp, midp + dirV ).LineProject( fp );
632 
633  // compute 'leader point' distance from the cursor (project cursor position
634  // on the extension of the starting segment pair of the DP)
635  int lead_dist = ( fpProj - fp ).EuclideanNorm();
636 
637  gwsTarget.SetFitVias( m_placingVia, m_sizes.ViaDiameter(), viaGap() );
638 
639  // far from the initial segment extension line -> allow a 45-degree obtuse turn
640  if( lead_dist > m_sizes.DiffPairGap() + m_sizes.DiffPairWidth() )
641  {
642  gwsTarget.BuildForCursor( fp );
643  }
644  // close to the initial segment extension line -> keep straight part only, project as close
645  // as possible to the cursor
646  else
647  {
648  gwsTarget.BuildForCursor( fpProj );
649  gwsTarget.FilterByOrientation( DIRECTION_45::ANG_STRAIGHT | DIRECTION_45::ANG_HALF_FULL, DIRECTION_45( dirV ) );
650  }
651 
652  m_snapOnTarget = false;
653  }
654 
655  m_currentTrace = DIFF_PAIR();
658 
659  bool result = gwsEntry.FitGateways( gwsEntry, gwsTarget, m_startDiagonal, m_currentTrace );
660 
661  if( result )
662  {
666 
667  if( m_placingVia )
668  {
670  makeVia( m_currentTrace.CN().CPoint( -1 ), m_netN ) );
671  }
672 
673  return true;
674  }
675 
676  return false;
677 }
double EuclideanNorm(const wxPoint &vector)
Euclidean norm of a 2D vector.
Definition: trigo.h:148
SIZES_SETTINGS m_sizes
Are we placing a via?
void SetLayer(int aLayer)
Definition: pns_item.h:153
void AppendVias(const VIA &aViaP, const VIA &aViaN)
const SHAPE_LINE_CHAIN & CN() const
const VIA makeVia(const VECTOR2I &aP, int aNet)
const VECTOR2I & CPoint(int aIndex) const
Function Point()
void SetGap(int aGap)
bool propagateDpHeadForces(const VECTOR2I &aP, VECTOR2I &aNewP)
VECTOR2I LineProject(const VECTOR2I &aP) const
Compute the perpendicular projection point of aP on a line passing through ends of the segment.
Definition: seg.h:389
Represent route directions & corner angles in a 45-degree metric.
Definition: direction45.h:36
bool m_placingVia
current via diameter
void SetWidth(int aWidth)
Definition: seg.h:41
const SHAPE_LINE_CHAIN & CP() const
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
static bool FindDpPrimitivePair(NODE *aWorld, const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
OPT< DP_PRIMITIVE_PAIR > m_prevPair
current algorithm iteration
void SetNets(int aP, int aN)

References DIRECTION_45::ANG_HALF_FULL, DIRECTION_45::ANG_STRAIGHT, PNS::DIFF_PAIR::AppendVias(), PNS::DP_GATEWAYS::BuildForCursor(), PNS::DP_GATEWAYS::BuildFromPrimitivePair(), PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), SHAPE_LINE_CHAIN::CPoint(), PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), EuclideanNorm(), PNS::DP_GATEWAYS::FilterByOrientation(), FindDpPrimitivePair(), PNS::DP_GATEWAYS::FitGateways(), gap(), SEG::LineProject(), m_currentEndItem, m_currentLayer, m_currentNode, m_currentTrace, m_fitOk, m_netN, m_netP, m_placingVia, m_prevPair, m_sizes, m_snapOnTarget, m_start, m_startDiagonal, makeVia(), propagateDpHeadForces(), PNS::DP_GATEWAYS::SetFitVias(), PNS::DIFF_PAIR::SetGap(), PNS::ITEM::SetLayer(), PNS::DIFF_PAIR::SetNets(), PNS::DIFF_PAIR::SetWidth(), PNS::SIZES_SETTINGS::ViaDiameter(), and viaGap().

Referenced by rhMarkObstacles(), rhShoveOnly(), and rhWalkOnly().

◆ Router()

◆ SetDebugDecorator()

void PNS::ALGO_BASE::SetDebugDecorator ( DEBUG_DECORATOR aDecorator)
inlineinherited

Assign a debug decorator allowing this algo to draw extra graphics for visual debugging.

Definition at line 73 of file pns_algo_base.h.

74  {
75  m_debugDecorator = aDecorator;
76  }
DEBUG_DECORATOR * m_debugDecorator
Definition: pns_algo_base.h:86

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::SHOVE::SHOVE(), and PNS::DRAGGER::tryWalkaround().

◆ setInitialDirection()

void PNS::DIFF_PAIR_PLACER::setInitialDirection ( const DIRECTION_45 aDirection)
private

Set preferred direction of the very first track segment to be laid.

Used by posture switching mechanism.

◆ SetLayer()

bool PNS::DIFF_PAIR_PLACER::SetLayer ( int  aLayer)
overridevirtual

Set the current routing layer.

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 381 of file pns_diff_pair_placer.cpp.

382 {
383  if( m_idle )
384  {
385  m_currentLayer = aLayer;
386  return true;
387  }
388  else if( m_chainedPlacement || !m_prevPair )
389  {
390  return false;
391  }
392  else if( !m_prevPair->PrimP() || ( m_prevPair->PrimP()->OfKind( ITEM::VIA_T ) &&
393  m_prevPair->PrimP()->Layers().Overlaps( aLayer ) ) )
394  {
395  m_currentLayer = aLayer;
396  m_start = *m_prevPair;
397  initPlacement();
398  Move( m_currentEnd, NULL );
399  return true;
400  }
401 
402  return false;
403 }
#define NULL
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL).
void initPlacement()
Initialize placement of a new line with given parameters.
OPT< DP_PRIMITIVE_PAIR > m_prevPair
current algorithm iteration

References initPlacement(), m_chainedPlacement, m_currentEnd, m_currentLayer, m_idle, m_prevPair, m_start, Move(), NULL, and PNS::ITEM::VIA_T.

◆ SetLogger()

void PNS::ALGO_BASE::SetLogger ( LOGGER aLogger)
inlineinherited

Definition at line 65 of file pns_algo_base.h.

66  {
67  m_logger = aLogger;
68  }
LOGGER * m_logger
Definition: pns_algo_base.h:88

References PNS::ALGO_BASE::m_logger.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), and PNS::DRAGGER::tryWalkaround().

◆ SetOrthoMode()

void PNS::DIFF_PAIR_PLACER::SetOrthoMode ( bool  aOrthoMode)
overridevirtual

Function SetOrthoMode()

Forces the router to place a straight 90/45 degree trace (with the end as near to the cursor as possible) instead of a standard 135 degree two-segment bend.

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 90 of file pns_diff_pair_placer.cpp.

91 {
92  m_orthoMode = aOrthoMode;
93 
94  if( !m_idle )
96 }
#define NULL
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL).

References m_currentEnd, m_idle, m_orthoMode, Move(), and NULL.

◆ Settings()

◆ setWorld()

void PNS::DIFF_PAIR_PLACER::setWorld ( NODE aWorld)
private

Set the board to route.

Definition at line 74 of file pns_diff_pair_placer.cpp.

75 {
76  m_world = aWorld;
77 }
NODE * m_world
current routing start point (end of tail, beginning of head)

References m_world.

Referenced by initPlacement(), and Start().

◆ Start()

bool PNS::DIFF_PAIR_PLACER::Start ( const VECTOR2I aP,
ITEM aStartItem 
)
overridevirtual

Start routing a single track at point aP, taking item aStartItem as anchor (unless NULL).

Implements PNS::PLACEMENT_ALGO.

Definition at line 548 of file pns_diff_pair_placer.cpp.

549 {
550  VECTOR2I p( aP );
551 
552  setWorld( Router()->GetWorld() );
554 
555  if( !FindDpPrimitivePair( m_currentNode, aP, aStartItem, m_start ) )
556  return false;
557 
558  m_netP = m_start.PrimP()->Net();
559  m_netN = m_start.PrimN()->Net();
560 
561  m_currentStart = p;
562  m_currentEnd = p;
563  m_placingVia = false;
564  m_chainedPlacement = false;
565 
566  initPlacement();
567 
568  return true;
569 }
ROUTER * Router() const
Return current router settings.
Definition: pns_algo_base.h:54
NODE * m_world
current routing start point (end of tail, beginning of head)
ITEM * PrimP() const
int Net() const
Definition: pns_item.h:148
bool m_placingVia
current via diameter
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)
ITEM * PrimN() const
void initPlacement()
Initialize placement of a new line with given parameters.
static bool FindDpPrimitivePair(NODE *aWorld, const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
void setWorld(NODE *aWorld)
Set the board to route.

References FindDpPrimitivePair(), initPlacement(), m_chainedPlacement, m_currentEnd, m_currentNode, m_currentStart, m_netN, m_netP, m_placingVia, m_start, m_world, PNS::ITEM::Net(), PNS::DP_PRIMITIVE_PAIR::PrimN(), PNS::DP_PRIMITIVE_PAIR::PrimP(), PNS::ALGO_BASE::Router(), and setWorld().

◆ ToggleVia()

bool PNS::DIFF_PAIR_PLACER::ToggleVia ( bool  aEnabled)
overridevirtual

Enable/disable a via at the end of currently routed trace.

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 99 of file pns_diff_pair_placer.cpp.

100 {
101  m_placingVia = aEnabled;
102 
103  if( !m_idle )
104  Move( m_currentEnd, NULL );
105 
106  return true;
107 }
#define NULL
bool m_placingVia
current via diameter
bool Move(const VECTOR2I &aP, ITEM *aEndItem) override
Move the end of the currently routed trace to the point aP, taking aEndItem as anchor (if not NULL).

References m_currentEnd, m_idle, m_placingVia, Move(), and NULL.

◆ Traces()

const ITEM_SET PNS::DIFF_PAIR_PLACER::Traces ( )
overridevirtual

Return the complete routed line, as a single-member ITEM_SET.

Implements PNS::PLACEMENT_ALGO.

Definition at line 352 of file pns_diff_pair_placer.cpp.

353 {
354  ITEM_SET t;
355 
356  t.Add( &m_currentTrace.PLine() );
357  t.Add( &m_currentTrace.NLine() );
358 
359  return t;
360 }

References PNS::ITEM_SET::Add(), m_currentTrace, PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

◆ tryWalkDp()

bool PNS::DIFF_PAIR_PLACER::tryWalkDp ( NODE aNode,
DIFF_PAIR aPair,
bool  aSolidsOnly 
)
private

route step, walk around mode

Definition at line 238 of file pns_diff_pair_placer.cpp.

239 {
240  DIFF_PAIR best;
241  double bestScore = 100000000000000.0;
242 
243  for( int attempt = 0; attempt <= 3; attempt++ )
244  {
245  DIFF_PAIR p;
246  NODE *tmp = m_currentNode->Branch();
247 
248  bool pfirst = ( attempt & 1 ) ? true : false;
249  bool wind_cw = ( attempt & 2 ) ? true : false;
250 
251  if( attemptWalk( tmp, &aPair, p, pfirst, wind_cw, aSolidsOnly ) )
252  {
253  // double len = p.TotalLength();
254  double cl = p.CoupledLength();
255  double skew = p.Skew();
256 
257  double score = cl + fabs( skew ) * 3.0;
258 
259  if( score < bestScore )
260  {
261  bestScore = score;
262  best = p;
263  }
264  }
265 
266  delete tmp;
267  }
268 
269  if( bestScore > 0.0 )
270  {
271  OPTIMIZER optimizer( m_currentNode );
272 
273  aPair.SetShape( best );
274  optimizer.Optimize( &aPair );
275 
276  return true;
277  }
278 
279  return false;
280 }
bool attemptWalk(NODE *aNode, DIFF_PAIR *aCurrent, DIFF_PAIR &aWalk, bool aPFirst, bool aWindCw, bool aSolidsOnly)
NODE * Branch()
Create a lightweight copy (called branch) of self that tracks the changes (added/removed items) wrs t...
Definition: pns_node.cpp:124
NODE * m_currentNode
Postprocessed world state (including marked collisions & removed loops)

References attemptWalk(), PNS::NODE::Branch(), PNS::DIFF_PAIR::CoupledLength(), m_currentNode, PNS::OPTIMIZER::Optimize(), PNS::DIFF_PAIR::SetShape(), and PNS::DIFF_PAIR::Skew().

Referenced by rhShoveOnly(), and rhWalkOnly().

◆ UnfixRoute()

virtual bool PNS::PLACEMENT_ALGO::UnfixRoute ( )
inlinevirtualinherited

Reimplemented in PNS::LINE_PLACER.

Definition at line 81 of file pns_placement_algo.h.

81 { return false; };

◆ updateLeadingRatLine()

void PNS::DIFF_PAIR_PLACER::updateLeadingRatLine ( )
private

Draw the "leading" ratsnest line, which connects the end of currently routed track and the nearest yet unrouted item.

If the routing for current net is complete, draws nothing.

Definition at line 818 of file pns_diff_pair_placer.cpp.

819 {
820  SHAPE_LINE_CHAIN ratLineN, ratLineP;
821  TOPOLOGY topo( m_lastNode );
822 
823  if( topo.LeadingRatLine( &m_currentTrace.PLine(), ratLineP ) )
824  m_router->GetInterface()->DisplayRatline( ratLineP, 1 );
825 
826  if( topo.LeadingRatLine ( &m_currentTrace.NLine(), ratLineN ) )
827  m_router->GetInterface()->DisplayRatline( ratLineN, 3 );
828 }
virtual void DisplayRatline(const SHAPE_LINE_CHAIN &aRatline, int aColor=-1)=0
ROUTER * m_router
Definition: pns_algo_base.h:87
SHAPE_LINE_CHAIN.
ROUTER_IFACE * GetInterface() const
Definition: pns_router.h:215

References PNS::ROUTER_IFACE::DisplayRatline(), PNS::ROUTER::GetInterface(), PNS::TOPOLOGY::LeadingRatLine(), m_currentTrace, m_lastNode, PNS::ALGO_BASE::m_router, PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

Referenced by Move().

◆ UpdateSizes()

void PNS::DIFF_PAIR_PLACER::UpdateSizes ( const SIZES_SETTINGS aSizes)
overridevirtual

Perform on-the-fly update of the width, via diameter & drill size from a settings class.

Used to dynamically change these parameters as the track is routed.

Reimplemented from PNS::PLACEMENT_ALGO.

Definition at line 702 of file pns_diff_pair_placer.cpp.

703 {
704  m_sizes = aSizes;
705 
706  if( !m_idle )
707  {
710 
712  {
715  }
716  }
717 }
SIZES_SETTINGS m_sizes
Are we placing a via?
bool EndsWithVias() const
void SetGap(int aGap)
void SetViaDiameter(int aDiameter)
void SetWidth(int aWidth)
void SetViaDrill(int aDrill)

References PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), PNS::DIFF_PAIR::EndsWithVias(), m_currentTrace, m_idle, m_sizes, PNS::DIFF_PAIR::SetGap(), PNS::DIFF_PAIR::SetViaDiameter(), PNS::DIFF_PAIR::SetViaDrill(), PNS::DIFF_PAIR::SetWidth(), PNS::SIZES_SETTINGS::ViaDiameter(), and PNS::SIZES_SETTINGS::ViaDrill().

◆ viaGap()

int PNS::DIFF_PAIR_PLACER::viaGap ( ) const
private

◆ VisibleViewArea()

const BOX2I & PNS::ALGO_BASE::VisibleViewArea ( ) const
inherited

Definition at line 39 of file pns_algo_base.cpp.

40 {
41  auto bb = m_router->VisibleViewArea();
42  return m_router->VisibleViewArea();
43 }
ROUTER * m_router
Definition: pns_algo_base.h:87
const BOX2I & VisibleViewArea() const
Definition: pns_router.h:225

References PNS::ALGO_BASE::m_router, and PNS::ROUTER::VisibleViewArea().

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

Member Data Documentation

◆ m_chainedPlacement

bool PNS::DIFF_PAIR_PLACER::m_chainedPlacement
private

Definition at line 220 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), SetLayer(), and Start().

◆ m_currentEnd

VECTOR2I PNS::DIFF_PAIR_PLACER::m_currentEnd
private

◆ m_currentEndItem

ITEM* PNS::DIFF_PAIR_PLACER::m_currentEndItem
private

Definition at line 272 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), initPlacement(), Move(), and routeHead().

◆ m_currentLayer

int PNS::DIFF_PAIR_PLACER::m_currentLayer
private

◆ m_currentMode

PNS_MODE PNS::DIFF_PAIR_PLACER::m_currentMode
private

◆ m_currentNet

int PNS::DIFF_PAIR_PLACER::m_currentNet
private

Definition at line 262 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

◆ m_currentNode

NODE* PNS::DIFF_PAIR_PLACER::m_currentNode
private

Postprocessed world state (including marked collisions & removed loops)

Definition at line 243 of file pns_diff_pair_placer.h.

Referenced by CommitPlacement(), CurrentNode(), DIFF_PAIR_PLACER(), initPlacement(), Move(), propagateDpHeadForces(), rhMarkObstacles(), rhShoveOnly(), rhWalkOnly(), routeHead(), Start(), and tryWalkDp().

◆ m_currentStart

VECTOR2I PNS::DIFF_PAIR_PLACER::m_currentStart
private

Definition at line 269 of file pns_diff_pair_placer.h.

Referenced by Start().

◆ m_currentTrace

DIFF_PAIR PNS::DIFF_PAIR_PLACER::m_currentTrace
private

◆ m_currentWidth

int PNS::DIFF_PAIR_PLACER::m_currentWidth
private

Definition at line 260 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

◆ m_debugDecorator

DEBUG_DECORATOR* PNS::ALGO_BASE::m_debugDecorator
protectedinherited

Definition at line 86 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::Dbg(), and PNS::ALGO_BASE::SetDebugDecorator().

◆ m_fitOk

bool PNS::DIFF_PAIR_PLACER::m_fitOk
private

◆ m_idle

bool PNS::DIFF_PAIR_PLACER::m_idle
private

◆ m_initialDiagonal

bool PNS::DIFF_PAIR_PLACER::m_initialDiagonal
private

Definition at line 221 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), and initPlacement().

◆ m_iteration

int PNS::DIFF_PAIR_PLACER::m_iteration
private

pointer to world to search colliding items

Definition at line 231 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

◆ m_lastNode

NODE* PNS::DIFF_PAIR_PLACER::m_lastNode
private

◆ m_logger

LOGGER* PNS::ALGO_BASE::m_logger
protectedinherited

Definition at line 88 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::SetLogger(), and PNS::WALKAROUND::singleStep().

◆ m_netN

int PNS::DIFF_PAIR_PLACER::m_netN
private

◆ m_netP

int PNS::DIFF_PAIR_PLACER::m_netP
private

◆ m_orthoMode

bool PNS::DIFF_PAIR_PLACER::m_orthoMode
private

Definition at line 266 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), initPlacement(), and SetOrthoMode().

◆ m_p_start

VECTOR2I PNS::DIFF_PAIR_PLACER::m_p_start
private

The shove engine.

Definition at line 237 of file pns_diff_pair_placer.h.

◆ m_placingVia

bool PNS::DIFF_PAIR_PLACER::m_placingVia
private

current via diameter

Definition at line 251 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), IsPlacingVia(), propagateDpHeadForces(), routeHead(), Start(), and ToggleVia().

◆ m_prevPair

OPT<DP_PRIMITIVE_PAIR> PNS::DIFF_PAIR_PLACER::m_prevPair
private

current algorithm iteration

Definition at line 228 of file pns_diff_pair_placer.h.

Referenced by FixRoute(), routeHead(), and SetLayer().

◆ m_router

◆ m_shove

SHOVE* PNS::DIFF_PAIR_PLACER::m_shove
private

Current world state.

Definition at line 240 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), initPlacement(), rhShoveOnly(), and ~DIFF_PAIR_PLACER().

◆ m_sizes

SIZES_SETTINGS PNS::DIFF_PAIR_PLACER::m_sizes
private

Are we placing a via?

Definition at line 248 of file pns_diff_pair_placer.h.

Referenced by gap(), makeVia(), propagateDpHeadForces(), routeHead(), UpdateSizes(), and viaGap().

◆ m_snapOnTarget

bool PNS::DIFF_PAIR_PLACER::m_snapOnTarget
private

Definition at line 267 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FixRoute(), and routeHead().

◆ m_start

DP_PRIMITIVE_PAIR PNS::DIFF_PAIR_PLACER::m_start
private

Definition at line 227 of file pns_diff_pair_placer.h.

Referenced by routeHead(), SetLayer(), and Start().

◆ m_startDiagonal

bool PNS::DIFF_PAIR_PLACER::m_startDiagonal
private

Definition at line 222 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER(), FlipPosture(), initPlacement(), and routeHead().

◆ m_startsOnVia

bool PNS::DIFF_PAIR_PLACER::m_startsOnVia
private

Definition at line 265 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

◆ m_state

State PNS::DIFF_PAIR_PLACER::m_state
private

Definition at line 218 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

◆ m_viaDiameter

int PNS::DIFF_PAIR_PLACER::m_viaDiameter
private

current via drill

Definition at line 254 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

◆ m_viaDrill

int PNS::DIFF_PAIR_PLACER::m_viaDrill
private

current track width

Definition at line 257 of file pns_diff_pair_placer.h.

Referenced by DIFF_PAIR_PLACER().

◆ m_world

NODE* PNS::DIFF_PAIR_PLACER::m_world
private

current routing start point (end of tail, beginning of head)

Definition at line 234 of file pns_diff_pair_placer.h.

Referenced by AbortPlacement(), DIFF_PAIR_PLACER(), setWorld(), and Start().


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