#include <pns_kicad_iface.h>

Inheritance diagram for PNS_KICAD_IFACE_BASE:

Public Member Functions
	PNS_KICAD_IFACE_BASE ()

	~PNS_KICAD_IFACE_BASE ()

void	EraseView () override

void	SetBoard (BOARD *aBoard)

void	SyncWorld (PNS::NODE *aWorld) override

bool	IsAnyLayerVisible (const LAYER_RANGE &aLayer) const override

bool	IsFlashedOnLayer (const PNS::ITEM *aItem, int aLayer) const override

bool	IsItemVisible (const PNS::ITEM *aItem) const override

void	HideItem (PNS::ITEM *aItem) override

void	DisplayItem (const PNS::ITEM *aItem, int aClearance, bool aEdit=false) override

void	DisplayRatline (const SHAPE_LINE_CHAIN &aRatline, int aColor=-1) override

void	AddItem (PNS::ITEM *aItem) override

void	UpdateItem (PNS::ITEM *aItem) override

void	RemoveItem (PNS::ITEM *aItem) override

void	Commit () override

bool	ImportSizes (PNS::SIZES_SETTINGS &aSizes, PNS::ITEM *aStartItem, int aNet) override

int	StackupHeight (int aFirstLayer, int aSecondLayer) const override

void	UpdateNet (int aNetCode) override

void	SetDebugDecorator (PNS::DEBUG_DECORATOR *aDec)

void	SetStartLayer (int aLayer)

virtual PNS::NODE *	GetWorld () const override

BOARD *	GetBoard () const

PNS::RULE_RESOLVER *	GetRuleResolver () override

PNS::DEBUG_DECORATOR *	GetDebugDecorator () override

Protected Member Functions
std::unique_ptr< PNS::SOLID >	syncPad (PAD *aPad)

std::unique_ptr< PNS::SEGMENT >	syncTrack (PCB_TRACK *aTrack)

std::unique_ptr< PNS::ARC >	syncArc (PCB_ARC *aArc)

std::unique_ptr< PNS::VIA >	syncVia (PCB_VIA *aVia)

bool	syncTextItem (PNS::NODE aWorld, EDA_TEXT aText, PCB_LAYER_ID aLayer)

bool	syncGraphicalItem (PNS::NODE aWorld, PCB_SHAPE aItem)

bool	syncZone (PNS::NODE aWorld, ZONE aZone, SHAPE_POLY_SET *aBoardOutline)

bool	inheritTrackWidth (PNS::ITEM aItem, int aInheritedWidth)

Protected Attributes
PNS_PCBNEW_RULE_RESOLVER *	m_ruleResolver

PNS::DEBUG_DECORATOR *	m_debugDecorator

PNS::NODE *	m_world

BOARD *	m_board

int	m_startLayer

Detailed Description

Definition at line 49 of file pns_kicad_iface.h.

Constructor & Destructor Documentation

◆ PNS_KICAD_IFACE_BASE()

PNS_KICAD_IFACE_BASE::PNS_KICAD_IFACE_BASE ( )

Definition at line 841 of file pns_kicad_iface.cpp.

 {
  m_ruleResolver = nullptr;
  m_board = nullptr;
  m_world = nullptr;
  m_debugDecorator = nullptr;
  m_startLayer = -1;
 }

References m_board, m_debugDecorator, m_ruleResolver, m_startLayer, and m_world.

◆ ~PNS_KICAD_IFACE_BASE()

PNS_KICAD_IFACE_BASE::~PNS_KICAD_IFACE_BASE ( )

Definition at line 860 of file pns_kicad_iface.cpp.

861 {

862 }

Member Function Documentation

◆ AddItem()

void PNS_KICAD_IFACE_BASE::AddItem ( PNS::ITEM * aItem )

overridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 1568 of file pns_kicad_iface.cpp.

 {
 
 }

◆ Commit()

void PNS_KICAD_IFACE_BASE::Commit ( )

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 67 of file pns_kicad_iface.h.

67 {}

◆ DisplayItem()

void PNS_KICAD_IFACE_BASE::DisplayItem	(	const PNS::ITEM *	aItem,
		int	aClearance,
		bool	aEdit = `false`
	)

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 62 of file pns_kicad_iface.h.

62 {}

◆ DisplayRatline()

void PNS_KICAD_IFACE_BASE::DisplayRatline	(	const SHAPE_LINE_CHAIN &	aRatline,
		int	aColor = `-1`
	)

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 63 of file pns_kicad_iface.h.

63 {}

◆ EraseView()

void PNS_KICAD_IFACE_BASE::EraseView ( )

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 55 of file pns_kicad_iface.h.

55 {};

◆ GetBoard()

BOARD* PNS_KICAD_IFACE_BASE::GetBoard ( ) const

inline

Definition at line 82 of file pns_kicad_iface.h.

  {
  return m_board;
  }

References m_board.

Referenced by ROUTER_TOOL::saveRouterDebugLog().

◆ GetDebugDecorator()

