#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, bool aIsHeadTrace=false) override

void	DisplayRatline (const SHAPE_LINE_CHAIN &aRatline, int aNetCode) 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

virtual EDA_UNITS	GetUnits () 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 1030 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 1049 of file pns_kicad_iface.cpp.

1050{

1051}

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 1796 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`,
		bool	aIsHeadTrace = `false`
	)

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Reimplemented in PNS_KICAD_IFACE, and PNS_LOG_PLAYER_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	aNetCode
	)

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 79 of file pns_kicad_iface.h.

79{ 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 1024 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 1942 of file pns_kicad_iface.cpp.

{
 return m_ruleResolver;
}

References m_ruleResolver.

Referenced by ROUTER_TOOL::UpdateMessagePanel().

◆ GetUnits()

virtual EDA_UNITS PNS_KICAD_IFACE_BASE::GetUnits ( ) const

inlinevirtual

Reimplemented in PNS_KICAD_IFACE.

Definition at line 81 of file pns_kicad_iface.h.

81{ return EDA_UNITS::MILLIMETRES; };

EDA_UNITS::MILLIMETRES

@ MILLIMETRES

References MILLIMETRES.

Referenced by syncZone().

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

77{ 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, and PNS_LOG_PLAYER_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 590 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 );
 aSizes.SetClearanceSource( _( "board minimum clearance" ) );
 
 if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_CLEARANCE, aStartItem, nullptr,
 m_startLayer, &constraint ) )
 {
 if( constraint.m_Value.Min() > bds.m_MinClearance )
 {
 aSizes.SetMinClearance( constraint.m_Value.Min() );
 aSizes.SetClearanceSource( constraint.m_RuleName );
 }
 }
 
 int trackWidth = bds.m_TrackMinWidth;
 bool found = false;
 aSizes.SetWidthSource( _( "board minimum track width" ) );
 
 if( bds.m_UseConnectedTrackWidth && !bds.m_TempOverrideTrackWidth && 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 );
 }
 }
 
 if( !found )
 {
 trackWidth = std::max( trackWidth, bds.GetCurrentTrackWidth() );
 
 if( bds.UseNetClassTrack() )
 aSizes.SetWidthSource( _( "netclass 'Default'" ) );
 else if( trackWidth == bds.GetCurrentTrackWidth() )
 aSizes.SetWidthSource( _( "user choice" ) );
 }
 
 aSizes.SetTrackWidth( trackWidth );
 aSizes.SetTrackWidthIsExplicit( !bds.m_UseConnectedTrackWidth || bds.m_TempOverrideTrackWidth );
 
 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;
 
 aSizes.SetDiffPairWidthSource( _( "board minimum track width" ) );
 aSizes.SetDiffPairGapSource( _( "board minimum clearance" ) );
 
 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( diffPairWidth == constraint.m_Value.Opt() )
 aSizes.SetDiffPairWidthSource( constraint.m_RuleName );
 }
 
 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() );
 
 if( diffPairGap == constraint.m_Value.Opt() )
 aSizes.SetDiffPairGapSource( constraint.m_RuleName );
 }
 }
 else
 {
 diffPairWidth = bds.GetCurrentDiffPairWidth();
 diffPairGap = bds.GetCurrentDiffPairGap();
 diffPairViaGap = bds.GetCurrentDiffPairViaGap();
 
 aSizes.SetDiffPairWidthSource( _( "user choice" ) );
 aSizes.SetDiffPairGapSource( _( "user choice" ) );
 }
 
 aSizes.SetDiffPairWidth( diffPairWidth );
 aSizes.SetDiffPairGap( diffPairGap );
 aSizes.SetDiffPairViaGap( diffPairViaGap );
 aSizes.SetDiffPairViaGapSameAsTraceGap( false );
 
 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 );
 
 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 527 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

overridevirtual

Default is all layers

Implements PNS::ROUTER_IFACE.

Definition at line 1417 of file pns_kicad_iface.cpp.

{
 if( aLayer < 0 )
 return true;
 
 if( aItem->Parent() )
 {
 switch( aItem->Parent()->Type() )
 {
 case PCB_VIA_T:
 {
 const PCB_VIA* via = static_cast<const PCB_VIA*>( aItem->Parent() );
 
 return via->FlashLayer( ToLAYER_ID( aLayer ) );
 }
 
 case PCB_PAD_T:
 {
 const PAD* pad = static_cast<const PAD*>( aItem->Parent() );
 
 return pad->FlashLayer( ToLAYER_ID( aLayer ) );
 }
 
 default:
 break;
 }
 }
 
 return aItem->Layers().Overlaps( aLayer );
}

References PNS::ITEM::Layers(), LAYER_RANGE::Overlaps(), pad, PNS::ITEM::Parent(), PCB_PAD_T, PCB_VIA_T, ToLAYER_ID(), EDA_ITEM::Type(), and via.

◆ 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 1704 of file pns_kicad_iface.cpp.

1705{

1706}

◆ SetBoard()

void PNS_KICAD_IFACE_BASE::SetBoard ( BOARD * aBoard )

Definition at line 1395 of file pns_kicad_iface.cpp.

{
 m_board = aBoard;
 wxLogTrace( wxT( "PNS" ), wxT( "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 1601 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; }

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 741 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 1175 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 1348 of file pns_kicad_iface.cpp.

{
 if( aItem->GetLayer() == Edge_Cuts
 || aItem->GetLayer() == Margin
 || IsCopperLayer( aItem->GetLayer() ) )
 {
 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(), IsCopperLayer(), EDA_SHAPE::MakeEffectiveShapes(), Margin, PCAD2KICAD::SetWidth(), 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 1067 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( wxT( "PNS" ), wxT( "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() );
 
 if( aPad->IsFreePad() )
 solid->SetIsFreePad();
 
 VECTOR2I wx_c = aPad->ShapePos();
 VECTOR2I 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 )
 solid->SetHole( aPad->GetEffectiveHoleShape()->Clone() );
 
 // We generate a single SOLID for a pad, so we have to treat it as ALWAYS_FLASHED and then
 // perform layer-specific flashing tests internally.
 std::shared_ptr<SHAPE> shape = aPad->GetEffectiveShape( UNDEFINED_LAYER,
 FLASHING::ALWAYS_FLASHED );
 
 if( shape->HasIndexableSubshapes() && shape->GetIndexableSubshapeCount() == 1 )
 {
 std::vector<const SHAPE*> subshapes;
 shape->GetIndexableSubshapes( subshapes );
 
 solid->SetShape( subshapes[0]->Clone() );
 }
 else
 {
 solid->SetShape( shape->Clone() );
 }
 
 return solid;
}

References LSET::AllCuMask(), ALWAYS_FLASHED, PNS::Clone(), CONN, PAD::GetAttribute(), PAD::GetDrillSize(), PAD::GetEffectiveHoleShape(), PAD::GetEffectiveShape(), PAD::GetLayerSet(), BOARD_CONNECTED_ITEM::GetNetCode(), PAD::GetOffset(), PAD::GetOrientation(), PAD::GetPadToDieLength(), PAD::IsFreePad(), MAX_CU_LAYERS, NPTH, PTH, RotatePoint(), PAD::ShapePos(), SMD, UNDEFINED_LAYER, 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 1287 of file pns_kicad_iface.cpp.

{
 if( !IsCopperLayer( aLayer ) )
 return false;
 
 std::unique_ptr<PNS::SOLID> solid = std::make_unique<PNS::SOLID>();
 
 solid->SetLayer( aLayer );
 solid->SetNet( -1 );
 solid->SetParent( dynamic_cast<BOARD_ITEM*>( aText ) );
 
 PCB_TEXT* pcb_text = dynamic_cast<PCB_TEXT*>( aText );
 
 if( pcb_text && pcb_text->IsKnockout() )
 {
 TEXT_ATTRIBUTES attrs = pcb_text->GetAttributes();
 SHAPE_POLY_SET buffer;
 int margin = attrs.m_StrokeWidth * 1.5
 + GetKnockoutTextMargin( attrs.m_Size, attrs.m_StrokeWidth );
 pcb_text->TransformBoundingBoxToPolygon( &buffer, margin );
 // buffer should contain a single rectangular polygon
 SHAPE_SIMPLE* rectShape = new SHAPE_SIMPLE;
 
 for( int ii = 0; ii < buffer.Outline(0).PointCount(); ii++ )
 {
 VECTOR2I point = buffer.Outline(0).CPoint(ii);
 rectShape->Append( point );
 }
 
 solid->SetShape( rectShape );
 }
 else
 solid->SetShape( aText->GetEffectiveTextShape()->Clone() );
 
 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->TransformBoundingBoxToPolygon( &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(), SHAPE_SIMPLE::Append(), SHAPE_LINE_CHAIN::CPoint(), EDA_TEXT::GetAttributes(), EDA_TEXT::GetEffectiveTextShape(), GetKnockoutTextMargin(), IsCopperLayer(), BOARD_ITEM::IsKnockout(), TEXT_ATTRIBUTES::m_Size, TEXT_ATTRIBUTES::m_StrokeWidth, SHAPE_POLY_SET::Outline(), and EDA_TEXT::TransformBoundingBoxToPolygon().

Referenced by SyncWorld().

◆ syncTrack()

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

protected

Definition at line 1159 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 1191 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 ) );
 
 return via;
}

References PCB_VIA::BottomLayer(), BOARD::GetDesignSettings(), PCB_VIA::GetDrillValue(), 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 1481 of file pns_kicad_iface.cpp.

{
 if( !m_board )
 {
 wxLogTrace( wxT( "PNS" ), wxT( "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 || gitem->Type() == PCB_TEXTBOX_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() );
 
 if( pad->GetProperty() == PAD_PROP::CASTELLATED )
 {
 std::unique_ptr<SHAPE> hole;
 hole.reset( pad->GetEffectiveHoleShape()->Clone() );
 aWorld->AddEdgeExclusion( std::move( hole ) );
 }
 }
 
 syncTextItem( aWorld, &footprint->Reference(), footprint->Reference().GetLayer() );
 syncTextItem( aWorld, &footprint->Value(), footprint->Value().GetLayer() );
 
 for( FP_ZONE* zone : footprint->Zones() )
 syncZone( aWorld, zone, boardOutline );
 
 for( BOARD_ITEM* mgitem : footprint->GraphicalItems() )
 {
 if( mgitem->Type() == PCB_FP_SHAPE_T || mgitem->Type() == PCB_FP_TEXTBOX_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::NODE::AddEdgeExclusion(), CASTELLATED, PNS_PCBNEW_RULE_RESOLVER::ClearanceEpsilon(), BOARD::Drawings(), BOARD::Footprints(), BOARD_DESIGN_SETTINGS::GetBiggestClearanceValue(), BOARD::GetBoardPolygonOutlines(), BOARD::GetDesignSettings(), BOARD_ITEM::GetLayer(), m_board, m_ruleResolver, m_world, pad, PCB_ARC_T, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_FP_TEXTBOX_T, PCB_SHAPE_T, PCB_TEXT_T, PCB_TEXTBOX_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 1218 of file pns_kicad_iface.cpp.

{
 SHAPE_POLY_SET* poly;
 
 if( !aZone->GetIsRuleArea() && aZone->GetZoneName().IsEmpty() )
 return false;
 
 // TODO handle aZone->GetDoNotAllowVias()
 // TODO handle rules which disallow tracks & vias
 if( !aZone->GetIsRuleArea() || !aZone->GetDoNotAllowTracks() )
 return false;
 
 LSET layers = aZone->GetLayerSet();
 
 poly = aZone->Outline();
 poly->CacheTriangulation( false );
 
 if( !poly->IsTriangulationUpToDate() )
 {
 UNITS_PROVIDER unitsProvider( pcbIUScale, GetUnits() );
 KIDIALOG dlg( nullptr, wxString::Format( _( "%s is malformed." ),
 aZone->GetItemDescription( &unitsProvider ) ),
 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, SHAPE_POLY_SET::CacheTriangulation(), KIDIALOG::DoNotShowCheckbox(), F_Cu, Format(), ZONE::GetDoNotAllowTracks(), ZONE::GetIsRuleArea(), ZONE::GetItemDescription(), ZONE::GetLayerSet(), SHAPE_POLY_SET::TRIANGULATED_POLYGON::GetTriangle(), SHAPE_POLY_SET::TRIANGULATED_POLYGON::GetTriangleCount(), GetUnits(), ZONE::GetZoneName(), SHAPE_POLY_SET::IsTriangulationUpToDate(), KIDIALOG::KD_WARNING, ZONE::Outline(), SHAPE_POLY_SET::OutlineCount(), pcbIUScale, 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 1729 of file pns_kicad_iface.cpp.

1730{

1731}

◆ 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 101 of file pns_kicad_iface.h.

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

◆ m_debugDecorator

PNS::DEBUG_DECORATOR* PNS_KICAD_IFACE_BASE::m_debugDecorator

protected

Definition at line 88 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 87 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 102 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 100 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()

◆ GetUnits()

◆ 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