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, bool aConnectivityAlreadyRebuilt=false)
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, const std::initializer_list< KICAD_T > &aTypes={}, bool aCheckOptionalFlashing=false) 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, VECTOR2I *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, VECTOR2I aInternalOffset={ 0, 0 })
	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 std::initializer_list< 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
void	AddExclusion (const KIID &aBoardItemId1, const KIID &aBoardItemId2)
void	RemoveExclusion (const KIID &aBoardItemId1, const KIID &aBoardItemId2)
const std::vector< CN_EDGE >	GetRatsnestForItems (const std::vector< BOARD_ITEM * > aItems)
const std::vector< CN_EDGE >	GetRatsnestForPad (const PAD *aPad)
const std::vector< CN_EDGE >	GetRatsnestForComponent (FOOTPRINT *aComponent, bool aSkipInternalConnections=false)
std::shared_ptr< FROM_TO_CACHE >	GetFromToCache ()

Private Member Functions
void	updateRatsnest ()
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
bool	m_skipRatsnest = false
	Used to suppress ratsnest calculations on dynamic ratsnests. More...
std::set< std::pair< KIID, KIID > >	m_exclusions
	Ratsnest lines that have been excluded in DRC. More...
KISPINLOCK	m_lock
std::map< int, wxString >	m_netclassMap
	Map of netcode -> netclass the net is a member of; used for ratsnest painting. More...
PROGRESS_REPORTER *	m_progressReporter

Detailed Description

Definition at line 100 of file connectivity_data.h.

Constructor & Destructor Documentation

CONNECTIVITY_DATA() [1/2]

CONNECTIVITY_DATA::CONNECTIVITY_DATA

(

)

Definition at line 46 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 63 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 54 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 69 of file connectivity_data.cpp.

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

References m_connAlgo.

AddExclusion()

void CONNECTIVITY_DATA::AddExclusion	(	const KIID &	aBoardItemId1,
		const KIID &	aBoardItemId2
	)

Definition at line 881 of file connectivity_data.cpp.

{
 m_exclusions.emplace( aBoardItemId1, aBoardItemId2 );
 m_exclusions.emplace( aBoardItemId2, aBoardItemId1 );
 
 for( RN_NET* rnNet : m_nets )
 {
 for( CN_EDGE& edge : rnNet->GetEdges() )
 {
 if( ( edge.GetSourceNode()->Parent()->m_Uuid == aBoardItemId1
 && edge.GetTargetNode()->Parent()->m_Uuid == aBoardItemId2 )
 || ( edge.GetSourceNode()->Parent()->m_Uuid == aBoardItemId2
 && edge.GetTargetNode()->Parent()->m_Uuid == aBoardItemId1 ) )
 {
 edge.SetVisible( false );
 }
 }
 }
}

References m_exclusions, and m_nets.

addRatsnestCluster()

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

private

Definition at line 185 of file connectivity_data.cpp.

{
 RN_NET* rnNet = m_nets[ aCluster->OriginNet() ];
 
 rnNet->AddCluster( aCluster );
}

References RN_NET::AddCluster(), and m_nets.

Referenced by RecalculateRatsnest().

BlockRatsnestItems()

void CONNECTIVITY_DATA::BlockRatsnestItems

(

const std::vector< BOARD_ITEM * > &

aItems

)

Definition at line 245 of file connectivity_data.cpp.