PNS::DEBUG_DECORATOR * PNS_KICAD_IFACE_BASE::GetDebugDecorator ( )

overridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 835 of file pns_kicad_iface.cpp.

 {
  return m_debugDecorator;
 }

References m_debugDecorator.

◆ GetRuleResolver()

PNS::RULE_RESOLVER * PNS_KICAD_IFACE_BASE::GetRuleResolver ( )

overridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 1710 of file pns_kicad_iface.cpp.

 {
  return m_ruleResolver;
 }

References m_ruleResolver.

Referenced by ROUTER_TOOL::updateMessagePanel().

◆ GetWorld()

virtual PNS::NODE* PNS_KICAD_IFACE_BASE::GetWorld ( ) const

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 77 of file pns_kicad_iface.h.

  {
  return m_world;
  };

References m_world.

◆ HideItem()

void PNS_KICAD_IFACE_BASE::HideItem ( PNS::ITEM * aItem )

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 61 of file pns_kicad_iface.h.

61 {}

◆ ImportSizes()

bool PNS_KICAD_IFACE_BASE::ImportSizes	(	PNS::SIZES_SETTINGS &	aSizes,
		PNS::ITEM *	aStartItem,
		int	aNet
	)

overridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 455 of file pns_kicad_iface.cpp.

 {
  BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
  PNS::CONSTRAINT constraint;
 
  if( aStartItem && m_startLayer < 0 )
  m_startLayer = aStartItem->Layer();
 
  aSizes.SetMinClearance( bds.m_MinClearance );
 
  int trackWidth = bds.m_TrackMinWidth;
  bool found = false;
 
  if( bds.m_UseConnectedTrackWidth && aStartItem != nullptr )
  {
  found = inheritTrackWidth( aStartItem, &trackWidth );
 
  if( found )
  aSizes.SetWidthSource( _( "existing track" ) );
  }
 
  if( !found && bds.UseNetClassTrack() && aStartItem )
  {
  if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_WIDTH, aStartItem, nullptr,
  m_startLayer, &constraint ) )
  {
  trackWidth = std::max( trackWidth, constraint.m_Value.Opt() );
  found = true;
 
  if( trackWidth == constraint.m_Value.Opt() )
  aSizes.SetWidthSource( constraint.m_RuleName );
  else
  aSizes.SetWidthSource( _( "board minimum width" ) );
  }
  }
 
  if( !found )
  {
  trackWidth = std::max( trackWidth, bds.GetCurrentTrackWidth() );
 
  if( bds.UseNetClassTrack() )
  aSizes.SetWidthSource( _( "netclass 'Default'" ) );
  else if( trackWidth == bds.GetCurrentTrackWidth() )
  aSizes.SetWidthSource( _( "user choice" ) );
  else
  aSizes.SetWidthSource( _( "board minimum width" ) );
  }
 
  aSizes.SetTrackWidth( trackWidth );
  aSizes.SetTrackWidthIsExplicit( !bds.m_UseConnectedTrackWidth );
 
  int viaDiameter = bds.m_ViasMinSize;
  int viaDrill = bds.m_MinThroughDrill;
 
  if( bds.UseNetClassVia() && aStartItem ) // netclass value
  {
  if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_VIA_DIAMETER, aStartItem,
  nullptr, m_startLayer, &constraint ) )
  {
  viaDiameter = std::max( viaDiameter, constraint.m_Value.Opt() );
  }
 
  if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_VIA_HOLE, aStartItem, nullptr,
  m_startLayer, &constraint ) )
  {
  viaDrill = std::max( viaDrill, constraint.m_Value.Opt() );
  }
  }
  else
  {
  viaDiameter = bds.GetCurrentViaSize();
  viaDrill = bds.GetCurrentViaDrill();
  }
 
  aSizes.SetViaDiameter( viaDiameter );
  aSizes.SetViaDrill( viaDrill );
 
  int diffPairWidth = bds.m_TrackMinWidth;
  int diffPairGap = bds.m_MinClearance;
  int diffPairViaGap = bds.m_MinClearance;
 
  found = false;
 
  // First try to pick up diff pair width from starting track, if enabled
  if( bds.m_UseConnectedTrackWidth && aStartItem )
  found = inheritTrackWidth( aStartItem, &diffPairWidth );
 
  // Next, pick up gap from netclass, and width also if we didn't get a starting width above
  if( bds.UseNetClassDiffPair() && aStartItem )
  {
  if( !found && m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_WIDTH, aStartItem,
  nullptr, m_startLayer, &constraint ) )
  {
  diffPairWidth = std::max( diffPairWidth, constraint.m_Value.Opt() );
  }
 
  if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_DIFF_PAIR_GAP, aStartItem,
  nullptr, m_startLayer, &constraint ) )
  {
  diffPairGap = std::max( diffPairGap, constraint.m_Value.Opt() );
  diffPairViaGap = std::max( diffPairViaGap, constraint.m_Value.Opt() );
  }
  }
  else
  {
  diffPairWidth = bds.GetCurrentDiffPairWidth();
  diffPairGap = bds.GetCurrentDiffPairGap();
  diffPairViaGap = bds.GetCurrentDiffPairViaGap();
  }
 
  aSizes.SetDiffPairWidth( diffPairWidth );
  aSizes.SetDiffPairGap( diffPairGap );
  aSizes.SetDiffPairViaGap( diffPairViaGap );
 
  int holeToHoleMin = bds.m_HoleToHoleMin;
  PNS::VIA dummyVia;
 
  if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_HOLE_TO_HOLE, &dummyVia,
  &dummyVia, UNDEFINED_LAYER, &constraint ) )
  {
  holeToHoleMin = constraint.m_Value.Min();
  }
 
  aSizes.SetHoleToHole( holeToHoleMin );
 
  aSizes.ClearLayerPairs();
 
  return true;
 }

