2017-03-22 13:43:10 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KICAD, a free EDA CAD application.
|
|
|
|
*
|
2018-02-04 13:34:17 +00:00
|
|
|
* Copyright (C) 2016-2018 CERN
|
2023-01-23 16:23:43 +00:00
|
|
|
* Copyright (C) 2020-2023 KiCad Developers, see AUTHORS.txt for contributors.
|
2020-08-18 14:17:16 +00:00
|
|
|
*
|
2017-03-22 13:43:10 +00:00
|
|
|
* @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2022-06-15 00:41:10 +00:00
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <future>
|
|
|
|
#include <mutex>
|
|
|
|
|
2018-10-12 06:17:15 +00:00
|
|
|
#include <connectivity/connectivity_algo.h>
|
2021-08-14 20:05:21 +00:00
|
|
|
#include <progress_reporter.h>
|
2018-05-21 00:06:01 +00:00
|
|
|
#include <geometry/geometry_utils.h>
|
2019-05-25 01:55:40 +00:00
|
|
|
#include <board_commit.h>
|
2023-09-06 21:19:38 +00:00
|
|
|
#include <core/thread_pool.h>
|
2023-07-30 19:39:07 +00:00
|
|
|
#include <pcb_shape.h>
|
2017-11-23 16:20:27 +00:00
|
|
|
|
2021-06-01 05:17:57 +00:00
|
|
|
#include <wx/log.h>
|
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
#ifdef PROFILE
|
2023-09-07 11:22:10 +00:00
|
|
|
#include <core/profile.h>
|
2017-03-22 13:43:10 +00:00
|
|
|
#endif
|
|
|
|
|
2018-02-09 13:14:32 +00:00
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
bool CN_CONNECTIVITY_ALGO::Remove( BOARD_ITEM* aItem )
|
|
|
|
{
|
2017-06-23 11:56:28 +00:00
|
|
|
markItemNetAsDirty( aItem );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
|
|
|
switch( aItem->Type() )
|
|
|
|
{
|
2020-11-13 12:21:02 +00:00
|
|
|
case PCB_FOOTPRINT_T:
|
2020-11-13 15:15:52 +00:00
|
|
|
for( PAD* pad : static_cast<FOOTPRINT*>( aItem )->Pads() )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2020-08-07 20:37:00 +00:00
|
|
|
m_itemMap[pad].MarkItemsAsInvalid();
|
|
|
|
m_itemMap.erase( pad );
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2018-05-21 00:06:01 +00:00
|
|
|
m_itemList.SetDirty( true );
|
2017-03-22 13:43:10 +00:00
|
|
|
break;
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
case PCB_PAD_T:
|
|
|
|
case PCB_TRACE_T:
|
2019-05-17 00:13:21 +00:00
|
|
|
case PCB_ARC_T:
|
2017-03-22 13:43:10 +00:00
|
|
|
case PCB_VIA_T:
|
2020-11-11 23:05:59 +00:00
|
|
|
case PCB_ZONE_T:
|
2023-07-30 19:39:07 +00:00
|
|
|
case PCB_SHAPE_T:
|
2020-08-07 20:37:00 +00:00
|
|
|
m_itemMap[aItem].MarkItemsAsInvalid();
|
|
|
|
m_itemMap.erase ( aItem );
|
2018-07-06 21:55:25 +00:00
|
|
|
m_itemList.SetDirty( true );
|
2017-03-22 13:43:10 +00:00
|
|
|
break;
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
default:
|
2017-06-23 11:56:28 +00:00
|
|
|
return false;
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2018-05-21 00:06:01 +00:00
|
|
|
// Once we delete an item, it may connect between lists, so mark both as potentially invalid
|
|
|
|
m_itemList.SetHasInvalid( true );
|
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
|
|
|
void CN_CONNECTIVITY_ALGO::markItemNetAsDirty( const BOARD_ITEM* aItem )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2017-06-23 11:56:28 +00:00
|
|
|
if( aItem->IsConnected() )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2022-02-13 11:54:41 +00:00
|
|
|
const BOARD_CONNECTED_ITEM* citem = static_cast<const BOARD_CONNECTED_ITEM*>( aItem );
|
2017-07-01 21:54:17 +00:00
|
|
|
MarkNetAsDirty( citem->GetNetCode() );
|
2017-06-23 11:56:28 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-11-13 12:21:02 +00:00
|
|
|
if( aItem->Type() == PCB_FOOTPRINT_T )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2020-11-13 15:15:52 +00:00
|
|
|
const FOOTPRINT* footprint = static_cast<const FOOTPRINT*>( aItem );
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2020-11-13 15:15:52 +00:00
|
|
|
for( PAD* pad : footprint->Pads() )
|
2017-07-01 21:54:17 +00:00
|
|
|
MarkNetAsDirty( pad->GetNetCode() );
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool CN_CONNECTIVITY_ALGO::Add( BOARD_ITEM* aItem )
|
2017-06-23 11:56:28 +00:00
|
|
|
{
|
2019-07-25 11:08:41 +00:00
|
|
|
if( !aItem->IsOnCopperLayer() )
|
2018-07-10 19:22:36 +00:00
|
|
|
return false;
|
|
|
|
|
2023-05-21 16:56:29 +00:00
|
|
|
auto alreadyAdded =
|
|
|
|
[this]( BOARD_ITEM* item )
|
|
|
|
{
|
|
|
|
auto it = m_itemMap.find( item );
|
|
|
|
|
|
|
|
if( it == m_itemMap.end() )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Don't be fooled by an empty ITEM_MAP_ENTRY auto-created by operator[].
|
|
|
|
return !it->second.GetItems().empty();
|
|
|
|
};
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
switch( aItem->Type() )
|
|
|
|
{
|
2017-07-01 21:54:17 +00:00
|
|
|
case PCB_NETINFO_T:
|
2020-12-08 13:02:08 +00:00
|
|
|
MarkNetAsDirty( static_cast<NETINFO_ITEM*>( aItem )->GetNetCode() );
|
2020-11-13 12:21:02 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PCB_FOOTPRINT_T:
|
2021-12-09 01:38:59 +00:00
|
|
|
{
|
|
|
|
if( static_cast<FOOTPRINT*>( aItem )->GetAttributes() & FP_JUST_ADDED )
|
|
|
|
return false;
|
|
|
|
|
2020-11-13 15:15:52 +00:00
|
|
|
for( PAD* pad : static_cast<FOOTPRINT*>( aItem )->Pads() )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2023-05-21 16:56:29 +00:00
|
|
|
if( alreadyAdded( pad ) )
|
2017-06-23 11:56:28 +00:00
|
|
|
return false;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2018-05-21 00:06:01 +00:00
|
|
|
add( m_itemList, pad );
|
2017-06-23 11:56:28 +00:00
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
break;
|
2021-12-09 01:38:59 +00:00
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
case PCB_PAD_T:
|
2021-12-09 01:38:59 +00:00
|
|
|
{
|
2023-03-30 11:49:23 +00:00
|
|
|
if( FOOTPRINT* fp = aItem->GetParentFootprint() )
|
2021-12-09 01:38:59 +00:00
|
|
|
{
|
|
|
|
if( fp->GetAttributes() & FP_JUST_ADDED )
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2023-05-21 16:56:29 +00:00
|
|
|
if( alreadyAdded( aItem ) )
|
2017-06-23 11:56:28 +00:00
|
|
|
return false;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-11-12 22:30:02 +00:00
|
|
|
add( m_itemList, static_cast<PAD*>( aItem ) );
|
2017-06-23 11:56:28 +00:00
|
|
|
break;
|
2021-12-09 01:38:59 +00:00
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
case PCB_TRACE_T:
|
2023-05-21 16:56:29 +00:00
|
|
|
if( alreadyAdded( aItem ) )
|
2017-06-23 11:56:28 +00:00
|
|
|
return false;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2021-06-11 21:07:02 +00:00
|
|
|
add( m_itemList, static_cast<PCB_TRACK*>( aItem ) );
|
2017-06-23 11:56:28 +00:00
|
|
|
break;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2019-05-17 00:13:21 +00:00
|
|
|
case PCB_ARC_T:
|
2023-05-21 16:56:29 +00:00
|
|
|
if( alreadyAdded( aItem ) )
|
2019-05-17 00:13:21 +00:00
|
|
|
return false;
|
|
|
|
|
2021-06-11 21:07:02 +00:00
|
|
|
add( m_itemList, static_cast<PCB_ARC*>( aItem ) );
|
2019-05-17 00:13:21 +00:00
|
|
|
break;
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
case PCB_VIA_T:
|
2023-05-21 16:56:29 +00:00
|
|
|
if( alreadyAdded( aItem ) )
|
2017-06-23 11:56:28 +00:00
|
|
|
return false;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2021-06-11 21:07:02 +00:00
|
|
|
add( m_itemList, static_cast<PCB_VIA*>( aItem ) );
|
2017-06-23 11:56:28 +00:00
|
|
|
break;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2023-07-30 19:39:07 +00:00
|
|
|
case PCB_SHAPE_T:
|
|
|
|
if( alreadyAdded( aItem ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if( !IsCopperLayer( aItem->GetLayer() ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
add( m_itemList, static_cast<PCB_SHAPE*>( aItem ) );
|
|
|
|
break;
|
|
|
|
|
2020-11-11 23:05:59 +00:00
|
|
|
case PCB_ZONE_T:
|
2017-06-23 11:56:28 +00:00
|
|
|
{
|
2020-11-11 23:05:59 +00:00
|
|
|
ZONE* zone = static_cast<ZONE*>( aItem );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2023-05-21 16:56:29 +00:00
|
|
|
if( alreadyAdded( aItem ) )
|
2017-06-23 11:56:28 +00:00
|
|
|
return false;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
m_itemMap[zone] = ITEM_MAP_ENTRY();
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2024-03-05 20:56:30 +00:00
|
|
|
// Don't check for connections on layers that only exist in the zone but
|
|
|
|
// were disabled in the board
|
|
|
|
BOARD* board = zone->GetBoard();
|
|
|
|
LSET layerset = board->GetEnabledLayers() & zone->GetLayerSet();
|
|
|
|
|
2024-06-12 10:05:56 +00:00
|
|
|
layerset.RunOnLayers(
|
|
|
|
[&]( PCB_LAYER_ID layer )
|
|
|
|
{
|
|
|
|
for( CN_ITEM* zitem : m_itemList.Add( zone, layer ) )
|
|
|
|
m_itemMap[zone].Link( zitem );
|
|
|
|
} );
|
2017-06-23 11:56:28 +00:00
|
|
|
}
|
2020-11-13 12:21:02 +00:00
|
|
|
break;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
default:
|
|
|
|
return false;
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2021-12-09 01:38:59 +00:00
|
|
|
markItemNetAsDirty( aItem );
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-12-01 15:53:58 +00:00
|
|
|
|
2023-11-01 13:53:30 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::RemoveInvalidRefs()
|
|
|
|
{
|
|
|
|
for( CN_ITEM* item : m_itemList )
|
|
|
|
item->RemoveInvalidRefs();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-06-26 06:12:11 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::searchConnections()
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2018-05-15 22:50:59 +00:00
|
|
|
#ifdef PROFILE
|
2022-09-17 18:43:46 +00:00
|
|
|
PROF_TIMER garbage_collection( "garbage-collection" );
|
2018-05-15 22:50:59 +00:00
|
|
|
#endif
|
2017-06-23 11:56:28 +00:00
|
|
|
std::vector<CN_ITEM*> garbage;
|
|
|
|
garbage.reserve( 1024 );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2023-11-01 13:53:30 +00:00
|
|
|
m_parentConnectivityData->RemoveInvalidRefs();
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2023-11-01 12:47:42 +00:00
|
|
|
if( m_isLocal )
|
2023-11-01 13:53:30 +00:00
|
|
|
m_globalConnectivityData->RemoveInvalidRefs();
|
|
|
|
|
|
|
|
m_itemList.RemoveInvalidItems( garbage );
|
2023-11-01 12:47:42 +00:00
|
|
|
|
2022-02-13 11:54:41 +00:00
|
|
|
for( CN_ITEM* item : garbage )
|
2017-03-22 13:43:10 +00:00
|
|
|
delete item;
|
|
|
|
|
|
|
|
#ifdef PROFILE
|
2018-05-15 22:50:59 +00:00
|
|
|
garbage_collection.Show();
|
2022-09-17 18:43:46 +00:00
|
|
|
PROF_TIMER search_basic( "search-basic" );
|
2017-03-22 13:43:10 +00:00
|
|
|
#endif
|
|
|
|
|
2022-06-15 00:41:10 +00:00
|
|
|
thread_pool& tp = GetKiCadThreadPool();
|
2018-10-05 13:22:20 +00:00
|
|
|
std::vector<CN_ITEM*> dirtyItems;
|
|
|
|
std::copy_if( m_itemList.begin(), m_itemList.end(), std::back_inserter( dirtyItems ),
|
2020-10-26 12:50:12 +00:00
|
|
|
[] ( CN_ITEM* aItem )
|
|
|
|
{
|
|
|
|
return aItem->Dirty();
|
|
|
|
} );
|
2018-09-21 12:21:12 +00:00
|
|
|
|
2018-06-26 06:12:11 +00:00
|
|
|
if( m_progressReporter )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2018-10-05 13:22:20 +00:00
|
|
|
m_progressReporter->SetMaxProgress( dirtyItems.size() );
|
2020-10-26 12:54:30 +00:00
|
|
|
|
|
|
|
if( !m_progressReporter->KeepRefreshing() )
|
|
|
|
return;
|
2018-06-26 06:12:11 +00:00
|
|
|
}
|
|
|
|
|
2018-09-20 02:10:12 +00:00
|
|
|
if( m_itemList.IsDirty() )
|
2018-06-26 06:12:11 +00:00
|
|
|
{
|
2018-10-27 01:00:43 +00:00
|
|
|
|
2022-06-15 00:41:10 +00:00
|
|
|
std::vector<std::future<size_t>> returns( dirtyItems.size() );
|
2018-09-20 02:10:12 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
auto conn_lambda =
|
2022-06-15 00:41:10 +00:00
|
|
|
[&dirtyItems]( size_t aItem, CN_LIST* aItemList,
|
2022-08-03 09:10:23 +00:00
|
|
|
PROGRESS_REPORTER* aReporter) -> size_t
|
2020-10-26 12:50:12 +00:00
|
|
|
{
|
2022-06-15 00:41:10 +00:00
|
|
|
if( aReporter && aReporter->IsCancelled() )
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
CN_VISITOR visitor( dirtyItems[aItem] );
|
|
|
|
aItemList->FindNearby( dirtyItems[aItem], visitor );
|
|
|
|
|
|
|
|
if( aReporter )
|
|
|
|
aReporter->AdvanceProgress();
|
2018-06-26 06:12:11 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
return 1;
|
|
|
|
};
|
2018-09-20 02:10:12 +00:00
|
|
|
|
2022-06-15 00:41:10 +00:00
|
|
|
for( size_t ii = 0; ii < dirtyItems.size(); ++ii )
|
|
|
|
returns[ii] = tp.submit( conn_lambda, ii, &m_itemList, m_progressReporter );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2022-09-14 20:28:46 +00:00
|
|
|
for( const std::future<size_t>& ret : returns )
|
2022-06-15 00:41:10 +00:00
|
|
|
{
|
2022-08-03 09:10:23 +00:00
|
|
|
// Here we balance returns with a 250ms timeout to allow UI updating
|
2022-09-14 20:28:46 +00:00
|
|
|
std::future_status status = ret.wait_for( std::chrono::milliseconds( 250 ) );
|
|
|
|
|
|
|
|
while( status != std::future_status::ready )
|
2018-10-25 11:20:12 +00:00
|
|
|
{
|
2022-06-15 00:41:10 +00:00
|
|
|
if( m_progressReporter )
|
|
|
|
m_progressReporter->KeepRefreshing();
|
2018-10-27 01:00:43 +00:00
|
|
|
|
2022-09-14 20:28:46 +00:00
|
|
|
status = ret.wait_for( std::chrono::milliseconds( 250 ) );
|
2022-08-03 09:10:23 +00:00
|
|
|
}
|
2018-09-20 02:10:12 +00:00
|
|
|
}
|
2018-10-25 11:20:12 +00:00
|
|
|
|
|
|
|
if( m_progressReporter )
|
|
|
|
m_progressReporter->KeepRefreshing();
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
2018-09-20 02:10:12 +00:00
|
|
|
|
|
|
|
#ifdef PROFILE
|
|
|
|
search_basic.Show();
|
2018-06-26 06:12:11 +00:00
|
|
|
#endif
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2018-06-26 06:12:11 +00:00
|
|
|
m_itemList.ClearDirtyFlags();
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
const CN_CONNECTIVITY_ALGO::CLUSTERS CN_CONNECTIVITY_ALGO::SearchClusters( CLUSTER_SEARCH_MODE aMode )
|
|
|
|
{
|
2018-07-06 21:55:25 +00:00
|
|
|
if( aMode == CSM_PROPAGATE )
|
2022-08-20 09:27:35 +00:00
|
|
|
{
|
2022-03-03 23:49:05 +00:00
|
|
|
return SearchClusters( aMode,
|
2023-07-30 19:39:07 +00:00
|
|
|
{ PCB_TRACE_T, PCB_ARC_T, PCB_PAD_T, PCB_VIA_T, PCB_FOOTPRINT_T,
|
|
|
|
PCB_SHAPE_T },
|
2022-08-20 09:27:35 +00:00
|
|
|
-1 );
|
|
|
|
}
|
2018-07-06 21:55:25 +00:00
|
|
|
else
|
2022-08-20 09:27:35 +00:00
|
|
|
{
|
2022-03-03 23:49:05 +00:00
|
|
|
return SearchClusters( aMode,
|
2023-07-30 19:39:07 +00:00
|
|
|
{ PCB_TRACE_T, PCB_ARC_T, PCB_PAD_T, PCB_VIA_T, PCB_ZONE_T,
|
|
|
|
PCB_FOOTPRINT_T, PCB_SHAPE_T },
|
2022-08-20 09:27:35 +00:00
|
|
|
-1 );
|
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2022-02-06 17:26:30 +00:00
|
|
|
const CN_CONNECTIVITY_ALGO::CLUSTERS
|
2022-08-03 09:10:23 +00:00
|
|
|
CN_CONNECTIVITY_ALGO::SearchClusters( CLUSTER_SEARCH_MODE aMode,
|
|
|
|
const std::initializer_list<KICAD_T>& aTypes,
|
2022-02-06 17:26:30 +00:00
|
|
|
int aSingleNet, CN_ITEM* rootItem )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
|
|
|
bool withinAnyNet = ( aMode != CSM_PROPAGATE );
|
|
|
|
|
|
|
|
std::deque<CN_ITEM*> Q;
|
2020-07-27 16:33:01 +00:00
|
|
|
std::set<CN_ITEM*> item_set;
|
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
CLUSTERS clusters;
|
|
|
|
|
2018-10-12 12:57:56 +00:00
|
|
|
if( m_itemList.IsDirty() )
|
2018-06-26 06:12:11 +00:00
|
|
|
searchConnections();
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
auto addToSearchList =
|
2022-08-03 09:10:23 +00:00
|
|
|
[&item_set, withinAnyNet, aSingleNet, &aTypes, rootItem ]( CN_ITEM *aItem )
|
2020-10-26 12:50:12 +00:00
|
|
|
{
|
|
|
|
if( withinAnyNet && aItem->Net() <= 0 )
|
|
|
|
return;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
if( !aItem->Valid() )
|
|
|
|
return;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
if( aSingleNet >=0 && aItem->Net() != aSingleNet )
|
|
|
|
return;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
bool found = false;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2022-03-03 23:49:05 +00:00
|
|
|
for( KICAD_T type : aTypes )
|
2020-10-26 12:50:12 +00:00
|
|
|
{
|
2022-03-03 23:49:05 +00:00
|
|
|
if( aItem->Parent()->Type() == type )
|
2020-10-26 12:50:12 +00:00
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2022-02-06 17:26:30 +00:00
|
|
|
if( !found && aItem != rootItem )
|
2020-10-26 12:50:12 +00:00
|
|
|
return;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
aItem->SetVisited( false );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
item_set.insert( aItem );
|
|
|
|
};
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2018-05-21 00:06:01 +00:00
|
|
|
std::for_each( m_itemList.begin(), m_itemList.end(), addToSearchList );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:54:30 +00:00
|
|
|
if( m_progressReporter && m_progressReporter->IsCancelled() )
|
|
|
|
return CLUSTERS();
|
|
|
|
|
2020-07-27 16:33:01 +00:00
|
|
|
while( !item_set.empty() )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2022-02-13 11:54:41 +00:00
|
|
|
std::shared_ptr<CN_CLUSTER> cluster = std::make_shared<CN_CLUSTER>();
|
|
|
|
CN_ITEM* root;
|
|
|
|
auto it = item_set.begin();
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-07-27 16:33:01 +00:00
|
|
|
while( it != item_set.end() && (*it)->Visited() )
|
|
|
|
it = item_set.erase( item_set.begin() );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-07-27 16:33:01 +00:00
|
|
|
if( it == item_set.end() )
|
|
|
|
break;
|
|
|
|
|
|
|
|
root = *it;
|
2020-10-26 12:50:12 +00:00
|
|
|
root->SetVisited( true );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-07-27 16:33:01 +00:00
|
|
|
Q.clear();
|
2017-03-22 13:43:10 +00:00
|
|
|
Q.push_back( root );
|
|
|
|
|
|
|
|
while( Q.size() )
|
|
|
|
{
|
|
|
|
CN_ITEM* current = Q.front();
|
|
|
|
|
|
|
|
Q.pop_front();
|
|
|
|
cluster->Add( current );
|
|
|
|
|
2022-02-13 11:54:41 +00:00
|
|
|
for( CN_ITEM* n : current->ConnectedItems() )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2017-06-23 11:56:28 +00:00
|
|
|
if( withinAnyNet && n->Net() != root->Net() )
|
2017-03-22 13:43:10 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if( !n->Visited() && n->Valid() )
|
|
|
|
{
|
|
|
|
n->SetVisited( true );
|
|
|
|
Q.push_back( n );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
clusters.push_back( cluster );
|
|
|
|
}
|
|
|
|
|
2020-10-26 12:54:30 +00:00
|
|
|
if( m_progressReporter && m_progressReporter->IsCancelled() )
|
|
|
|
return CLUSTERS();
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-10-26 12:50:12 +00:00
|
|
|
std::sort( clusters.begin(), clusters.end(),
|
2022-02-13 11:54:41 +00:00
|
|
|
[]( const std::shared_ptr<CN_CLUSTER>& a, const std::shared_ptr<CN_CLUSTER>& b )
|
2020-10-26 12:50:12 +00:00
|
|
|
{
|
|
|
|
return a->OriginNet() < b->OriginNet();
|
|
|
|
} );
|
2017-03-22 13:43:10 +00:00
|
|
|
|
|
|
|
return clusters;
|
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2020-09-23 10:46:41 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::Build( BOARD* aBoard, PROGRESS_REPORTER* aReporter )
|
|
|
|
{
|
2022-02-16 14:10:43 +00:00
|
|
|
// Generate CN_ZONE_LAYERs for each island on each layer of each zone
|
|
|
|
//
|
|
|
|
std::vector<CN_ZONE_LAYER*> zitems;
|
2020-09-23 10:46:41 +00:00
|
|
|
|
2022-02-16 14:10:43 +00:00
|
|
|
for( ZONE* zone : aBoard->Zones() )
|
|
|
|
{
|
|
|
|
if( zone->IsOnCopperLayer() )
|
|
|
|
{
|
|
|
|
m_itemMap[zone] = ITEM_MAP_ENTRY();
|
|
|
|
markItemNetAsDirty( zone );
|
|
|
|
|
2024-03-05 20:56:30 +00:00
|
|
|
// Don't check for connections on layers that only exist in the zone but
|
|
|
|
// were disabled in the board
|
|
|
|
BOARD* board = zone->GetBoard();
|
|
|
|
LSET layerset = board->GetEnabledLayers() & zone->GetLayerSet() & LSET::AllCuMask();
|
|
|
|
|
2024-06-12 10:05:56 +00:00
|
|
|
layerset.RunOnLayers(
|
|
|
|
[&]( PCB_LAYER_ID layer )
|
|
|
|
{
|
|
|
|
for( int j = 0; j < zone->GetFilledPolysList( layer )->OutlineCount(); j++ )
|
|
|
|
zitems.push_back( new CN_ZONE_LAYER( zone, layer, j ) );
|
|
|
|
} );
|
2022-02-16 14:10:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Setup progress metrics
|
|
|
|
//
|
2022-08-03 09:10:23 +00:00
|
|
|
int progressDelta = 50;
|
2022-02-16 14:10:43 +00:00
|
|
|
double size = 0.0;
|
|
|
|
|
|
|
|
size += zitems.size(); // Once for building RTrees
|
|
|
|
size += zitems.size(); // Once for adding to connectivity
|
2020-09-23 10:46:41 +00:00
|
|
|
size += aBoard->Tracks().size();
|
2023-07-30 19:39:07 +00:00
|
|
|
size += aBoard->Drawings().size();
|
2020-09-23 10:46:41 +00:00
|
|
|
|
2020-11-13 15:15:52 +00:00
|
|
|
for( FOOTPRINT* footprint : aBoard->Footprints() )
|
2020-11-12 23:50:33 +00:00
|
|
|
size += footprint->Pads().size();
|
2020-09-23 10:46:41 +00:00
|
|
|
|
2022-02-16 14:10:43 +00:00
|
|
|
size *= 1.5; // Our caller gets the other third of the progress bar
|
2020-09-23 10:46:41 +00:00
|
|
|
|
2022-08-03 09:10:23 +00:00
|
|
|
progressDelta = std::max( progressDelta, (int) size / 4 );
|
2021-11-25 16:19:03 +00:00
|
|
|
|
2022-02-16 14:10:43 +00:00
|
|
|
auto report =
|
|
|
|
[&]( int progress )
|
|
|
|
{
|
2022-08-03 09:10:23 +00:00
|
|
|
if( aReporter && ( progress % progressDelta ) == 0 )
|
2022-02-16 14:10:43 +00:00
|
|
|
{
|
|
|
|
aReporter->SetCurrentProgress( progress / size );
|
|
|
|
aReporter->KeepRefreshing( false );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Generate RTrees for CN_ZONE_LAYER items (in parallel)
|
|
|
|
//
|
2022-06-15 00:41:10 +00:00
|
|
|
thread_pool& tp = GetKiCadThreadPool();
|
|
|
|
std::vector<std::future<size_t>> returns( zitems.size() );
|
2022-02-16 14:10:43 +00:00
|
|
|
|
2022-08-03 09:10:23 +00:00
|
|
|
auto cache_zones =
|
|
|
|
[aReporter]( CN_ZONE_LAYER* aZoneLayer ) -> size_t
|
2022-06-15 00:41:10 +00:00
|
|
|
{
|
|
|
|
if( aReporter && aReporter->IsCancelled() )
|
|
|
|
return 0;
|
2022-02-14 17:19:28 +00:00
|
|
|
|
2022-08-03 09:10:23 +00:00
|
|
|
aZoneLayer->BuildRTree();
|
2022-02-16 14:10:43 +00:00
|
|
|
|
2022-06-15 00:41:10 +00:00
|
|
|
if( aReporter )
|
|
|
|
aReporter->AdvanceProgress();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
};
|
2022-02-16 14:10:43 +00:00
|
|
|
|
2022-06-15 00:41:10 +00:00
|
|
|
for( size_t ii = 0; ii < zitems.size(); ++ii )
|
|
|
|
returns[ii] = tp.submit( cache_zones, zitems[ii] );
|
|
|
|
|
2022-09-14 20:28:46 +00:00
|
|
|
for( const std::future<size_t>& ret : returns )
|
2022-02-16 14:10:43 +00:00
|
|
|
{
|
2022-09-14 20:28:46 +00:00
|
|
|
std::future_status status = ret.wait_for( std::chrono::milliseconds( 250 ) );
|
2022-06-15 00:41:10 +00:00
|
|
|
|
2022-09-14 20:28:46 +00:00
|
|
|
while( status != std::future_status::ready )
|
2022-02-14 17:19:28 +00:00
|
|
|
{
|
2022-06-15 00:41:10 +00:00
|
|
|
if( aReporter )
|
|
|
|
aReporter->KeepRefreshing();
|
|
|
|
|
2022-09-14 20:28:46 +00:00
|
|
|
status = ret.wait_for( std::chrono::milliseconds( 250 ) );
|
2022-08-03 09:10:23 +00:00
|
|
|
}
|
2022-02-16 14:10:43 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add CN_ZONE_LAYERS, tracks, and pads to connectivity
|
|
|
|
//
|
|
|
|
int ii = zitems.size();
|
|
|
|
|
|
|
|
for( CN_ZONE_LAYER* zitem : zitems )
|
|
|
|
{
|
|
|
|
m_itemList.Add( zitem );
|
|
|
|
m_itemMap[ zitem->Parent() ].Link( zitem );
|
|
|
|
report( ++ii );
|
2020-09-23 10:46:41 +00:00
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2021-06-11 21:07:02 +00:00
|
|
|
for( PCB_TRACK* tv : aBoard->Tracks() )
|
2020-09-23 10:46:41 +00:00
|
|
|
{
|
2017-03-22 13:43:10 +00:00
|
|
|
Add( tv );
|
2022-02-16 14:10:43 +00:00
|
|
|
report( ++ii );
|
2020-09-23 10:46:41 +00:00
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2020-11-13 15:15:52 +00:00
|
|
|
for( FOOTPRINT* footprint : aBoard->Footprints() )
|
2017-06-23 11:56:28 +00:00
|
|
|
{
|
2020-11-12 22:30:02 +00:00
|
|
|
for( PAD* pad : footprint->Pads() )
|
2020-09-23 10:46:41 +00:00
|
|
|
{
|
2017-03-22 13:43:10 +00:00
|
|
|
Add( pad );
|
2022-02-16 14:10:43 +00:00
|
|
|
report( ++ii );
|
2020-09-23 10:46:41 +00:00
|
|
|
}
|
2017-06-23 11:56:28 +00:00
|
|
|
}
|
2022-02-14 17:19:28 +00:00
|
|
|
|
2023-07-30 19:39:07 +00:00
|
|
|
for( BOARD_ITEM* drawing : aBoard->Drawings() )
|
|
|
|
{
|
|
|
|
if( PCB_SHAPE* shape = dynamic_cast<PCB_SHAPE*>( drawing ) )
|
|
|
|
{
|
|
|
|
if( shape->IsOnCopperLayer() )
|
|
|
|
Add( shape );
|
|
|
|
}
|
|
|
|
|
|
|
|
report( ++ii );
|
|
|
|
}
|
|
|
|
|
2022-02-14 17:19:28 +00:00
|
|
|
if( aReporter )
|
|
|
|
{
|
|
|
|
aReporter->SetCurrentProgress( (double) ii / (double) size );
|
|
|
|
aReporter->KeepRefreshing( false );
|
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2023-11-01 13:53:30 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::LocalBuild( std::shared_ptr<CONNECTIVITY_DATA> aGlobalConnectivity,
|
2023-11-01 12:47:42 +00:00
|
|
|
const std::vector<BOARD_ITEM*>& aLocalItems )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2023-11-01 12:47:42 +00:00
|
|
|
m_isLocal = true;
|
2023-11-01 13:53:30 +00:00
|
|
|
m_globalConnectivityData = aGlobalConnectivity;
|
2023-11-01 12:47:42 +00:00
|
|
|
|
|
|
|
for( BOARD_ITEM* item : aLocalItems )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
|
|
|
switch( item->Type() )
|
|
|
|
{
|
2022-02-16 12:00:18 +00:00
|
|
|
case PCB_TRACE_T:
|
|
|
|
case PCB_ARC_T:
|
|
|
|
case PCB_VIA_T:
|
|
|
|
case PCB_PAD_T:
|
|
|
|
case PCB_FOOTPRINT_T:
|
2023-07-30 19:39:07 +00:00
|
|
|
case PCB_SHAPE_T:
|
2022-02-16 12:00:18 +00:00
|
|
|
Add( item );
|
|
|
|
break;
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2022-02-16 12:00:18 +00:00
|
|
|
default:
|
|
|
|
break;
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2023-01-23 16:23:43 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::propagateConnections( BOARD_COMMIT* aCommit )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2022-02-14 17:19:28 +00:00
|
|
|
for( const std::shared_ptr<CN_CLUSTER>& cluster : m_connClusters )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2023-01-23 16:23:43 +00:00
|
|
|
if( cluster->IsConflicting() )
|
2017-09-29 09:40:10 +00:00
|
|
|
{
|
2023-01-23 16:23:43 +00:00
|
|
|
// Conflicting pads in cluster: we don't know the user's intent so best to do
|
|
|
|
// nothing.
|
|
|
|
wxLogTrace( wxT( "CN" ), wxT( "Conflicting pads in cluster %p; skipping propagation" ),
|
|
|
|
cluster.get() );
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
else if( cluster->HasValidNet() )
|
|
|
|
{
|
2023-01-23 16:23:43 +00:00
|
|
|
// Propagate from the origin (will be a pad if there are any, or another item if
|
|
|
|
// there are no pads).
|
2017-03-22 13:43:10 +00:00
|
|
|
int n_changed = 0;
|
|
|
|
|
2022-08-03 09:10:23 +00:00
|
|
|
for( CN_ITEM* item : *cluster )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2023-01-23 11:38:47 +00:00
|
|
|
if( item->Valid() && item->CanChangeNet()
|
|
|
|
&& item->Parent()->GetNetCode() != cluster->OriginNet() )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2023-01-23 16:23:43 +00:00
|
|
|
MarkNetAsDirty( item->Parent()->GetNetCode() );
|
|
|
|
MarkNetAsDirty( cluster->OriginNet() );
|
2023-01-23 11:38:47 +00:00
|
|
|
|
2023-01-23 16:23:43 +00:00
|
|
|
if( aCommit )
|
|
|
|
aCommit->Modify( item->Parent() );
|
2019-05-25 01:55:40 +00:00
|
|
|
|
2023-01-23 16:23:43 +00:00
|
|
|
item->Parent()->SetNetCode( cluster->OriginNet() );
|
|
|
|
n_changed++;
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( n_changed )
|
2020-01-11 21:28:25 +00:00
|
|
|
{
|
2023-01-23 16:23:43 +00:00
|
|
|
wxLogTrace( wxT( "CN" ), wxT( "Cluster %p: net: %d %s" ),
|
2022-02-04 22:44:59 +00:00
|
|
|
cluster.get(),
|
|
|
|
cluster->OriginNet(),
|
|
|
|
(const char*) cluster->OriginNetName().c_str() );
|
2020-01-11 21:28:25 +00:00
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
else
|
2022-08-03 09:10:23 +00:00
|
|
|
{
|
2023-01-23 16:23:43 +00:00
|
|
|
wxLogTrace( wxT( "CN" ), wxT( "Cluster %p: no changeable items to propagate to" ),
|
2022-02-04 22:44:59 +00:00
|
|
|
cluster.get() );
|
2022-08-03 09:10:23 +00:00
|
|
|
}
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-01-23 16:23:43 +00:00
|
|
|
wxLogTrace( wxT( "CN" ), wxT( "Cluster %p: connected to unused net" ),
|
2022-02-04 22:44:59 +00:00
|
|
|
cluster.get() );
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-01-23 16:23:43 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::PropagateNets( BOARD_COMMIT* aCommit )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
|
|
|
m_connClusters = SearchClusters( CSM_PROPAGATE );
|
2023-01-23 16:23:43 +00:00
|
|
|
propagateConnections( aCommit );
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2017-12-01 15:53:58 +00:00
|
|
|
|
2023-03-25 10:44:46 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::FillIsolatedIslandsMap(
|
|
|
|
std::map<ZONE*, std::map<PCB_LAYER_ID, ISOLATED_ISLANDS>>& aMap,
|
|
|
|
bool aConnectivityAlreadyRebuilt )
|
2017-11-23 16:20:27 +00:00
|
|
|
{
|
2022-08-03 09:10:23 +00:00
|
|
|
int progressDelta = 50;
|
2022-02-15 15:19:39 +00:00
|
|
|
int ii = 0;
|
|
|
|
|
2023-03-25 10:44:46 +00:00
|
|
|
progressDelta = std::max( progressDelta, (int) aMap.size() / 4 );
|
2022-08-03 09:10:23 +00:00
|
|
|
|
2022-06-18 18:47:11 +00:00
|
|
|
if( !aConnectivityAlreadyRebuilt )
|
2018-06-26 06:12:11 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
for( const auto& [ zone, islands ] : aMap )
|
2022-02-15 15:19:39 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
Remove( zone );
|
|
|
|
Add( zone );
|
2022-06-18 18:47:11 +00:00
|
|
|
ii++;
|
2022-02-15 15:19:39 +00:00
|
|
|
|
2022-08-03 09:10:23 +00:00
|
|
|
if( m_progressReporter && ( ii % progressDelta ) == 0 )
|
2022-06-18 18:47:11 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
m_progressReporter->SetCurrentProgress( (double) ii / (double) aMap.size() );
|
2022-06-18 18:47:11 +00:00
|
|
|
m_progressReporter->KeepRefreshing( false );
|
|
|
|
}
|
|
|
|
|
|
|
|
if( m_progressReporter && m_progressReporter->IsCancelled() )
|
|
|
|
return;
|
|
|
|
}
|
2017-11-23 16:20:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
m_connClusters = SearchClusters( CSM_CONNECTIVITY_CHECK );
|
|
|
|
|
2023-03-25 10:44:46 +00:00
|
|
|
for( auto& [ zone, zoneIslands ] : aMap )
|
2017-11-23 16:20:27 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
for( auto& [ layer, layerIslands ] : zoneIslands )
|
2017-11-23 16:20:27 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
if( zone->GetFilledPolysList( layer )->IsEmpty() )
|
2020-07-01 02:21:59 +00:00
|
|
|
continue;
|
|
|
|
|
2022-02-13 11:54:41 +00:00
|
|
|
for( const std::shared_ptr<CN_CLUSTER>& cluster : m_connClusters )
|
2017-11-23 16:20:27 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
for( CN_ITEM* item : *cluster )
|
2017-11-23 16:20:27 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
if( item->Parent() == zone && item->Layer() == layer )
|
2020-07-01 02:21:59 +00:00
|
|
|
{
|
2023-03-25 10:44:46 +00:00
|
|
|
CN_ZONE_LAYER* z = static_cast<CN_ZONE_LAYER*>( item );
|
|
|
|
|
|
|
|
if( cluster->IsOrphaned() )
|
|
|
|
layerIslands.m_IsolatedOutlines.push_back( z->SubpolyIndex() );
|
|
|
|
else if( z->HasSingleConnection() )
|
|
|
|
layerIslands.m_SingleConnectionOutlines.push_back( z->SubpolyIndex() );
|
2020-07-01 02:21:59 +00:00
|
|
|
}
|
2017-11-23 16:20:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
const CN_CONNECTIVITY_ALGO::CLUSTERS& CN_CONNECTIVITY_ALGO::GetClusters()
|
|
|
|
{
|
|
|
|
m_ratsnestClusters = SearchClusters( CSM_RATSNEST );
|
|
|
|
return m_ratsnestClusters;
|
2017-06-23 11:56:28 +00:00
|
|
|
}
|
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
|
2017-07-01 21:54:17 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::MarkNetAsDirty( int aNet )
|
2017-03-22 13:43:10 +00:00
|
|
|
{
|
2017-07-01 21:54:17 +00:00
|
|
|
if( aNet < 0 )
|
2017-03-22 13:43:10 +00:00
|
|
|
return;
|
|
|
|
|
2017-06-23 17:22:44 +00:00
|
|
|
if( (int) m_dirtyNets.size() <= aNet )
|
2018-04-06 12:57:12 +00:00
|
|
|
{
|
|
|
|
int lastNet = m_dirtyNets.size() - 1;
|
|
|
|
|
|
|
|
if( lastNet < 0 )
|
|
|
|
lastNet = 0;
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
m_dirtyNets.resize( aNet + 1 );
|
|
|
|
|
2018-04-06 12:57:12 +00:00
|
|
|
for( int i = lastNet; i < aNet + 1; i++ )
|
|
|
|
m_dirtyNets[i] = true;
|
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
m_dirtyNets[aNet] = true;
|
2017-03-22 13:43:10 +00:00
|
|
|
}
|
|
|
|
|
2017-06-23 11:56:28 +00:00
|
|
|
|
2020-09-23 19:02:21 +00:00
|
|
|
void CN_VISITOR::checkZoneItemConnection( CN_ZONE_LAYER* aZoneLayer, CN_ITEM* aItem )
|
2018-05-21 00:06:01 +00:00
|
|
|
{
|
2022-10-20 17:27:54 +00:00
|
|
|
PCB_LAYER_ID layer = aZoneLayer->GetLayer();
|
|
|
|
BOARD_CONNECTED_ITEM* item = aItem->Parent();
|
2022-02-14 13:34:45 +00:00
|
|
|
|
2022-10-20 17:27:54 +00:00
|
|
|
if( !item->IsOnLayer( layer ) )
|
2022-02-14 13:34:45 +00:00
|
|
|
return;
|
|
|
|
|
2022-02-15 18:15:22 +00:00
|
|
|
auto connect =
|
|
|
|
[&]()
|
|
|
|
{
|
|
|
|
aZoneLayer->Connect( aItem );
|
|
|
|
aItem->Connect( aZoneLayer );
|
|
|
|
};
|
|
|
|
|
|
|
|
// Try quick checks first...
|
2022-10-20 17:27:54 +00:00
|
|
|
if( item->Type() == PCB_PAD_T )
|
|
|
|
{
|
|
|
|
PAD* pad = static_cast<PAD*>( item );
|
|
|
|
|
2023-02-05 13:07:30 +00:00
|
|
|
if( pad->ConditionallyFlashed( layer )
|
|
|
|
&& pad->GetZoneLayerOverride( layer ) == ZLO_FORCE_NO_ZONE_CONNECTION )
|
|
|
|
{
|
2022-10-20 17:27:54 +00:00
|
|
|
return;
|
2023-02-05 13:07:30 +00:00
|
|
|
}
|
2022-10-20 17:27:54 +00:00
|
|
|
}
|
|
|
|
else if( item->Type() == PCB_VIA_T )
|
|
|
|
{
|
|
|
|
PCB_VIA* via = static_cast<PCB_VIA*>( item );
|
|
|
|
|
2023-02-05 13:07:30 +00:00
|
|
|
if( via->ConditionallyFlashed( layer )
|
|
|
|
&& via->GetZoneLayerOverride( layer ) == ZLO_FORCE_NO_ZONE_CONNECTION )
|
|
|
|
{
|
2022-10-20 17:27:54 +00:00
|
|
|
return;
|
2023-02-05 13:07:30 +00:00
|
|
|
}
|
2022-10-20 17:27:54 +00:00
|
|
|
}
|
|
|
|
|
2022-02-15 18:15:22 +00:00
|
|
|
for( int i = 0; i < aItem->AnchorCount(); ++i )
|
2020-09-23 19:02:21 +00:00
|
|
|
{
|
2022-02-15 18:15:22 +00:00
|
|
|
if( aZoneLayer->ContainsPoint( aItem->GetAnchor( i ) ) )
|
|
|
|
{
|
|
|
|
connect();
|
|
|
|
return;
|
|
|
|
}
|
2018-05-21 00:06:01 +00:00
|
|
|
}
|
2022-02-15 18:15:22 +00:00
|
|
|
|
2022-10-20 17:27:54 +00:00
|
|
|
if( item->Type() == PCB_VIA_T || item->Type() == PCB_PAD_T )
|
2022-03-16 23:48:24 +00:00
|
|
|
{
|
|
|
|
// As long as the pad/via crosses the zone layer, check for the full effective shape
|
|
|
|
// We check for the overlapping layers above
|
2022-10-20 17:27:54 +00:00
|
|
|
if( aZoneLayer->Collide( item->GetEffectiveShape( layer, FLASHING::ALWAYS_FLASHED ).get() ) )
|
2022-03-16 23:48:24 +00:00
|
|
|
connect();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-10-20 17:27:54 +00:00
|
|
|
if( aZoneLayer->Collide( item->GetEffectiveShape( layer ).get() ) )
|
2022-02-15 18:15:22 +00:00
|
|
|
connect();
|
2018-05-21 00:06:01 +00:00
|
|
|
}
|
|
|
|
|
2020-09-23 19:02:21 +00:00
|
|
|
void CN_VISITOR::checkZoneZoneConnection( CN_ZONE_LAYER* aZoneLayerA, CN_ZONE_LAYER* aZoneLayerB )
|
2018-05-21 00:06:01 +00:00
|
|
|
{
|
2022-02-14 01:07:25 +00:00
|
|
|
const ZONE* zoneA = static_cast<const ZONE*>( aZoneLayerA->Parent() );
|
|
|
|
const ZONE* zoneB = static_cast<const ZONE*>( aZoneLayerB->Parent() );
|
|
|
|
|
2020-09-23 19:02:21 +00:00
|
|
|
const BOX2I& boxA = aZoneLayerA->BBox();
|
|
|
|
const BOX2I& boxB = aZoneLayerB->BBox();
|
2020-08-07 22:57:59 +00:00
|
|
|
|
2022-02-14 13:34:45 +00:00
|
|
|
PCB_LAYER_ID layer = aZoneLayerA->GetLayer();
|
|
|
|
|
|
|
|
if( aZoneLayerB->GetLayer() != layer )
|
2022-02-13 00:29:12 +00:00
|
|
|
return;
|
2018-05-21 00:06:01 +00:00
|
|
|
|
2022-02-14 13:34:45 +00:00
|
|
|
if( !boxA.Intersects( boxB ) )
|
|
|
|
return;
|
2020-08-07 22:57:59 +00:00
|
|
|
|
2022-02-14 01:07:25 +00:00
|
|
|
const SHAPE_LINE_CHAIN& outline =
|
2022-02-15 17:34:38 +00:00
|
|
|
zoneA->GetFilledPolysList( layer )->COutline( aZoneLayerA->SubpolyIndex() );
|
2022-02-14 01:07:25 +00:00
|
|
|
|
|
|
|
for( int i = 0; i < outline.PointCount(); i++ )
|
|
|
|
{
|
|
|
|
if( !boxB.Contains( outline.CPoint( i ) ) )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if( aZoneLayerB->ContainsPoint( outline.CPoint( i ) ) )
|
|
|
|
{
|
|
|
|
aZoneLayerA->Connect( aZoneLayerB );
|
|
|
|
aZoneLayerB->Connect( aZoneLayerA );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const SHAPE_LINE_CHAIN& outline2 =
|
2022-02-15 17:34:38 +00:00
|
|
|
zoneB->GetFilledPolysList( layer )->COutline( aZoneLayerB->SubpolyIndex() );
|
2022-02-14 01:07:25 +00:00
|
|
|
|
|
|
|
for( int i = 0; i < outline2.PointCount(); i++ )
|
2020-09-23 19:02:21 +00:00
|
|
|
{
|
2022-02-14 01:07:25 +00:00
|
|
|
if( !boxA.Contains( outline2.CPoint( i ) ) )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if( aZoneLayerA->ContainsPoint( outline2.CPoint( i ) ) )
|
|
|
|
{
|
|
|
|
aZoneLayerA->Connect( aZoneLayerB );
|
|
|
|
aZoneLayerB->Connect( aZoneLayerA );
|
|
|
|
return;
|
|
|
|
}
|
2018-05-21 00:06:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool CN_VISITOR::operator()( CN_ITEM* aCandidate )
|
|
|
|
{
|
2020-07-25 11:58:17 +00:00
|
|
|
const BOARD_CONNECTED_ITEM* parentA = aCandidate->Parent();
|
|
|
|
const BOARD_CONNECTED_ITEM* parentB = m_item->Parent();
|
2018-05-21 00:06:01 +00:00
|
|
|
|
|
|
|
if( !aCandidate->Valid() || !m_item->Valid() )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if( parentA == parentB )
|
|
|
|
return true;
|
|
|
|
|
2022-10-11 22:02:22 +00:00
|
|
|
// Don't connect items in different nets that can't be changed
|
|
|
|
if( !aCandidate->CanChangeNet() && !m_item->CanChangeNet() && aCandidate->Net() != m_item->Net() )
|
|
|
|
return true;
|
|
|
|
|
2018-07-06 21:55:25 +00:00
|
|
|
// If both m_item and aCandidate are marked dirty, they will both be searched
|
|
|
|
// Since we are reciprocal in our connection, we arbitrarily pick one of the connections
|
|
|
|
// to conduct the expensive search
|
|
|
|
if( aCandidate->Dirty() && aCandidate < m_item )
|
|
|
|
return true;
|
|
|
|
|
2018-05-21 00:06:01 +00:00
|
|
|
// We should handle zone-zone connection separately
|
2020-11-11 23:05:59 +00:00
|
|
|
if ( parentA->Type() == PCB_ZONE_T && parentB->Type() == PCB_ZONE_T )
|
2018-05-21 00:06:01 +00:00
|
|
|
{
|
2020-09-23 19:02:21 +00:00
|
|
|
checkZoneZoneConnection( static_cast<CN_ZONE_LAYER*>( m_item ),
|
|
|
|
static_cast<CN_ZONE_LAYER*>( aCandidate ) );
|
2018-05-21 00:06:01 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-11-11 23:05:59 +00:00
|
|
|
if( parentA->Type() == PCB_ZONE_T )
|
2018-05-21 00:06:01 +00:00
|
|
|
{
|
2020-09-23 19:02:21 +00:00
|
|
|
checkZoneItemConnection( static_cast<CN_ZONE_LAYER*>( aCandidate ), m_item );
|
2018-05-21 00:06:01 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-11-11 23:05:59 +00:00
|
|
|
if( parentB->Type() == PCB_ZONE_T )
|
2018-05-21 00:06:01 +00:00
|
|
|
{
|
2020-09-23 19:02:21 +00:00
|
|
|
checkZoneItemConnection( static_cast<CN_ZONE_LAYER*>( m_item ), aCandidate );
|
2018-05-21 00:06:01 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-02-14 13:34:45 +00:00
|
|
|
LSET commonLayers = parentA->GetLayerSet() & parentB->GetLayerSet();
|
|
|
|
|
2024-06-12 10:05:56 +00:00
|
|
|
for( size_t ii = 0; ii < commonLayers.size(); ++ii )
|
2019-09-19 19:43:24 +00:00
|
|
|
{
|
2024-06-12 10:05:56 +00:00
|
|
|
if( commonLayers.test( ii ) )
|
2022-03-16 23:48:24 +00:00
|
|
|
{
|
2024-06-12 10:05:56 +00:00
|
|
|
PCB_LAYER_ID layer = PCB_LAYER_ID( ii );
|
|
|
|
FLASHING flashingA = FLASHING::NEVER_FLASHED;
|
|
|
|
FLASHING flashingB = FLASHING::NEVER_FLASHED;
|
2022-03-16 23:48:24 +00:00
|
|
|
|
2024-06-12 10:05:56 +00:00
|
|
|
if( parentA->Type() == PCB_PAD_T )
|
|
|
|
{
|
|
|
|
if( !static_cast<const PAD*>( parentA )->ConditionallyFlashed( layer ) )
|
|
|
|
flashingA = FLASHING::ALWAYS_FLASHED;
|
|
|
|
}
|
|
|
|
else if( parentA->Type() == PCB_VIA_T )
|
|
|
|
{
|
|
|
|
if( !static_cast<const PCB_VIA*>( parentA )->ConditionallyFlashed( layer ) )
|
|
|
|
flashingA = FLASHING::ALWAYS_FLASHED;
|
|
|
|
}
|
2022-03-16 23:48:24 +00:00
|
|
|
|
2024-06-12 10:05:56 +00:00
|
|
|
if( parentB->Type() == PCB_PAD_T )
|
|
|
|
{
|
|
|
|
if( !static_cast<const PAD*>( parentB )->ConditionallyFlashed( layer ) )
|
|
|
|
flashingB = FLASHING::ALWAYS_FLASHED;
|
|
|
|
}
|
|
|
|
else if( parentB->Type() == PCB_VIA_T )
|
|
|
|
{
|
|
|
|
if( !static_cast<const PCB_VIA*>( parentB )->ConditionallyFlashed( layer ) )
|
|
|
|
flashingB = FLASHING::ALWAYS_FLASHED;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( parentA->GetEffectiveShape( layer, flashingA )->Collide(
|
|
|
|
parentB->GetEffectiveShape( layer, flashingB ).get() ) )
|
|
|
|
{
|
|
|
|
m_item->Connect( aCandidate );
|
|
|
|
aCandidate->Connect( m_item );
|
|
|
|
return true;
|
|
|
|
}
|
2019-09-19 19:43:24 +00:00
|
|
|
}
|
2018-05-21 00:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2017-03-22 13:43:10 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::Clear()
|
|
|
|
{
|
|
|
|
m_ratsnestClusters.clear();
|
|
|
|
m_connClusters.clear();
|
|
|
|
m_itemMap.clear();
|
2018-05-21 00:06:01 +00:00
|
|
|
m_itemList.Clear();
|
2017-03-22 13:43:10 +00:00
|
|
|
|
|
|
|
}
|
2017-03-28 16:30:49 +00:00
|
|
|
|
2017-11-23 16:20:27 +00:00
|
|
|
void CN_CONNECTIVITY_ALGO::SetProgressReporter( PROGRESS_REPORTER* aReporter )
|
|
|
|
{
|
|
|
|
m_progressReporter = aReporter;
|
|
|
|
}
|