#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)

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 (TRACK *aTrack)

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

std::unique_ptr< PNS::VIA >	syncVia (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

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

 {
     m_ruleResolver = nullptr;
     m_board = nullptr;
     m_world = nullptr;
     m_debugDecorator = nullptr;
 }

References m_board, m_debugDecorator, m_ruleResolver, and m_world.

◆ ~PNS_KICAD_IFACE_BASE()

PNS_KICAD_IFACE_BASE::~PNS_KICAD_IFACE_BASE ( )

Definition at line 838 of file pns_kicad_iface.cpp.

839 {

840 }

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 1550 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 80 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 814 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 1689 of file pns_kicad_iface.cpp.

 {
     return m_ruleResolver;
 }

References m_ruleResolver.

◆ GetWorld()

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

inlineoverridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 75 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 431 of file pns_kicad_iface.cpp.

 {
     BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
     PNS::CONSTRAINT        constraint;
 
     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 && bds.UseNetClassTrack() && aStartItem )
     {
         if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_WIDTH, aStartItem, nullptr,
                                              aStartItem->Layer(), &constraint ) )
         {
             trackWidth = constraint.m_Value.Opt();
             found = true;    // Note: allowed to override anything, including bds.m_TrackMinWidth
         }
     }
 
     if( !found )
     {
         trackWidth = bds.GetCurrentTrackWidth();
     }
 
     aSizes.SetTrackWidth( trackWidth );
 
     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, aStartItem->Layer(), &constraint ) )
         {
             viaDiameter = constraint.m_Value.Opt();
         }
 
         if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_VIA_HOLE, aStartItem,
                                              nullptr, aStartItem->Layer(), &constraint ) )
         {
             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, aStartItem->Layer(), &constraint ) )
         {
             diffPairWidth = constraint.m_Value.Opt();
         }
 
         if( m_ruleResolver->QueryConstraint( PNS::CONSTRAINT_TYPE::CT_DIFF_PAIR_GAP, aStartItem,
                                              nullptr, aStartItem->Layer(), &constraint ) )
         {
             diffPairGap = constraint.m_Value.Opt();
             diffPairViaGap = constraint.m_Value.Opt();
         }
     }
     else
     {
         diffPairWidth  = bds.GetCurrentDiffPairWidth();
         diffPairGap    = bds.GetCurrentDiffPairGap();
         diffPairViaGap = bds.GetCurrentDiffPairViaGap();
     }
 
     //printf( "DPWidth: %d gap %d\n", diffPairWidth, diffPairGap );
 
     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 368 of file pns_kicad_iface.cpp.

 {
     VECTOR2I p;
 
     assert( aItem->Owner() != NULL );
 
     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 != NULL );
 
     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(), NULL, 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 1456 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( "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 1389 of file pns_kicad_iface.cpp.

 {
     m_debugDecorator = aDec;
 }

References m_debugDecorator.

◆ StackupHeight()

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

overridevirtual

Implements PNS::ROUTER_IFACE.

Definition at line 545 of file pns_kicad_iface.cpp.

 {
     if( !m_board )
         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, and ToLAYER_ID().

◆ syncArc()

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

protected

Definition at line 984 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 TRACK::GetEnd(), BOARD_ITEM::GetLayer(), ARC::GetMid(), BOARD_CONNECTED_ITEM::GetNetCode(), TRACK::GetStart(), 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 1148 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() == S_POLYGON && aItem->IsFilled() )
             return false;
 
         for( SHAPE* shape : aItem->MakeEffectiveShapes() )
         {
             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 );
             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(), PCB_SHAPE::GetShape(), IsCopperLayer(), PCB_SHAPE::IsFilled(), PCB_SHAPE::MakeEffectiveShapes(), Margin, S_POLYGON, 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 856 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 NULL;
 
     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 NULL;
         }
         break;
 
     default:
         wxLogTrace( "PNS", "unsupported pad type 0x%x", aPad->GetAttribute() );
         return NULL;
     }
 
     std::unique_ptr<PNS::SOLID> solid = std::make_unique<PNS::SOLID>();
 
     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 );
     }
 
     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 ) );
 
 
     auto shapes = std::dynamic_pointer_cast<SHAPE_COMPOUND>( aPad->GetEffectiveShape() );
 
     if( shapes && shapes->Size() == 1 )
     {
         solid->SetShape( shapes->Shapes()[0]->Clone() );
     }
     else
     {
         // Fixme (but not urgent). For complex pad shapes, we pass a single simple polygon to the
         // router, otherwise it won't know how to correctly build walkaround 'hulls' for the pad
         // primitives - it can recognize only simple shapes, but not COMPOUNDs made of multiple shapes.
         // The proper way to fix this would be to implement SHAPE_COMPOUND::ConvertToSimplePolygon(),
         // but the complexity of pad polygonization code (see PAD::GetEffectivePolygon), including
         // approximation error handling makes me slightly scared to do it right now.
 
         // NOTE: PAD::GetEffectivePolygon puts the error on the inside, but we want the error on
         // the outside so that the collision hull is larger than the pad
 
         SHAPE_POLY_SET outline;
         aPad->TransformShapeWithClearanceToPolygon( outline, UNDEFINED_LAYER, 0, ARC_HIGH_DEF,
                                                     ERROR_OUTSIDE );
 
         SHAPE_SIMPLE* shape = new SHAPE_SIMPLE();
 
         for( auto iter = outline.CIterate( 0 ); iter; iter++ )
             shape->Append( *iter );
 
         solid->SetShape( shape );
     }
 
     return solid;
 }

