CONNECTIVITY_DATA Class Reference

#include <connectivity_data.h>

Public Member Functions
	CONNECTIVITY_DATA ()
	~CONNECTIVITY_DATA ()
	CONNECTIVITY_DATA (const std::vector< BOARD_ITEM * > &aItems, bool aSkipItems=false)
void	Build (BOARD *aBoard, PROGRESS_REPORTER *aReporter=nullptr)
	Function Build() Builds the connectivity database for the board aBoard. More...
void	Build (const std::vector< BOARD_ITEM * > &aItems)
	Function Build() Builds the connectivity database for a set of items aItems. More...
bool	Add (BOARD_ITEM *aItem)
	Function Add() Adds an item to the connectivity data. More...
bool	Remove (BOARD_ITEM *aItem)
	Function Remove() Removes an item from the connectivity data. More...
bool	Update (BOARD_ITEM *aItem)
	Function Update() Updates the connectivity data for an item. More...
void	Move (const VECTOR2I &aDelta)
	Moves the connectivity list anchors. More...
void	Clear ()
	Function Clear() Erases the connectivity database. More...
int	GetNetCount () const
	Function GetNetCount() Returns the total number of nets in the connectivity database. More...
RN_NET *	GetRatsnestForNet (int aNet)
	Function GetRatsnestForNet() Returns the ratsnest, expressed as a set of graph edges for a given net. More...
void	PropagateNets (BOARD_COMMIT *aCommit=nullptr, PROPAGATE_MODE aMode=PROPAGATE_MODE::SKIP_CONFLICTS)
	Propagates the net codes from the source pads to the tracks/vias. More...
bool	CheckConnectivity (std::vector< CN_DISJOINT_NET_ENTRY > &aReport)
void	FindIsolatedCopperIslands (ZONE *aZone, std::vector< int > &aIslands)
	Function FindIsolatedCopperIslands() Searches for copper islands in zone aZone that are not connected to any pad. More...
void	FindIsolatedCopperIslands (std::vector< CN_ZONE_ISOLATED_ISLAND_LIST > &aZones)
void	RecalculateRatsnest (BOARD_COMMIT *aCommit=nullptr)
	Function RecalculateRatsnest() Updates the ratsnest for the board. More...
unsigned int	GetUnconnectedCount () const
	Function GetUnconnectedCount() Returns the number of remaining edges in the ratsnest. More...
bool	IsConnectedOnLayer (const BOARD_CONNECTED_ITEM *aItem, int aLayer, std::vector< KICAD_T > aTypes={}) const
unsigned int	GetNodeCount (int aNet=-1) const
unsigned int	GetPadCount (int aNet=-1) const
const std::vector< PCB_TRACK * >	GetConnectedTracks (const BOARD_CONNECTED_ITEM *aItem) const
const std::vector< PAD * >	GetConnectedPads (const BOARD_CONNECTED_ITEM *aItem) const
void	GetConnectedPads (const BOARD_CONNECTED_ITEM *aItem, std::set< PAD * > *pads) const
const std::vector< BOARD_CONNECTED_ITEM * >	GetConnectedItemsAtAnchor (const BOARD_CONNECTED_ITEM *aItem, const VECTOR2I &aAnchor, const KICAD_T aTypes[], const int &aMaxError=0) const
	Function GetConnectedItemsAtAnchor() Returns a list of items connected to a source item aItem at position aAnchor with an optional maximum distance from the defined anchor. More...
