CN_VISITOR Class Reference

#include <connectivity_algo.h>

Public Member Functions
	CN_VISITOR (CN_ITEM *aItem)
bool	operator() (CN_ITEM *aCandidate)

Protected Member Functions
void	checkZoneItemConnection (CN_ZONE_LAYER *aZoneLayer, CN_ITEM *aItem)
void	checkZoneZoneConnection (CN_ZONE_LAYER *aZoneLayerA, CN_ZONE_LAYER *aZoneLayerB)

Protected Attributes
CN_ITEM *	m_item
	The item we are looking for connections to. More...

Detailed Description

Definition at line 289 of file connectivity_algo.h.

Constructor & Destructor Documentation

CN_VISITOR()

CN_VISITOR::CN_VISITOR ( CN_ITEM *  aItem )

inline

Definition at line 292 of file connectivity_algo.h.

 :
 m_item( aItem )
 {}

Member Function Documentation

checkZoneItemConnection()

void CN_VISITOR::checkZoneItemConnection ( CN_ZONE_LAYER *  aZoneLayer, CN_ITEM *  aItem  )

protected

Definition at line 746 of file connectivity_algo.cpp.

{
 PCB_LAYER_ID layer = aZoneLayer->GetLayer();
 BOARD_CONNECTED_ITEM* item = aItem->Parent();
 
 if( !item->IsOnLayer( layer ) )
 return;
 
 auto connect =
 [&]()
 {
 aZoneLayer->Connect( aItem );
 aItem->Connect( aZoneLayer );
 };
 
 // Try quick checks first...
 if( item->Type() == PCB_PAD_T )
 {
 PAD* pad = static_cast<PAD*>( item );
 
 if( pad->GetRemoveUnconnected() && pad->ZoneConnectionCache( layer ) == ZLC_UNCONNECTED )
 return;
 }
 else if( item->Type() == PCB_VIA_T )
 {
 PCB_VIA* via = static_cast<PCB_VIA*>( item );
 
 if( via->GetRemoveUnconnected() && via->ZoneConnectionCache( layer ) == ZLC_UNCONNECTED )
 return;
 }
 
 for( int i = 0; i < aItem->AnchorCount(); ++i )
 {
 if( aZoneLayer->ContainsPoint( aItem->GetAnchor( i ) ) )
 {
 connect();
 return;
 }
 }
 
 if( item->Type() == PCB_VIA_T || item->Type() == PCB_PAD_T )
 {
 // As long as the pad/via crosses the zone layer, check for the full effective shape
 // We check for the overlapping layers above
 if( aZoneLayer->Collide( item->GetEffectiveShape( layer, FLASHING::ALWAYS_FLASHED ).get() ) )
 connect();
 
 return;
 }
 
 if( aZoneLayer->Collide( item->GetEffectiveShape( layer ).get() ) )
 connect();
}

References ALWAYS_FLASHED, CN_ITEM::AnchorCount(), CN_ZONE_LAYER::Collide(), CN_ITEM::Connect(), CN_ZONE_LAYER::ContainsPoint(), CN_ITEM::GetAnchor(), BOARD_ITEM::GetEffectiveShape(), CN_ZONE_LAYER::GetLayer(), BOARD_ITEM::IsOnLayer(), pad, CN_ITEM::Parent(), PCB_PAD_T, PCB_VIA_T, EDA_ITEM::Type(), via, and ZLC_UNCONNECTED.

Referenced by operator()().

checkZoneZoneConnection()

void CN_VISITOR::checkZoneZoneConnection ( CN_ZONE_LAYER *  aZoneLayerA, CN_ZONE_LAYER *  aZoneLayerB  )

protected

Definition at line 800 of file connectivity_algo.cpp.

{
 const ZONE* zoneA = static_cast<const ZONE*>( aZoneLayerA->Parent() );
 const ZONE* zoneB = static_cast<const ZONE*>( aZoneLayerB->Parent() );
 
 const BOX2I& boxA = aZoneLayerA->BBox();
 const BOX2I& boxB = aZoneLayerB->BBox();
 
 PCB_LAYER_ID layer = aZoneLayerA->GetLayer();
 
 if( aZoneLayerB->GetLayer() != layer )
 return;
 
 if( !boxA.Intersects( boxB ) )
 return;
 
 const SHAPE_LINE_CHAIN& outline =
 zoneA->GetFilledPolysList( layer )->COutline( aZoneLayerA->SubpolyIndex() );
 
 for( int i = 0; i < outline.PointCount(); i++ )
 {
 if( !boxB.Contains( outline.CPoint( i ) ) )
 continue;
 
 if( aZoneLayerB->ContainsPoint( outline.CPoint( i ) ) )
 {
 aZoneLayerA->Connect( aZoneLayerB );
 aZoneLayerB->Connect( aZoneLayerA );
 return;
 }
 }
 
 const SHAPE_LINE_CHAIN& outline2 =
 zoneB->GetFilledPolysList( layer )->COutline( aZoneLayerB->SubpolyIndex() );
 
 for( int i = 0; i < outline2.PointCount(); i++ )
 {
 if( !boxA.Contains( outline2.CPoint( i ) ) )
 continue;
 
 if( aZoneLayerA->ContainsPoint( outline2.CPoint( i ) ) )
 {
 aZoneLayerA->Connect( aZoneLayerB );
 aZoneLayerB->Connect( aZoneLayerA );
 return;
 }
 }
}