{
 std::vector<BOARD_CONNECTED_ITEM*> citems;
 
 for( BOARD_ITEM* item : aItems )
 {
 if( item->Type() == PCB_FOOTPRINT_T )
 {
 for( PAD* pad : static_cast<FOOTPRINT*>(item)->Pads() )
 citems.push_back( pad );
 }
 else
 {
 if( BOARD_CONNECTED_ITEM* citem = dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
 citems.push_back( citem );
 }
 }
 
 for( const BOARD_CONNECTED_ITEM* item : citems )
 {
 if ( m_connAlgo->ItemExists( item ) )
 {
 CN_CONNECTIVITY_ALGO::ITEM_MAP_ENTRY& entry = m_connAlgo->ItemEntry( item );
 
 for( CN_ITEM* cnItem : entry.GetItems() )
 {
 for( const std::shared_ptr<CN_ANCHOR>& anchor : cnItem->Anchors() )
 anchor->SetNoLine( true );
 }
 }
 }
}

References anchor, CN_CONNECTIVITY_ALGO::ITEM_MAP_ENTRY::GetItems(), 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 91 of file connectivity_data.cpp.

{
 aBoard->CacheTriangulation( aReporter );
 
 std::unique_lock<KISPINLOCK> lock( m_lock, std::try_to_lock );
 
 if( !lock )
 return;
 
 if( aReporter )
 {
 aReporter->Report( _( "Updating nets..." ) );
 aReporter->KeepRefreshing( false );
 }
 
 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();
 }
 
 if( aReporter )
 {
 aReporter->SetCurrentProgress( 0.75 );
 aReporter->KeepRefreshing( false );
 }
 
 RecalculateRatsnest();
 
 if( aReporter )
 {
 aReporter->SetCurrentProgress( 1.0 );
 aReporter->KeepRefreshing( false );
 }
}

References _, BOARD::CacheTriangulation(), NETCLASS::Default, BOARD::GetNetInfo(), PROGRESS_REPORTER::KeepRefreshing(), m_connAlgo, m_lock, m_netclassMap, RecalculateRatsnest(), PROGRESS_REPORTER::Report(), and PROGRESS_REPORTER::SetCurrentProgress().

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 133 of file connectivity_data.cpp.

{
 std::unique_lock<KISPINLOCK> lock( m_lock, std::try_to_lock );
 
 if( !lock )
 return;
 
 m_connAlgo.reset( new CN_CONNECTIVITY_ALGO );
 m_connAlgo->LocalBuild( aItems );
 
 RecalculateRatsnest();
}

References m_connAlgo, m_lock, and RecalculateRatsnest().

CheckConnectivity()

bool CONNECTIVITY_DATA::CheckConnectivity

(

std::vector< CN_DISJOINT_NET_ENTRY > &

aReport

)

Definition at line 541 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 476 of file connectivity_data.cpp.

{
 for( RN_NET* 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 350 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,
		VECTOR2I	aInternalOffset = { 0, 0 }
	)

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

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

Definition at line 300 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 )
 {
 RN_NET* ourNet = m_nets[nc];
 VECTOR2I pos1, pos2;
 
 if( ourNet->NearestBicoloredPair( *dynNet, &pos1, &pos2 ) )
 {
 RN_DYNAMIC_LINE l;
 l.a = pos1;
 l.b = pos2;
 l.netCode = nc;
 
 m_dynamicRatsnest.push_back( l );
 }
 }
 }
 
 // This gets the ratsnest for internal connections in the moving set
 const std::vector<CN_EDGE>& edges = GetRatsnestForItems( aItems );
 
 for( const CN_EDGE& edge : edges )
 {
 const std::shared_ptr<CN_ANCHOR>& nodeA = edge.GetSourceNode();
 const std::shared_ptr<CN_ANCHOR>& nodeB = edge.GetTargetNode();
 RN_DYNAMIC_LINE l;
 
 // Use the parents' positions
 l.a = nodeA->Parent()->GetPosition() + aInternalOffset;
 l.b = nodeB->Parent()->GetPosition() + aInternalOffset;
 l.netCode = 0;
 m_dynamicRatsnest.push_back( l );
 }
}

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

FindIsolatedCopperIslands() [1/2]

void CONNECTIVITY_DATA::FindIsolatedCopperIslands	(	std::vector< CN_ZONE_ISOLATED_ISLAND_LIST > &	aZones,
		bool	aConnectivityAlreadyRebuilt = false
	)

Definition at line 293 of file connectivity_data.cpp.

{
 m_connAlgo->FindIsolatedCopperIslands( aZones, aConnectivityAlreadyRebuilt );
}

References m_connAlgo.