void	GetUnconnectedEdges (std::vector< CN_EDGE > &aEdges) const
bool	TestTrackEndpointDangling (PCB_TRACK *aTrack, wxPoint *aPos=nullptr)
void	ClearDynamicRatsnest ()
	Function ClearDynamicRatsnest() Erases the temporary dynamic ratsnest (i.e. More...
void	HideDynamicRatsnest ()
	Hides the temporary dynamic ratsnest lines. More...
void	ComputeDynamicRatsnest (const std::vector< BOARD_ITEM * > &aItems, const CONNECTIVITY_DATA *aDynamicData)
	Function ComputeDynamicRatsnest() Calculates the temporary dynamic ratsnest (i.e. More...
const std::vector< RN_DYNAMIC_LINE > &	GetDynamicRatsnest () const
const std::vector< BOARD_CONNECTED_ITEM * >	GetConnectedItems (const BOARD_CONNECTED_ITEM *aItem, const KICAD_T aTypes[], bool aIgnoreNetcodes=false) const
	Function GetConnectedItems() Returns a list of items connected to a source item aItem. More...
const std::vector< BOARD_CONNECTED_ITEM * >	GetNetItems (int aNetCode, const KICAD_T aTypes[]) const
	Function GetNetItems() Returns the list of items that belong to a certain net. More...
void	BlockRatsnestItems (const std::vector< BOARD_ITEM * > &aItems)
std::shared_ptr< CN_CONNECTIVITY_ALGO >	GetConnectivityAlgo () const
KISPINLOCK &	GetLock ()
void	MarkItemNetAsDirty (BOARD_ITEM *aItem)
void	SetProgressReporter (PROGRESS_REPORTER *aReporter)
const std::map< int, wxString > &	GetNetclassMap () const
const std::vector< CN_EDGE >	GetRatsnestForItems (const std::vector< BOARD_ITEM * > aItems)
const std::vector< CN_EDGE >	GetRatsnestForComponent (FOOTPRINT *aComponent, bool aSkipInternalConnections=false)
std::shared_ptr< FROM_TO_CACHE >	GetFromToCache ()

Private Member Functions
void	updateRatsnest ()
void	updateItemPositions (const std::vector< BOARD_ITEM * > &aItems)
	Updates the item positions without modifying the dirtyNet flag. More...
void	addRatsnestCluster (const std::shared_ptr< CN_CLUSTER > &aCluster)

Private Attributes
std::shared_ptr< CN_CONNECTIVITY_ALGO >	m_connAlgo
std::shared_ptr< FROM_TO_CACHE >	m_fromToCache
std::vector< RN_DYNAMIC_LINE >	m_dynamicRatsnest
std::vector< RN_NET * >	m_nets
PROGRESS_REPORTER *	m_progressReporter
bool	m_skipRatsnest = false
KISPINLOCK	m_lock
std::map< int, wxString >	m_netclassMap
	Map of netcode -> netclass the net is a member of; used for ratsnest painting. More...

Detailed Description

Definition at line 95 of file connectivity_data.h.

Constructor & Destructor Documentation

CONNECTIVITY_DATA() [1/2]

CONNECTIVITY_DATA::CONNECTIVITY_DATA

(

)

Definition at line 41 of file connectivity_data.cpp.

{
    m_connAlgo.reset( new CN_CONNECTIVITY_ALGO );
    m_progressReporter = nullptr;
    m_fromToCache.reset( new FROM_TO_CACHE );
}

References m_connAlgo, m_fromToCache, and m_progressReporter.

~CONNECTIVITY_DATA()

CONNECTIVITY_DATA::~CONNECTIVITY_DATA

(

)

Definition at line 58 of file connectivity_data.cpp.

{
    Clear();
}

References Clear().

CONNECTIVITY_DATA() [2/2]

CONNECTIVITY_DATA::CONNECTIVITY_DATA	(	const std::vector< BOARD_ITEM * > &	aItems,
		bool	aSkipItems = false
	)

Definition at line 49 of file connectivity_data.cpp.

    : m_skipRatsnest( aSkipRatsnest )
{
    Build( aItems );
    m_progressReporter = nullptr;
    m_fromToCache.reset( new FROM_TO_CACHE );
}

References Build(), m_fromToCache, and m_progressReporter.

Member Function Documentation

Add()

bool CONNECTIVITY_DATA::Add

(

BOARD_ITEM *

aItem

)

Function Add() Adds an item to the connectivity data.

Parameters

aItem

is an item to be added.

Returns

True if operation succeeded.

Definition at line 64 of file connectivity_data.cpp.

{
    m_connAlgo->Add( aItem );
    return true;
}

References m_connAlgo.

addRatsnestCluster()

void CONNECTIVITY_DATA::addRatsnestCluster ( const std::shared_ptr< CN_CLUSTER > &  aCluster )

private

Definition at line 164 of file connectivity_data.cpp.

{
    auto rnNet = m_nets[ aCluster->OriginNet() ];

    rnNet->AddCluster( aCluster );
}

References m_nets.

Referenced by RecalculateRatsnest().

BlockRatsnestItems()

void CONNECTIVITY_DATA::BlockRatsnestItems

(

const std::vector< BOARD_ITEM * > &

aItems

)

Definition at line 224 of file connectivity_data.cpp.

{
    std::vector<BOARD_CONNECTED_ITEM*> citems;

    for( auto item : aItems )
    {
        if( item->Type() == PCB_FOOTPRINT_T )
        {
            for( PAD* pad : static_cast<FOOTPRINT*>(item)->Pads() )
                citems.push_back( pad );
        }
        else
        {
            if( auto citem = dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
                citems.push_back( citem );
        }
    }

    for( const auto& item : citems )
    {
        if ( m_connAlgo->ItemExists( item ) )
        {
            auto& entry = m_connAlgo->ItemEntry( item );

            for( const auto& cnItem : entry.GetItems() )
            {
                for( auto anchor : cnItem->Anchors() )
                    anchor->SetNoLine( true );
            }
        }
    }
}

References anchor, m_connAlgo, pad, and PCB_FOOTPRINT_T.

Build() [1/2]

void CONNECTIVITY_DATA::Build	(	BOARD *	aBoard,
		PROGRESS_REPORTER *	aReporter = nullptr
	)

Function Build() Builds the connectivity database for the board aBoard.

Definition at line 86 of file connectivity_data.cpp.

{
    m_connAlgo.reset( new CN_CONNECTIVITY_ALGO );
    m_connAlgo->Build( aBoard, aReporter );

    m_netclassMap.clear();

    for( NETINFO_ITEM* net : aBoard->GetNetInfo() )
        if( net->GetNetClass()->GetName() != NETCLASS::Default )
            m_netclassMap[ net->GetNetCode() ] = net->GetNetClass()->GetName();

    RecalculateRatsnest();
}

References NETCLASS::Default, BOARD::GetNetInfo(), m_connAlgo, m_netclassMap, and RecalculateRatsnest().

Referenced by CONNECTIVITY_DATA().

Build() [2/2]

void CONNECTIVITY_DATA::Build

(

const std::vector< BOARD_ITEM * > &

aItems

)

Function Build() Builds the connectivity database for a set of items aItems.

Definition at line 101 of file connectivity_data.cpp.

{
    m_connAlgo.reset( new CN_CONNECTIVITY_ALGO );
    m_connAlgo->Build( aItems );

    RecalculateRatsnest();
}

References m_connAlgo, and RecalculateRatsnest().

CheckConnectivity()

bool CONNECTIVITY_DATA::CheckConnectivity

(

std::vector< CN_DISJOINT_NET_ENTRY > &

aReport

)

Definition at line 463 of file connectivity_data.cpp.

{
    RecalculateRatsnest();

    for( auto net : m_nets )
    {
        if( net )
        {
            for( const auto& edge : net->GetEdges() )
            {
                CN_DISJOINT_NET_ENTRY ent;
                ent.net = edge.GetSourceNode()->Parent()->GetNetCode();
                ent.a   = edge.GetSourceNode()->Parent();
                ent.b   = edge.GetTargetNode()->Parent();
                ent.anchorA = edge.GetSourceNode()->Pos();
                ent.anchorB = edge.GetTargetNode()->Pos();
                aReport.push_back( ent );
            }
        }
    }

    return aReport.empty();
}

References CN_DISJOINT_NET_ENTRY::a, CN_DISJOINT_NET_ENTRY::anchorA, CN_DISJOINT_NET_ENTRY::anchorB, CN_DISJOINT_NET_ENTRY::b, m_nets, CN_DISJOINT_NET_ENTRY::net, and RecalculateRatsnest().

Clear()

void CONNECTIVITY_DATA::Clear

(

)

Function Clear() Erases the connectivity database.

Definition at line 401 of file connectivity_data.cpp.

{
    for( auto net : m_nets )
        delete net;

    m_nets.clear();
}

References m_nets.

Referenced by ~CONNECTIVITY_DATA().

ClearDynamicRatsnest()

void CONNECTIVITY_DATA::ClearDynamicRatsnest

(

)

Function ClearDynamicRatsnest() Erases the temporary dynamic ratsnest (i.e.

the ratsnest lines that pcbnew displays when moving an item/set of items)

Definition at line 327 of file connectivity_data.cpp.

{
    m_connAlgo->ForEachAnchor( []( CN_ANCHOR& anchor )
                               {
                                   anchor.SetNoLine( false );
                               } );
    HideDynamicRatsnest();
}

References anchor, HideDynamicRatsnest(), and m_connAlgo.

ComputeDynamicRatsnest()

void CONNECTIVITY_DATA::ComputeDynamicRatsnest	(	const std::vector< BOARD_ITEM * > &	aItems,
		const CONNECTIVITY_DATA *	aDynamicData
	)

Function ComputeDynamicRatsnest() Calculates the temporary dynamic ratsnest (i.e.

the ratsnest lines that) for the set of items aItems.

Definition at line 278 of file connectivity_data.cpp.

{
    if( !aDynamicData )
        return;

    m_dynamicRatsnest.clear();

    // This gets connections between the stationary board and the
    // moving selection
    for( unsigned int nc = 1; nc < aDynamicData->m_nets.size(); nc++ )
    {
        auto dynNet = aDynamicData->m_nets[nc];

        if( dynNet->GetNodeCount() != 0 )
        {
            auto ourNet = m_nets[nc];
            CN_ANCHOR_PTR nodeA, nodeB;

            if( ourNet->NearestBicoloredPair( *dynNet, nodeA, nodeB ) )
            {
                RN_DYNAMIC_LINE l;
                l.a = nodeA->Pos();
                l.b = nodeB->Pos();
                l.netCode = nc;

                m_dynamicRatsnest.push_back( l );
            }
        }
    }

    // This gets the ratsnest for internal connections in the moving set
    const auto& edges = GetRatsnestForItems( aItems );

    for( const auto& edge : edges )
    {
        const auto& nodeA   = edge.GetSourceNode();
        const auto& nodeB   = edge.GetTargetNode();
        RN_DYNAMIC_LINE l;

        // Use the parents' positions
        l.a = nodeA->Parent()->GetPosition();
        l.b = nodeB->Parent()->GetPosition();
        l.netCode = 0;
        m_dynamicRatsnest.push_back( l );
    }
}

References RN_DYNAMIC_LINE::a, RN_DYNAMIC_LINE::b, GetRatsnestForItems(), m_dynamicRatsnest, m_nets, and RN_DYNAMIC_LINE::netCode.

FindIsolatedCopperIslands() [1/2]

void CONNECTIVITY_DATA::FindIsolatedCopperIslands	(	ZONE *	aZone,
		std::vector< int > &	aIslands
	)

Function FindIsolatedCopperIslands() Searches for copper islands in zone aZone that are not connected to any pad.

Parameters

aZone	zone to test
aIslands	list of islands that have no connections (outline indices in the polygon set)

Definition at line 264 of file connectivity_data.cpp.

{
    // TODO(JE) ZONES
#if 0
    m_connAlgo->FindIsolatedCopperIslands( aZone, aIslands );
#endif
}

References m_connAlgo.

FindIsolatedCopperIslands() [2/2]

void CONNECTIVITY_DATA::FindIsolatedCopperIslands

(

std::vector< CN_ZONE_ISOLATED_ISLAND_LIST > &

aZones

)

Definition at line 272 of file connectivity_data.cpp.

{
    m_connAlgo->FindIsolatedCopperIslands( aZones );
}

References m_connAlgo.

GetConnectedItems()

const std::vector< BOARD_CONNECTED_ITEM * > CONNECTIVITY_DATA::GetConnectedItems	(	const BOARD_CONNECTED_ITEM *	aItem,
		const KICAD_T	aTypes[],
		bool	aIgnoreNetcodes = false
	)		const

Function GetConnectedItems() Returns a list of items connected to a source item aItem.

Parameters

aItem	is the reference item to find other connected items.
aTypes	allows one to filter by item types.

Definition at line 410 of file connectivity_data.cpp.

{
    std::vector<BOARD_CONNECTED_ITEM*> rv;
    const auto clusters = m_connAlgo->SearchClusters(
            aIgnoreNetcodes ?
                    CN_CONNECTIVITY_ALGO::CSM_PROPAGATE :
                    CN_CONNECTIVITY_ALGO::CSM_CONNECTIVITY_CHECK, aTypes,
            aIgnoreNetcodes ? -1 : aItem->GetNetCode() );

    for( auto cl : clusters )
    {
        if( cl->Contains( aItem ) )
        {
            for( const auto item : *cl )
            {
                if( item->Valid() )
                    rv.push_back( item->Parent() );
            }
        }
    }

    return rv;
}

References CN_CONNECTIVITY_ALGO::CSM_CONNECTIVITY_CHECK, CN_CONNECTIVITY_ALGO::CSM_PROPAGATE, BOARD_CONNECTED_ITEM::GetNetCode(), and m_connAlgo.

GetConnectedItemsAtAnchor()

const std::vector< BOARD_CONNECTED_ITEM * > CONNECTIVITY_DATA::GetConnectedItemsAtAnchor	(	const BOARD_CONNECTED_ITEM *	aItem,
		const VECTOR2I &	aAnchor,
		const KICAD_T	aTypes[],
		const int &	aMaxError = 0
	)		const

Function GetConnectedItemsAtAnchor() Returns a list of items connected to a source item aItem at position aAnchor with an optional maximum distance from the defined anchor.

Parameters

aItem	is the reference item to find other connected items.
aAnchor	is the position to find connected items on.
aTypes	allows one to filter by item types.
aMaxError	Maximum distance of the found items' anchors to aAnchor in IU

Returns

Definition at line 716 of file connectivity_data.cpp.

{
    auto&                              entry = m_connAlgo->ItemEntry( aItem );
    std::vector<BOARD_CONNECTED_ITEM*> rv;
    SEG::ecoord                        maxErrorSq = (SEG::ecoord) aMaxError * aMaxError;

    for( auto cnItem : entry.GetItems() )
    {
        for( auto connected : cnItem->ConnectedItems() )
        {
            for( auto anchor : connected->Anchors() )
            {
                if( ( anchor->Pos() - aAnchor ).SquaredEuclideanNorm() <= maxErrorSq )
                {
                    for( int i = 0; aTypes[i] > 0; i++ )
                    {
                        if( connected->Valid() && connected->Parent()->Type() == aTypes[i] )
                        {
                            rv.push_back( connected->Parent() );
                            break;
                        }
                    }

                    break;
                }
            }
        }
    }

    return rv;
}

References anchor, and m_connAlgo.

GetConnectedPads() [1/2]

const std::vector< PAD * > CONNECTIVITY_DATA::GetConnectedPads

(

const BOARD_CONNECTED_ITEM *

aItem

)

const

Definition at line 527 of file connectivity_data.cpp.

{
    std::set<PAD*>    pads;
    std::vector<PAD*> rv;

    GetConnectedPads( aItem, &pads );

    std::copy( pads.begin(), pads.end(), std::back_inserter( rv ) );
    return rv;
}

GetConnectedPads() [2/2]

void CONNECTIVITY_DATA::GetConnectedPads	(	const BOARD_CONNECTED_ITEM *	aItem,
		std::set< PAD * > *	pads
	)		const

Definition at line 513 of file connectivity_data.cpp.

{
    for( CN_ITEM* citem : m_connAlgo->ItemEntry( aItem ).GetItems() )
    {
        for( CN_ITEM* connected : citem->ConnectedItems() )
        {
            if( connected->Valid() && connected->Parent()->Type() == PCB_PAD_T )
                pads->insert( static_cast<PAD*> ( connected->Parent() ) );
        }
    }
}

References CN_ITEM::ConnectedItems(), m_connAlgo, and PCB_PAD_T.

GetConnectedTracks()

const std::vector< PCB_TRACK * > CONNECTIVITY_DATA::GetConnectedTracks

(

const BOARD_CONNECTED_ITEM *

aItem

)

const

Definition at line 488 of file connectivity_data.cpp.

{
    auto& entry = m_connAlgo->ItemEntry( aItem );

    std::set<PCB_TRACK*> tracks;
    std::vector<PCB_TRACK*> rv;

    for( CN_ITEM* citem : entry.GetItems() )
    {
        for( CN_ITEM* connected : citem->ConnectedItems() )
        {
            if( connected->Valid() &&
                    ( connected->Parent()->Type() == PCB_TRACE_T ||
                            connected->Parent()->Type() == PCB_VIA_T ||
                            connected->Parent()->Type() == PCB_ARC_T ) )
                tracks.insert( static_cast<PCB_TRACK*> ( connected->Parent() ) );
        }
    }

    std::copy( tracks.begin(), tracks.end(), std::back_inserter( rv ) );
    return rv;
}

References CN_ITEM::ConnectedItems(), m_connAlgo, PCB_ARC_T, PCB_TRACE_T, and PCB_VIA_T.

GetConnectivityAlgo()

std::shared_ptr<CN_CONNECTIVITY_ALGO> CONNECTIVITY_DATA::GetConnectivityAlgo ( ) const

inline

Definition at line 276 of file connectivity_data.h.

    {
        return m_connAlgo;
    }

References m_connAlgo.

Referenced by TestTrackEndpointDangling().

GetDynamicRatsnest()

const std::vector<RN_DYNAMIC_LINE>& CONNECTIVITY_DATA::GetDynamicRatsnest ( ) const

inline

Definition at line 251 of file connectivity_data.h.

    {
        return m_dynamicRatsnest;
    }

References m_dynamicRatsnest.

GetFromToCache()

std::shared_ptr<FROM_TO_CACHE> CONNECTIVITY_DATA::GetFromToCache ( )

inline

Definition at line 301 of file connectivity_data.h.

    {
        return m_fromToCache;
    }

References m_fromToCache.

GetLock()

KISPINLOCK& CONNECTIVITY_DATA::GetLock ( )

inline

Definition at line 281 of file connectivity_data.h.

    {
        return m_lock;
    }

References m_lock.

GetNetclassMap()

const std::map<int, wxString>& CONNECTIVITY_DATA::GetNetclassMap ( ) const

inline

Definition at line 289 of file connectivity_data.h.

    {
        return m_netclassMap;
    }

References m_netclassMap.

GetNetCount()

int CONNECTIVITY_DATA::GetNetCount

(

)

const

Function GetNetCount() Returns the total number of nets in the connectivity database.

Definition at line 258 of file connectivity_data.cpp.

{
    return m_connAlgo->NetCount();
}

References m_connAlgo.

GetNetItems()

const std::vector< BOARD_CONNECTED_ITEM * > CONNECTIVITY_DATA::GetNetItems	(	int	aNetCode,
		const KICAD_T	aTypes[]
	)		const

Function GetNetItems() Returns the list of items that belong to a certain net.

Parameters

aNetCode	is the net code.
aTypes	allows one to filter by item types.

Definition at line 438 of file connectivity_data.cpp.

{
    std::vector<BOARD_CONNECTED_ITEM*> items;
    items.reserve( 32 );

    std::bitset<MAX_STRUCT_TYPE_ID> type_bits;

    for( unsigned int i = 0; aTypes[i] != EOT; ++i )
    {
        wxASSERT( aTypes[i] < MAX_STRUCT_TYPE_ID );
        type_bits.set( aTypes[i] );
    }

    m_connAlgo->ForEachItem( [&]( CN_ITEM& aItem ) {
        if( aItem.Valid() && ( aItem.Net() == aNetCode ) && type_bits[aItem.Parent()->Type()] )
            items.push_back( aItem.Parent() );
    } );

    std::sort( items.begin(), items.end() );
    items.erase( std::unique( items.begin(), items.end() ), items.end() );
    return items;
}

References EOT, m_connAlgo, MAX_STRUCT_TYPE_ID, CN_ITEM::Net(), CN_ITEM::Parent(), EDA_ITEM::Type(), and CN_ITEM::Valid().

GetNodeCount()

unsigned int CONNECTIVITY_DATA::GetNodeCount

(

int

aNet = -1

)

const

Definition at line 540 of file connectivity_data.cpp.

{
    int sum = 0;

    if( aNet < 0 )      // Node count for all nets
    {
        for( const RN_NET* net : m_nets )
            sum += net->GetNodeCount();
    }
    else if( aNet < (int) m_nets.size() )
    {
        sum = m_nets[aNet]->GetNodeCount();
    }

    return sum;
}

References m_nets.

GetPadCount()

unsigned int CONNECTIVITY_DATA::GetPadCount

(

int

aNet = -1

)

const

Definition at line 558 of file connectivity_data.cpp.

{
    int n = 0;

    for( CN_ITEM* pad : m_connAlgo->ItemList() )
    {
        if( !pad->Valid() || pad->Parent()->Type() != PCB_PAD_T)
            continue;

        PAD* dpad = static_cast<PAD*>( pad->Parent() );

        if( aNet < 0 || aNet == dpad->GetNetCode() )
            n++;
    }

    return n;
}

References m_connAlgo, pad, and PCB_PAD_T.

GetRatsnestForComponent()

const std::vector< CN_EDGE > CONNECTIVITY_DATA::GetRatsnestForComponent	(	FOOTPRINT *	aComponent,
		bool	aSkipInternalConnections = false
	)

Definition at line 834 of file connectivity_data.cpp.

{
    std::set<int> nets;
    std::set<const PAD*> pads;
    std::vector<CN_EDGE> edges;

    for( auto pad : aComponent->Pads() )
    {
        nets.insert( pad->GetNetCode() );
        pads.insert( pad );
    }

    for( const auto& netcode : nets )
    {
        const auto& net = GetRatsnestForNet( netcode );

        for( const auto& edge : net->GetEdges() )
        {
            auto srcNode = edge.GetSourceNode();
            auto dstNode = edge.GetTargetNode();

            const PAD* srcParent = static_cast<const PAD*>( srcNode->Parent() );
            const PAD* dstParent = static_cast<const PAD*>( dstNode->Parent() );

            bool srcFound = ( pads.find(srcParent) != pads.end() );
            bool dstFound = ( pads.find(dstParent) != pads.end() );

            if ( srcFound && dstFound && !aSkipInternalConnections )
            {
                edges.push_back( edge );
            }
            else if ( srcFound || dstFound )
            {
                edges.push_back( edge );
            }
        }
    }

    return edges;
}

References GetRatsnestForNet(), pad, and FOOTPRINT::Pads().

GetRatsnestForItems()

const std::vector< CN_EDGE > CONNECTIVITY_DATA::GetRatsnestForItems

(

const std::vector< BOARD_ITEM * >

aItems

)

Definition at line 785 of file connectivity_data.cpp.

{
    std::set<int> nets;
    std::vector<CN_EDGE> edges;
    std::set<BOARD_CONNECTED_ITEM*> item_set;

    for( auto item : aItems )
    {
        if( item->Type() == PCB_FOOTPRINT_T )
        {
            FOOTPRINT* footprint = static_cast<FOOTPRINT*>( item );

            for( PAD* pad : footprint->Pads() )
            {
                nets.insert( pad->GetNetCode() );
                item_set.insert( pad );
            }
        }
        else if( auto conn_item = dyn_cast<BOARD_CONNECTED_ITEM*>( item ) )
        {
            item_set.insert( conn_item );
            nets.insert( conn_item->GetNetCode() );
        }
    }

    for( const auto& netcode : nets )
    {
        const auto& net = GetRatsnestForNet( netcode );

        for( const auto& edge : net->GetEdges() )
        {
            auto srcNode = edge.GetSourceNode();
            auto dstNode = edge.GetTargetNode();

            auto srcParent = srcNode->Parent();
            auto dstParent = dstNode->Parent();

            bool srcFound = ( item_set.find(srcParent) != item_set.end() );
            bool dstFound = ( item_set.find(dstParent) != item_set.end() );

            if ( srcFound && dstFound )
                edges.push_back( edge );
        }
    }

    return edges;
}

References GetRatsnestForNet(), pad, FOOTPRINT::Pads(), and PCB_FOOTPRINT_T.

Referenced by ComputeDynamicRatsnest().

GetRatsnestForNet()

RN_NET * CONNECTIVITY_DATA::GetRatsnestForNet

(

int

aNet

)

Function GetRatsnestForNet() Returns the ratsnest, expressed as a set of graph edges for a given net.

Definition at line 753 of file connectivity_data.cpp.

{
    if ( aNet < 0 || aNet >= (int) m_nets.size() )
    {
        return nullptr;
    }

    return m_nets[ aNet ];
}

References m_nets.

Referenced by GetRatsnestForComponent(), and GetRatsnestForItems().

GetUnconnectedCount()

unsigned int CONNECTIVITY_DATA::GetUnconnectedCount

(

)

const

Function GetUnconnectedCount() Returns the number of remaining edges in the ratsnest.

Definition at line 380 of file connectivity_data.cpp.

{
    unsigned int unconnected = 0;

    for( auto net : m_nets )
    {
        if( !net )
            continue;

        const auto& edges = net->GetUnconnected();

        if( edges.empty() )
            continue;

        unconnected += edges.size();
    }

    return unconnected;
}

References m_nets.

GetUnconnectedEdges()

void CONNECTIVITY_DATA::GetUnconnectedEdges

(

std::vector< CN_EDGE > &

aEdges

)

const

Definition at line 577 of file connectivity_data.cpp.

{
    for( const RN_NET* rnNet : m_nets )
    {
        if( rnNet )
        {
            for( const CN_EDGE& edge : rnNet->GetEdges() )
                aEdges.push_back( edge );
        }
    }
}

References m_nets.

HideDynamicRatsnest()

void CONNECTIVITY_DATA::HideDynamicRatsnest

(

)

Hides the temporary dynamic ratsnest lines.

Definition at line 337 of file connectivity_data.cpp.

{
    m_dynamicRatsnest.clear();
}

References m_dynamicRatsnest.

Referenced by ClearDynamicRatsnest().

IsConnectedOnLayer()

bool CONNECTIVITY_DATA::IsConnectedOnLayer	(	const BOARD_CONNECTED_ITEM *	aItem,
		int	aLayer,
		std::vector< KICAD_T >	aTypes = {}
	)		const

Definition at line 349 of file connectivity_data.cpp.

{
    CN_CONNECTIVITY_ALGO::ITEM_MAP_ENTRY &entry = m_connAlgo->ItemEntry( aItem );

    auto matchType = [&]( KICAD_T aItemType )
    {
        if( aTypes.empty() )
            return true;

        return std::count( aTypes.begin(), aTypes.end(), aItemType ) > 0;
    };

    for( CN_ITEM* citem : entry.GetItems() )
    {
        for( CN_ITEM* connected : citem->ConnectedItems() )
        {
            if( connected->Valid()
                    && connected->Layers().Overlaps( aLayer )
                    && connected->Net() == aItem->GetNetCode()
                    && matchType( connected->Parent()->Type() ) )
            {
                    return true;
            }
        }
    }

    return false;
}

References CN_ITEM::ConnectedItems(), CN_CONNECTIVITY_ALGO::ITEM_MAP_ENTRY::GetItems(), BOARD_CONNECTED_ITEM::GetNetCode(), and m_connAlgo.

MarkItemNetAsDirty()

void CONNECTIVITY_DATA::MarkItemNetAsDirty

(

BOARD_ITEM *

aItem

)

Definition at line 764 of file connectivity_data.cpp.

{
    if ( aItem->Type() == PCB_FOOTPRINT_T)
    {
        for( PAD* pad : static_cast<FOOTPRINT*>( aItem )->Pads() )
            m_connAlgo->MarkNetAsDirty( pad->GetNetCode() );
    }
    if (aItem->IsConnected() )
    {
        m_connAlgo->MarkNetAsDirty( static_cast<BOARD_CONNECTED_ITEM*>( aItem )->GetNetCode() );
    }
}

References BOARD_ITEM::IsConnected(), m_connAlgo, pad, PCB_FOOTPRINT_T, and EDA_ITEM::Type().

Move()

void CONNECTIVITY_DATA::Move

(

const VECTOR2I &

aDelta

)

Moves the connectivity list anchors.

N.B., this does not move the bounding boxes for the RTree, so the use of this function will invalidate the connectivity data for uses other than the dynamic ratsnest

Parameters

aDelta

vector for movement of the tree

Definition at line 110 of file connectivity_data.cpp.

{
    m_connAlgo->ForEachAnchor( [&aDelta]( CN_ANCHOR& anchor )
                               {
                                   anchor.Move( aDelta );
                               } );
}

References anchor, and m_connAlgo.

Referenced by BOARD_INSPECTION_TOOL::calculateSelectionRatsnest().

PropagateNets()

void CONNECTIVITY_DATA::PropagateNets	(	BOARD_COMMIT *	aCommit = nullptr,
		PROPAGATE_MODE	aMode = PROPAGATE_MODE::SKIP_CONFLICTS
	)

Propagates the net codes from the source pads to the tracks/vias.

Parameters

aCommit	is used to save the undo state of items modified by this call
aMode	controls how conflicts between pads are resolved

Definition at line 343 of file connectivity_data.cpp.

{
    m_connAlgo->PropagateNets( aCommit, aMode );
}

References m_connAlgo.

RecalculateRatsnest()

void CONNECTIVITY_DATA::RecalculateRatsnest

(

BOARD_COMMIT *

aCommit = nullptr

)

Function RecalculateRatsnest() Updates the ratsnest for the board.

Parameters

aCommit

is used to save the undo state of items modified by this call

Definition at line 172 of file connectivity_data.cpp.

{
    m_connAlgo->PropagateNets( aCommit );

    int lastNet = m_connAlgo->NetCount();

    if( lastNet >= (int) m_nets.size() )
    {
        unsigned int prevSize = m_nets.size();
        m_nets.resize( lastNet + 1 );

        for( unsigned int i = prevSize; i < m_nets.size(); i++ )
            m_nets[i] = new RN_NET;
    }

    auto clusters = m_connAlgo->GetClusters();

    int dirtyNets = 0;

    for( int net = 0; net < lastNet; net++ )
    {
        if( m_connAlgo->IsNetDirty( net ) )
        {
            m_nets[net]->Clear();
            dirtyNets++;
        }
    }

    for( const auto& c : clusters )
    {
        int net = c->OriginNet();

        // Don't add intentionally-kept zone islands to the ratsnest
        if( c->IsOrphaned() && c->Size() == 1 )
        {
            if( dynamic_cast<CN_ZONE_LAYER*>( *c->begin() ) )
                continue;
        }

        if( m_connAlgo->IsNetDirty( net ) )
        {
            addRatsnestCluster( c );
        }
    }

    m_connAlgo->ClearDirtyFlags();

    if( !m_skipRatsnest )
        updateRatsnest();
}

References addRatsnestCluster(), m_connAlgo, m_nets, m_skipRatsnest, and updateRatsnest().

Referenced by Build(), and CheckConnectivity().

Remove()

bool CONNECTIVITY_DATA::Remove

(

BOARD_ITEM *

aItem

)

Function Remove() Removes an item from the connectivity data.

Parameters

aItem

is an item to be updated.

Returns

True if operation succeeded.

Definition at line 71 of file connectivity_data.cpp.

{
    m_connAlgo->Remove( aItem );
    return true;
}

References m_connAlgo.

SetProgressReporter()

void CONNECTIVITY_DATA::SetProgressReporter

(

PROGRESS_REPORTER *

aReporter

)

Definition at line 778 of file connectivity_data.cpp.

{
    m_progressReporter = aReporter;
    m_connAlgo->SetProgressReporter( m_progressReporter );
}

References m_connAlgo, and m_progressReporter.

TestTrackEndpointDangling()

bool CONNECTIVITY_DATA::TestTrackEndpointDangling	(	PCB_TRACK *	aTrack,
		wxPoint *	aPos = nullptr
	)

Definition at line 609 of file connectivity_data.cpp.

{
    std::list<CN_ITEM*> items = GetConnectivityAlgo()->ItemEntry( aTrack ).GetItems();

    // Not in the connectivity system.  This is a bug!
    if( items.empty() )
    {
        wxFAIL_MSG( "track not in connectivity system" );
        return false;
    }

    CN_ITEM* citem = items.front();

    if( !citem->Valid() )
        return false;

    if( aTrack->Type() == PCB_TRACE_T || aTrack->Type() == PCB_ARC_T )
    {
        // Test if a segment is connected on each end.
        //
        // NB: be wary of short segments which can be connected to the *same* other item on
        // each end.  If that's their only connection then they're still dangling.

        PCB_LAYER_ID layer = aTrack->GetLayer();
        int          accuracy = KiROUND( aTrack->GetWidth() / 2 );
        int          start_count = 0;
        int          end_count = 0;

        for( CN_ITEM* connected : citem->ConnectedItems() )
        {
            BOARD_CONNECTED_ITEM* item = connected->Parent();

            if( item->GetFlags() & IS_DELETED )
                continue;

            std::shared_ptr<SHAPE> shape = item->GetEffectiveShape( layer );

            bool hitStart = shape->Collide( aTrack->GetStart(), accuracy );
            bool hitEnd = shape->Collide( aTrack->GetEnd(), accuracy );

            if( hitStart && hitEnd )
            {
                if( getMinDist( item, aTrack->GetStart() ) < getMinDist( item, aTrack->GetEnd() ) )
                    start_count++;
                else
                    end_count++;
            }
            else if( hitStart )
            {
                start_count++;
            }
            else if( hitEnd )
            {
                end_count++;
            }

            if( start_count > 0 && end_count > 0 )
                return false;
        }

        if( aPos )
            *aPos = (start_count == 0 ) ? aTrack->GetStart() : aTrack->GetEnd();

        return true;
    }
    else if( aTrack->Type() == PCB_VIA_T )
    {
        // Test if a via is only connected on one layer

        const std::vector<CN_ITEM*>& connected = citem->ConnectedItems();

        if( connected.empty() )
        {
            if( aPos )
                *aPos = aTrack->GetPosition();

            return true;
        }

        // Here, we check if the via is connected only to items on a single layer
        int first_layer = UNDEFINED_LAYER;

        for( CN_ITEM* item : connected )
        {
            if( item->Parent()->GetFlags() & IS_DELETED )
                continue;

            if( first_layer == UNDEFINED_LAYER )
                first_layer = item->Layer();
            else if( item->Layer() != first_layer )
               return false;
        }

        if( aPos )
            *aPos = aTrack->GetPosition();

        return true;
    }
    else
    {
        wxFAIL_MSG( "CONNECTIVITY_DATA::TestTrackEndpointDangling: unknown track type" );
    }

    return false;
}

References CN_ITEM::ConnectedItems(), GetConnectivityAlgo(), BOARD_ITEM::GetEffectiveShape(), PCB_TRACK::GetEnd(), EDA_ITEM::GetFlags(), BOARD_ITEM::GetLayer(), getMinDist(), PCB_TRACK::GetPosition(), PCB_TRACK::GetStart(), PCB_TRACK::GetWidth(), IS_DELETED, KiROUND(), PCB_ARC_T, PCB_TRACE_T, PCB_VIA_T, EDA_ITEM::Type(), UNDEFINED_LAYER, and CN_ITEM::Valid().

Update()

bool CONNECTIVITY_DATA::Update

(

BOARD_ITEM *

aItem

)

Function Update() Updates the connectivity data for an item.

Parameters

aItem

is an item to be updated.

Returns

True if operation succeeded.

Definition at line 78 of file connectivity_data.cpp.

{
    m_connAlgo->Remove( aItem );
    m_connAlgo->Add( aItem );
    return true;
}

References m_connAlgo.

Referenced by updateRatsnest().

updateItemPositions()

void CONNECTIVITY_DATA::updateItemPositions ( const std::vector< BOARD_ITEM * > &  aItems )

private

Updates the item positions without modifying the dirtyNet flag.

This is valid only when the item list contains all elements in the connectivity database

Parameters

aItems

List of items with new positions

updateRatsnest()

void CONNECTIVITY_DATA::updateRatsnest ( )

private

Definition at line 119 of file connectivity_data.cpp.

{
    #ifdef PROFILE
    PROF_COUNTER rnUpdate( "update-ratsnest" );
    #endif
    std::vector<RN_NET*> dirty_nets;

    // Start with net 1 as net 0 is reserved for not-connected
    // Nets without nodes are also ignored
    std::copy_if( m_nets.begin() + 1, m_nets.end(), std::back_inserter( dirty_nets ),
            [] ( RN_NET* aNet ) { return aNet->IsDirty() && aNet->GetNodeCount() > 0; } );

    // We don't want to spin up a new thread for fewer than 8 nets (overhead costs)
    size_t parallelThreadCount = std::min<size_t>( std::thread::hardware_concurrency(),
            ( dirty_nets.size() + 7 ) / 8 );

    std::atomic<size_t> nextNet( 0 );
    std::vector<std::future<size_t>> returns( parallelThreadCount );

    auto update_lambda = [&nextNet, &dirty_nets]() -> size_t
    {
        for( size_t i = nextNet++; i < dirty_nets.size(); i = nextNet++ )
            dirty_nets[i]->Update();

        return 1;
    };

    if( parallelThreadCount == 1 )
        update_lambda();
    else
    {
        for( size_t ii = 0; ii < parallelThreadCount; ++ii )
            returns[ii] = std::async( std::launch::async, update_lambda );

        // Finalize the ratsnest threads
        for( size_t ii = 0; ii < parallelThreadCount; ++ii )
            returns[ii].wait();
    }

    #ifdef PROFILE
    rnUpdate.Show();
    #endif /* PROFILE */
}

References m_nets, PROF_COUNTER::Show(), and Update().

Referenced by RecalculateRatsnest().

Member Data Documentation

m_connAlgo

std::shared_ptr<CN_CONNECTIVITY_ALGO> CONNECTIVITY_DATA::m_connAlgo

private

Definition at line 318 of file connectivity_data.h.

Referenced by Add(), BlockRatsnestItems(), Build(), ClearDynamicRatsnest(), CONNECTIVITY_DATA(), FindIsolatedCopperIslands(), GetConnectedItems(), GetConnectedItemsAtAnchor(), GetConnectedPads(), GetConnectedTracks(), GetConnectivityAlgo(), GetNetCount(), GetNetItems(), GetPadCount(), IsConnectedOnLayer(), MarkItemNetAsDirty(), Move(), PropagateNets(), RecalculateRatsnest(), Remove(), SetProgressReporter(), and Update().

m_dynamicRatsnest

std::vector<RN_DYNAMIC_LINE> CONNECTIVITY_DATA::m_dynamicRatsnest

private

Definition at line 320 of file connectivity_data.h.

Referenced by ComputeDynamicRatsnest(), GetDynamicRatsnest(), and HideDynamicRatsnest().

m_fromToCache

std::shared_ptr<FROM_TO_CACHE> CONNECTIVITY_DATA::m_fromToCache

private

Definition at line 319 of file connectivity_data.h.

Referenced by CONNECTIVITY_DATA(), and GetFromToCache().

m_lock

KISPINLOCK CONNECTIVITY_DATA::m_lock

private

Definition at line 327 of file connectivity_data.h.

Referenced by GetLock().

m_netclassMap

std::map<int, wxString> CONNECTIVITY_DATA::m_netclassMap

private

Map of netcode -> netclass the net is a member of; used for ratsnest painting.

Definition at line 330 of file connectivity_data.h.

Referenced by Build(), and GetNetclassMap().

m_nets

std::vector<RN_NET*> CONNECTIVITY_DATA::m_nets

private

Definition at line 321 of file connectivity_data.h.

Referenced by addRatsnestCluster(), CheckConnectivity(), Clear(), ComputeDynamicRatsnest(), GetNodeCount(), GetRatsnestForNet(), GetUnconnectedCount(), GetUnconnectedEdges(), RecalculateRatsnest(), and updateRatsnest().

m_progressReporter

PROGRESS_REPORTER* CONNECTIVITY_DATA::m_progressReporter

private

Definition at line 323 of file connectivity_data.h.

Referenced by CONNECTIVITY_DATA(), and SetProgressReporter().

m_skipRatsnest

bool CONNECTIVITY_DATA::m_skipRatsnest = false

private

Definition at line 325 of file connectivity_data.h.

Referenced by RecalculateRatsnest().

---

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

• connectivity_data.h
• connectivity_data.cpp