KiCad PCB EDA Suite
PNS::ROUTER Class Reference

#include <pns_router.h>

Public Types

enum  RouterState { IDLE, DRAG_SEGMENT, ROUTE_TRACK }
 

Public Member Functions

 ROUTER ()
 
 ~ROUTER ()
 
void SetInterface (ROUTER_IFACE *aIface)
 
void SetMode (ROUTER_MODE aMode)
 
ROUTER_MODE Mode () const
 
RouterState GetState () const
 
DRAG_ALGOGetDragger ()
 
void ClearWorld ()
 
void SyncWorld ()
 
bool RoutingInProgress () const
 
bool StartRouting (const VECTOR2I &aP, ITEM *aItem, int aLayer)
 
void Move (const VECTOR2I &aP, ITEM *aItem)
 
bool FixRoute (const VECTOR2I &aP, ITEM *aItem, bool aForceFinish=false)
 
void BreakSegment (ITEM *aItem, const VECTOR2I &aP)
 
void UndoLastSegment ()
 
void CommitRouting ()
 
void StopRouting ()
 
void ClearViewDecorations ()
 
NODEGetWorld () const
 
void FlipPosture ()
 
bool SwitchLayer (int layer)
 
void ToggleViaPlacement ()
 
void SetOrthoMode (bool aEnable)
 
void ToggleRounded ()
 
int GetCurrentLayer () const
 
const std::vector< int > GetCurrentNets () const
 
LOGGERLogger ()
 
RULE_RESOLVERGetRuleResolver () const
 
bool IsPlacingVia () const
 
const ITEM_SET QueryHoverItems (const VECTOR2I &aP)
 
bool StartDragging (const VECTOR2I &aP, ITEM *aItem, int aDragMode=DM_ANY)
 
bool StartDragging (const VECTOR2I &aP, ITEM_SET aItems, int aDragMode=DM_COMPONENT)
 
void SetIterLimit (int aX)
 
int GetIterLimit () const
 
ROUTING_SETTINGSSettings ()
 
void CommitRouting (NODE *aNode)
 
void UpdateSizes (const SIZES_SETTINGS &aSizes)
 Applies stored settings. More...
 
void LoadSettings (ROUTING_SETTINGS *aSettings)
 Changes routing settings to ones passed in the parameter. More...
 
SIZES_SETTINGSSizes ()
 
void SetFailureReason (const wxString &aReason)
 
const wxString & FailureReason () const
 
PLACEMENT_ALGOPlacer ()
 
ROUTER_IFACEGetInterface () const
 
void SetVisibleViewArea (const BOX2I &aExtents)
 
const BOX2IVisibleViewArea () const
 

Static Public Member Functions

static ROUTERGetInstance ()
 

Private Member Functions

void movePlacing (const VECTOR2I &aP, ITEM *aItem)
 
void moveDragging (const VECTOR2I &aP, ITEM *aItem)
 
void updateView (NODE *aNode, ITEM_SET &aCurrent, bool aDragging=false)
 
void markViolations (NODE *aNode, ITEM_SET &aCurrent, NODE::ITEM_VECTOR &aRemoved)
 
bool isStartingPointRoutable (const VECTOR2I &aWhere, ITEM *aItem, int aLayer)
 

Private Attributes

BOX2I m_visibleViewArea
 
VECTOR2I m_currentEnd
 
RouterState m_state
 
std::unique_ptr< NODEm_world
 
NODEm_lastNode
 
std::unique_ptr< PLACEMENT_ALGOm_placer
 
std::unique_ptr< DRAG_ALGOm_dragger
 
std::unique_ptr< SHOVEm_shove
 
ROUTER_IFACEm_iface
 
int m_iterLimit
 
bool m_forceMarkObstaclesMode = false
 
ROUTING_SETTINGSm_settings
 
SIZES_SETTINGS m_sizes
 
ROUTER_MODE m_mode
 
LOGGERm_logger
 
wxString m_toolStatusbarName
 
wxString m_failureReason
 

Detailed Description

Definition at line 115 of file pns_router.h.

Member Enumeration Documentation

◆ RouterState

Enumerator
IDLE 
DRAG_SEGMENT 
ROUTE_TRACK 

Definition at line 118 of file pns_router.h.

Constructor & Destructor Documentation

◆ ROUTER()

PNS::ROUTER::ROUTER ( )

Definition at line 61 of file pns_router.cpp.

62 {
63  theRouter = this;
64 
65  m_state = IDLE;
67 
68  m_logger = new LOGGER;
69 
70  // Initialize all other variables:
71  m_lastNode = nullptr;
72  m_iterLimit = 0;
73  m_settings = nullptr;
74  m_iface = nullptr;
76 }
BOX2I m_visibleViewArea
Definition: pns_router.h:236
int m_iterLimit
Definition: pns_router.h:249
ROUTING_SETTINGS * m_settings
Definition: pns_router.h:252
NODE * m_lastNode
Definition: pns_router.h:241
void SetMaximum()
Definition: box2.h:73
RouterState m_state
Definition: pns_router.h:238
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
LOGGER * m_logger
Definition: pns_router.h:255
static ROUTER * theRouter
Definition: pns_router.cpp:59
ROUTER_MODE m_mode
Definition: pns_router.h:254

References IDLE, m_iface, m_iterLimit, m_lastNode, m_logger, m_mode, m_settings, m_state, m_visibleViewArea, PNS::PNS_MODE_ROUTE_SINGLE, BOX2< Vec >::SetMaximum(), and PNS::theRouter.

◆ ~ROUTER()

PNS::ROUTER::~ROUTER ( )

Definition at line 85 of file pns_router.cpp.

86 {
87  ClearWorld();
88  theRouter = nullptr;
89  delete m_logger;
90 }
void ClearWorld()
Definition: pns_router.cpp:102
LOGGER * m_logger
Definition: pns_router.h:255
static ROUTER * theRouter
Definition: pns_router.cpp:59

References ClearWorld(), m_logger, and PNS::theRouter.

Member Function Documentation

◆ BreakSegment()

void PNS::ROUTER::BreakSegment ( ITEM aItem,
const VECTOR2I aP 
)

Definition at line 810 of file pns_router.cpp.

811 {
812  NODE *node = m_world->Branch();
813 
814  LINE_PLACER placer( this );
815 
816  if( placer.SplitAdjacentSegments( node, aItem, aP ) )
817  {
818  CommitRouting( node );
819  }
820  else
821  {
822  delete node;
823  }
824 }
void CommitRouting()
Definition: pns_router.cpp:664
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240