Referenced by ROUTER_TOOL::onTrackViaSizeChanged(), and ROUTER_TOOL::prepareInteractive().

◆ inheritTrackWidth()

bool PNS_KICAD_IFACE_BASE::inheritTrackWidth	(	PNS::ITEM *	aItem,
		int *	aInheritedWidth
	)

protected

Definition at line 392 of file pns_kicad_iface.cpp.

 {
  VECTOR2I p;
 
  assert( aItem->Owner() != nullptr );
 
  auto tryGetTrackWidth =
  []( PNS::ITEM* aPnsItem ) -> int
  {
  switch( aPnsItem->Kind() )
  {
  case PNS::ITEM::SEGMENT_T: return static_cast<PNS::SEGMENT*>( aPnsItem )->Width();
  case PNS::ITEM::ARC_T: return static_cast<PNS::ARC*>( aPnsItem )->Width();
  default: return -1;
  }
  };
 
  int itemTrackWidth = tryGetTrackWidth( aItem );
 
  if( itemTrackWidth > 0 )
  {
  *aInheritedWidth = itemTrackWidth;
  return true;
  }
 
  switch( aItem->Kind() )
  {
  case PNS::ITEM::VIA_T:
  p = static_cast<PNS::VIA*>( aItem )->Pos();
  break;
 
  case PNS::ITEM::SOLID_T:
  p = static_cast<PNS::SOLID*>( aItem )->Pos();
  break;
 
  default:
  return false;
  }
 
  PNS::JOINT* jt = static_cast<PNS::NODE*>( aItem->Owner() )->FindJoint( p, aItem );
 
  assert( jt != nullptr );
 
  int mval = INT_MAX;
 
  PNS::ITEM_SET linkedSegs = jt->Links();
  linkedSegs.ExcludeItem( aItem ).FilterKinds( PNS::ITEM::SEGMENT_T | PNS::ITEM::ARC_T );
 
  for( PNS::ITEM* item : linkedSegs.Items() )
  {
  int w = tryGetTrackWidth( item );
  assert( w > 0 );
  mval = std::min( w, mval );
  }
 
  if( mval == INT_MAX )
  return false;
 
  *aInheritedWidth = mval;
  return true;
 }

References PNS::ITEM::ARC_T, PNS::ITEM_SET::ExcludeItem(), PNS::ITEM_SET::FilterKinds(), PNS::ITEM_SET::Items(), PNS::ITEM::Kind(), PNS::JOINT::Links(), PNS::ITEM::Owner(), PNS::ITEM::SEGMENT_T, PNS::ITEM::SOLID_T, and PNS::ITEM::VIA_T.

Referenced by ImportSizes().

◆ IsAnyLayerVisible()

bool PNS_KICAD_IFACE_BASE::IsAnyLayerVisible ( const LAYER_RANGE & aLayer ) const

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 58 of file pns_kicad_iface.h.

58 { return true; };

◆ IsFlashedOnLayer()

bool PNS_KICAD_IFACE_BASE::IsFlashedOnLayer	(	const PNS::ITEM *	aItem,
		int	aLayer
	)		const

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 59 of file pns_kicad_iface.h.

59 { return true; };

◆ IsItemVisible()

bool PNS_KICAD_IFACE_BASE::IsItemVisible ( const PNS::ITEM * aItem ) const

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 60 of file pns_kicad_iface.h.

60 { return true; }

◆ RemoveItem()

void PNS_KICAD_IFACE_BASE::RemoveItem ( PNS::ITEM * aItem )

overridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 1476 of file pns_kicad_iface.cpp.

1477 {

1478 }

◆ SetBoard()

void PNS_KICAD_IFACE_BASE::SetBoard ( BOARD * aBoard )

Definition at line 1207 of file pns_kicad_iface.cpp.

 {
  m_board = aBoard;
  wxLogTrace( "PNS", "m_board = %p", m_board );
 }

References m_board.

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

◆ SetDebugDecorator()

void PNS_KICAD_IFACE_BASE::SetDebugDecorator ( PNS::DEBUG_DECORATOR * aDec )

Definition at line 1406 of file pns_kicad_iface.cpp.

 {
  m_debugDecorator = aDec;
 }

References m_debugDecorator.

