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 ()
	Function PropagateNets() 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< 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
	Function GetConnectedItemsAtAnchor() Returns a list of items connected to a source item aItem at position aAnchor. More...
void	GetUnconnectedEdges (std::vector< CN_EDGE > &aEdges) const
bool	TestTrackEndpointDangling (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 86 of file connectivity_data.h.

Constructor & Destructor Documentation

CONNECTIVITY_DATA() [1/2]

CONNECTIVITY_DATA::CONNECTIVITY_DATA

(

)

Definition at line 40 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 57 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 48 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 63 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 163 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 223 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 m_connAlgo, 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 85 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 100 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 461 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 399 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 326 of file connectivity_data.cpp.

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

References HideDynamicRatsnest(), m_connAlgo, and CN_ANCHOR::SetNoLine().

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 277 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 263 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 271 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 408 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

Function GetConnectedItemsAtAnchor() Returns a list of items connected to a source item aItem at position aAnchor.

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.

Returns

Definition at line 648 of file connectivity_data.cpp.

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

    for( auto cnItem : entry.GetItems() )
    {
        for( auto connected : cnItem->ConnectedItems() )
        {
            for( auto anchor : connected->Anchors() )
            {
                if( anchor->Pos() == aAnchor )
                {
                    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 m_connAlgo.

GetConnectedPads() [1/2]

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

(

const BOARD_CONNECTED_ITEM *

aItem

)

const

Definition at line 525 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 511 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< TRACK * > CONNECTIVITY_DATA::GetConnectedTracks

(

const BOARD_CONNECTED_ITEM *

aItem

)

const

Definition at line 486 of file connectivity_data.cpp.

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

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

    for( auto citem : entry.GetItems() )
    {
        for( auto 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<TRACK*> ( connected->Parent() ) );
        }
    }

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

References 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 260 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 235 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 285 of file connectivity_data.h.

    {
        return m_fromToCache;
    }

References m_fromToCache.

GetLock()

KISPINLOCK& CONNECTIVITY_DATA::GetLock ( )

inline

Definition at line 265 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 273 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 257 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 436 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 538 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 556 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, and PCB_PAD_T.

GetRatsnestForComponent()

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

Definition at line 762 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(), and FOOTPRINT::Pads().

GetRatsnestForItems()

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

(

const std::vector< BOARD_ITEM * >

aItems

)

Definition at line 713 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(), 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 681 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 378 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 575 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 336 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 347 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 692 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, 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 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 109 of file connectivity_data.cpp.

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

References m_connAlgo, and CN_ANCHOR::Move().

Referenced by BOARD_INSPECTION_TOOL::calculateSelectionRatsnest().

PropagateNets()

void CONNECTIVITY_DATA::PropagateNets

(

)

Function PropagateNets() Propagates the net codes from the source pads to the tracks/vias.

Definition at line 342 of file connectivity_data.cpp.

{
    m_connAlgo->PropagateNets();
}

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 171 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 70 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 706 of file connectivity_data.cpp.

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

References m_connAlgo, and m_progressReporter.

TestTrackEndpointDangling()

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

Definition at line 588 of file connectivity_data.cpp.

{
    auto 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;

    for( const std::shared_ptr<CN_ANCHOR>& anchor : citem->Anchors() )
    {
        if( anchor->IsDangling() )
        {
            if( aPos )
                *aPos = static_cast<wxPoint>( anchor->Pos() );

            return true;
        }
    }

    // Test if a via is only connected on one layer
    if( aTrack->Type() == PCB_VIA_T )
    {
        const CN_ITEM::CONNECTED_ITEMS& connected = citem->ConnectedItems();

        // This is a bit redundant but better safe than sorry here
        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 = connected.front()->Layer();

        for( auto& item : connected )
        {
           if( item->Layer() != first_layer )
               return false;
        }

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

        return true;
    }

    return false;
}

References CN_ITEM::Anchors(), CN_ITEM::ConnectedItems(), GetConnectivityAlgo(), TRACK::GetPosition(), PCB_VIA_T, EDA_ITEM::Type(), 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 77 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 118 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 302 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 304 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 303 of file connectivity_data.h.

Referenced by CONNECTIVITY_DATA(), and GetFromToCache().

m_lock

KISPINLOCK CONNECTIVITY_DATA::m_lock

private

Definition at line 311 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 314 of file connectivity_data.h.

Referenced by Build(), and GetNetclassMap().

m_nets

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

private

Definition at line 305 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 307 of file connectivity_data.h.

Referenced by CONNECTIVITY_DATA(), and SetProgressReporter().

m_skipRatsnest

bool CONNECTIVITY_DATA::m_skipRatsnest = false

private

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