Mirrors
/
kicad
mirror of https://github.com/KiCad/kicad-source-mirror
3
0
Fork 0
Code Releases Activity
Browse Source

Pcbnew: more work on a better algorithm to calculate the full ratsnest. 

Lee algorithm replaced by a Minimun Spanning Tree algo (using Prim's algorithm ).
Tested on a 5350 pads board, it is more than 100 times faster.
Also fix a crash when clicking on tool  "delete selected items" (main horizontal toolbar),
and remove this tool (currently, no code in Pcbnew for this tool)
pull/1/head
jean-pierre charras 14 years ago
parent
ed2141a6d6
commit
936d831b82
7 changed files with 369 additions and 409 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      include/wxBasePcbFrame.h
  2. 1
      pcbnew/CMakeLists.txt
  3. 5
      pcbnew/edit.cpp
  4. 144
      pcbnew/minumun_spanning_tree.cpp
  5. 77
      pcbnew/minumun_spanning_tree.h
  6. 542
      pcbnew/ratsnest.cpp
  7. 3
      pcbnew/tool_pcb.cpp

6
include/wxBasePcbFrame.h
View File

@ -352,7 +352,11 @@ public:
*/
void TraceModuleRatsNest( wxDC* aDC );
void Build_Board_Ratsnest( wxDC* DC );
/**
* Function Build_Board_Ratsnest.
* Calculates the full ratsnest depending only on pads.
*/
void Build_Board_Ratsnest();
/**
* function Displays the general ratsnest

1
pcbnew/CMakeLists.txt
View File

@ -132,6 +132,7 @@ set(PCBNEW_SRCS
magnetic_tracks_functions.cpp
menubar_modedit.cpp
menubar_pcbframe.cpp
minumun_spanning_tree.cpp
mirepcb.cpp
modedit.cpp
modedit_onclick.cpp

5
pcbnew/edit.cpp
View File

@ -66,7 +66,6 @@ void PCB_EDIT_FRAME::Process_Special_Functions( wxCommandEvent& event )
int itmp;
INSTALL_UNBUFFERED_DC( dc, DrawPanel );
BOARD_ITEM* DrawStruct = GetCurItem();
MODULE* module;
DrawPanel->CrossHairOff( &dc );
@ -1080,8 +1079,8 @@ void PCB_EDIT_FRAME::Process_Special_Functions( wxCommandEvent& event )
default:
wxString msg;
msg.Printf( wxT( "PCB_EDIT_FRAME::Process_Special_Functions() id %d error" ),
DrawStruct->Type() );
msg.Printf( wxT( "PCB_EDIT_FRAME::Process_Special_Functions() unknown event id %d" ),
id );
DisplayError( this, msg );
break;
}

144
pcbnew/minumun_spanning_tree.cpp
View File

@ -0,0 +1,144 @@
/**
* @file minumun_spanning_tree.cpp
*/
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2011 Jean-Pierre Charras
* Copyright (C) 2004-2011 KiCad Developers, see change_log.txt for contributors.
*
* derived from this article:
* http://compprog.wordpress.com/2007/11/09/minimal-spanning-trees-prims-algorithm
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <limits.h>
#include "minumun_spanning_tree.h"
#include "class_pad.h"
/*
* The class MIN_SPAN_TREE calculates the rectilinear minimum spanning tree
* of a set of points (pads usually having the same net)
* using the Prim's algorithm.
*/
/*
* Prim's Algorithm
* Step 0
* Pick any vertex as a starting vertex. (Call it S).
* Mark it with any given flag, say 1.
*
* Step 1
* Find the nearest neighbour of S (call it P1).
* Mark both P1 and the edge SP1.
* cheapest unmarked edge in the graph that doesn't close a marked circuit.
* Mark this edge.
*
* Step 2
* Find the nearest unmarked neighbour to the marked subgraph
* (i.e., the closest vertex to any marked vertex).
* Mark it and the edge connecting the vertex.
*
* Step 3
* Repeat Step 2 until all vertices are marked.
* The marked subgraph is a minimum spanning tree.
*/
MIN_SPAN_TREE::MIN_SPAN_TREE()
{
MSP_Init( 0 );
}
void MIN_SPAN_TREE::MSP_Init( int aNodesCount )
{
m_Size = aNodesCount;
inTree.clear();
linkedTo.clear();
distTo.clear();
if( m_Size == 0 )
return;
// Reserve space in memory
inTree.reserve( m_Size );
linkedTo.reserve( m_Size );
distTo.reserve( m_Size );
// Initialize values:
for( int ii = 0; ii < m_Size; ii++ )
{
// Initialise dist with infinity:
distTo.push_back( INT_MAX );
// Mark all nodes as NOT beeing in the minimum spanning tree:
inTree.push_back( 0 );
linkedTo.push_back( 0 );
}
}
/* updateDistances(int target)
* should be called immediately after target is added to the tree;
* updates dist so that the values are correct (goes through target's
* neighbours making sure that the distances between them and the tree
* are indeed minimum)
*/
void MIN_SPAN_TREE::updateDistances( int target )
{
for( int ii = 0; ii < m_Size; ++ii )
{
if( !inTree[ii] ) // no need to evaluate weight for already in tree items
{
int weight = GetWeight( target, ii );
if( (weight > 0) && (distTo[ii] > weight ) )
{
distTo[ii] = weight;
linkedTo[ii] = target;
}
}
}
}
void MIN_SPAN_TREE::BuildTree()
{
/* Add the first node to the tree */
inTree[0] = 1;
updateDistances( 0 );
for( int treeSize = 1; treeSize < m_Size; ++treeSize )
{
// Find the node with the smallest distance to the tree
int min = -1;
for( int ii = 0; ii < m_Size; ++ii )
{
if( !inTree[ii] )
{
if( (min == -1) || (distTo[min] > distTo[ii]) )
min = ii;
}
}
inTree[min] = 1;
updateDistances( min );
}
}

77
pcbnew/minumun_spanning_tree.h
View File

@ -0,0 +1,77 @@
/**
* @file minumun_spanning_tree.h
*/
#include <vector>
/**
* @brief The class MIN_SPAN_TREE calculates the rectilinear minimum spanning tree
* of a set of points (pads usually having the same net)
* this class is an abstract class because you must provide the function
* int GetWeight( int aItem1, int aItem2 )
* that calculate the distance between 2 items
* MIN_SPAN_TREE does not know anything about the actual items to link
* by the tree
*/
class MIN_SPAN_TREE
{
protected:
int m_Size; /* The number of nodes in the graph
*/
private:
std::vector<char> inTree; /* inTree[ii] is a flag set to 1 if the node ii
* is already in the minimum spanning tree; 0 otherwise
*/
std::vector<int> linkedTo; /* linkedTo[ii] holds the index of the node ii would have to be
* linked to in order to get a distance of d[ii]
* NOTE: linkedTo[0] is the starting point of the tree
* linkedTo[1] is the first linked point to use
* ii and linkedTo[ii] are the 2 ends of an edge in the graph
*/
std::vector<int> distTo; /* distTo[ii] is the distance between node ii and the minimum spanning
* tree;
* this is initially infinity (INT_MAX);
* if ii is already in the tree, then d[ii] is undefined;
* this is just a temporary variable. It's not necessary but speeds
* up execution considerably (by a factor of n)
*/
public:
MIN_SPAN_TREE();
void MSP_Init( int aNodesCount );
void BuildTree();
int GetWhoTo( int aIdx )
{
return linkedTo[aIdx];
}
int GetDist( int aIdx )
{
return distTo[aIdx];
}
/**
* Function GetWeight
* calculates the weight between 2 items
* NOTE: The weight between a node and itself should be 0
* It is virtual pure, you must provide your GetWeight function
* @param aItem1 = first item
* @param aItem2 = other item
* @return the weight between items ( usually the distance )
*/
virtual int GetWeight( int aItem1, int aItem2 ) = 0;
private:
/**
* Function updateDistances
* should be called immediately after target is added to the tree;
* updates d so that the values are correct (goes through target's
* neighbours making sure that the distances between them and the tree
* are indeed minimum)
* @param target = index of curr item
*/
void updateDistances( int aTarget );
};

542
pcbnew/ratsnest.cpp
View File

@ -7,7 +7,6 @@
#include "gr_basic.h"
#include "common.h"
#include "class_drawpanel.h"
#include "confirm.h"
#include "colors_selection.h"
#include "wxBasePcbFrame.h"
#include "macros.h"
@ -17,96 +16,116 @@
#include "class_track.h"
#include "pcbnew.h"
#include "protos.h"
#include "minumun_spanning_tree.h"
static std::vector <D_PAD*> s_localPadBuffer; // for local ratsnest
// calculations when moving a
// footprint: buffer of pads to
// consider
static bool DisplayRastnestInProgress; // Enable the display of the
// ratsnest during the ratsnest
// computations
/**
* @brief class MIN_SPAN_TREE_PADS (derived from MIN_SPAN_TREE) specialize
* the basic class to calculate a minimum spanning tree from a list of pads,
* and to add this tree as ratsnest to the main ratsnest list.
*/
class MIN_SPAN_TREE_PADS: public MIN_SPAN_TREE
{
friend class MIN_SPAN_TREE;
public:
std::vector <D_PAD*>* m_PadsList; // list of pads:
/* these pads are the parents of nodes of the tree.
* Each node position is the corresponding pad position.
* This pad list is used to evaluate the weight of an edge in tree.
* -> edge = link between 2 nodes = links between 2 pads.
* -> weight of a link = rectilinear distance between the 2 pads
*/
public:
MIN_SPAN_TREE_PADS(): MIN_SPAN_TREE()
{
m_PadsList = NULL;
}
void MSP_Init( std::vector <D_PAD*>* aPadsList )
{
m_PadsList = aPadsList;
MIN_SPAN_TREE::MSP_Init( (int) m_PadsList->size() );
}
/**
* Function AddItemsToRatsnest
* Adds the current minimum spanning tree as ratsnest items
* to the main ratsnest list
* @param aRatsnestList = the main ratsnest list
*/
void AddItemsToRatsnest( std::vector<RATSNEST_ITEM> &aRatsnestList );
/**
* Function GetWeight
* calculates the weight between 2 items
* NOTE: The weight between a node and itself should be 0
* @param aItem1 = first item
* @param aItem2 = other item
* @return the weight between items ( the rectilinear distance )
*/
int GetWeight( int aItem1, int aItem2 );
};
void MIN_SPAN_TREE_PADS::AddItemsToRatsnest( std::vector<RATSNEST_ITEM> &aRatsnestList )
{
std::vector<D_PAD*> & padsBuffer = *m_PadsList;
int netcode = padsBuffer[0]->GetNet();
// Note: to get edges in minimum spanning tree,
// the index value 0 is not used: it is just
// the entry point of the minimum spanning tree.
// The first edge (i.e. rastnest) starts at index 1
for( int ii = 1; ii < m_Size; ii++ )
{
/* Create the new ratsnest */
RATSNEST_ITEM net;
net.SetNet( netcode );
net.m_Status = CH_ACTIF | CH_VISIBLE;
net.m_Lenght = GetDist(ii);
net.m_PadStart = padsBuffer[ii];
net.m_PadEnd = padsBuffer[ GetWhoTo(ii) ];
aRatsnestList.push_back( net );
}
}
/* Function GetWeight
* calculates the weight between 2 items
* Here it calculate the rectilinear distance between 2 pads (2 items)
* NOTE: The weight between a node and itself should be <=0
* aItem1 and aItem2 are the 2 items
* return the rectilinear distance
*/
int MIN_SPAN_TREE_PADS::GetWeight( int aItem1, int aItem2 )
{
// NOTE: The distance (weight) between a node and itself should be 0
// so we add 1 to other distances th be sure we never have 0
// in cases other than a node and itself
D_PAD* pad1 = (*m_PadsList)[aItem1];
D_PAD* pad2 = (*m_PadsList)[aItem2];
if( pad1 == pad2 )
return 0;
int weight = abs( pad2->m_Pos.x - pad1->m_Pos.x ) +
abs( pad2->m_Pos.y - pad1->m_Pos.y );
return weight + 1;
}
/* Note about the ratsnest computation:
* Building the general ratsnest:
* I used the "lee algorithm".
* This is a 2 steps algorithm.
* the m_SubRatsnest member of pads handle a "block number" or a "cluster
* number" or a "subnet number"
* initially, m_SubRatsnest = 0 (pad not connected).
* Build_Board_Ratsnest( wxDC* DC ) Create this ratsnest
* for each net:
* First:
* we create a link (and therefore a logical block) between 2 pad. This is
* achieved by:
* search for a pad without link.
* search its nearest pad
* link these 2 pads (i.e. create a ratsnest item)
* the pads are grouped in a logical block ( a cluster).
* until no pad without link found.
* Each logical block has a number called block number or "subnet number",
* stored in m_SubRatsnest member for each pad of the block.
* The first block has its block number = 1, the second is 2 ...
* the function to do that is gen_rats_pad_to_pad()
*
* Secondly:
* The first pass created many logical blocks
* A block contains 2 or more pads.
* we create links between 2 block. This is achieved by:
* Test all pads in the first block, and search (for each pad)
* a neighbor in other blocks and compute the distance between pads,
* We select the pad pair which have the smallest distance.
* These 2 pads are linked (i.e. a new ratsnest item is created between the 2
* pads)
* and the 2 block are merged.
* Therefore the logical block 1 contains the initial block 1 "eats" the pads
* of the other block
* The computation is made until only one block is found.
* the function used is gen_rats_block_to_block()
*
*
* How existing and new tracks are handled:
* The complete ratsnest (using the pad analysis) is computed.
* it is independent of the tracks and handle the "logical connections".
* It depends only on the footprints geometry (and the netlist),
* and must be computed only after a netlist read or a footprints geometry
* change.
* Each link (ratsnest) can only be INACTIVE (because pads are connected by a
* track) or ACTIVE (no tracks)
*
* After the complete ratsnest is built, or when a track is added or deleted,
* we run an algorithm derived from the complete ratsnest computation.
* it is much faster because it analysis only the existing ratsnest and not all
* the pads list
* and determine only if an existing ratsnest must be activated
* (no physical track exists) or not (a physical track exists)
* if a track is added or deleted only the corresponding net is tested.
*
* the m_SubRatsnest member of pads is set to 0 (no blocks), and all links are
* set to INACTIVE (ratsnest not show).
* Before running this fast lee algorithm, we create blocks (and their
* corresponding block number)
* by grouping pads connected by tracks.
* So, when tracks exists, the fast lee algorithm is started with some blocks
* already created.
* because the fast lee algorithm test only the ratsnest and does not search
* for nearest pads (this search was previously made) the online ratsnest
* can be done when a track is created without noticeable computing time
* First:
* for all links (in this step, all are inactive):
* search for a link which have 1 (or 2) pad having the m_SubRatsnest member =
* 0.
* if found the link is set to ACTIVE (i.e. the ratsnest will be showed) and
* the pad is merged with the block
* or a new block is created ( see tst_rats_pad_to_pad() ).
* Secondly:
* blocks are tested:
* for all links we search if the 2 pads linked are in 2 different block.
* if yes, the link status is set to ACTIVE, and the 2 block are merged
* until only one block is found
* ( see tst_rats_block_to_block() )
* Building the general ratsnest:
* For each net, the ratsnest is the set of lines connecting pads,
* using the shorter distance
* Therefore this problem is well known in graph therory, and sloved
* using the "minimum spanning tree".
* We use here an algorithm to build the minimum spanning tree known as Prim's algorithm
*/
/**
@ -121,8 +140,6 @@ void PCB_BASE_FRAME::Compile_Ratsnest( wxDC* aDC, bool aDisplayStatus )
{
wxString msg;
DisplayRastnestInProgress = true;
GetBoard()->m_Status_Pcb = 0; /* we want a full ratsnest computation, from the scratch */
ClearMsgPanel();
@ -140,18 +157,16 @@ void PCB_BASE_FRAME::Compile_Ratsnest( wxDC* aDC, bool aDisplayStatus )
/* Compute the full ratsnest
* which can be see like all the possible links or logical connections.
* some of them are active (no track connected) and others are inactive
* (when track connect pads)
* (when tracks connect pads)
* This full ratsnest is not modified by track editing.
* It changes only when a netlist is read, or footprints are modified
*/
Build_Board_Ratsnest( aDC );
Build_Board_Ratsnest();
/* Compute the pad connections due to the existing tracks (physical connections) */
TestConnections( aDC );
/* Compute the active ratsnest, i.e. the unconnected links
* it is faster than Build_Board_Ratsnest()
* because many optimizations and computations are already made
*/
TestRatsNest( aDC, 0 );
@ -167,256 +182,29 @@ void PCB_BASE_FRAME::Compile_Ratsnest( wxDC* aDC, bool aDisplayStatus )
/* Sort function used by QSORT
* Sort pads by net code
*/
static int sortByNetcode( const void* o1, const void* o2 )
static bool sortByNetcode( const D_PAD* const & ref, const D_PAD* const & item )
{
D_PAD** pt_ref = (D_PAD**) o1;
D_PAD** pt_compare = (D_PAD**) o2;
return (*pt_ref)->GetNet() - (*pt_compare)->GetNet();
}
/* Sort function used by QSORT
* Sort ratsnest by length
*/
static int sort_by_length( const void* o1, const void* o2 )
{
RATSNEST_ITEM* ref = (RATSNEST_ITEM*) o1;
RATSNEST_ITEM* compare = (RATSNEST_ITEM*) o2;
return ref->m_Lenght - compare->m_Lenght;
return ref->GetNet() < item->GetNet();
}
/**
* Function used by Build_Board_Ratsnest
* This function creates a ratsnest between two blocks ( which fit the same
* net )
* A block is a group of pads already linked (by a previous ratsnest
* computation, or tracks)
* The search is made between the pads in block 1 (the reference block) and
* other blocks
* the block n ( n > 1 ) it connected to block 1 by their 2 nearest pads.
* When the block is found, it is merged with the block 1
* the D_PAD member m_SubRatsnest handles the block number
* @param aRatsnestBuffer = a std::vector<RATSNEST_ITEM> buffer to fill with
* new ratsnest items
* @param aPadBuffer = a std::vector<D_PAD*> that is the list of pads to consider
* @param aPadIdxStart = starting index (within the pad list) for search
* @param aPadIdxMax = ending index (within the pad list) for search
* @return blocks not connected count
*/
static int gen_rats_block_to_block
(
std::vector<RATSNEST_ITEM>& aRatsnestBuffer,
std::vector<D_PAD*>& aPadBuffer,
unsigned aPadIdxStart,
unsigned aPadIdxMax )
{
int dist_min, current_dist;
int current_num_block = 1;
int padBlock1Idx = -1; // Index in aPadBuffer for the "better" pad
// found in block 1
int padBlockToMergeIdx = -1; // Index in aPadBuffer for the "better" pad
// found in block to merge
dist_min = 0x7FFFFFFF;
/* Search the nearest pad from block 1 */
for( unsigned ii = aPadIdxStart; ii < aPadIdxMax; ii++ )
{
D_PAD* ref_pad = aPadBuffer[ii];
/* search a pad which is in the block 1 */
if( ref_pad->GetSubRatsnest() != 1 )
continue;
/* pad is found, search its nearest neighbor in other blocks */
for( unsigned jj = aPadIdxStart; jj < aPadIdxMax; jj++ )
{
D_PAD* curr_pad = aPadBuffer[jj];
if( curr_pad->GetSubRatsnest() == 1 ) // not in an other block
continue;
/* Compare distance between pads ("Manhattan" distance) */
current_dist = abs( curr_pad->m_Pos.x - ref_pad->m_Pos.x ) +
abs( curr_pad->m_Pos.y - ref_pad->m_Pos.y );
if( dist_min > current_dist ) // we have found a better pad pair
{
// The tested block can be a good candidate for merging
// we memorize the "best" current values for merging
current_num_block = curr_pad->GetSubRatsnest();
dist_min = current_dist;
padBlockToMergeIdx = jj;
padBlock1Idx = ii;
}
}
}
/* The reference block is labeled block 1.
* if current_num_block != 1 we have found an other block, and we must
* merge it with the reference block
* The link is made by the 2 nearest pads
*/
if( current_num_block > 1 )
{
/* The block n (n=current_num_block) is merged with the bloc 1 :
* to do that, we set the m_SubRatsnest member to 1 for all pads in
* block n
*/
for( unsigned ii = aPadIdxStart; ii < aPadIdxMax; ii++ )
{
D_PAD* pad = aPadBuffer[ii];
if( pad->GetSubRatsnest() == current_num_block )
pad->SetSubRatsnest( 1 );
}
if( padBlock1Idx < 0 )
{
DisplayError( NULL,
wxT( "gen_rats_block_to_block() internal error" ) );
}
else
{
/* Create the new ratsnest */
RATSNEST_ITEM net;
net.SetNet( aPadBuffer[padBlock1Idx]->GetNet() );
net.m_Status = CH_ACTIF | CH_VISIBLE;
net.m_Lenght = dist_min;
net.m_PadStart = aPadBuffer[padBlock1Idx];
net.m_PadEnd = aPadBuffer[padBlockToMergeIdx];
aRatsnestBuffer.push_back( net );
}
}
return current_num_block;
}
/**
* Function used by Build_Board_Ratsnest
* this is the first pass of the lee algorithm
* This function creates the link (ratsnest) between 2 pads ( fitting the same
* net )
* the function search for a first not connected pad and search its nearest
* neighbor
* Its creates a block if the 2 pads are not connected, or merge the
* unconnected pad to the existing block.
* These blocks include 2 pads and the 2 pads are linked by a ratsnest.
*
* @param aRatsnestBuffer = a std::vector<RATSNEST_ITEM> buffer to fill with
* new ratsnest items
* @param aPadBuffer = a std::vector<D_PAD*> that is the list of pads to
* consider
* @param aPadIdxStart = starting index (within the pad list) for search
* @param aPadIdxMax = ending index (within the pad list) for search
* @param current_num_block = Last existing block number of pads
* These block are created by the existing tracks analysis
*
* @return the last block number used
*/
static int gen_rats_pad_to_pad( vector<RATSNEST_ITEM>& aRatsnestBuffer,
std::vector<D_PAD*>& aPadBuffer,
unsigned aPadIdxStart,
unsigned aPadIdxMax,
int current_num_block )
{
int dist_min, current_dist;
D_PAD* ref_pad, * pad;
for( unsigned ii = aPadIdxStart; ii < aPadIdxMax; ii++ )
{
ref_pad = aPadBuffer[ii];
if( ref_pad->GetSubRatsnest() )
continue; // Pad already connected
dist_min = 0x7FFFFFFF;
int padBlockToMergeIdx = -1; // Index in aPadBuffer for the "better"
// pad found in block to merge
for( unsigned jj = aPadIdxStart; jj < aPadIdxMax; jj++ )
{
if( ii == jj )
continue;
pad = aPadBuffer[jj];
/* Compare distance between pads ("Manhattan" distance) */
current_dist = abs( pad->m_Pos.x - ref_pad->m_Pos.x ) +
abs( pad->m_Pos.y - ref_pad->m_Pos.y );
if( dist_min > current_dist )
{
dist_min = current_dist;
padBlockToMergeIdx = jj;
}
}
if( padBlockToMergeIdx >= 0 )
{
pad = aPadBuffer[padBlockToMergeIdx];
/* Update the block number
* if the 2 pads are not already created : a new block is created
*/
if( (pad->GetSubRatsnest() == 0) && (ref_pad->GetSubRatsnest() == 0) )
{
current_num_block++; // Creates a new block number (or subratsnest)
pad->SetSubRatsnest( current_num_block );
ref_pad->SetSubRatsnest( current_num_block );
}
/* If a pad is already connected connected : merge the other pad in
* the block */
else
{
ref_pad->SetSubRatsnest( pad->GetSubRatsnest() );
}
/* Create the new ratsnest item */
RATSNEST_ITEM rast;
rast.SetNet( ref_pad->GetNet() );
rast.m_Status = CH_ACTIF | CH_VISIBLE;
rast.m_Lenght = dist_min;
rast.m_PadStart = ref_pad;
rast.m_PadEnd = pad;
aRatsnestBuffer.push_back( rast );
}
}
return current_num_block;
}
/**
* Function to compute the full ratsnest (using the LEE algorithm )
* Function to compute the full ratsnest
* In the functions tracks are not considered
* This is only the "basic" ratsnest depending only on pads.
*
* - Create the sorted pad list (if necessary)
* The active pads (i.e included in a net ) are called nodes
* This pad list is sorted by net codes
*
* - Compute the ratsnest (LEE algorithm ):
* a - Create the ratsnest between a not connected pad and its nearest
* neighbor. Blocks of pads are created
* b - Create the ratsnest between blocks:
* Test the pads of the 1st block and create a link (ratsnest)
* with the nearest pad found in an other block.
* The other block is merged with the first block.
* until only one block is left.
*
* A ratsnest can be seen as a logical connection.
* Create the sorted pad list (if necessary)
* The active pads (i.e included in a net ) are called nodes
* This pad list is sorted by net codes
* A ratsnest can be seen as a logical connection.
*
* Update :
* nb_nodes = Active pads count for the board
* nb_links = link count for the board (logical connection count)
* (there are n-1 links for an connection which have n active pads) .
* (there are n-1 links for a connection which have n active pads) .
*
*/
void PCB_BASE_FRAME::Build_Board_Ratsnest( wxDC* DC )
void PCB_BASE_FRAME::Build_Board_Ratsnest()
{
D_PAD* pad;
int noconn;
@ -442,80 +230,36 @@ void PCB_BASE_FRAME::Build_Board_Ratsnest( wxDC* DC )
return; /* No useful connections. */
/* Ratsnest computation */
DisplayRastnestInProgress = true;
unsigned current_net_code = 1; // First net code is analyzed.
// (net_code = 0 -> no connect)
noconn = 0;
MIN_SPAN_TREE_PADS min_spanning_tree;
for( ; current_net_code < m_Pcb->m_NetInfo->GetCount(); current_net_code++ )
{
NETINFO_ITEM* net = m_Pcb->FindNet( current_net_code );
if( net == NULL ) //Should not occur
{
DisplayError( this,
wxT( "Build_Board_Ratsnest() error: net not found" ) );
wxMessageBox( wxT( "Build_Board_Ratsnest() error: net not found" ) );
return;
}
net->m_RatsnestStartIdx = m_Pcb->GetRatsnestsCount();
// Search for the last subratsnest already in use
int num_block = 0;
for( unsigned ii = 0; ii < net->m_ListPad.size(); ii++ )
{
pad = net->m_ListPad[ii];
if( num_block < pad->GetSubRatsnest() )
num_block = pad->GetSubRatsnest();
}
/* Compute the ratsnest relative to the current net */
/* a - first pass : create the blocks from not already in block pads */
int icnt = gen_rats_pad_to_pad( m_Pcb->m_FullRatsnest,
net->m_ListPad,
0,
net->m_ListPad.size(),
num_block );
/* b - blocks connection (Iteration) */
while( icnt > 1 )
{
icnt = gen_rats_block_to_block( m_Pcb->m_FullRatsnest,
net->m_ListPad,
0,
net->m_ListPad.size() );
net = m_Pcb->FindNet( current_net_code );
}
min_spanning_tree.MSP_Init( &net->m_ListPad );
min_spanning_tree.BuildTree();
min_spanning_tree.AddItemsToRatsnest( m_Pcb->m_FullRatsnest );
net->m_RatsnestEndIdx = m_Pcb->GetRatsnestsCount();
/* sort by length */
net = m_Pcb->FindNet( current_net_code );
if( ( net->m_RatsnestEndIdx - net->m_RatsnestStartIdx ) > 1 )
{
RATSNEST_ITEM* rats = &m_Pcb->m_FullRatsnest[0];
qsort( rats + net->m_RatsnestStartIdx,
net->m_RatsnestEndIdx - net->m_RatsnestStartIdx,
sizeof(RATSNEST_ITEM), sort_by_length );
}
}
m_Pcb->m_NbNoconnect = noconn;
m_Pcb->m_Status_Pcb |= LISTE_RATSNEST_ITEM_OK;
// erase the ratsnest displayed on screen if needed
// Update the ratsnest display option (visible/invisible) flag
for( unsigned ii = 0; ii < m_Pcb->GetRatsnestsCount(); ii++ )
{
if( !GetBoard()->IsElementVisible(RATSNEST_VISIBLE) ) // Clear VISIBLE flag
m_Pcb->m_FullRatsnest[ii].m_Status &= ~CH_VISIBLE;
if( DC )
m_Pcb->m_FullRatsnest[ii].Draw( DrawPanel, DC, GR_XOR, wxPoint( 0, 0 ) );
}
}
@ -557,12 +301,10 @@ void PCB_BASE_FRAME::DrawGeneralRatsnest( wxDC* aDC, int aNetcode )
/**
* Function used by TestRatsNest
* Function like gen_rats_block_to_block(..)
* Function testing the ratsnest between 2 blocks ( same net )
* The search is made between pads in block 1 and the others blocks
* The block n ( n > 1 ) is merged with block 1 by the smallest ratsnest
* Difference between gen_rats_block_to_block(..):
* The analysis is not made pads to pads but uses the general ratsnest list.
* The analysis uses the general ratsnest list.
* The function activate the smallest ratsnest between block 1 and the block n
* (activate a logical connexion)
* @param aRatsnestBuffer = the buffer to store NETINFO_ITEM* items
@ -625,7 +367,7 @@ static int tst_rats_block_to_block( NETINFO_ITEM* net,
* Activates the ratsnest between 2 pads ( assumes the same net )
* The function links 1 pad not already connected an other pad and activate
* some blocks linked by a ratsnest
* Its test only the existing ratsnest and activate some ratsnest (status bit
* It tests only the existing ratsnest and activate some ratsnest (status bit
* CH_ACTIF set)
*
* @param start_rat_list = starting address for the ratsnest list
@ -688,7 +430,7 @@ void PCB_BASE_FRAME::TestRatsNest( wxDC* aDC, int aNetCode )
return;
if( (m_Pcb->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK) == 0 )
Build_Board_Ratsnest( aDC );
Build_Board_Ratsnest();
for( int net_code = 1; net_code < (int) m_Pcb->m_NetInfo->GetCount(); net_code++ )
{
@ -740,7 +482,6 @@ void PCB_BASE_FRAME::TestRatsNest( wxDC* aDC, int aNetCode )
int PCB_BASE_FRAME::TestOneRatsNest( wxDC* aDC, int aNetCode )
{
DisplayRastnestInProgress = false;
DrawGeneralRatsnest( aDC, aNetCode );
TestRatsNest( aDC, aNetCode );
DrawGeneralRatsnest( aDC, aNetCode );
@ -755,7 +496,6 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
// code) for the footprint being moved
static unsigned internalRatsCount; // number of internal links (links
// between pads of the module)
D_PAD** baseListePad;
D_PAD* pad_ref;
D_PAD* pad_externe;
int current_net_code;
@ -778,7 +518,8 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
goto CalculateExternalRatsnest;
/* Compute the "internal" ratsnest, i.e the links between the current
*footprint pads */
* footprint pads
*/
s_localPadBuffer.clear();
m_Pcb->m_LocalRatsnest.clear();
@ -797,11 +538,9 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
if( pads_module_count == 0 )
return; /* no connection! */
qsort( &s_localPadBuffer[0], pads_module_count, sizeof( D_PAD* ), sortByNetcode );
sort( s_localPadBuffer.begin(), s_localPadBuffer.end(), sortByNetcode );
/* Build the list of pads linked to the current footprint pads */
DisplayRastnestInProgress = false;
current_net_code = 0;
for( unsigned ii = 0; ii < pads_module_count; ii++ )
@ -816,8 +555,7 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
if( net == NULL ) //Should not occur
{
DisplayError( this,
wxT( "build_ratsnest_module() error: net not found" ) );
wxMessageBox( wxT( "build_ratsnest_module() error: net not found" ) );
return;
}
@ -836,10 +574,8 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
}
/* Sort the pad list by net_code */
baseListePad = &s_localPadBuffer[0];
qsort( baseListePad + pads_module_count, s_localPadBuffer.size() - pads_module_count,
sizeof(D_PAD*), sortByNetcode );
sort( s_localPadBuffer.begin() + pads_module_count, s_localPadBuffer.end(),
sortByNetcode );
/* Compute the internal rats nest:
* this is the same as general ratsnest, but considers only the current
@ -848,6 +584,9 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
*/
current_net_code = s_localPadBuffer[0]->GetNet();
{
MIN_SPAN_TREE_PADS min_spanning_tree;
std::vector<D_PAD*> padsBuffer;
for( unsigned ii = 0; ii < pads_module_count; ii++ )
{
/* Search the end of pad list relative to the current net */
@ -862,22 +601,17 @@ void PCB_BASE_FRAME::build_ratsnest_module( MODULE* aModule )
break;
}
/* End of list found: */
/* a - first step of lee algorithm : build the pad to pad link list */
int icnt = gen_rats_pad_to_pad( m_Pcb->m_LocalRatsnest, s_localPadBuffer, ii, jj, 0 );
/* b - second step of lee algorithm : build the block to block link
*list (Iteration) */
while( icnt > 1 )
{
icnt = gen_rats_block_to_block( m_Pcb->m_LocalRatsnest, s_localPadBuffer, ii, jj );
}
for(unsigned kk = ii; kk < jj; kk++ )
padsBuffer.push_back( s_localPadBuffer[kk] );
min_spanning_tree.MSP_Init( &padsBuffer );
min_spanning_tree.BuildTree();
min_spanning_tree.AddItemsToRatsnest( m_Pcb->m_LocalRatsnest );
padsBuffer.clear();
ii = jj;
if( ii < s_localPadBuffer.size() )
current_net_code = s_localPadBuffer[ii]->GetNet();
}
}
internalRatsCount = m_Pcb->m_LocalRatsnest.size();
@ -1088,7 +822,7 @@ void PCB_BASE_FRAME::build_ratsnest_pad( BOARD_ITEM* ref, const wxPoint& refpos,
if( net == NULL ) // Should not occur
{
DisplayError( this, wxT( "build_ratsnest_pad() error: net not found" ) );
wxMessageBox( wxT( "build_ratsnest_pad() error: net not found" ) );
return;
}

3
pcbnew/tool_pcb.cpp
View File

@ -204,11 +204,12 @@ void PCB_EDIT_FRAME::ReCreateHToolbar()
m_HToolBar->AddTool( ID_OPEN_MODULE_EDITOR, wxEmptyString, KiBitmap( modedit_xpm ),
_( "Open module editor" ) );
#if 0
// Not yet existing commands
m_HToolBar->AddSeparator();
m_HToolBar->AddTool( wxID_CUT, wxEmptyString, KiBitmap( cut_button_xpm ),
_( "Cut selected item" ) );
#if 0
m_HToolBar->AddTool( wxID_COPY, wxEmptyString, KiBitmap( copy_button_xpm ),
_( "Copy selected item" ) );

Write Preview
Loading…
Cancel
Save