PNS_KICAD_IFACE_BASE Class Reference

#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
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 848 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 866 of file pns_kicad_iface.cpp.

{
}

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

{}

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, and PNS_LOG_PLAYER_KICAD_IFACE.

Definition at line 62 of file pns_kicad_iface.h.

{}

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.

{}

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.

{};

GetBoard()

BOARD * PNS_KICAD_IFACE_BASE::GetBoard ( ) const

inline

Definition at line 79 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 842 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 1714 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.

{ return EDA_UNITS::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.

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

{}

ImportSizes()

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

overridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 507 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 && !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 );
 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 || 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;
 
 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 );
 
 return true;
}

References _, PNS::CT_DIFF_PAIR_GAP, PNS::CT_HOLE_TO_HOLE, PNS::CT_VIA_DIAMETER, PNS::CT_VIA_HOLE, PNS::CT_WIDTH, BOARD_DESIGN_SETTINGS::GetCurrentDiffPairGap(), BOARD_DESIGN_SETTINGS::GetCurrentDiffPairViaGap(), BOARD_DESIGN_SETTINGS::GetCurrentDiffPairWidth(), BOARD_DESIGN_SETTINGS::GetCurrentTrackWidth(), BOARD_DESIGN_SETTINGS::GetCurrentViaDrill(), BOARD_DESIGN_SETTINGS::GetCurrentViaSize(), BOARD::GetDesignSettings(), inheritTrackWidth(), PNS::ITEM::Layer(), m_board, BOARD_DESIGN_SETTINGS::m_HoleToHoleMin, BOARD_DESIGN_SETTINGS::m_MinClearance, BOARD_DESIGN_SETTINGS::m_MinThroughDrill, PNS::CONSTRAINT::m_RuleName, m_ruleResolver, m_startLayer, BOARD_DESIGN_SETTINGS::m_TempOverrideTrackWidth, BOARD_DESIGN_SETTINGS::m_TrackMinWidth, BOARD_DESIGN_SETTINGS::m_UseConnectedTrackWidth, PNS::CONSTRAINT::m_Value, BOARD_DESIGN_SETTINGS::m_ViasMinSize, MINOPTMAX< T >::Min(), MINOPTMAX< T >::Opt(), PNS_PCBNEW_RULE_RESOLVER::QueryConstraint(), PNS::SIZES_SETTINGS::SetDiffPairGap(), PNS::SIZES_SETTINGS::SetDiffPairViaGap(), PNS::SIZES_SETTINGS::SetDiffPairWidth(), PNS::SIZES_SETTINGS::SetHoleToHole(), PNS::SIZES_SETTINGS::SetMinClearance(), PNS::SIZES_SETTINGS::SetTrackWidth(), PNS::SIZES_SETTINGS::SetTrackWidthIsExplicit(), PNS::SIZES_SETTINGS::SetViaDiameter(), PNS::SIZES_SETTINGS::SetViaDrill(), PNS::SIZES_SETTINGS::SetWidthSource(), UNDEFINED_LAYER, BOARD_DESIGN_SETTINGS::UseNetClassDiffPair(), BOARD_DESIGN_SETTINGS::UseNetClassTrack(), and BOARD_DESIGN_SETTINGS::UseNetClassVia().

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

{ 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 1215 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( static_cast<PCB_LAYER_ID>( aLayer ) );
 }
 
 case PCB_PAD_T:
 {
 const PAD* pad = static_cast<const PAD*>( aItem->Parent() );
 
 return pad->FlashLayer( static_cast<PCB_LAYER_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, 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.

{ 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 1475 of file pns_kicad_iface.cpp.

{
}

SetBoard()

void PNS_KICAD_IFACE_BASE::SetBoard

(

BOARD *

aBoard

)

Definition at line 1193 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 1402 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.

{ 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 637 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 996 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 1146 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 884 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() );
 
 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 )
 {
 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<const SHAPE*> subshapes;
 shape->GetIndexableSubshapes( subshapes );
 
 solid->SetShape( subshapes[0]->Clone() );
 }
 else
 {
 solid->SetShape( shape->Clone() );
 }
 
 return solid;
}

References LSET::AllCuMask(), 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 1107 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 ) );
 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->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::GetEffectiveTextShape(), and IsCopperLayer().

Referenced by SyncWorld().

syncTrack()

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

protected

Definition at line 980 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 1012 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 1279 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 );
 
 if( footprint->IsNetTie() )
 continue;
 
 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 1039 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() )
 {
 KIDIALOG dlg( nullptr, wxString::Format( _( "%s is malformed." ),
 aZone->GetSelectMenuText( GetUnits() ) ),
 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::GetLayerSet(), ZONE::GetSelectMenuText(), 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(), 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 1500 of file pns_kicad_iface.cpp.

{
}

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.

{}

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(), 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 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:

• pns_kicad_iface.h
• pns_kicad_iface.cpp