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 295 of file connectivity_algo.h.

Constructor & Destructor Documentation

CN_VISITOR()

CN_VISITOR::CN_VISITOR ( CN_ITEM *  aItem )

inline

Definition at line 298 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 670 of file connectivity_algo.cpp.

{
 if( aZoneLayer->Net() != aItem->Net() && !aItem->CanChangeNet() )
 return;

 if( !aZoneLayer->BBox().Intersects( aItem->BBox() ) )
 return;

 int accuracy = 0;

 if( aItem->Parent()->Type() == PCB_VIA_T
 || aItem->Parent()->Type() == PCB_TRACE_T
 || aItem->Parent()->Type() == PCB_ARC_T )
 {
 accuracy = ( static_cast<PCB_TRACK*>( aItem->Parent() )->GetWidth() + 1 ) / 2;
 }

 for( int i = 0; i < aItem->AnchorCount(); ++i )
 {
 if( aZoneLayer->ContainsPoint( aItem->GetAnchor( i ), accuracy ) )
 {
 aZoneLayer->Connect( aItem );
 aItem->Connect( aZoneLayer );
 return;
 }
 }
}

References CN_ITEM::AnchorCount(), CN_ITEM::BBox(), CN_ZONE_LAYER::BBox(), CN_ITEM::CanChangeNet(), CN_ITEM::Connect(), CN_ZONE_LAYER::ContainsPoint(), CN_ITEM::GetAnchor(), BOX2< Vec >::Intersects(), CN_ITEM::Net(), CN_ITEM::Parent(), PCB_ARC_T, PCB_TRACE_T, PCB_VIA_T, and EDA_ITEM::Type().

Referenced by operator()().

checkZoneZoneConnection()

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

protected

Definition at line 698 of file connectivity_algo.cpp.

{
 const ZONE* zoneA = static_cast<const ZONE*>( aZoneLayerA->Parent() );
 const ZONE* zoneB = static_cast<const ZONE*>( aZoneLayerB->Parent() );

 if( aZoneLayerA->Layer() != aZoneLayerB->Layer() )
 return;

 if( aZoneLayerB->Net() != aZoneLayerA->Net() )
 return; // we only test zones belonging to the same net

 const BOX2I& boxA = aZoneLayerA->BBox();
 const BOX2I& boxB = aZoneLayerB->BBox();

 int radiusA = 0;
 int radiusB = 0;

 if( zoneA->GetFilledPolysUseThickness() )
 radiusA = ( zoneA->GetMinThickness() + 1 ) / 2;

 if( zoneB->GetFilledPolysUseThickness() )
 radiusB = ( zoneB->GetMinThickness() + 1 ) / 2;

 PCB_LAYER_ID layer = static_cast<PCB_LAYER_ID>( aZoneLayerA->Layer() );

 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 ), radiusA ) )
 {
 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 ), radiusB ) )
 {
 aZoneLayerA->Connect( aZoneLayerB );
 aZoneLayerB->Connect( aZoneLayerA );
 return;
 }
 }
}

References CN_ZONE_LAYER::BBox(), CN_ITEM::Connect(), BOX2< Vec >::Contains(), CN_ZONE_LAYER::ContainsPoint(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), ZONE::GetFilledPolysList(), ZONE::GetFilledPolysUseThickness(), ZONE::GetMinThickness(), CN_ITEM::Layer(), CN_ITEM::Net(), 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 757 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;

 LSET commonLayers = parentA->GetLayerSet() & parentB->GetLayerSet();

 if( !commonLayers.any() )
 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;
 }

 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, checkZoneItemConnection(), checkZoneZoneConnection(), CN_ITEM::Connect(), CN_ITEM::Dirty(), F_Cu, BOARD_ITEM::GetEffectiveShape(), BOARD_ITEM::GetLayerSet(), m_item, 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 310 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