FindIsolatedCopperIslands() [2/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 285 of file connectivity_data.cpp.

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

References m_connAlgo.

GetConnectedItems()

const std::vector< BOARD_CONNECTED_ITEM * > CONNECTIVITY_DATA::GetConnectedItems	(	const BOARD_CONNECTED_ITEM *	aItem,
		const std::initializer_list< 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 486 of file connectivity_data.cpp.

{
 std::vector<BOARD_CONNECTED_ITEM*> rv;
 CN_CONNECTIVITY_ALGO::CLUSTER_SEARCH_MODE searchMode;
 
 if( aIgnoreNetcodes )
 searchMode = CN_CONNECTIVITY_ALGO::CSM_PROPAGATE;
 else
 searchMode = CN_CONNECTIVITY_ALGO::CSM_CONNECTIVITY_CHECK;
 
 const auto clusters = m_connAlgo->SearchClusters( searchMode, aTypes,
 aIgnoreNetcodes ? -1 : aItem->GetNetCode() );
 
 for( const std::shared_ptr<CN_CLUSTER>& cl : clusters )
 {
 if( cl->Contains( aItem ) )
 {
 for( const CN_ITEM* 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 812 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 605 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;
}

References GetConnectedPads().

Referenced by GetConnectedPads().

GetConnectedPads() [2/2]

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

Definition at line 591 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 566 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 285 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 260 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 315 of file connectivity_data.h.

 {
 return m_fromToCache;
 }

References m_fromToCache.

GetLock()

KISPINLOCK & CONNECTIVITY_DATA::GetLock ( )

inline

Definition at line 290 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 298 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 279 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 516 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 618 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 636 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 987 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 )
 {
 RN_NET* net = GetRatsnestForNet( netcode );
 
 for( const CN_EDGE& 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 RN_NET::GetEdges(), GetRatsnestForNet(), pad, and FOOTPRINT::Pads().

GetRatsnestForItems()

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

(

const std::vector< BOARD_ITEM * >

aItems

)

Definition at line 923 of file connectivity_data.cpp.

{
 std::set<int> nets;
 std::vector<CN_EDGE> edges;
 std::set<BOARD_CONNECTED_ITEM*> item_set;
 
 for( BOARD_ITEM* 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( int netcode : nets )
 {
 RN_NET* net = GetRatsnestForNet( netcode );
 
 for( const CN_EDGE& edge : net->GetEdges() )
 {
 std::shared_ptr<CN_ANCHOR> srcNode = edge.GetSourceNode();
 std::shared_ptr<CN_ANCHOR> dstNode = edge.GetTargetNode();
 
 BOARD_CONNECTED_ITEM* srcParent = srcNode->Parent();
 BOARD_CONNECTED_ITEM* 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 RN_NET::GetEdges(), 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 849 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(), GetRatsnestForItems(), and GetRatsnestForPad().

GetRatsnestForPad()

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

(

const PAD *

aPad

)

Definition at line 972 of file connectivity_data.cpp.

{
 std::vector<CN_EDGE> edges;
 RN_NET* net = GetRatsnestForNet( aPad->GetNetCode() );
 
 for( const CN_EDGE& edge : net->GetEdges() )
 {
 if( edge.GetSourceNode()->Parent() == aPad || edge.GetTargetNode()->Parent() == aPad )
 edges.push_back( edge );
 }
 
 return edges;
}

References RN_NET::GetEdges(), BOARD_CONNECTED_ITEM::GetNetCode(), and GetRatsnestForNet().

GetUnconnectedCount()

unsigned int CONNECTIVITY_DATA::GetUnconnectedCount

(

)

const

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

Definition at line 456 of file connectivity_data.cpp.

{
 unsigned int unconnected = 0;
 
 for( RN_NET* net : m_nets )
 {
 if( !net )
 continue;
 
 for( const CN_EDGE& edge : net->GetEdges() )
 {
 if( edge.IsVisible() )
 ++unconnected;
 }
 }
 
 return unconnected;
}

References m_nets.

GetUnconnectedEdges()

void CONNECTIVITY_DATA::GetUnconnectedEdges

(

std::vector< CN_EDGE > &

aEdges

)

const

Definition at line 655 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 360 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,
		const std::initializer_list< KICAD_T > &	aTypes = {},
		bool	aCheckOptionalFlashing = false
	)		const

Definition at line 372 of file connectivity_data.cpp.

{
 CN_CONNECTIVITY_ALGO::ITEM_MAP_ENTRY &entry = m_connAlgo->ItemEntry( aItem );
 
 auto matchType =
 [&]( KICAD_T aItemType )
 {
 if( aTypes.size() == 0 )
 return true;
 
 return alg::contains( aTypes, aItemType);
 };
 
 for( CN_ITEM* citem : entry.GetItems() )
 {
 for( CN_ITEM* connected : citem->ConnectedItems() )
 {
 CN_ZONE_LAYER* zoneLayer = dynamic_cast<CN_ZONE_LAYER*>( connected );
 
 if( connected->Valid()
 && connected->Layers().Overlaps( aLayer )
 && matchType( connected->Parent()->Type() )
 && connected->Net() == aItem->GetNetCode() )
 {
 if( aItem->Type() == PCB_PAD_T && zoneLayer )
 {
 const PAD* pad = static_cast<const PAD*>( aItem );
 ZONE* zone = static_cast<ZONE*>( zoneLayer->Parent() );
 int islandIdx = zoneLayer->SubpolyIndex();
 
 if( zone->IsFilled() )
 {
 const SHAPE_POLY_SET* zoneFill = zone->GetFill( ToLAYER_ID( aLayer ) );
 const SHAPE_LINE_CHAIN& padHull = pad->GetEffectivePolygon()->Outline( 0 );
 
 for( const VECTOR2I& pt : zoneFill->COutline( islandIdx ).CPoints() )
 {
 // If the entire island is inside the pad's flashing then the pad
 // won't actually connect to anything else, so only return true if
 // part of the island is *outside* the pad's flashing.
 
 if( !padHull.PointInside( pt ) )
 return true;
 }
 }
 
 continue;
 }
 else if( aItem->Type() == PCB_VIA_T && zoneLayer )
 {
 const PCB_VIA* via = static_cast<const PCB_VIA*>( aItem );
 ZONE* zone = static_cast<ZONE*>( zoneLayer->Parent() );
 int islandIdx = zoneLayer->SubpolyIndex();
 
 if( zone->IsFilled() )
 {
 const SHAPE_POLY_SET* zoneFill = zone->GetFill( ToLAYER_ID( aLayer ) );
 SHAPE_CIRCLE viaHull( via->GetCenter(), via->GetWidth() / 2 );
 
 for( const VECTOR2I& pt : zoneFill->COutline( islandIdx ).CPoints() )
 {
 // If the entire island is inside the via's flashing then the via
 // won't actually connect to anything else, so only return true if
 // part of the island is *outside* the via's flashing.
 
 if( !viaHull.SHAPE::Collide( pt ) )
 return true;
 }
 }
 
 continue;
 }
 
 return true;
 }
 }
 }
 
 return false;
}

References CN_ITEM::ConnectedItems(), alg::contains(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoints(), ZONE::GetFill(), CN_CONNECTIVITY_ALGO::ITEM_MAP_ENTRY::GetItems(), BOARD_CONNECTED_ITEM::GetNetCode(), ZONE::IsFilled(), m_connAlgo, pad, CN_ITEM::Parent(), PCB_PAD_T, PCB_VIA_T, SHAPE_LINE_CHAIN_BASE::PointInside(), CN_ZONE_LAYER::SubpolyIndex(), ToLAYER_ID(), EDA_ITEM::Type(), and via.

MarkItemNetAsDirty()

void CONNECTIVITY_DATA::MarkItemNetAsDirty

(

BOARD_ITEM *

aItem

)

Definition at line 860 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 147 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 366 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 193 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;
 }
 
 const std::vector<std::shared_ptr<CN_CLUSTER>>& 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 std::shared_ptr<CN_CLUSTER>& 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 76 of file connectivity_data.cpp.

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

References m_connAlgo.

RemoveExclusion()

void CONNECTIVITY_DATA::RemoveExclusion	(	const KIID &	aBoardItemId1,
		const KIID &	aBoardItemId2
	)

Definition at line 902 of file connectivity_data.cpp.

{
 m_exclusions.erase( std::pair<KIID, KIID>( aBoardItemId1, aBoardItemId2 ) );
 m_exclusions.erase( std::pair<KIID, KIID>( aBoardItemId2, aBoardItemId1 ) );
 
 for( RN_NET* rnNet : m_nets )
 {
 for( CN_EDGE& edge : rnNet->GetEdges() )
 {
 if( ( edge.GetSourceNode()->Parent()->m_Uuid == aBoardItemId1
 && edge.GetTargetNode()->Parent()->m_Uuid == aBoardItemId2 )
 || ( edge.GetSourceNode()->Parent()->m_Uuid == aBoardItemId2
  && edge.GetTargetNode()->Parent()->m_Uuid == aBoardItemId1 ) )
 {
 edge.SetVisible( true );
 }
 }
 }
}

References m_exclusions, and m_nets.

SetProgressReporter()

void CONNECTIVITY_DATA::SetProgressReporter

(

PROGRESS_REPORTER *

aReporter

)

Definition at line 874 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,
		VECTOR2I *	aPos = nullptr
	)

Definition at line 687 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( wxT( "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();
 ZONE* zone = dynamic_cast<ZONE*>( item );
 DRC_RTREE* rtree = nullptr;
 bool hitStart = false;
 bool hitEnd = false;
 
 if( item->GetFlags() & IS_DELETED )
 continue;
 
 if( zone )
 rtree = zone->GetBoard()->m_CopperZoneRTreeCache[ zone ].get();
 
 if( rtree )
 {
 SHAPE_CIRCLE start( aTrack->GetStart(), accuracy );
 SHAPE_CIRCLE end( aTrack->GetEnd(), accuracy );
 
 hitStart = rtree->QueryColliding( start.BBox(), &start, layer );
 hitEnd = rtree->QueryColliding( end.BBox(), &end, layer );
 }
 else
 {
 std::shared_ptr<SHAPE> shape = item->GetEffectiveShape( layer );
 
 hitStart = shape->Collide( aTrack->GetStart(), accuracy );
 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( wxT( "CONNECTIVITY_DATA::TestTrackEndpointDangling: unknown track type" ) );
 }
 
 return false;
}

References SHAPE_CIRCLE::BBox(), CN_ITEM::ConnectedItems(), BOARD_ITEM::GetBoard(), 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(), BOARD::m_CopperZoneRTreeCache, PCB_ARC_T, PCB_TRACE_T, PCB_VIA_T, DRC_RTREE::QueryColliding(), 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 83 of file connectivity_data.cpp.

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

References m_connAlgo.

updateRatsnest()

void CONNECTIVITY_DATA::updateRatsnest ( )

private

Definition at line 156 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;
 } );
 
 GetKiCadThreadPool().parallelize_loop( 0, dirty_nets.size(),
 [&]( const int a, const int b)
 {
 for( int ii = a; ii < b; ++ii )
 dirty_nets[ii]->Update( m_exclusions );
 }).wait();
 
#ifdef PROFILE
 rnUpdate.Show();
#endif
}

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

Referenced by RecalculateRatsnest().

Member Data Documentation

m_connAlgo

std::shared_ptr<CN_CONNECTIVITY_ALGO> CONNECTIVITY_DATA::m_connAlgo

private

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

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

m_exclusions

std::set<std::pair<KIID, KIID> > CONNECTIVITY_DATA::m_exclusions

private

Ratsnest lines that have been excluded in DRC.

Definition at line 336 of file connectivity_data.h.

Referenced by AddExclusion(), and RemoveExclusion().

m_fromToCache

std::shared_ptr<FROM_TO_CACHE> CONNECTIVITY_DATA::m_fromToCache

private

Definition at line 328 of file connectivity_data.h.

Referenced by CONNECTIVITY_DATA(), and GetFromToCache().

m_lock

KISPINLOCK CONNECTIVITY_DATA::m_lock

private

Definition at line 338 of file connectivity_data.h.

Referenced by Build(), and 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 341 of file connectivity_data.h.

Referenced by Build(), and GetNetclassMap().

m_nets

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

private

Definition at line 330 of file connectivity_data.h.

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

m_progressReporter

PROGRESS_REPORTER* CONNECTIVITY_DATA::m_progressReporter

private

Definition at line 343 of file connectivity_data.h.

Referenced by CONNECTIVITY_DATA(), and SetProgressReporter().

m_skipRatsnest

bool CONNECTIVITY_DATA::m_skipRatsnest = false

private

Used to suppress ratsnest calculations on dynamic ratsnests.

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