References CommitRouting(), m_world, and PNS::LINE_PLACER::SplitAdjacentSegments().

Referenced by ROUTER_TOOL::breakTrack().

◆ ClearViewDecorations()

void PNS::ROUTER::ClearViewDecorations ( )

◆ ClearWorld()

void PNS::ROUTER::ClearWorld ( )

Definition at line 102 of file pns_router.cpp.

103 {
104  if( m_world )
105  {
106  m_world->KillChildren();
107  m_world.reset();
108  }
109 
110  m_placer.reset();
111 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240

References m_placer, and m_world.

Referenced by ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), PNS::TOOL_BASE::Reset(), SyncWorld(), and ~ROUTER().

◆ CommitRouting() [1/2]

◆ CommitRouting() [2/2]

void PNS::ROUTER::CommitRouting ( NODE aNode)

Definition at line 583 of file pns_router.cpp.

584 {
585  if( m_state == ROUTE_TRACK && !m_placer->HasPlacedAnything() )
586  return;
587 
588  NODE::ITEM_VECTOR removed;
589  NODE::ITEM_VECTOR added;
590  NODE::ITEM_VECTOR changed;
591 
592  aNode->GetUpdatedItems( removed, added );
593 
594  for( ITEM* item : removed )
595  {
596  bool is_changed = false;
597 
598  // Items in remove/add that share the same parent are just updated versions
599  // We move them to the updated vector to preserve attributes such as UUID and pad data
600  if( item->Parent() )
601  {
602  for( NODE::ITEM_VECTOR::iterator added_it = added.begin();
603  added_it != added.end(); ++added_it )
604  {
605  if( ( *added_it )->Parent() && ( *added_it )->Parent() == item->Parent() )
606  {
607  changed.push_back( *added_it );
608  added.erase( added_it );
609  is_changed = true;
610  break;
611  }
612  }
613  }
614 
615  if( !is_changed )
616  m_iface->RemoveItem( item );
617  }
618 
619  for( ITEM* item : added )
620  m_iface->AddItem( item );
621 
622  for( ITEM* item : changed )
623  m_iface->UpdateItem( item );
624 
625  m_iface->Commit();
626  m_world->Commit( aNode );
627 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
virtual void AddItem(ITEM *aItem)=0
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240
RouterState m_state
Definition: pns_router.h:238
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
virtual void UpdateItem(ITEM *aItem)=0
virtual void Commit()=0
virtual void RemoveItem(ITEM *aItem)=0
std::vector< ITEM * > ITEM_VECTOR
Definition: pns_node.h:148

References PNS::ROUTER_IFACE::AddItem(), PNS::ROUTER_IFACE::Commit(), PNS::NODE::GetUpdatedItems(), m_iface, m_placer, m_state, m_world, PNS::ROUTER_IFACE::RemoveItem(), ROUTE_TRACK, and PNS::ROUTER_IFACE::UpdateItem().

◆ FailureReason()

const wxString& PNS::ROUTER::FailureReason ( ) const
inline

Definition at line 206 of file pns_router.h.

206 { return m_failureReason; }
wxString m_failureReason
Definition: pns_router.h:258

References m_failureReason.

Referenced by LENGTH_TUNER_TOOL::performTuning(), and ROUTER_TOOL::prepareInteractive().

◆ FixRoute()

bool PNS::ROUTER::FixRoute ( const VECTOR2I aP,
ITEM aItem,
bool  aForceFinish = false 
)

Definition at line 630 of file pns_router.cpp.

631 {
632  bool rv = false;
633 
634  if( m_logger )
635  m_logger->Log( LOGGER::EVT_FIX, aP, aEndItem );
636 
637  switch( m_state )
638  {
639  case ROUTE_TRACK:
640  rv = m_placer->FixRoute( aP, aEndItem, aForceFinish );
641  break;
642 
643  case DRAG_SEGMENT:
644  rv = m_dragger->FixRoute();
645  break;
646 
647  default:
648  break;
649  }
650 
651  return rv;
652 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:244
RouterState m_state
Definition: pns_router.h:238
LOGGER * m_logger
Definition: pns_router.h:255
void Log(EVENT_TYPE evt, VECTOR2I pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:65

References DRAG_SEGMENT, PNS::LOGGER::EVT_FIX, PNS::LOGGER::Log(), m_dragger, m_logger, m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), and LENGTH_TUNER_TOOL::performTuning().

◆ FlipPosture()

void PNS::ROUTER::FlipPosture ( )

Definition at line 707 of file pns_router.cpp.

708 {
709  if( m_state == ROUTE_TRACK )
710  {
711  m_placer->FlipPosture();
712  }
713 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
RouterState m_state
Definition: pns_router.h:238

References m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::performRouting().

◆ GetCurrentLayer()

int PNS::ROUTER::GetCurrentLayer ( ) const

Definition at line 746 of file pns_router.cpp.

747 {
748  if( m_placer )
749  return m_placer->CurrentLayer();
750  else if( m_dragger )
751  return m_dragger->CurrentLayer();
752 
753  return -1;
754 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:244

References m_dragger, and m_placer.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::performRouting(), ROUTER_TOOL::switchLayerOnViaPlacement(), and PNS::TOOL_BASE::updateEndItem().

◆ GetCurrentNets()

const std::vector< int > PNS::ROUTER::GetCurrentNets ( ) const

Definition at line 735 of file pns_router.cpp.

736 {
737  if( m_placer )
738  return m_placer->CurrentNets();
739  else if( m_dragger )
740  return m_dragger->CurrentNets();
741 
742  return std::vector<int>();
743 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:244

References m_dragger, and m_placer.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::onTrackViaSizeChanged(), and PNS::TOOL_BASE::updateEndItem().

◆ GetDragger()

DRAG_ALGO* PNS::ROUTER::GetDragger ( )
inline

Definition at line 135 of file pns_router.h.

135 { return m_dragger.get(); }
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:244

References m_dragger.

◆ GetInstance()

◆ GetInterface()

◆ GetIterLimit()

int PNS::ROUTER::GetIterLimit ( ) const
inline

Definition at line 182 of file pns_router.h.

182 { return m_iterLimit; };
int m_iterLimit
Definition: pns_router.h:249

References m_iterLimit.

◆ GetRuleResolver()

RULE_RESOLVER* PNS::ROUTER::GetRuleResolver ( ) const
inline

Definition at line 169 of file pns_router.h.

170  {
171  return m_iface->GetRuleResolver();
172  }
virtual RULE_RESOLVER * GetRuleResolver()=0
ROUTER_IFACE * m_iface
Definition: pns_router.h:247

References PNS::ROUTER_IFACE::GetRuleResolver(), and m_iface.

Referenced by movePlacing(), and updateView().

◆ GetState()

RouterState PNS::ROUTER::GetState ( ) const
inline

Definition at line 133 of file pns_router.h.

133 { return m_state; }
RouterState m_state
Definition: pns_router.h:238

References m_state.

◆ GetWorld()

◆ IsPlacingVia()

bool PNS::ROUTER::IsPlacingVia ( ) const

Definition at line 763 of file pns_router.cpp.

764 {
765  if( !m_placer )
766  return false;
767 
768  return m_placer->IsPlacingVia();
769 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243

References m_placer.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::performRouting(), and PNS::TOOL_BASE::updateEndItem().

◆ isStartingPointRoutable()

bool PNS::ROUTER::isStartingPointRoutable ( const VECTOR2I aWhere,
ITEM aItem,
int  aLayer 
)
private

Definition at line 183 of file pns_router.cpp.

184 {
185  if( Settings().AllowDRCViolations() )
186  return true;
187 
189  {
191  {
192  SetFailureReason( _( "Diff pair gap is less than board minimum clearance." ) );
193  return false;
194  }
195  }
196 
197  ITEM_SET candidates = QueryHoverItems( aWhere );
198 
199  for( ITEM* item : candidates.Items() )
200  {
201  if( !item->IsRoutable() && item->Layers().Overlaps( aLayer ) )
202  {
203  BOARD_ITEM* parent = item->Parent();
204 
205  switch( parent->Type() )
206  {
207  case PCB_PAD_T:
208  {
209  PAD* pad = static_cast<PAD*>( parent );
210 
211  if( pad->GetAttribute() == PAD_ATTRIB::NPTH )
212  SetFailureReason( _( "Cannot start routing from a non-plated hole." ) );
213  }
214  break;
215 
216  case PCB_ZONE_T:
217  case PCB_FP_ZONE_T:
218  {
219  ZONE* zone = static_cast<ZONE*>( parent );
220 
221  if( !zone->GetZoneName().IsEmpty() )
222  {
223  SetFailureReason( wxString::Format( _( "Rule area '%s' disallows tracks." ),
224  zone->GetZoneName() ) );
225  }
226  else
227  {
228  SetFailureReason( _( "Rule area disallows tracks." ) );
229  }
230  }
231  break;
232 
233  case PCB_TEXT_T:
234  case PCB_FP_TEXT_T:
235  SetFailureReason( _( "Cannot start routing from a text item." ) );
236  break;
237 
238  case PCB_SHAPE_T:
239  case PCB_FP_SHAPE_T:
240  SetFailureReason( _( "Cannot start routing from a graphic." ) );
241 
242  default:
243  break;
244  }
245 
246  return false;
247  }
248  }
249 
250  VECTOR2I startPoint = aStartItem ? aStartItem->Anchor( 0 ) : aWhere;
251 
252  if( aStartItem && aStartItem->OfKind( ITEM::SEGMENT_T | ITEM::ARC_T ) )
253  {
254  VECTOR2I otherEnd = aStartItem->Anchor( 1 );
255 
256  if( ( otherEnd - aWhere ).SquaredEuclideanNorm()
257  < ( startPoint - aWhere ).SquaredEuclideanNorm() )
258  {
259  startPoint = otherEnd;
260  }
261  }
262 
264  {
265  SHAPE_LINE_CHAIN dummyStartSeg;
266  LINE dummyStartLine;
267 
268  dummyStartSeg.Append( startPoint );
269  dummyStartSeg.Append( startPoint, true );
270 
271  dummyStartLine.SetShape( dummyStartSeg );
272  dummyStartLine.SetLayer( aLayer );
273  dummyStartLine.SetNet( aStartItem ? aStartItem->Net() : 0 );
274  dummyStartLine.SetWidth( m_sizes.TrackWidth() );
275 
276  if( m_world->CheckColliding( &dummyStartLine, ITEM::ANY_T ) )
277  {
278  ITEM_SET dummyStartSet( &dummyStartLine );
279  NODE::ITEM_VECTOR highlightedItems;
280 
281  markViolations( m_world.get(), dummyStartSet, highlightedItems );
282 
283  for( ITEM* item : highlightedItems )
284  m_iface->HideItem( item );
285 
286  SetFailureReason( _( "The routing start point violates DRC." ) );
287  return false;
288  }
289  }
290  else if( m_mode == PNS_MODE_ROUTE_DIFF_PAIR )
291  {
292  if( !aStartItem )
293  {
294  SetFailureReason( _( "Cannot start a differential pair in the middle of nowhere." ) );
295  return false;
296  }
297 
298  DP_PRIMITIVE_PAIR dpPair;
299  wxString errorMsg;
300 
301  if( !DIFF_PAIR_PLACER::FindDpPrimitivePair( m_world.get(), startPoint, aStartItem, dpPair,
302  &errorMsg ) )
303  {
304  SetFailureReason( errorMsg );
305  return false;
306  }
307 
308  SHAPE_LINE_CHAIN dummyStartSegA;
309  SHAPE_LINE_CHAIN dummyStartSegB;
310  LINE dummyStartLineA;
311  LINE dummyStartLineB;
312 
313  dummyStartSegA.Append( dpPair.AnchorN() );
314  dummyStartSegA.Append( dpPair.AnchorN(), true );
315 
316  dummyStartSegB.Append( dpPair.AnchorP() );
317  dummyStartSegB.Append( dpPair.AnchorP(), true );
318 
319  dummyStartLineA.SetShape( dummyStartSegA );
320  dummyStartLineA.SetLayer( aLayer );
321  dummyStartLineA.SetNet( dpPair.PrimN()->Net() );
322  dummyStartLineA.SetWidth( m_sizes.DiffPairWidth() );
323 
324  dummyStartLineB.SetShape( dummyStartSegB );
325  dummyStartLineB.SetLayer( aLayer );
326  dummyStartLineB.SetNet( dpPair.PrimP()->Net() );
327  dummyStartLineB.SetWidth( m_sizes.DiffPairWidth() );
328 
329  if( m_world->CheckColliding( &dummyStartLineA, ITEM::ANY_T )
330  || m_world->CheckColliding( &dummyStartLineB, ITEM::ANY_T ) )
331  {
332  ITEM_SET dummyStartSet;
333  NODE::ITEM_VECTOR highlightedItems;
334 
335  dummyStartSet.Add( dummyStartLineA );
336  dummyStartSet.Add( dummyStartLineB );
337  markViolations( m_world.get(), dummyStartSet, highlightedItems );
338 
339  for( ITEM* item : highlightedItems )
340  m_iface->HideItem( item );
341 
342  SetFailureReason( _( "The routing start point violates DRC." ) );
343  return false;
344  }
345  }
346 
347  return true;
348 }
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
const ITEM_SET QueryHoverItems(const VECTOR2I &aP)
Definition: pns_router.cpp:120
virtual void HideItem(ITEM *aItem)=0
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
class FP_SHAPE, a footprint edge
Definition: typeinfo.h:93
class PAD, a pad in a footprint
Definition: typeinfo.h:89
void Append(int aX, int aY, bool aAllowDuplication=false)
Function Append()
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240
like PAD_PTH, but not plated
void SetFailureReason(const wxString &aReason)
Definition: pns_router.h:205
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
Handle a list of polygons defining a copper zone.
Definition: zone.h:57
class ZONE, a copper pour area
Definition: typeinfo.h:105
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
SHAPE_LINE_CHAIN.
class ZONE, managed by a footprint
Definition: typeinfo.h:94
static bool FindDpPrimitivePair(NODE *aWorld, const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
SIZES_SETTINGS m_sizes
Definition: pns_router.h:253
ROUTER_MODE m_mode
Definition: pns_router.h:254
Definition: pad.h:60
wxString GetZoneName() const
Definition: zone.h:129
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:90
ROUTING_SETTINGS & Settings()
Definition: pns_router.h:184
std::vector< ITEM * > ITEM_VECTOR
Definition: pns_node.h:148
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:163
void markViolations(NODE *aNode, ITEM_SET &aCurrent, NODE::ITEM_VECTOR &aRemoved)
Definition: pns_router.cpp:440

References _, PNS::ITEM_SET::Add(), PNS::ITEM::Anchor(), PNS::ITEM::ANY_T, SHAPE_LINE_CHAIN::Append(), PNS::ITEM::ARC_T, PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), PNS::DIFF_PAIR_PLACER::FindDpPrimitivePair(), Format(), ZONE::GetZoneName(), PNS::ROUTER_IFACE::HideItem(), PNS::ITEM_SET::Items(), m_iface, m_mode, m_sizes, m_world, markViolations(), PNS::SIZES_SETTINGS::MinClearance(), PNS::ITEM::Net(), NPTH, PNS::ITEM::OfKind(), pad, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_FP_ZONE_T, PCB_PAD_T, PCB_SHAPE_T, PCB_TEXT_T, PCB_ZONE_T, PNS::PNS_MODE_ROUTE_DIFF_PAIR, PNS::PNS_MODE_ROUTE_SINGLE, QueryHoverItems(), PNS::ITEM::SEGMENT_T, SetFailureReason(), PNS::ITEM::SetLayer(), PNS::ITEM::SetNet(), PNS::LINE::SetShape(), Settings(), PNS::LINE::SetWidth(), PNS::SIZES_SETTINGS::TrackWidth(), and EDA_ITEM::Type().

Referenced by StartRouting().

◆ LoadSettings()

void PNS::ROUTER::LoadSettings ( ROUTING_SETTINGS aSettings)
inline

Changes routing settings to ones passed in the parameter.

Parameters
aSettingsare the new settings.

Definition at line 198 of file pns_router.h.

199  {
200  m_settings = aSettings;
201  }
ROUTING_SETTINGS * m_settings
Definition: pns_router.h:252

References m_settings.

Referenced by PNS::TOOL_BASE::Reset().

◆ Logger()

LOGGER * PNS::ROUTER::Logger ( )

Definition at line 757 of file pns_router.cpp.

758 {
759  return m_logger;
760 }
LOGGER * m_logger
Definition: pns_router.h:255

References m_logger.

Referenced by ROUTER_TOOL::saveRouterDebugLog().

◆ markViolations()

void PNS::ROUTER::markViolations ( NODE aNode,
ITEM_SET aCurrent,
NODE::ITEM_VECTOR aRemoved 
)
private

Definition at line 440 of file pns_router.cpp.

441 {
442  auto updateItem =
443  [&]( ITEM* currentItem, ITEM* itemToMark )
444  {
445  std::unique_ptr<ITEM> tmp( itemToMark->Clone() );
446  int clearance;
447  bool removeOriginal = true;
448 
449  if( itemToMark->Marker() & MK_HOLE )
450  clearance = aNode->GetHoleClearance( currentItem, itemToMark );
451  else
452  clearance = aNode->GetClearance( currentItem, itemToMark );
453 
454  if( itemToMark->Layers().IsMultilayer() && !currentItem->Layers().IsMultilayer() )
455  tmp->SetLayer( currentItem->Layer() );
456 
457  if( itemToMark->Kind() == ITEM::SOLID_T )
458  {
459  if( ( itemToMark->Marker() & PNS::MK_HOLE )
460  || !m_iface->IsFlashedOnLayer( itemToMark, itemToMark->Layer() ) )
461  {
462  SOLID* solid = static_cast<SOLID*>( tmp.get() );
463  solid->SetShape( solid->Hole()->Clone() );
464 
465  // Leave the pad flashing around the highlighted hole
466  removeOriginal = false;
467  }
468  }
469 
470  m_iface->DisplayItem( tmp.get(), clearance );
471 
472  if( removeOriginal )
473  aRemoved.push_back( itemToMark );
474  };
475 
476  for( ITEM* item : aCurrent.Items() )
477  {
478  NODE::OBSTACLES obstacles;
479 
480  aNode->QueryColliding( item, obstacles, ITEM::ANY_T );
481 
482  if( item->OfKind( ITEM::LINE_T ) )
483  {
484  LINE* l = static_cast<LINE*>( item );
485 
486  if( l->EndsWithVia() )
487  {
488  VIA v( l->Via() );
489  aNode->QueryColliding( &v, obstacles, ITEM::ANY_T );
490  }
491  }
492 
493  for( OBSTACLE& obs : obstacles )
494  {
495  obs.m_item->Mark( obs.m_item->Marker() | MK_VIOLATION );
496  updateItem( item, obs.m_item );
497  }
498 
499  if( item->Kind() == ITEM::LINE_T )
500  {
501  LINE* line = static_cast<LINE*>( item );
502 
503  // Show clearance on any blocking obstacles
504  if( line->GetBlockingObstacle() )
505  updateItem( item, line->GetBlockingObstacle() );
506  }
507  }
508 }
Definition: track.h:343
virtual void DisplayItem(const ITEM *aItem, int aClearance, bool aEdit=false)=0
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
virtual bool IsFlashedOnLayer(const PNS::ITEM *aItem, int aLayer) const =0
std::vector< OBSTACLE > OBSTACLES
Definition: pns_node.h:149

References PNS::ITEM::ANY_T, SHAPE::Clone(), PNS::ROUTER_IFACE::DisplayItem(), PNS::LINE::EndsWithVia(), PNS::LINE::GetBlockingObstacle(), PNS::NODE::GetClearance(), PNS::NODE::GetHoleClearance(), PNS::SOLID::Hole(), PNS::ROUTER_IFACE::IsFlashedOnLayer(), LAYER_RANGE::IsMultilayer(), PNS::ITEM_SET::Items(), PNS::ITEM::Layer(), PNS::ITEM::Layers(), PNS::ITEM::LINE_T, m_iface, PNS::MK_HOLE, PNS::MK_VIOLATION, PNS::NODE::QueryColliding(), PNS::SOLID::SetShape(), PNS::ITEM::SOLID_T, and PNS::LINE::Via().

Referenced by isStartingPointRoutable(), and updateView().

◆ Mode()

ROUTER_MODE PNS::ROUTER::Mode ( ) const
inline

◆ Move()

void PNS::ROUTER::Move ( const VECTOR2I aP,
ITEM aItem 
)

Definition at line 406 of file pns_router.cpp.

407 {
408  m_currentEnd = aP;
409 
410  if( m_logger )
411  m_logger->Log( LOGGER::EVT_MOVE, aP, endItem );
412 
413  switch( m_state )
414  {
415  case ROUTE_TRACK:
416  movePlacing( aP, endItem );
417  break;
418 
419  case DRAG_SEGMENT:
420  moveDragging( aP, endItem );
421  break;
422 
423  default:
424  break;
425  }
426 }
void moveDragging(const VECTOR2I &aP, ITEM *aItem)
Definition: pns_router.cpp:429
VECTOR2I m_currentEnd
Definition: pns_router.h:237
RouterState m_state
Definition: pns_router.h:238
void movePlacing(const VECTOR2I &aP, ITEM *aItem)
Definition: pns_router.cpp:547
LOGGER * m_logger
Definition: pns_router.h:255
void Log(EVENT_TYPE evt, VECTOR2I pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:65

References DRAG_SEGMENT, PNS::LOGGER::EVT_MOVE, PNS::LOGGER::Log(), m_currentEnd, m_logger, m_state, moveDragging(), movePlacing(), and ROUTE_TRACK.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::onTrackViaSizeChanged(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), and LENGTH_TUNER_TOOL::performTuning().

◆ moveDragging()

void PNS::ROUTER::moveDragging ( const VECTOR2I aP,
ITEM aItem 
)
private

Definition at line 429 of file pns_router.cpp.

430 {
431  m_iface->EraseView();
432 
433  m_dragger->Drag( aP );
434  ITEM_SET dragged = m_dragger->Traces();
435 
436  updateView( m_dragger->CurrentNode(), dragged, true );
437 }
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:244
void updateView(NODE *aNode, ITEM_SET &aCurrent, bool aDragging=false)
Definition: pns_router.cpp:511
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
virtual void EraseView()=0

References PNS::ROUTER_IFACE::EraseView(), m_dragger, m_iface, and updateView().

Referenced by Move().

◆ movePlacing()

void PNS::ROUTER::movePlacing ( const VECTOR2I aP,
ITEM aItem 
)
private

Definition at line 547 of file pns_router.cpp.

548 {
549  m_iface->EraseView();
550 
551  m_placer->Move( aP, aEndItem );
552  ITEM_SET current = m_placer->Traces();
553 
554  for( const ITEM* item : current.CItems() )
555  {
556  if( !item->OfKind( ITEM::LINE_T ) )
557  continue;
558 
559  const LINE* l = static_cast<const LINE*>( item );
560  int clearance = GetRuleResolver()->Clearance( item, nullptr );
561 
562  m_iface->DisplayItem( l, clearance );
563 
564  if( l->EndsWithVia() )
565  {
566  const VIA& via = l->Via();
567  int viaClearance = GetRuleResolver()->Clearance( &via, nullptr );
568  int holeClearance = GetRuleResolver()->HoleClearance( &via, nullptr );
569 
570  if( holeClearance + via.Drill() / 2 > viaClearance + via.Diameter() / 2 )
571  viaClearance = holeClearance + via.Drill() / 2 - via.Diameter() / 2;
572 
573  m_iface->DisplayItem( &l->Via(), viaClearance );
574  }
575  }
576 
577  //ITEM_SET tmp( &current );
578 
579  updateView( m_placer->CurrentNode( true ), current );
580 }
Definition: track.h:343
RULE_RESOLVER * GetRuleResolver() const
Definition: pns_router.h:169
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
virtual int Clearance(const ITEM *aA, const ITEM *aB)=0
virtual void DisplayItem(const ITEM *aItem, int aClearance, bool aEdit=false)=0
void updateView(NODE *aNode, ITEM_SET &aCurrent, bool aDragging=false)
Definition: pns_router.cpp:511
virtual int HoleClearance(const ITEM *aA, const ITEM *aB)=0
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
virtual void EraseView()=0

References PNS::ITEM_SET::CItems(), PNS::RULE_RESOLVER::Clearance(), PNS::ROUTER_IFACE::DisplayItem(), PNS::LINE::EndsWithVia(), PNS::ROUTER_IFACE::EraseView(), GetRuleResolver(), PNS::RULE_RESOLVER::HoleClearance(), PNS::ITEM::LINE_T, m_iface, m_placer, updateView(), PNS::LINE::Via(), and via.

Referenced by Move().

◆ Placer()

PLACEMENT_ALGO* PNS::ROUTER::Placer ( )
inline

Definition at line 208 of file pns_router.h.

208 { return m_placer.get(); }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243

References m_placer.

Referenced by LENGTH_TUNER_TOOL::meanderSettingsDialog(), LENGTH_TUNER_TOOL::performTuning(), and PNS_TUNE_STATUS_POPUP::UpdateStatus().

◆ QueryHoverItems()

const ITEM_SET PNS::ROUTER::QueryHoverItems ( const VECTOR2I aP)

Definition at line 120 of file pns_router.cpp.

121 {
122  if( m_state == IDLE || m_placer == nullptr )
123  return m_world->HitTest( aP );
124  else
125  return m_placer->CurrentNode()->HitTest( aP );
126 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240
RouterState m_state
Definition: pns_router.h:238

References IDLE, m_placer, m_state, and m_world.

Referenced by isStartingPointRoutable(), and PNS::TOOL_BASE::pickSingleItem().

◆ RoutingInProgress()

◆ SetFailureReason()

void PNS::ROUTER::SetFailureReason ( const wxString &  aReason)
inline

◆ SetInterface()

void PNS::ROUTER::SetInterface ( ROUTER_IFACE aIface)

Definition at line 805 of file pns_router.cpp.

806 {
807  m_iface = aIface;
808 }
ROUTER_IFACE * m_iface
Definition: pns_router.h:247

References m_iface.

Referenced by PNS::TOOL_BASE::Reset().

◆ SetIterLimit()

void PNS::ROUTER::SetIterLimit ( int  aX)
inline

Definition at line 181 of file pns_router.h.

181 { m_iterLimit = aX; }
int m_iterLimit
Definition: pns_router.h:249

References m_iterLimit.

◆ SetMode()

void PNS::ROUTER::SetMode ( ROUTER_MODE  aMode)

Definition at line 799 of file pns_router.cpp.

800 {
801  m_mode = aMode;
802 }
ROUTER_MODE m_mode
Definition: pns_router.h:254

References m_mode.

Referenced by ROUTER_TOOL::MainLoop(), and LENGTH_TUNER_TOOL::MainLoop().

◆ SetOrthoMode()

void PNS::ROUTER::SetOrthoMode ( bool  aEnable)

Definition at line 790 of file pns_router.cpp.

791 {
792  if( !m_placer )
793  return;
794 
795  m_placer->SetOrthoMode( aEnable );
796 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243

References m_placer.

Referenced by ROUTER_TOOL::performRouting().

◆ Settings()

◆ SetVisibleViewArea()

void PNS::ROUTER::SetVisibleViewArea ( const BOX2I aExtents)
inline

Definition at line 215 of file pns_router.h.

216  {
217  m_visibleViewArea = aExtents;
218  }
BOX2I m_visibleViewArea
Definition: pns_router.h:236

References m_visibleViewArea.

Referenced by ROUTER_TOOL::handleCommonEvents(), and ROUTER_TOOL::InlineDrag().

◆ Sizes()

◆ StartDragging() [1/2]

bool PNS::ROUTER::StartDragging ( const VECTOR2I aP,
ITEM aItem,
int  aDragMode = DM_ANY 
)

Definition at line 129 of file pns_router.cpp.

130 {
131  return StartDragging( aP, ITEM_SET( aItem ), aDragMode );
132 }
bool StartDragging(const VECTOR2I &aP, ITEM *aItem, int aDragMode=DM_ANY)
Definition: pns_router.cpp:129

Referenced by ROUTER_TOOL::InlineDrag(), and ROUTER_TOOL::performDragging().

◆ StartDragging() [2/2]

bool PNS::ROUTER::StartDragging ( const VECTOR2I aP,
ITEM_SET  aItems,
int  aDragMode = DM_COMPONENT 
)

Definition at line 135 of file pns_router.cpp.

136 {
137  if( aStartItems.Empty() )
138  return false;
139 
140  if( aStartItems.Count( ITEM::SOLID_T ) == aStartItems.Size() )
141  {
142  m_dragger = std::make_unique<COMPONENT_DRAGGER>( this );
144  }
145  else
146  {
147  if( aDragMode & DM_FREE_ANGLE )
149  else
150  m_forceMarkObstaclesMode = false;
151 
152  m_dragger = std::make_unique<DRAGGER>( this );
153  }
154 
155  m_dragger->SetMode( aDragMode );
156  m_dragger->SetWorld( m_world.get() );
157  m_dragger->SetLogger( m_logger );
158  m_dragger->SetDebugDecorator( m_iface->GetDebugDecorator() );
159 
160  if( m_logger )
161  m_logger->Clear();
162 
163  if( m_logger && aStartItems.Size() )
164  {
165  m_logger->Log( LOGGER::EVT_START_DRAG, aP, aStartItems[0] );
166  }
167 
168  if( m_dragger->Start( aP, aStartItems ) )
169  {
171  }
172  else
173  {
174  m_dragger.reset();
175  m_state = IDLE;
176  return false;
177  }
178 
179  return true;
180 }
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:244
RouterState m_state
Definition: pns_router.h:238
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
void Clear()
Definition: pns_logger.cpp:38
LOGGER * m_logger
Definition: pns_router.h:255
virtual DEBUG_DECORATOR * GetDebugDecorator()=0
void Log(EVENT_TYPE evt, VECTOR2I pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:65
bool m_forceMarkObstaclesMode
Definition: pns_router.h:250

References PNS::LOGGER::Clear(), PNS::ITEM_SET::Count(), PNS::DM_FREE_ANGLE, DRAG_SEGMENT, PNS::ITEM_SET::Empty(), PNS::LOGGER::EVT_START_DRAG, PNS::ROUTER_IFACE::GetDebugDecorator(), IDLE, PNS::LOGGER::Log(), m_dragger, m_forceMarkObstaclesMode, m_iface, m_logger, m_state, m_world, PNS::ITEM_SET::Size(), and PNS::ITEM::SOLID_T.

◆ StartRouting()

bool PNS::ROUTER::StartRouting ( const VECTOR2I aP,
ITEM aItem,
int  aLayer 
)

Definition at line 351 of file pns_router.cpp.

352 {
353  if( !isStartingPointRoutable( aP, aStartItem, aLayer ) )
354  return false;
355 
356  m_forceMarkObstaclesMode = false;
357 
358  switch( m_mode )
359  {
361  m_placer = std::make_unique<LINE_PLACER>( this );
362  break;
363 
365  m_placer = std::make_unique<DIFF_PAIR_PLACER>( this );
366  break;
367 
369  m_placer = std::make_unique<MEANDER_PLACER>( this );
370  break;
371 
373  m_placer = std::make_unique<DP_MEANDER_PLACER>( this );
374  break;
375 
377  m_placer = std::make_unique<MEANDER_SKEW_PLACER>( this );
378  break;
379 
380  default:
381  return false;
382  }
383 
384  m_placer->UpdateSizes( m_sizes );
385  m_placer->SetLayer( aLayer );
386  m_placer->SetDebugDecorator( m_iface->GetDebugDecorator() );
387  m_placer->SetLogger( m_logger );
388 
389  if( m_logger )
390  {
391  m_logger->Clear();
392  m_logger->Log( LOGGER::EVT_START_ROUTE, aP, aStartItem );
393  }
394 
395  bool rv = m_placer->Start( aP, aStartItem );
396 
397  if( !rv )
398  return false;
399 
400  m_currentEnd = aP;
402  return rv;
403 }
bool isStartingPointRoutable(const VECTOR2I &aWhere, ITEM *aItem, int aLayer)
Definition: pns_router.cpp:183
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
VECTOR2I m_currentEnd
Definition: pns_router.h:237
RouterState m_state
Definition: pns_router.h:238
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
void Clear()
Definition: pns_logger.cpp:38
LOGGER * m_logger
Definition: pns_router.h:255
virtual DEBUG_DECORATOR * GetDebugDecorator()=0
SIZES_SETTINGS m_sizes
Definition: pns_router.h:253
ROUTER_MODE m_mode
Definition: pns_router.h:254
void Log(EVENT_TYPE evt, VECTOR2I pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:65
bool m_forceMarkObstaclesMode
Definition: pns_router.h:250

References PNS::LOGGER::Clear(), PNS::LOGGER::EVT_START_ROUTE, PNS::ROUTER_IFACE::GetDebugDecorator(), isStartingPointRoutable(), PNS::LOGGER::Log(), m_currentEnd, m_forceMarkObstaclesMode, m_iface, m_logger, m_mode, m_placer, m_sizes, m_state, PNS::PNS_MODE_ROUTE_DIFF_PAIR, PNS::PNS_MODE_ROUTE_SINGLE, PNS::PNS_MODE_TUNE_DIFF_PAIR, PNS::PNS_MODE_TUNE_DIFF_PAIR_SKEW, PNS::PNS_MODE_TUNE_SINGLE, and ROUTE_TRACK.

Referenced by LENGTH_TUNER_TOOL::performTuning(), and ROUTER_TOOL::prepareInteractive().

◆ StopRouting()

void PNS::ROUTER::StopRouting ( )

Definition at line 673 of file pns_router.cpp.

674 {
675  // Update the ratsnest with new changes
676 
677  if( m_placer )
678  {
679  std::vector<int> nets;
680  m_placer->GetModifiedNets( nets );
681 
682  // Update the ratsnest with new changes
683  for( int n : nets )
684  m_iface->UpdateNet( n );
685  }
686 
687  if( !RoutingInProgress() )
688  return;
689 
690  m_placer.reset();
691  m_dragger.reset();
692 
693  m_iface->EraseView();
694 
695  m_state = IDLE;
696  m_world->KillChildren();
697  m_world->ClearRanks();
698 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:244
virtual void UpdateNet(int aNetCode)=0
RouterState m_state
Definition: pns_router.h:238
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
virtual void EraseView()=0
bool RoutingInProgress() const
Definition: pns_router.cpp:114

References PNS::ROUTER_IFACE::EraseView(), IDLE, m_dragger, m_iface, m_placer, m_state, m_world, RoutingInProgress(), and PNS::ROUTER_IFACE::UpdateNet().

Referenced by CommitRouting(), ROUTER_TOOL::finishInteractive(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::MainLoop(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), and LENGTH_TUNER_TOOL::performTuning().

◆ SwitchLayer()

bool PNS::ROUTER::SwitchLayer ( int  layer)

Definition at line 716 of file pns_router.cpp.

717 {
718  if( m_state == ROUTE_TRACK )
719  return m_placer->SetLayer( aLayer );
720 
721  return false;
722 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
RouterState m_state
Definition: pns_router.h:238

References m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::MainLoop(), and ROUTER_TOOL::switchLayerOnViaPlacement().

◆ SyncWorld()

void PNS::ROUTER::SyncWorld ( )

Definition at line 93 of file pns_router.cpp.

94 {
95  ClearWorld();
96 
97  m_world = std::make_unique<NODE>( );
98  m_iface->SyncWorld( m_world.get() );
99 
100 }
std::unique_ptr< NODE > m_world
Definition: pns_router.h:240
void ClearWorld()
Definition: pns_router.cpp:102
virtual void SyncWorld(NODE *aNode)=0
ROUTER_IFACE * m_iface
Definition: pns_router.h:247

References ClearWorld(), m_iface, m_world, and PNS::ROUTER_IFACE::SyncWorld().

Referenced by ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), and PNS::TOOL_BASE::Reset().

◆ ToggleRounded()

void PNS::ROUTER::ToggleRounded ( )

Definition at line 772 of file pns_router.cpp.

773 {
775 
776  switch( m_settings->GetCornerMode() )
777  {
779  newMode = CORNER_MODE::ROUNDED_45;
780  break;
781 
782  default:
783  break;
784  }
785 
786  m_settings->SetCornerMode( newMode );
787 }
void SetCornerMode(CORNER_MODE aMode)
H/V/45 with filleted corners.
ROUTING_SETTINGS * m_settings
Definition: pns_router.h:252
CORNER_MODE GetCornerMode() const
H/V/45 with mitered corners (default)

References PNS::ROUTING_SETTINGS::GetCornerMode(), m_settings, PNS::MITERED_45, PNS::ROUNDED_45, and PNS::ROUTING_SETTINGS::SetCornerMode().

Referenced by ROUTER_TOOL::performRouting().

◆ ToggleViaPlacement()

void PNS::ROUTER::ToggleViaPlacement ( )

Definition at line 725 of file pns_router.cpp.

726 {
727  if( m_state == ROUTE_TRACK )
728  {
729  bool toggle = !m_placer->IsPlacingVia();
730  m_placer->ToggleVia( toggle );
731  }
732 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
RouterState m_state
Definition: pns_router.h:238

References m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::handleLayerSwitch().

◆ UndoLastSegment()

void PNS::ROUTER::UndoLastSegment ( )

Definition at line 655 of file pns_router.cpp.

656 {
657  if( !RoutingInProgress() )
658  return;
659 
660  m_placer->UnfixRoute();
661 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
bool RoutingInProgress() const
Definition: pns_router.cpp:114

References m_placer, and RoutingInProgress().

Referenced by ROUTER_TOOL::performRouting().

◆ UpdateSizes()

void PNS::ROUTER::UpdateSizes ( const SIZES_SETTINGS aSizes)

Applies stored settings.

See also
Settings()

Definition at line 535 of file pns_router.cpp.

536 {
537  m_sizes = aSizes;
538 
539  // Change track/via size settings
540  if( m_state == ROUTE_TRACK )
541  {
542  m_placer->UpdateSizes( m_sizes );
543  }
544 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:243
RouterState m_state
Definition: pns_router.h:238
SIZES_SETTINGS m_sizes
Definition: pns_router.h:253

References m_placer, m_sizes, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::DpDimensionsDialog(), ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::onTrackViaSizeChanged(), ROUTER_TOOL::prepareInteractive(), and PNS::TOOL_BASE::Reset().

◆ updateView()

void PNS::ROUTER::updateView ( NODE aNode,
ITEM_SET aCurrent,
bool  aDragging = false 
)
private

Definition at line 511 of file pns_router.cpp.

512 {
513  NODE::ITEM_VECTOR removed, added;
514  NODE::OBSTACLES obstacles;
515 
516  if( !aNode )
517  return;
518 
520  markViolations( aNode, aCurrent, removed );
521 
522  aNode->GetUpdatedItems( removed, added );
523 
524  for( ITEM* item : added )
525  {
526  int clearance = GetRuleResolver()->Clearance( item, nullptr );
527  m_iface->DisplayItem( item, clearance, aDragging );
528  }
529 
530  for( ITEM* item : removed )
531  m_iface->HideItem( item );
532 }
RULE_RESOLVER * GetRuleResolver() const
Definition: pns_router.h:169
virtual void HideItem(ITEM *aItem)=0
virtual int Clearance(const ITEM *aA, const ITEM *aB)=0
virtual void DisplayItem(const ITEM *aItem, int aClearance, bool aEdit=false)=0
ROUTER_IFACE * m_iface
Definition: pns_router.h:247
Ignore collisions, mark obstacles.
std::vector< OBSTACLE > OBSTACLES
Definition: pns_node.h:149
ROUTER_MODE Mode() const
Definition: pns_router.h:131
ROUTING_SETTINGS & Settings()
Definition: pns_router.h:184
bool m_forceMarkObstaclesMode
Definition: pns_router.h:250
std::vector< ITEM * > ITEM_VECTOR
Definition: pns_node.h:148
void markViolations(NODE *aNode, ITEM_SET &aCurrent, NODE::ITEM_VECTOR &aRemoved)
Definition: pns_router.cpp:440

References PNS::RULE_RESOLVER::Clearance(), PNS::ROUTER_IFACE::DisplayItem(), GetRuleResolver(), PNS::NODE::GetUpdatedItems(), PNS::ROUTER_IFACE::HideItem(), m_forceMarkObstaclesMode, m_iface, markViolations(), Mode(), PNS::RM_MarkObstacles, and Settings().

Referenced by moveDragging(), and movePlacing().

◆ VisibleViewArea()

const BOX2I& PNS::ROUTER::VisibleViewArea ( ) const
inline

Definition at line 220 of file pns_router.h.

221  {
222  return m_visibleViewArea;
223  }
BOX2I m_visibleViewArea
Definition: pns_router.h:236

References m_visibleViewArea.

Referenced by PNS::ALGO_BASE::VisibleViewArea().

Member Data Documentation

◆ m_currentEnd

VECTOR2I PNS::ROUTER::m_currentEnd
private

Definition at line 237 of file pns_router.h.

Referenced by Move(), and StartRouting().

◆ m_dragger

std::unique_ptr<DRAG_ALGO> PNS::ROUTER::m_dragger
private

◆ m_failureReason

wxString PNS::ROUTER::m_failureReason
private

Definition at line 258 of file pns_router.h.

Referenced by FailureReason(), and SetFailureReason().

◆ m_forceMarkObstaclesMode

bool PNS::ROUTER::m_forceMarkObstaclesMode = false
private

Definition at line 250 of file pns_router.h.

Referenced by StartDragging(), StartRouting(), and updateView().

◆ m_iface

◆ m_iterLimit

int PNS::ROUTER::m_iterLimit
private

Definition at line 249 of file pns_router.h.

Referenced by GetIterLimit(), ROUTER(), and SetIterLimit().

◆ m_lastNode

NODE* PNS::ROUTER::m_lastNode
private

Definition at line 241 of file pns_router.h.

Referenced by ROUTER().

◆ m_logger

LOGGER* PNS::ROUTER::m_logger
private

Definition at line 255 of file pns_router.h.

Referenced by FixRoute(), Logger(), Move(), ROUTER(), StartDragging(), StartRouting(), and ~ROUTER().

◆ m_mode

ROUTER_MODE PNS::ROUTER::m_mode
private

Definition at line 254 of file pns_router.h.

Referenced by isStartingPointRoutable(), Mode(), ROUTER(), SetMode(), and StartRouting().

◆ m_placer

◆ m_settings

ROUTING_SETTINGS* PNS::ROUTER::m_settings
private

Definition at line 252 of file pns_router.h.

Referenced by LoadSettings(), ROUTER(), Settings(), and ToggleRounded().

◆ m_shove

std::unique_ptr<SHOVE> PNS::ROUTER::m_shove
private

Definition at line 245 of file pns_router.h.

◆ m_sizes

SIZES_SETTINGS PNS::ROUTER::m_sizes
private

Definition at line 253 of file pns_router.h.

Referenced by isStartingPointRoutable(), Sizes(), StartRouting(), and UpdateSizes().

◆ m_state

◆ m_toolStatusbarName

wxString PNS::ROUTER::m_toolStatusbarName
private

Definition at line 257 of file pns_router.h.

◆ m_visibleViewArea

BOX2I PNS::ROUTER::m_visibleViewArea
private

Definition at line 236 of file pns_router.h.

Referenced by ROUTER(), SetVisibleViewArea(), and VisibleViewArea().

◆ m_world

std::unique_ptr<NODE> PNS::ROUTER::m_world
private

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