◆ SetStartLayer()

void PNS_KICAD_IFACE_BASE::SetStartLayer ( int aLayer )

inline

Definition at line 75 of file pns_kicad_iface.h.

75 { m_startLayer = aLayer; }

PNS_KICAD_IFACE_BASE::m_startLayer

int m_startLayer

Definition: pns_kicad_iface.h:106

References m_startLayer.

Referenced by ROUTER_TOOL::prepareInteractive().

◆ StackupHeight()

int PNS_KICAD_IFACE_BASE::StackupHeight	(	int	aFirstLayer,
		int	aSecondLayer
	)		const

overridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 587 of file pns_kicad_iface.cpp.

 {
  if( !m_board || !m_board->GetDesignSettings().m_UseHeightForLengthCalcs )
  return 0;
 
  BOARD_STACKUP& stackup = m_board->GetDesignSettings().GetStackupDescriptor();
 
  return stackup.GetLayerDistance( ToLAYER_ID( aFirstLayer ), ToLAYER_ID( aSecondLayer ) );
 }

References BOARD::GetDesignSettings(), BOARD_STACKUP::GetLayerDistance(), BOARD_DESIGN_SETTINGS::GetStackupDescriptor(), m_board, BOARD_DESIGN_SETTINGS::m_UseHeightForLengthCalcs, and ToLAYER_ID().

◆ syncArc()

std::unique_ptr< PNS::ARC > PNS_KICAD_IFACE_BASE::syncArc ( PCB_ARC * aArc )

protected

Definition at line 990 of file pns_kicad_iface.cpp.

 {
  auto arc = std::make_unique<PNS::ARC>(
  SHAPE_ARC( aArc->GetStart(), aArc->GetMid(), aArc->GetEnd(), aArc->GetWidth() ),
  aArc->GetNetCode() );
 
  arc->SetLayers( LAYER_RANGE( aArc->GetLayer() ) );
  arc->SetParent( aArc );
 
  if( aArc->IsLocked() )
  arc->Mark( PNS::MK_LOCKED );
 
  return arc;
 }

References PCB_TRACK::GetEnd(), BOARD_ITEM::GetLayer(), PCB_ARC::GetMid(), BOARD_CONNECTED_ITEM::GetNetCode(), PCB_TRACK::GetStart(), PCB_TRACK::GetWidth(), BOARD_ITEM::IsLocked(), and PNS::MK_LOCKED.

Referenced by SyncWorld().

◆ syncGraphicalItem()

bool PNS_KICAD_IFACE_BASE::syncGraphicalItem	(	PNS::NODE *	aWorld,
		PCB_SHAPE *	aItem
	)

protected

Definition at line 1156 of file pns_kicad_iface.cpp.

 {
  if( aItem->GetLayer() == Edge_Cuts
  || aItem->GetLayer() == Margin
  || IsCopperLayer( aItem->GetLayer() ) )
  {
  // TODO: where do we handle filled polygons on copper layers?
  if( aItem->GetShape() == SHAPE_T::POLY && aItem->IsFilled() )
  return false;
 
  std::vector<SHAPE*> shapes = aItem->MakeEffectiveShapes();
 
  for( SHAPE* shape : shapes )
  {
  std::unique_ptr<PNS::SOLID> solid = std::make_unique<PNS::SOLID>();
 
  if( aItem->GetLayer() == Edge_Cuts || aItem->GetLayer() == Margin )
  solid->SetLayers( LAYER_RANGE( F_Cu, B_Cu ) );
  else
  solid->SetLayer( aItem->GetLayer() );
 
  if( aItem->GetLayer() == Edge_Cuts )
  {
  switch( shape->Type() )
  {
  case SH_SEGMENT: static_cast<SHAPE_SEGMENT*>( shape )->SetWidth( 0 ); break;
  case SH_ARC: static_cast<SHAPE_ARC*>( shape )->SetWidth( 0 ); break;
  case SH_LINE_CHAIN: static_cast<SHAPE_LINE_CHAIN*>( shape )->SetWidth( 0 ); break;
  default: /* remaining shapes don't have width */ break;
  }
  }
 
  solid->SetNet( -1 );
  solid->SetParent( aItem );
  solid->SetShape( shape ); // takes ownership
 
  if( shapes.size() > 1 )
  solid->SetIsCompoundShapePrimitive();
 
  solid->SetRoutable( false );
 
  aWorld->Add( std::move( solid ) );
  }
 
  return true;
  }
 
  return false;
 }

References PNS::NODE::Add(), B_Cu, Edge_Cuts, F_Cu, BOARD_ITEM::GetLayer(), EDA_SHAPE::GetShape(), IsCopperLayer(), EDA_SHAPE::IsFilled(), EDA_SHAPE::MakeEffectiveShapes(), Margin, POLY, SH_ARC, SH_LINE_CHAIN, and SH_SEGMENT.

Referenced by SyncWorld().

◆ syncPad()

std::unique_ptr< PNS::SOLID > PNS_KICAD_IFACE_BASE::syncPad ( PAD * aPad )

