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)
	The item we are looking for connections to. More...

Protected Attributes
CN_ITEM *	m_item

Detailed Description

Definition at line 288 of file connectivity_algo.h.

Constructor & Destructor Documentation

CN_VISITOR()

CN_VISITOR::CN_VISITOR ( CN_ITEM *  aItem )

inline

Definition at line 291 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 646 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

The item we are looking for connections to.

Definition at line 674 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 733 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;

    if( !( parentA->GetLayerSet() & parentB->GetLayerSet() ).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;
    }

    int accuracyA = 0;
    int accuracyB = 0;

    if( parentA->Type() == PCB_VIA_T
            || parentA->Type() == PCB_TRACE_T
            || parentA->Type() == PCB_ARC_T)
        accuracyA = ( static_cast<const PCB_TRACK*>( parentA )->GetWidth() + 1 ) / 2;

    if( parentB->Type() == PCB_VIA_T
            || parentB->Type() == PCB_TRACE_T
            || parentB->Type() == PCB_ARC_T )
        accuracyB = ( static_cast<const PCB_TRACK*>( parentB )->GetWidth() + 1 ) / 2;

    // Items do not necessarily have reciprocity as we only check for anchors
    //  therefore, we check HitTest both directions A->B & B->A
    for( int i = 0; i < aCandidate->AnchorCount(); ++i )
    {
        if( parentB->HitTest( wxPoint( aCandidate->GetAnchor( i ) ), accuracyA ) )
        {
            m_item->Connect( aCandidate );
            aCandidate->Connect( m_item );
            return true;
        }
    }

    for( int i = 0; i < m_item->AnchorCount(); ++i )
    {
        if( parentA->HitTest( wxPoint( m_item->GetAnchor( i ) ), accuracyB ) )
        {
            m_item->Connect( aCandidate );
            aCandidate->Connect( m_item );
            return true;
        }
    }

    return true;
};

References CN_ITEM::AnchorCount(), checkZoneItemConnection(), checkZoneZoneConnection(), CN_ITEM::Connect(), CN_ITEM::Dirty(), CN_ITEM::GetAnchor(), BOARD_ITEM::GetLayerSet(), EDA_ITEM::HitTest(), m_item, CN_ITEM::Parent(), PCB_ARC_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_T, EDA_ITEM::Type(), and CN_ITEM::Valid().

Member Data Documentation

m_item

CN_ITEM* CN_VISITOR::m_item

protected

Definition at line 303 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