Added main execs

1 files changed, 409 insertions, 0 deletions

diff --git a/pcbnew/zones_polygons_test_connections.cpp b/pcbnew/zones_polygons_test_connections.cpp
new file mode 100644
index 0000000..f0177fe
--- /dev/null
+++ b/pcbnew/zones_polygons_test_connections.cpp
@@ -0,0 +1,409 @@
+/**
+ * @file zones_polygons_test_connections.cpp
+ */
+
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2012 Jean-Pierre Charras, jean-pierre.charras@ujf-grenoble.fr
+ * Copyright (C) 1992-2012 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * 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 <algorithm> // sort
+
+#include <fctsys.h>
+#include <common.h>
+#include <macros.h>
+
+#include <class_board.h>
+#include <class_module.h>
+#include <class_track.h>
+#include <class_zone.h>
+
+#include <pcbnew.h>
+#include <zones.h>
+#include <polygon_test_point_inside.h>
+
+static bool CmpZoneSubnetValue( const BOARD_CONNECTED_ITEM* a, const BOARD_CONNECTED_ITEM* b );
+
+void Merge_SubNets_Connected_By_CopperAreas( BOARD* aPcb, int aNetcode );
+
+// This helper function sort a list of zones by netcode,
+// and for a given netcode by zone size
+// zone size = size of the m_FilledPolysList buffer
+bool sort_areas( const ZONE_CONTAINER* ref, const ZONE_CONTAINER* tst )
+{
+    if( ref->GetNetCode() == tst->GetNetCode() )
+        return ref->GetFilledPolysList().TotalVertices() <
+               tst->GetFilledPolysList().TotalVertices();
+    else
+        return ref->GetNetCode() < tst->GetNetCode();
+}
+
+/**
+ * Function Test_Connection_To_Copper_Areas
+ * init .m_ZoneSubnet parameter in tracks and pads according to the connections to areas found
+ * @param aNetcode = netcode to analyse. if -1, analyse all nets
+ */
+void BOARD::Test_Connections_To_Copper_Areas( int aNetcode )
+{
+    // list of pads and tracks candidates on this layer and on this net.
+    // It is static to avoid multiple memory realloc.
+    static std::vector <BOARD_CONNECTED_ITEM*> candidates;
+
+    // clear .m_ZoneSubnet parameter for pads
+    for( MODULE* module = m_Modules;  module;  module = module->Next() )
+    {
+        for( D_PAD* pad = module->Pads();  pad;  pad = pad->Next() )
+            if( aNetcode < 0 || aNetcode == pad->GetNetCode() )
+                pad->SetZoneSubNet( 0 );
+    }
+
+    // clear .m_ZoneSubnet parameter for tracks and vias
+    for( TRACK* track = m_Track;  track;  track = track->Next() )
+    {
+        if( aNetcode < 0 || aNetcode == track->GetNetCode() )
+            track->SetZoneSubNet( 0 );
+    }
+
+    // examine all zones, net by net:
+    int subnet = 0;
+
+    // Build zones candidates list
+    std::vector<ZONE_CONTAINER*> zones_candidates;
+
+    zones_candidates.reserve( GetAreaCount() );
+
+    for( int index = 0; index < GetAreaCount(); index++ )
+    {
+        ZONE_CONTAINER* zone = GetArea( index );
+
+        if( !zone->IsOnCopperLayer() )
+            continue;
+
+        if( aNetcode >= 0 &&  aNetcode != zone->GetNetCode() )
+            continue;
+
+        if( zone->GetFilledPolysList().IsEmpty() )
+            continue;
+
+        zones_candidates.push_back( zone );
+    }
+
+    // sort them by netcode then vertices count.
+    // For a given net, examine the smaller zones first slightly speed up calculation
+    // (25% faster)
+    // this is only noticeable with very large boards and depends on board zones topology
+    // This is due to the fact some items are connected by small zones ares,
+    // before examining large zones areas and these items are not tested after a connection is found
+    sort( zones_candidates.begin(), zones_candidates.end(), sort_areas );
+
+    int oldnetcode = -1;
+    for( unsigned idx = 0; idx < zones_candidates.size(); idx++ )
+    {
+        ZONE_CONTAINER* zone = zones_candidates[idx];
+
+        int netcode = zone->GetNetCode();
+
+        // Build a list of candidates connected to the net:
+        // At this point, layers are not considered, because areas on different layers can
+        // be connected by a via or a pad.
+        // (because zones are sorted by netcode, there is made only once per net)
+        NETINFO_ITEM* net = FindNet( netcode );
+
+        wxASSERT( net );
+        if( net == NULL )
+            continue;
+
+        if( oldnetcode != netcode )
+        {
+            oldnetcode = netcode;
+            candidates.clear();
+
+            // Build the list of pads candidates connected to the net:
+            candidates.reserve( net->m_PadInNetList.size() );
+
+            for( unsigned ii = 0; ii < net->m_PadInNetList.size(); ii++ )
+                candidates.push_back( net->m_PadInNetList[ii] );
+
+            // If we have any tracks...
+            if( m_Track.GetCount() > 0 )
+            {
+                // Build the list of track candidates connected to the net:
+                TRACK* track = m_Track.GetFirst()->GetStartNetCode( netcode );
+
+                for( ; track; track = track->Next() )
+                {
+                    if( track->GetNetCode() != netcode )
+                        break;
+
+                    candidates.push_back( track );
+                }
+            }
+        }
+
+        // test if a candidate is inside a filled area of this zone
+        const SHAPE_POLY_SET& polysList = zone->GetFilledPolysList();
+
+        for( int outline = 0; outline < polysList.OutlineCount(); outline++ )
+        {
+                subnet++;
+
+                for( unsigned ic = 0; ic < candidates.size(); ic++ )
+                {
+                    // test if this area is connected to a board item:
+                    BOARD_CONNECTED_ITEM* item = candidates[ic];
+
+                    if( item->GetZoneSubNet() == subnet )   // Already merged
+                        continue;
+
+                   if( !item->IsOnLayer( zone->GetLayer() ) )
+                        continue;
+
+                    wxPoint pos1, pos2;
+
+                    if( item->Type() == PCB_PAD_T )
+                    {
+                        // For pads we use the shape position instead of
+                        // the pad position, because the zones are connected
+                        // to the center of the shape, not the pad position
+                        // (this is important for pads with thermal relief)
+                        pos1 = pos2 = ( (D_PAD*) item )->ShapePos();
+                    }
+                    else if( item->Type() == PCB_VIA_T )
+                    {
+                        const VIA *via = static_cast<const VIA*>( item );
+                        pos1 = via->GetStart();
+                        pos2 = pos1;
+                    }
+                    else if( item->Type() == PCB_TRACE_T )
+                    {
+                        const TRACK *trk = static_cast<const TRACK*>( item );
+                        pos1 = trk->GetStart();
+                        pos2 = trk->GetEnd();
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    bool connected = false;
+
+                    if( polysList.Contains( VECTOR2I( pos1.x, pos1.y ), outline ) )
+                        connected = true;
+
+                    if( !connected && ( pos1 != pos2 ) )
+                    {
+                        if( polysList.Contains( VECTOR2I( pos2.x, pos2.y ), outline ) )
+                            connected = true;
+                    }
+
+                    if( connected )
+                    {
+                        // Set ZoneSubnet to the current subnet value.
+                        // If the previous subnet is not 0, merge all items with old subnet
+                        // to the new one
+                        int old_subnet = item->GetZoneSubNet();
+                        item->SetZoneSubNet( subnet );
+
+                        // Merge previous subnet with the current
+                        if( (old_subnet > 0) && (old_subnet != subnet) )
+                        {
+                            for( unsigned jj = 0; jj < candidates.size(); jj++ )
+                            {
+                                BOARD_CONNECTED_ITEM* item_to_merge = candidates[jj];
+
+                                if( old_subnet == item_to_merge->GetZoneSubNet() )
+                                {
+                                    item_to_merge->SetZoneSubNet( subnet );
+                                }
+                            }
+                        }   // End if ( old_subnet > 0 )
+                    }       // End if( connected )
+                }
+        }
+    } // End read all zones candidates
+}
+
+
+/**
+ * Function Merge_SubNets_Connected_By_CopperAreas(BOARD* aPcb)
+ * Calls Merge_SubNets_Connected_By_CopperAreas( BOARD* aPcb, int aNetcode ) for each
+ * netcode found in zone list
+ * @param aPcb = the current board
+ */
+void Merge_SubNets_Connected_By_CopperAreas( BOARD* aPcb )
+{
+    for( int index = 0; index < aPcb->GetAreaCount(); index++ )
+    {
+        ZONE_CONTAINER* zone = aPcb->GetArea( index );
+
+        if ( ! zone->IsOnCopperLayer() )
+            continue;
+
+        if ( zone->GetNetCode() <= 0 )
+            continue;
+
+        Merge_SubNets_Connected_By_CopperAreas( aPcb, zone->GetNetCode() );
+    }
+}
+
+
+/**
+ * Function Merge_SubNets_Connected_By_CopperAreas(BOARD* aPcb, int aNetcode)
+ * Used after connections by tracks calculations
+ * Merge subnets, in tracks ans pads when they are connected by a filled copper area
+ * for pads, this is the .m_physical_connexion member which is tested and modified
+ * for tracks, this is the .m_Subnet member which is tested and modified
+ * these members are block numbers (or cluster numbers) for a given net,
+ * calculated by Build_Pads_Info_Connections_By_Tracks()
+ * The result is merging 2 blocks (or subnets)
+ * @param aPcb = the current board
+ * @param aNetcode = netcode to consider
+ */
+void Merge_SubNets_Connected_By_CopperAreas( BOARD* aPcb, int aNetcode )
+{
+    // Ensure a zone with the given netcode exists: examine all zones:
+    bool found = false;
+
+    for( int index = 0; index < aPcb->GetAreaCount(); index++ )
+    {
+        ZONE_CONTAINER* zone = aPcb->GetArea( index );
+
+        if( aNetcode == zone->GetNetCode() )
+        {
+            found = true;
+            break;
+        }
+    }
+
+    if( !found )  // No zone with this netcode, therefore no connection by zone
+        return;
+
+    // list of pads and tracks candidates to test:
+    // It is static to avoid multiple memory realloc.
+    static std::vector <BOARD_CONNECTED_ITEM*> Candidates;
+    Candidates.clear();
+
+    // Build the list of pads candidates connected to the net:
+    NETINFO_ITEM* net = aPcb->FindNet( aNetcode );
+    wxASSERT( net );
+    Candidates.reserve( net->m_PadInNetList.size() );
+    for( unsigned ii = 0; ii < net->m_PadInNetList.size(); ii++ )
+        Candidates.push_back( net->m_PadInNetList[ii] );
+
+    // Build the list of track candidates connected to the net:
+    TRACK* track;
+
+    if( aPcb->m_Track.GetCount() > 0 )
+    {
+        track = aPcb->m_Track.GetFirst()->GetStartNetCode( aNetcode );
+
+        for( ; track; track = track->Next() )
+        {
+            if( track->GetNetCode() != aNetcode )
+                break;
+
+            Candidates.push_back( track );
+        }
+    }
+
+    if( Candidates.size() == 0 )
+        return;
+
+    int next_subnet_free_number = 0;
+    for( unsigned ii = 0; ii < Candidates.size(); ii++ )
+    {
+        int subnet = Candidates[ii]->GetSubNet();
+        next_subnet_free_number = std::max( next_subnet_free_number, subnet );
+    }
+
+    next_subnet_free_number++;     // This is a subnet we can use with not connected items
+                                   // by tracks, but connected by zone.
+
+    // Sort by zone_subnet:
+    sort( Candidates.begin(), Candidates.end(), CmpZoneSubnetValue );
+
+    // Some items can be not connected, but they can be connected to a filled area:
+    // give them a subnet common to these items connected only by the area,
+    // and not already used.
+    // a value like next_subnet_free_number+zone_subnet is right
+    for( unsigned jj = 0; jj < Candidates.size(); jj++ )
+    {
+        BOARD_CONNECTED_ITEM* item = Candidates[jj];
+        if ( item->GetSubNet() == 0 && (item->GetZoneSubNet() > 0) )
+        {
+            item->SetSubNet( next_subnet_free_number + item->GetZoneSubNet() );
+        }
+    }
+
+    // Now, for each zone subnet, we search for 2 items with different subnets.
+    // if found, the 2 subnet are merged in the whole candidate list.
+    int old_subnet      = 0;
+    int old_zone_subnet = 0;
+    for( unsigned ii = 0; ii < Candidates.size(); ii++ )
+    {
+        BOARD_CONNECTED_ITEM* item = Candidates[ii];
+        int zone_subnet = item->GetZoneSubNet();
+
+        if( zone_subnet == 0 )  // Not connected by a filled area, skip it
+            continue;
+
+        int subnet = item->GetSubNet();
+
+        if( zone_subnet != old_zone_subnet )  // a new zone subnet is found
+        {
+            old_subnet = subnet;
+            old_zone_subnet = zone_subnet;
+            continue;
+        }
+
+        // 2 successive items already from the same cluster: nothing to do
+        if( subnet == old_subnet )
+            continue;
+
+        // Here we have 2 items connected by the same area have 2 differents subnets: merge subnets
+        if( (subnet > old_subnet) || ( subnet <= 0) )
+            std::swap( subnet, old_subnet );
+
+        for( unsigned jj = 0; jj < Candidates.size(); jj++ )
+        {
+            BOARD_CONNECTED_ITEM * item_to_merge = Candidates[jj];
+
+            if( item_to_merge->GetSubNet() == old_subnet )
+                item_to_merge->SetSubNet( subnet );
+        }
+
+        old_subnet = subnet;
+    }
+}
+
+
+/* Compare function used for sorting candidates  by increasing zone subnet
+ */
+static bool CmpZoneSubnetValue( const BOARD_CONNECTED_ITEM* a, const BOARD_CONNECTED_ITEM* b )
+{
+    int asubnet, bsubnet;
+
+    asubnet = a->GetZoneSubNet();
+    bsubnet = b->GetZoneSubNet();
+
+    return asubnet < bsubnet;
+}