protected

Definition at line 878 of file pns_kicad_iface.cpp.

 {
  LAYER_RANGE layers( 0, MAX_CU_LAYERS - 1 );
 
  // ignore non-copper pads except for those with holes
  if( ( aPad->GetLayerSet() & LSET::AllCuMask() ).none() && aPad->GetDrillSize().x == 0 )
  return nullptr;
 
  switch( aPad->GetAttribute() )
  {
  case PAD_ATTRIB::PTH:
  case PAD_ATTRIB::NPTH:
  break;
 
  case PAD_ATTRIB::CONN:
  case PAD_ATTRIB::SMD:
  {
  LSET lmsk = aPad->GetLayerSet();
  bool is_copper = false;
 
  for( int i = 0; i < MAX_CU_LAYERS; i++ )
  {
  if( lmsk[i] )
  {
  is_copper = true;
 
  if( aPad->GetAttribute() != PAD_ATTRIB::NPTH )
  layers = LAYER_RANGE( i );
 
  break;
  }
  }
 
  if( !is_copper )
  return nullptr;
 
  break;
  }
 
  default:
  wxLogTrace( "PNS", "unsupported pad type 0x%x", aPad->GetAttribute() );
  return nullptr;
  }
 
  std::unique_ptr<PNS::SOLID> solid = std::make_unique<PNS::SOLID>();
 
  if( aPad->GetAttribute() == PAD_ATTRIB::NPTH )
  solid->SetRoutable( false );
 
  solid->SetLayers( layers );
  solid->SetNet( aPad->GetNetCode() );
  solid->SetParent( aPad );
  solid->SetPadToDie( aPad->GetPadToDieLength() );
  solid->SetOrientation( aPad->GetOrientation() );
 
  wxPoint wx_c = aPad->ShapePos();
  wxPoint offset = aPad->GetOffset();
 
  VECTOR2I c( wx_c.x, wx_c.y );
 
  RotatePoint( &offset, aPad->GetOrientation() );
 
  solid->SetPos( VECTOR2I( c.x - offset.x, c.y - offset.y ) );
  solid->SetOffset( VECTOR2I( offset.x, offset.y ) );
 
  if( aPad->GetDrillSize().x > 0 )
  {
  SHAPE_SEGMENT* slot = (SHAPE_SEGMENT*) aPad->GetEffectiveHoleShape()->Clone();
 
  if( aPad->GetAttribute() != PAD_ATTRIB::NPTH )
  {
  BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
  slot->SetWidth( slot->GetWidth() + bds.GetHolePlatingThickness() * 2 );
  }
 
  solid->SetHole( slot );
  }
 
  std::shared_ptr<SHAPE> shape = aPad->GetEffectiveShape();
 
  if( shape->HasIndexableSubshapes() && shape->GetIndexableSubshapeCount() == 1 )
  {
  std::vector<SHAPE*> subshapes;
  shape->GetIndexableSubshapes( subshapes );
 
  solid->SetShape( subshapes[0]->Clone() );
  }
  else
  {
  solid->SetShape( shape->Clone() );
  }
 
  return solid;
 }

References LSET::AllCuMask(), SHAPE_SEGMENT::Clone(), PNS::Clone(), CONN, PAD::GetAttribute(), BOARD::GetDesignSettings(), PAD::GetDrillSize(), PAD::GetEffectiveHoleShape(), PAD::GetEffectiveShape(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), PAD::GetLayerSet(), BOARD_CONNECTED_ITEM::GetNetCode(), PAD::GetOffset(), PAD::GetOrientation(), PAD::GetPadToDieLength(), SHAPE_SEGMENT::GetWidth(), m_board, MAX_CU_LAYERS, NPTH, PTH, RotatePoint(), SHAPE_SEGMENT::SetWidth(), PAD::ShapePos(), SMD, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SyncWorld().

◆ syncTextItem()

bool PNS_KICAD_IFACE_BASE::syncTextItem	(	PNS::NODE *	aWorld,
		EDA_TEXT *	aText,
		PCB_LAYER_ID	aLayer
	)

protected

Definition at line 1105 of file pns_kicad_iface.cpp.

 {
  if( !IsCopperLayer( aLayer ) )
  return false;
 
  int textWidth = aText->GetEffectiveTextPenWidth();
  std::vector<wxPoint> textShape = aText->TransformToSegmentList();
 
  if( textShape.size() < 2 )
  return false;
 
  for( size_t jj = 0; jj < textShape.size(); jj += 2 )
  {
  VECTOR2I start( textShape[jj] );
  VECTOR2I end( textShape[jj+1] );
  std::unique_ptr<PNS::SOLID> solid = std::make_unique<PNS::SOLID>();
 
  solid->SetLayer( aLayer );
  solid->SetNet( -1 );
  solid->SetParent( dynamic_cast<BOARD_ITEM*>( aText ) );
  solid->SetShape( new SHAPE_SEGMENT( start, end, textWidth ) );
  solid->SetIsCompoundShapePrimitive();
  solid->SetRoutable( false );
 
  aWorld->Add( std::move( solid ) );
  }
 
  return true;
 
  /* A coarser (but faster) method:
  *
  SHAPE_POLY_SET outline;
  SHAPE_SIMPLE* shape = new SHAPE_SIMPLE();
 
  aText->TransformBoundingBoxWithClearanceToPolygon( &outline, 0 );
 
  for( auto iter = outline.CIterate( 0 ); iter; iter++ )
  shape->Append( *iter );
 
  solid->SetShape( shape );
 
  solid->SetLayer( aLayer );
  solid->SetNet( -1 );
  solid->SetParent( nullptr );
  solid->SetRoutable( false );
  aWorld->Add( std::move( solid ) );
  return true;
  */
 }