References CN_ITEM::BBox(), CN_ITEM::Connect(), BOX2< Vec >::Contains(), CN_ZONE_LAYER::ContainsPoint(), SHAPE_LINE_CHAIN::CPoint(), ZONE::GetFilledPolysList(), CN_ZONE_LAYER::GetLayer(), BOX2< Vec >::Intersects(), CN_ITEM::Parent(), SHAPE_LINE_CHAIN::PointCount(), and CN_ZONE_LAYER::SubpolyIndex().

Referenced by operator()().

operator()()

bool CN_VISITOR::operator()

(

CN_ITEM *

aCandidate

)

Definition at line 850 of file connectivity_algo.cpp.

{
 const BOARD_CONNECTED_ITEM* parentA = aCandidate->Parent();
 const BOARD_CONNECTED_ITEM* parentB = m_item->Parent();
 
 if( !aCandidate->Valid() || !m_item->Valid() )
 return true;
 
 if( parentA == parentB )
 return true;
 
 // Don't connect items in different nets that can't be changed
 if( !aCandidate->CanChangeNet() && !m_item->CanChangeNet() && aCandidate->Net() != m_item->Net() )
 return true;
 
 // If both m_item and aCandidate are marked dirty, they will both be searched
 // Since we are reciprocal in our connection, we arbitrarily pick one of the connections
 // to conduct the expensive search
 if( aCandidate->Dirty() && aCandidate < m_item )
 return true;
 
 // We should handle zone-zone connection separately
 if ( parentA->Type() == PCB_ZONE_T && parentB->Type() == PCB_ZONE_T )
 {
 checkZoneZoneConnection( static_cast<CN_ZONE_LAYER*>( m_item ),
 static_cast<CN_ZONE_LAYER*>( aCandidate ) );
 return true;
 }
 
 if( parentA->Type() == PCB_ZONE_T )
 {
 checkZoneItemConnection( static_cast<CN_ZONE_LAYER*>( aCandidate ), m_item );
 return true;
 }
 
 if( parentB->Type() == PCB_ZONE_T )
 {
 checkZoneItemConnection( static_cast<CN_ZONE_LAYER*>( m_item ), aCandidate );
 return true;
 }
 
 LSET commonLayers = parentA->GetLayerSet() & parentB->GetLayerSet();
 
 for( PCB_LAYER_ID layer : commonLayers.Seq() )
 {
 FLASHING flashingA = FLASHING::NEVER_FLASHED;
 FLASHING flashingB = FLASHING::NEVER_FLASHED;
 
 if( const PAD* pad = dyn_cast<const PAD*>( parentA ) )
 {
 if( !pad->GetRemoveUnconnected() || ( ( layer == F_Cu || layer == B_Cu ) && pad->GetKeepTopBottom() ) )
 flashingA = FLASHING::ALWAYS_FLASHED;
 }
 else if( const PCB_VIA* via = dyn_cast<const PCB_VIA*>( parentA ) )
 {
 if( !via->GetRemoveUnconnected() || ( ( layer == F_Cu || layer == B_Cu ) && via->GetKeepTopBottom() ) )
 flashingA = FLASHING::ALWAYS_FLASHED;
 }
 
 if( const PAD* pad = dyn_cast<const PAD*>( parentB ) )
 {
 if( !pad->GetRemoveUnconnected() || ( ( layer == F_Cu || layer == B_Cu ) && pad->GetKeepTopBottom() ) )
 flashingB = FLASHING::ALWAYS_FLASHED;
 }
 else if( const PCB_VIA* via = dyn_cast<const PCB_VIA*>( parentB ) )
 {
 if( !via->GetRemoveUnconnected() || ( ( layer == F_Cu || layer == B_Cu ) && via->GetKeepTopBottom() ) )
 flashingB = FLASHING::ALWAYS_FLASHED;
 }
 
 if( parentA->GetEffectiveShape( layer, flashingA )->Collide(
 parentB->GetEffectiveShape( layer, flashingB ).get() ) )
 {
 m_item->Connect( aCandidate );
 aCandidate->Connect( m_item );
 return true;
 }
 }
 
 return true;
};

References ALWAYS_FLASHED, B_Cu, CN_ITEM::CanChangeNet(), checkZoneItemConnection(), checkZoneZoneConnection(), CN_ITEM::Connect(), CN_ITEM::Dirty(), F_Cu, BOARD_ITEM::GetEffectiveShape(), BOARD_ITEM::GetLayerSet(), m_item, CN_ITEM::Net(), NEVER_FLASHED, pad, CN_ITEM::Parent(), PCB_ZONE_T, LSET::Seq(), EDA_ITEM::Type(), CN_ITEM::Valid(), and via.

Member Data Documentation

m_item

CN_ITEM* CN_VISITOR::m_item

protected

The item we are looking for connections to.

Definition at line 304 of file connectivity_algo.h.

Referenced by operator()().

---

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

• connectivity_algo.h
• connectivity_algo.cpp