References LSET::AllCuMask(), SHAPE_SIMPLE::Append(), SHAPE_POLY_SET::CIterate(), SHAPE_SEGMENT::Clone(), ERROR_OUTSIDE, 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, NULL, PAD_ATTRIB_CONN, PAD_ATTRIB_NPTH, PAD_ATTRIB_PTH, PAD_ATTRIB_SMD, RotatePoint(), SHAPE_SEGMENT::SetWidth(), PAD::ShapePos(), PAD::TransformShapeWithClearanceToPolygon(), 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 1098 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->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 ( TRACK * aTrack )

protected

Definition at line 968 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 TRACK::GetEnd(), BOARD_ITEM::GetLayer(), BOARD_CONNECTED_ITEM::GetNetCode(), TRACK::GetStart(), TRACK::GetWidth(), BOARD_ITEM::IsLocked(), and PNS::MK_LOCKED.

Referenced by SyncWorld().

◆ syncVia()

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

protected

Definition at line 1000 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->GetDrill() / 2 + bds.GetHolePlatingThickness() ) );
 
     return via;
 }

References VIA::BottomLayer(), BOARD::GetDesignSettings(), VIA::GetDrill(), VIA::GetDrillValue(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), VIA::GetIsFree(), BOARD_CONNECTED_ITEM::GetNetCode(), VIA::GetPosition(), VIA::GetViaType(), TRACK::GetWidth(), BOARD_ITEM::IsLocked(), VIA::LayerPair(), m_board, PNS::MK_LOCKED, 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 1274 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( 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<ARC*>( t ) ) )
                 aWorld->Add( std::move( arc ) );
         }
         else if( type == PCB_VIA_T )
         {
             if( auto via = syncVia( static_cast<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 1027 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->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 1482 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.

71 {}

Member Data Documentation

◆ m_board

BOARD* PNS_KICAD_IFACE_BASE::m_board

protected

Definition at line 103 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 90 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 89 of file pns_kicad_iface.h.

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

◆ m_world

PNS::NODE* PNS_KICAD_IFACE_BASE::m_world

protected

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

◆ StackupHeight()

◆ syncArc()

◆ syncGraphicalItem()

◆ syncPad()

◆ syncTextItem()

◆ syncTrack()

◆ syncVia()

◆ SyncWorld()

◆ syncZone()

◆ UpdateItem()

◆ UpdateNet()

Member Data Documentation

◆ m_board

◆ m_debugDecorator

◆ m_ruleResolver

◆ m_world