References PNS::NODE::Add(), EDA_TEXT::GetEffectiveTextPenWidth(), IsCopperLayer(), and EDA_TEXT::TransformToSegmentList().

Referenced by SyncWorld().

◆ syncTrack()

std::unique_ptr< PNS::SEGMENT > PNS_KICAD_IFACE_BASE::syncTrack ( PCB_TRACK * aTrack )

protected

Definition at line 974 of file pns_kicad_iface.cpp.

 {
  auto segment = std::make_unique<PNS::SEGMENT>( SEG( aTrack->GetStart(), aTrack->GetEnd() ),
  aTrack->GetNetCode() );
 
  segment->SetWidth( aTrack->GetWidth() );
  segment->SetLayers( LAYER_RANGE( aTrack->GetLayer() ) );
  segment->SetParent( aTrack );
 
  if( aTrack->IsLocked() )
  segment->Mark( PNS::MK_LOCKED );
 
  return segment;
 }

References PCB_TRACK::GetEnd(), BOARD_ITEM::GetLayer(), BOARD_CONNECTED_ITEM::GetNetCode(), PCB_TRACK::GetStart(), PCB_TRACK::GetWidth(), BOARD_ITEM::IsLocked(), and PNS::MK_LOCKED.

Referenced by SyncWorld().

◆ syncVia()

std::unique_ptr< PNS::VIA > PNS_KICAD_IFACE_BASE::syncVia ( PCB_VIA * aVia )

protected

Definition at line 1006 of file pns_kicad_iface.cpp.

 {
  PCB_LAYER_ID top, bottom;
  aVia->LayerPair( &top, &bottom );
 
  auto via = std::make_unique<PNS::VIA>( aVia->GetPosition(),
  LAYER_RANGE( aVia->TopLayer(), aVia->BottomLayer() ),
  aVia->GetWidth(),
  aVia->GetDrillValue(),
  aVia->GetNetCode(),
  aVia->GetViaType() );
 
  via->SetParent( aVia );
 
  if( aVia->IsLocked() )
  via->Mark( PNS::MK_LOCKED );
 
  via->SetIsFree( aVia->GetIsFree() );
 
  BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
  via->SetHole( SHAPE_CIRCLE( aVia->GetPosition(),
  aVia->GetDrillValue() / 2 + bds.GetHolePlatingThickness() ) );
 
  return via;
 }

References PCB_VIA::BottomLayer(), BOARD::GetDesignSettings(), PCB_VIA::GetDrillValue(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), PCB_VIA::GetIsFree(), BOARD_CONNECTED_ITEM::GetNetCode(), PCB_VIA::GetPosition(), PCB_VIA::GetViaType(), PCB_TRACK::GetWidth(), BOARD_ITEM::IsLocked(), PCB_VIA::LayerPair(), m_board, PNS::MK_LOCKED, PCB_VIA::TopLayer(), and via.

Referenced by SyncWorld().

◆ SyncWorld()

void PNS_KICAD_IFACE_BASE::SyncWorld ( PNS::NODE * aWorld )

overridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 1290 of file pns_kicad_iface.cpp.

 {
  if( !m_board )
  {
  wxLogTrace( "PNS", "No board attached, aborting sync." );
  return;
  }
 
  int worstClearance = m_board->GetDesignSettings().GetBiggestClearanceValue();
 
  m_world = aWorld;
 
  for( BOARD_ITEM* gitem : m_board->Drawings() )
  {
  if ( gitem->Type() == PCB_SHAPE_T )
  {
  syncGraphicalItem( aWorld, static_cast<PCB_SHAPE*>( gitem ) );
  }
  else if( gitem->Type() == PCB_TEXT_T )
  {
  syncTextItem( aWorld, static_cast<PCB_TEXT*>( gitem ), gitem->GetLayer() );
  }
  }
 
  SHAPE_POLY_SET buffer;
  SHAPE_POLY_SET* boardOutline = nullptr;
 
  if( m_board->GetBoardPolygonOutlines( buffer ) )
  boardOutline = &buffer;
 
  for( ZONE* zone : m_board->Zones() )
  {
  syncZone( aWorld, zone, boardOutline );
  }
 
  for( FOOTPRINT* footprint : m_board->Footprints() )
  {
  for( PAD* pad : footprint->Pads() )
  {
  if( std::unique_ptr<PNS::SOLID> solid = syncPad( pad ) )
  aWorld->Add( std::move( solid ) );
 
  worstClearance = std::max( worstClearance, pad->GetLocalClearance() );
  }
 
  syncTextItem( aWorld, &footprint->Reference(), footprint->Reference().GetLayer() );
  syncTextItem( aWorld, &footprint->Value(), footprint->Value().GetLayer() );
 
  for( FP_ZONE* zone : footprint->Zones() )
  syncZone( aWorld, zone, boardOutline );
 
  if( footprint->IsNetTie() )
  continue;
 
  for( BOARD_ITEM* mgitem : footprint->GraphicalItems() )
  {
  if( mgitem->Type() == PCB_FP_SHAPE_T )
  {
  syncGraphicalItem( aWorld, static_cast<PCB_SHAPE*>( mgitem ) );
  }
  else if( mgitem->Type() == PCB_FP_TEXT_T )
  {
  syncTextItem( aWorld, static_cast<FP_TEXT*>( mgitem ), mgitem->GetLayer() );
  }
  }
  }
 
  for( PCB_TRACK* t : m_board->Tracks() )
  {
  KICAD_T type = t->Type();
 
  if( type == PCB_TRACE_T )
  {
  if( auto segment = syncTrack( t ) )
  aWorld->Add( std::move( segment ) );
  }
  else if( type == PCB_ARC_T )
  {
  if( auto arc = syncArc( static_cast<PCB_ARC*>( t ) ) )
  aWorld->Add( std::move( arc ) );
  }
  else if( type == PCB_VIA_T )
  {
  if( auto via = syncVia( static_cast<PCB_VIA*>( t ) ) )
  aWorld->Add( std::move( via ) );
  }
  }
 
  // NB: if this were ever to become a long-lived object we would need to dirty its
  // clearance cache here....
  delete m_ruleResolver;
  m_ruleResolver = new PNS_PCBNEW_RULE_RESOLVER( m_board, this );
 
  aWorld->SetRuleResolver( m_ruleResolver );
  aWorld->SetMaxClearance( worstClearance + m_ruleResolver->ClearanceEpsilon() );
 }

References PNS::NODE::Add(), PNS_PCBNEW_RULE_RESOLVER::ClearanceEpsilon(), BOARD::Drawings(), BOARD::Footprints(), BOARD_DESIGN_SETTINGS::GetBiggestClearanceValue(), BOARD::GetBoardPolygonOutlines(), BOARD::GetDesignSettings(), m_board, m_ruleResolver, m_world, pad, PCB_ARC_T, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_SHAPE_T, PCB_TEXT_T, PCB_TRACE_T, PCB_VIA_T, PNS::NODE::SetMaxClearance(), PNS::NODE::SetRuleResolver(), syncArc(), syncGraphicalItem(), syncPad(), syncTextItem(), syncTrack(), syncVia(), syncZone(), BOARD::Tracks(), via, and BOARD::Zones().

◆ syncZone()

bool PNS_KICAD_IFACE_BASE::syncZone	(	PNS::NODE *	aWorld,
		ZONE *	aZone,
		SHAPE_POLY_SET *	aBoardOutline
	)

protected

Definition at line 1033 of file pns_kicad_iface.cpp.

 {
  SHAPE_POLY_SET* poly;
 
  if( !aZone->GetIsRuleArea() && aZone->GetZoneName().IsEmpty() )
  return false;
 
  // Required by expression function insideArea()
  aZone->CacheBoundingBox();
 
  // TODO handle aZone->GetDoNotAllowVias()
  // TODO handle rules which disallow tracks & vias
  if( !aZone->GetIsRuleArea() || !aZone->GetDoNotAllowTracks() )
  return false;
 
  LSET layers = aZone->GetLayerSet();
  EDA_UNITS units = EDA_UNITS::MILLIMETRES; // TODO: get real units
 
  poly = aZone->Outline();
  poly->CacheTriangulation( false );
 
  if( !poly->IsTriangulationUpToDate() )
  {
  KIDIALOG dlg( nullptr, wxString::Format( _( "%s is malformed." ),
  aZone->GetSelectMenuText( units ) ),
  KIDIALOG::KD_WARNING );
  dlg.ShowDetailedText( wxString::Format( _( "This zone cannot be handled by the router.\n"
  "Please verify it is not a self-intersecting "
  "polygon." ) ) );
  dlg.DoNotShowCheckbox( __FILE__, __LINE__ );
  dlg.ShowModal();
 
  return false;
  }
 
  for( int layer = F_Cu; layer <= B_Cu; layer++ )
  {
  if( !layers[ layer ] )
  continue;
 
  for( int outline = 0; outline < poly->OutlineCount(); outline++ )
  {
  const SHAPE_POLY_SET::TRIANGULATED_POLYGON* tri = poly->TriangulatedPolygon( outline );
 
  for( size_t i = 0; i < tri->GetTriangleCount(); i++)
  {
  VECTOR2I a, b, c;
  tri->GetTriangle( i, a, b, c );
  SHAPE_SIMPLE* triShape = new SHAPE_SIMPLE;
 
  triShape->Append( a );
  triShape->Append( b );
  triShape->Append( c );
 
  std::unique_ptr<PNS::SOLID> solid = std::make_unique<PNS::SOLID>();
 
  solid->SetLayer( layer );
  solid->SetNet( -1 );
  solid->SetParent( aZone );
  solid->SetShape( triShape );
  solid->SetIsCompoundShapePrimitive();
  solid->SetRoutable( false );
 
  aWorld->Add( std::move( solid ) );
  }
  }
  }
 
  return true;
 }

