KiCad PCB EDA Suite
connectivity_data.h
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KICAD, a free EDA CAD application.
3  *
4  * Copyright (C) 2013-2017 CERN
5  * Copyright (C) 2018-2020 KiCad Developers, see AUTHORS.txt for contributors.
6  * @author Maciej Suminski <[email protected]>
7  * @author Tomasz Wlostowski <[email protected]>
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, you may find one here:
21  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22  * or you may search the http://www.gnu.org website for the version 2 license,
23  * or you may write to the Free Software Foundation, Inc.,
24  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25  */
26 
27 #ifndef __CONNECTIVITY_DATA_H
28 #define __CONNECTIVITY_DATA_H
29 
30 #include <core/typeinfo.h>
31 #include <core/spinlock.h>
32 
33 #include <memory>
34 #include <mutex>
35 #include <vector>
36 #include <wx/string.h>
37 
38 #include <math/vector2d.h>
40 #include <zone.h>
41 
42 class FROM_TO_CACHE;
43 class CN_CLUSTER;
45 class CN_EDGE;
46 class BOARD;
47 class BOARD_COMMIT;
49 class BOARD_ITEM;
50 class ZONE;
51 class RN_DATA;
52 class RN_NET;
53 class PCB_TRACK;
54 class PAD;
55 class FOOTPRINT;
56 class PROGRESS_REPORTER;
57 
58 
60 {
61  int net;
64 };
65 
66 
71 {
73  m_zone( aZone )
74  {}
75 
77 
78  std::map<PCB_LAYER_ID, std::vector<int>> m_islands;
79 };
80 
81 
83 {
84  int netCode;
86 };
87 
88 
92 enum class PROPAGATE_MODE
93 {
96 };
97 
98 
99 // a wrapper class encompassing the connectivity computation algorithm and the
101 {
102 public:
105 
106  CONNECTIVITY_DATA( const std::vector<BOARD_ITEM*>& aItems, bool aSkipItems = false );
107 
112  void Build( BOARD* aBoard, PROGRESS_REPORTER* aReporter = nullptr );
113 
118  void Build( const std::vector<BOARD_ITEM*>& aItems );
119 
126  bool Add( BOARD_ITEM* aItem );
127 
134  bool Remove( BOARD_ITEM* aItem );
135 
142  bool Update( BOARD_ITEM* aItem );
143 
151  void Move( const VECTOR2I& aDelta );
152 
157  void Clear();
158 
163  int GetNetCount() const;
164 
169  RN_NET* GetRatsnestForNet( int aNet );
170 
176  void PropagateNets( BOARD_COMMIT* aCommit = nullptr,
178 
179  bool CheckConnectivity( std::vector<CN_DISJOINT_NET_ENTRY>& aReport );
180 
187  void FindIsolatedCopperIslands( ZONE* aZone, std::vector<int>& aIslands );
188  void FindIsolatedCopperIslands( std::vector<CN_ZONE_ISOLATED_ISLAND_LIST>& aZones );
189 
195  void RecalculateRatsnest( BOARD_COMMIT* aCommit = nullptr );
196 
201  unsigned int GetUnconnectedCount() const;
202 
203  bool IsConnectedOnLayer( const BOARD_CONNECTED_ITEM* aItem,
204  int aLayer, std::vector<KICAD_T> aTypes = {},
205  bool aCheckOptionalFlashing = false ) const;
206 
207  unsigned int GetNodeCount( int aNet = -1 ) const;
208 
209  unsigned int GetPadCount( int aNet = -1 ) const;
210 
211  const std::vector<PCB_TRACK*> GetConnectedTracks( const BOARD_CONNECTED_ITEM* aItem ) const;
212 
213  const std::vector<PAD*> GetConnectedPads( const BOARD_CONNECTED_ITEM* aItem ) const;
214 
215  void GetConnectedPads( const BOARD_CONNECTED_ITEM* aItem, std::set<PAD*>* pads ) const;
216 
227  const std::vector<BOARD_CONNECTED_ITEM*> GetConnectedItemsAtAnchor(
228  const BOARD_CONNECTED_ITEM* aItem,
229  const VECTOR2I& aAnchor,
230  const KICAD_T aTypes[],
231  const int& aMaxError = 0 ) const;
232 
233  void GetUnconnectedEdges( std::vector<CN_EDGE>& aEdges ) const;
234 
235  bool TestTrackEndpointDangling( PCB_TRACK* aTrack, wxPoint* aPos = nullptr );
236 
242  void ClearDynamicRatsnest();
243 
247  void HideDynamicRatsnest();
248 
254  void ComputeDynamicRatsnest( const std::vector<BOARD_ITEM*>& aItems,
255  const CONNECTIVITY_DATA* aDynamicData,
256  VECTOR2I aInternalOffset = { 0, 0 } );
257 
258  const std::vector<RN_DYNAMIC_LINE>& GetDynamicRatsnest() const
259  {
260  return m_dynamicRatsnest;
261  }
262 
269  const std::vector<BOARD_CONNECTED_ITEM*> GetConnectedItems( const BOARD_CONNECTED_ITEM* aItem,
270  const KICAD_T aTypes[], bool aIgnoreNetcodes = false ) const;
271 
278  const std::vector<BOARD_CONNECTED_ITEM*> GetNetItems( int aNetCode,
279  const KICAD_T aTypes[] ) const;
280 
281  void BlockRatsnestItems( const std::vector<BOARD_ITEM*>& aItems );
282 
283  std::shared_ptr<CN_CONNECTIVITY_ALGO> GetConnectivityAlgo() const
284  {
285  return m_connAlgo;
286  }
287 
289  {
290  return m_lock;
291  }
292 
293  void MarkItemNetAsDirty( BOARD_ITEM* aItem );
294  void SetProgressReporter( PROGRESS_REPORTER* aReporter );
295 
296  const std::map<int, wxString>& GetNetclassMap() const
297  {
298  return m_netclassMap;
299  }
300 
301 #ifndef SWIG
302  const std::vector<CN_EDGE> GetRatsnestForItems( const std::vector<BOARD_ITEM*> aItems );
303 
304  const std::vector<CN_EDGE> GetRatsnestForPad( const PAD* aPad );
305 
306  const std::vector<CN_EDGE> GetRatsnestForComponent( FOOTPRINT* aComponent,
307  bool aSkipInternalConnections = false );
308 #endif
309 
310  std::shared_ptr<FROM_TO_CACHE> GetFromToCache()
311  {
312  return m_fromToCache;
313  }
314 
315 private:
316  void updateRatsnest();
317 
318  void addRatsnestCluster( const std::shared_ptr<CN_CLUSTER>& aCluster );
319 
320 private:
321  std::shared_ptr<CN_CONNECTIVITY_ALGO> m_connAlgo;
322 
323  std::shared_ptr<FROM_TO_CACHE> m_fromToCache;
324  std::vector<RN_DYNAMIC_LINE> m_dynamicRatsnest;
325  std::vector<RN_NET*> m_nets;
326 
328  bool m_skipRatsnest = false;
329 
331 
333  std::map<int, wxString> m_netclassMap;
334 
336 };
337 
338 #endif
bool IsConnectedOnLayer(const BOARD_CONNECTED_ITEM *aItem, int aLayer, std::vector< KICAD_T > aTypes={}, bool aCheckOptionalFlashing=false) const
void Clear()
Function Clear() Erases the connectivity database.
const std::vector< CN_EDGE > GetRatsnestForComponent(FOOTPRINT *aComponent, bool aSkipInternalConnections=false)
unsigned int GetNodeCount(int aNet=-1) const
PROPAGATE_MODE
Controls how nets are propagated through clusters.
const std::vector< PCB_TRACK * > GetConnectedTracks(const BOARD_CONNECTED_ITEM *aItem) const
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:49
A progress reporter interface for use in multi-threaded environments.
std::shared_ptr< CN_CONNECTIVITY_ALGO > m_connAlgo
PROGRESS_REPORTER * m_progressReporter
std::shared_ptr< CN_CONNECTIVITY_ALGO > GetConnectivityAlgo() const
bool Update(BOARD_ITEM *aItem)
Function Update() Updates the connectivity data for an item.
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.
void RecalculateRatsnest(BOARD_COMMIT *aCommit=nullptr)
Function RecalculateRatsnest() Updates the ratsnest for the board.
std::shared_ptr< FROM_TO_CACHE > m_fromToCache
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.
std::map< PCB_LAYER_ID, std::vector< int > > m_islands
BOARD_CONNECTED_ITEM * b
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
std::vector< RN_DYNAMIC_LINE > m_dynamicRatsnest
Clusters with conflicting drivers are not updated (default)
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.
VECTOR2I anchorB
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
const std::map< int, wxString > & GetNetclassMap() const
unsigned int GetPadCount(int aNet=-1) const
std::shared_ptr< FROM_TO_CACHE > GetFromToCache()
void Build(BOARD *aBoard, PROGRESS_REPORTER *aReporter=nullptr)
Function Build() Builds the connectivity database for the board aBoard.
VECTOR2I anchorA
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 posi...
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.
std::map< int, wxString > m_netclassMap
Map of netcode -> netclass the net is a member of; used for ratsnest painting.
unsigned int GetUnconnectedCount() const
Function GetUnconnectedCount() Returns the number of remaining edges in the ratsnest.
Handle a list of polygons defining a copper zone.
Definition: zone.h:56
void ClearDynamicRatsnest()
Function ClearDynamicRatsnest() Erases the temporary dynamic ratsnest (i.e.
void SetProgressReporter(PROGRESS_REPORTER *aReporter)
bool Remove(BOARD_ITEM *aItem)
Function Remove() Removes an item from the connectivity data.
void MarkItemNetAsDirty(BOARD_ITEM *aItem)
std::vector< RN_NET * > m_nets
void GetUnconnectedEdges(std::vector< CN_EDGE > &aEdges) const
bool Add(BOARD_ITEM *aItem)
Function Add() Adds an item to the connectivity data.
void BlockRatsnestItems(const std::vector< BOARD_ITEM * > &aItems)
RN_NET * GetRatsnestForNet(int aNet)
Function GetRatsnestForNet() Returns the ratsnest, expressed as a set of graph edges for a given net.
BOARD_CONNECTED_ITEM * a
const std::vector< CN_EDGE > GetRatsnestForPad(const PAD *aPad)
bool CheckConnectivity(std::vector< CN_DISJOINT_NET_ENTRY > &aReport)
A trivial spinlock implementation with no optimization.
Definition: spinlock.h:29
CN_EDGE represents a point-to-point connection, whether realized or unrealized (ie: tracks etc.
void FindIsolatedCopperIslands(ZONE *aZone, std::vector< int > &aIslands)
Function FindIsolatedCopperIslands() Searches for copper islands in zone aZone that are not connected...
const std::vector< RN_DYNAMIC_LINE > & GetDynamicRatsnest() const
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:191
int net
int GetNetCount() const
Function GetNetCount() Returns the total number of nets in the connectivity database.
bool TestTrackEndpointDangling(PCB_TRACK *aTrack, wxPoint *aPos=nullptr)
Describe ratsnest for a single net.
Definition: ratsnest_data.h:61
const std::vector< PAD * > GetConnectedPads(const BOARD_CONNECTED_ITEM *aItem) const
Definition: pad.h:57
void HideDynamicRatsnest()
Hides the temporary dynamic ratsnest lines.
void addRatsnestCluster(const std::shared_ptr< CN_CLUSTER > &aCluster)
void Move(const VECTOR2I &aDelta)
Moves the connectivity list anchors.
A structure used for calculating isolated islands on a given zone across all its layers.
const std::vector< CN_EDGE > GetRatsnestForItems(const std::vector< BOARD_ITEM * > aItems)
KISPINLOCK & GetLock()
bool m_skipRatsnest
Used to suppress ratsnest calculations on dynamic ratsnests.