References _, PNS::NODE::Add(), SHAPE_SIMPLE::Append(), B_Cu, ZONE::CacheBoundingBox(), SHAPE_POLY_SET::CacheTriangulation(), KIDIALOG::DoNotShowCheckbox(), F_Cu, Format(), ZONE::GetDoNotAllowTracks(), ZONE::GetIsRuleArea(), ZONE::GetLayerSet(), ZONE::GetSelectMenuText(), SHAPE_POLY_SET::TRIANGULATED_POLYGON::GetTriangle(), SHAPE_POLY_SET::TRIANGULATED_POLYGON::GetTriangleCount(), ZONE::GetZoneName(), SHAPE_POLY_SET::IsTriangulationUpToDate(), KIDIALOG::KD_WARNING, MILLIMETRES, ZONE::Outline(), SHAPE_POLY_SET::OutlineCount(), KIDIALOG::ShowModal(), and SHAPE_POLY_SET::TriangulatedPolygon().

Referenced by SyncWorld().

◆ UpdateItem()

void PNS_KICAD_IFACE_BASE::UpdateItem ( PNS::ITEM * aItem )

overridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 1501 of file pns_kicad_iface.cpp.

1502 {

1503 }

◆ UpdateNet()

void PNS_KICAD_IFACE_BASE::UpdateNet ( int aNetCode )

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE.

Definition at line 71 of file pns_kicad_iface.h.

71 {}

Member Data Documentation

◆ m_board

BOARD* PNS_KICAD_IFACE_BASE::m_board

protected

Definition at line 105 of file pns_kicad_iface.h.

Referenced by PNS_KICAD_IFACE::AddItem(), GetBoard(), ImportSizes(), PNS_KICAD_IFACE_BASE(), SetBoard(), StackupHeight(), syncPad(), syncVia(), and SyncWorld().

◆ m_debugDecorator

PNS::DEBUG_DECORATOR* PNS_KICAD_IFACE_BASE::m_debugDecorator

protected

Definition at line 92 of file pns_kicad_iface.h.

Referenced by PNS_KICAD_IFACE::EraseView(), GetDebugDecorator(), PNS_KICAD_IFACE_BASE(), SetDebugDecorator(), PNS_KICAD_IFACE::SetView(), and PNS_KICAD_IFACE::~PNS_KICAD_IFACE().

◆ m_ruleResolver

PNS_PCBNEW_RULE_RESOLVER* PNS_KICAD_IFACE_BASE::m_ruleResolver

protected

Definition at line 91 of file pns_kicad_iface.h.

Referenced by GetRuleResolver(), ImportSizes(), PNS_KICAD_IFACE_BASE(), SyncWorld(), and PNS_KICAD_IFACE::~PNS_KICAD_IFACE().

◆ m_startLayer

int PNS_KICAD_IFACE_BASE::m_startLayer

protected

Definition at line 106 of file pns_kicad_iface.h.

Referenced by ImportSizes(), PNS_KICAD_IFACE_BASE(), and SetStartLayer().

◆ m_world

PNS::NODE* PNS_KICAD_IFACE_BASE::m_world

protected

Definition at line 104 of file pns_kicad_iface.h.

Referenced by GetWorld(), PNS_KICAD_IFACE_BASE(), and SyncWorld().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PNS_KICAD_IFACE_BASE()

◆ ~PNS_KICAD_IFACE_BASE()

Member Function Documentation

◆ AddItem()

◆ Commit()

◆ DisplayItem()

◆ DisplayRatline()

◆ EraseView()

◆ GetBoard()

◆ GetDebugDecorator()

◆ GetRuleResolver()

◆ GetWorld()

◆ HideItem()

◆ ImportSizes()

◆ inheritTrackWidth()

◆ IsAnyLayerVisible()

◆ IsFlashedOnLayer()

◆ IsItemVisible()

◆ RemoveItem()

◆ SetBoard()

◆ SetDebugDecorator()

◆ SetStartLayer()

◆ StackupHeight()

◆ syncArc()

◆ syncGraphicalItem()

◆ syncPad()

◆ syncTextItem()

◆ syncTrack()

◆ syncVia()

◆ SyncWorld()

◆ syncZone()

◆ UpdateItem()

◆ UpdateNet()

Member Data Documentation

◆ m_board

◆ m_debugDecorator

◆ m_ruleResolver

◆ m_startLayer

◆ m_world