2013-09-18 17:55:16 +00:00
|
|
|
/*
|
|
|
|
* KiRouter - a push-and-(sometimes-)shove PCB router
|
|
|
|
*
|
2014-05-14 13:53:54 +00:00
|
|
|
* Copyright (C) 2013-2014 CERN
|
2021-03-02 13:10:37 +00:00
|
|
|
* Copyright (C) 2016-2021 KiCad Developers, see AUTHORS.txt for contributors.
|
2013-09-18 17:55:16 +00:00
|
|
|
* Author: Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
|
2013-09-26 21:53:54 +00:00
|
|
|
*
|
2013-09-18 17:55:16 +00:00
|
|
|
* 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 3 of the License, or (at your
|
|
|
|
* option) any later version.
|
2013-09-26 21:53:54 +00:00
|
|
|
*
|
2013-09-18 17:55:16 +00:00
|
|
|
* 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.
|
2013-09-26 21:53:54 +00:00
|
|
|
*
|
2013-09-18 17:55:16 +00:00
|
|
|
* You should have received a copy of the GNU General Public License along
|
2014-05-14 13:53:54 +00:00
|
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
2013-09-18 17:55:16 +00:00
|
|
|
*/
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2013-09-18 17:55:16 +00:00
|
|
|
#include <cstdio>
|
2019-12-05 13:43:55 +00:00
|
|
|
#include <memory>
|
2013-09-18 17:55:16 +00:00
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include <view/view.h>
|
|
|
|
#include <view/view_group.h>
|
|
|
|
#include <gal/graphics_abstraction_layer.h>
|
|
|
|
|
2020-01-13 01:44:19 +00:00
|
|
|
#include <settings/settings_manager.h>
|
|
|
|
|
2013-09-18 17:55:16 +00:00
|
|
|
#include <pcb_painter.h>
|
2020-01-13 01:44:19 +00:00
|
|
|
#include <pcbnew_settings.h>
|
2021-01-05 18:45:32 +00:00
|
|
|
#include <pad.h>
|
|
|
|
#include <zone.h>
|
2013-09-18 17:55:16 +00:00
|
|
|
|
|
|
|
#include <geometry/shape.h>
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2013-09-18 17:55:16 +00:00
|
|
|
#include "pns_node.h"
|
|
|
|
#include "pns_line_placer.h"
|
|
|
|
#include "pns_line.h"
|
|
|
|
#include "pns_solid.h"
|
|
|
|
#include "pns_utils.h"
|
|
|
|
#include "pns_router.h"
|
2014-05-14 13:53:54 +00:00
|
|
|
#include "pns_shove.h"
|
|
|
|
#include "pns_dragger.h"
|
2020-02-28 22:13:25 +00:00
|
|
|
#include "pns_component_dragger.h"
|
2015-02-26 15:34:10 +00:00
|
|
|
#include "pns_topology.h"
|
2015-02-18 00:29:54 +00:00
|
|
|
#include "pns_diff_pair_placer.h"
|
|
|
|
#include "pns_meander_placer.h"
|
|
|
|
#include "pns_meander_skew_placer.h"
|
|
|
|
#include "pns_dp_meander_placer.h"
|
|
|
|
|
2016-08-29 14:38:11 +00:00
|
|
|
namespace PNS {
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
// an ugly singleton for drawing debug items within the router context.
|
2013-09-26 21:53:54 +00:00
|
|
|
// To be fixed sometime in the future.
|
2016-08-29 17:31:13 +00:00
|
|
|
static ROUTER* theRouter;
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
ROUTER::ROUTER()
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2013-09-26 21:53:54 +00:00
|
|
|
theRouter = this;
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
m_state = IDLE;
|
2015-02-18 00:29:54 +00:00
|
|
|
m_mode = PNS_MODE_ROUTE_SINGLE;
|
2015-04-20 14:59:25 +00:00
|
|
|
|
2020-04-16 22:29:28 +00:00
|
|
|
m_logger = new LOGGER;
|
|
|
|
|
2015-04-20 14:59:25 +00:00
|
|
|
// Initialize all other variables:
|
2016-08-29 17:48:16 +00:00
|
|
|
m_lastNode = nullptr;
|
2015-04-20 14:59:25 +00:00
|
|
|
m_iterLimit = 0;
|
2020-01-13 01:44:19 +00:00
|
|
|
m_settings = nullptr;
|
2016-12-30 11:39:41 +00:00
|
|
|
m_iface = nullptr;
|
2021-02-17 21:01:09 +00:00
|
|
|
m_visibleViewArea.SetMaximum();
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
ROUTER* ROUTER::GetInstance()
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2013-09-26 21:53:54 +00:00
|
|
|
return theRouter;
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
ROUTER::~ROUTER()
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2013-09-26 21:53:54 +00:00
|
|
|
ClearWorld();
|
2016-08-29 17:48:16 +00:00
|
|
|
theRouter = nullptr;
|
2020-04-16 22:29:28 +00:00
|
|
|
delete m_logger;
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2017-01-24 15:14:38 +00:00
|
|
|
|
|
|
|
void ROUTER::SyncWorld()
|
2016-08-15 15:16:47 +00:00
|
|
|
{
|
|
|
|
ClearWorld();
|
|
|
|
|
2019-12-05 13:43:55 +00:00
|
|
|
m_world = std::make_unique<NODE>( );
|
2016-08-29 17:48:16 +00:00
|
|
|
m_iface->SyncWorld( m_world.get() );
|
2021-06-03 20:36:06 +00:00
|
|
|
m_world->FixupVirtualVias();
|
2016-08-15 15:16:47 +00:00
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2021-06-03 20:36:06 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::ClearWorld()
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2013-09-26 21:53:54 +00:00
|
|
|
if( m_world )
|
2014-08-13 15:25:54 +00:00
|
|
|
{
|
|
|
|
m_world->KillChildren();
|
2016-08-29 17:48:16 +00:00
|
|
|
m_world.reset();
|
2014-08-13 15:25:54 +00:00
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:48:16 +00:00
|
|
|
m_placer.reset();
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool ROUTER::RoutingInProgress() const
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2013-09-26 21:53:54 +00:00
|
|
|
return m_state != IDLE;
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-06-06 18:16:31 +00:00
|
|
|
const ITEM_SET ROUTER::QueryHoverItems( const VECTOR2I& aP, bool aUseClearance )
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2018-01-01 23:47:46 +00:00
|
|
|
if( m_state == IDLE || m_placer == nullptr )
|
2021-06-06 18:16:31 +00:00
|
|
|
{
|
|
|
|
if( aUseClearance )
|
|
|
|
{
|
|
|
|
SEGMENT test( SEG( aP, aP ), -1 );
|
|
|
|
test.SetWidth( 1 );
|
|
|
|
test.SetLayers( LAYER_RANGE::All() );
|
|
|
|
NODE::OBSTACLES obs;
|
|
|
|
m_world->QueryColliding( &test, obs, ITEM::ANY_T, -1, false );
|
|
|
|
|
|
|
|
PNS::ITEM_SET ret;
|
|
|
|
|
|
|
|
for( OBSTACLE& obstacle : obs )
|
|
|
|
ret.Add( obstacle.m_item, false );
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return m_world->HitTest( aP );
|
|
|
|
}
|
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
else
|
2014-05-14 13:53:54 +00:00
|
|
|
return m_placer->CurrentNode()->HitTest( aP );
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2021-03-02 13:10:37 +00:00
|
|
|
|
2020-02-28 22:13:25 +00:00
|
|
|
bool ROUTER::StartDragging( const VECTOR2I& aP, ITEM* aItem, int aDragMode )
|
|
|
|
{
|
|
|
|
return StartDragging( aP, ITEM_SET( aItem ), aDragMode );
|
|
|
|
}
|
|
|
|
|
2017-01-24 15:14:38 +00:00
|
|
|
|
2020-02-28 22:13:25 +00:00
|
|
|
bool ROUTER::StartDragging( const VECTOR2I& aP, ITEM_SET aStartItems, int aDragMode )
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2020-02-28 22:13:25 +00:00
|
|
|
if( aStartItems.Empty() )
|
|
|
|
return false;
|
2017-08-03 15:53:07 +00:00
|
|
|
|
2022-03-03 23:58:14 +00:00
|
|
|
if( Settings().Mode() == RM_MarkObstacles )
|
|
|
|
{
|
|
|
|
m_world->SetCollisionQueryScope( NODE::CQS_ALL_RULES );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_world->SetCollisionQueryScope( NODE::CQS_IGNORE_HOLE_CLEARANCE );
|
|
|
|
}
|
|
|
|
|
2020-02-28 22:13:25 +00:00
|
|
|
if( aStartItems.Count( ITEM::SOLID_T ) == aStartItems.Size() )
|
|
|
|
{
|
|
|
|
m_dragger = std::make_unique<COMPONENT_DRAGGER>( this );
|
2017-08-03 15:53:07 +00:00
|
|
|
m_forceMarkObstaclesMode = true;
|
2021-12-15 00:46:03 +00:00
|
|
|
m_state = DRAG_COMPONENT;
|
2020-02-28 22:13:25 +00:00
|
|
|
}
|
2017-08-03 15:53:07 +00:00
|
|
|
else
|
2020-02-28 22:13:25 +00:00
|
|
|
{
|
|
|
|
if( aDragMode & DM_FREE_ANGLE )
|
|
|
|
m_forceMarkObstaclesMode = true;
|
|
|
|
else
|
|
|
|
m_forceMarkObstaclesMode = false;
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2020-02-28 22:13:25 +00:00
|
|
|
m_dragger = std::make_unique<DRAGGER>( this );
|
2021-12-15 00:46:03 +00:00
|
|
|
m_state = DRAG_SEGMENT;
|
2020-02-28 22:13:25 +00:00
|
|
|
}
|
2018-09-16 03:18:59 +00:00
|
|
|
|
2017-08-03 15:53:07 +00:00
|
|
|
m_dragger->SetMode( aDragMode );
|
2016-08-29 17:48:16 +00:00
|
|
|
m_dragger->SetWorld( m_world.get() );
|
2020-04-16 22:29:28 +00:00
|
|
|
m_dragger->SetLogger( m_logger );
|
2021-02-25 16:18:13 +00:00
|
|
|
m_dragger->SetDebugDecorator( m_iface->GetDebugDecorator() );
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2021-03-02 13:10:37 +00:00
|
|
|
if( m_logger )
|
|
|
|
m_logger->Clear();
|
2020-10-18 21:00:33 +00:00
|
|
|
|
|
|
|
if( m_logger && aStartItems.Size() )
|
|
|
|
{
|
|
|
|
m_logger->Log( LOGGER::EVT_START_DRAG, aP, aStartItems[0] );
|
|
|
|
}
|
|
|
|
|
2021-02-25 16:18:13 +00:00
|
|
|
if( m_dragger->Start( aP, aStartItems ) )
|
2020-11-01 20:24:58 +00:00
|
|
|
{
|
2021-07-09 09:25:19 +00:00
|
|
|
return true;
|
2020-11-01 20:24:58 +00:00
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
else
|
2014-05-16 11:37:31 +00:00
|
|
|
{
|
2016-08-29 17:48:16 +00:00
|
|
|
m_dragger.reset();
|
2014-05-14 13:53:54 +00:00
|
|
|
m_state = IDLE;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2021-01-05 18:45:32 +00:00
|
|
|
|
2020-11-01 23:46:09 +00:00
|
|
|
bool ROUTER::isStartingPointRoutable( const VECTOR2I& aWhere, ITEM* aStartItem, int aLayer )
|
2018-02-03 09:39:46 +00:00
|
|
|
{
|
2021-04-10 09:31:42 +00:00
|
|
|
if( Settings().AllowDRCViolations() )
|
2019-02-23 16:07:04 +00:00
|
|
|
return true;
|
|
|
|
|
2021-03-30 18:48:36 +00:00
|
|
|
if( m_mode == PNS_MODE_ROUTE_DIFF_PAIR )
|
|
|
|
{
|
|
|
|
if( m_sizes.DiffPairGap() < m_sizes.MinClearance() )
|
|
|
|
{
|
|
|
|
SetFailureReason( _( "Diff pair gap is less than board minimum clearance." ) );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-01 23:46:09 +00:00
|
|
|
ITEM_SET candidates = QueryHoverItems( aWhere );
|
2018-02-03 09:39:46 +00:00
|
|
|
|
|
|
|
for( ITEM* item : candidates.Items() )
|
|
|
|
{
|
2022-06-29 19:43:07 +00:00
|
|
|
if( item->Parent() && item->Parent()->GetLayer() == Edge_Cuts )
|
|
|
|
{
|
|
|
|
// Edge cuts are put on all layers, but they're not *really* on all layers
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-11-01 20:24:58 +00:00
|
|
|
if( !item->IsRoutable() && item->Layers().Overlaps( aLayer ) )
|
2021-01-05 18:45:32 +00:00
|
|
|
{
|
|
|
|
BOARD_ITEM* parent = item->Parent();
|
|
|
|
|
|
|
|
switch( parent->Type() )
|
|
|
|
{
|
|
|
|
case PCB_PAD_T:
|
|
|
|
{
|
|
|
|
PAD* pad = static_cast<PAD*>( parent );
|
|
|
|
|
2021-05-01 14:46:50 +00:00
|
|
|
if( pad->GetAttribute() == PAD_ATTRIB::NPTH )
|
2021-01-05 18:45:32 +00:00
|
|
|
SetFailureReason( _( "Cannot start routing from a non-plated hole." ) );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PCB_ZONE_T:
|
|
|
|
case PCB_FP_ZONE_T:
|
|
|
|
{
|
|
|
|
ZONE* zone = static_cast<ZONE*>( parent );
|
|
|
|
|
|
|
|
if( !zone->GetZoneName().IsEmpty() )
|
|
|
|
{
|
|
|
|
SetFailureReason( wxString::Format( _( "Rule area '%s' disallows tracks." ),
|
|
|
|
zone->GetZoneName() ) );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SetFailureReason( _( "Rule area disallows tracks." ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PCB_TEXT_T:
|
|
|
|
case PCB_FP_TEXT_T:
|
2022-01-30 10:52:52 +00:00
|
|
|
case PCB_TEXTBOX_T:
|
|
|
|
case PCB_FP_TEXTBOX_T:
|
2021-01-05 18:45:32 +00:00
|
|
|
SetFailureReason( _( "Cannot start routing from a text item." ) );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PCB_SHAPE_T:
|
|
|
|
case PCB_FP_SHAPE_T:
|
|
|
|
SetFailureReason( _( "Cannot start routing from a graphic." ) );
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-02-03 09:39:46 +00:00
|
|
|
return false;
|
2021-01-05 18:45:32 +00:00
|
|
|
}
|
2018-02-03 09:39:46 +00:00
|
|
|
}
|
|
|
|
|
2022-07-21 14:30:28 +00:00
|
|
|
VECTOR2I startPoint = aWhere;
|
2021-01-05 18:45:32 +00:00
|
|
|
|
|
|
|
if( m_mode == PNS_MODE_ROUTE_SINGLE )
|
2020-11-01 23:46:09 +00:00
|
|
|
{
|
2021-01-04 17:51:50 +00:00
|
|
|
SHAPE_LINE_CHAIN dummyStartSeg;
|
|
|
|
LINE dummyStartLine;
|
2020-11-01 23:46:09 +00:00
|
|
|
|
2021-01-04 17:51:50 +00:00
|
|
|
dummyStartSeg.Append( startPoint );
|
|
|
|
dummyStartSeg.Append( startPoint, true );
|
|
|
|
|
|
|
|
dummyStartLine.SetShape( dummyStartSeg );
|
|
|
|
dummyStartLine.SetLayer( aLayer );
|
2021-01-05 18:45:32 +00:00
|
|
|
dummyStartLine.SetNet( aStartItem ? aStartItem->Net() : 0 );
|
2021-01-04 17:51:50 +00:00
|
|
|
dummyStartLine.SetWidth( m_sizes.TrackWidth() );
|
|
|
|
|
|
|
|
if( m_world->CheckColliding( &dummyStartLine, ITEM::ANY_T ) )
|
|
|
|
{
|
|
|
|
ITEM_SET dummyStartSet( &dummyStartLine );
|
|
|
|
NODE::ITEM_VECTOR highlightedItems;
|
|
|
|
|
|
|
|
markViolations( m_world.get(), dummyStartSet, highlightedItems );
|
|
|
|
|
|
|
|
for( ITEM* item : highlightedItems )
|
|
|
|
m_iface->HideItem( item );
|
2020-11-01 23:46:09 +00:00
|
|
|
|
2021-01-05 18:45:32 +00:00
|
|
|
SetFailureReason( _( "The routing start point violates DRC." ) );
|
2020-11-01 23:46:09 +00:00
|
|
|
return false;
|
2021-01-04 17:51:50 +00:00
|
|
|
}
|
2020-11-01 23:46:09 +00:00
|
|
|
}
|
2021-01-05 18:45:32 +00:00
|
|
|
else if( m_mode == PNS_MODE_ROUTE_DIFF_PAIR )
|
2020-11-01 23:46:09 +00:00
|
|
|
{
|
2021-01-05 18:45:32 +00:00
|
|
|
if( !aStartItem )
|
|
|
|
{
|
|
|
|
SetFailureReason( _( "Cannot start a differential pair in the middle of nowhere." ) );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
DP_PRIMITIVE_PAIR dpPair;
|
|
|
|
wxString errorMsg;
|
|
|
|
|
|
|
|
if( !DIFF_PAIR_PLACER::FindDpPrimitivePair( m_world.get(), startPoint, aStartItem, dpPair,
|
|
|
|
&errorMsg ) )
|
|
|
|
{
|
|
|
|
SetFailureReason( errorMsg );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
SHAPE_LINE_CHAIN dummyStartSegA;
|
|
|
|
SHAPE_LINE_CHAIN dummyStartSegB;
|
|
|
|
LINE dummyStartLineA;
|
|
|
|
LINE dummyStartLineB;
|
|
|
|
|
|
|
|
dummyStartSegA.Append( dpPair.AnchorN() );
|
|
|
|
dummyStartSegA.Append( dpPair.AnchorN(), true );
|
|
|
|
|
|
|
|
dummyStartSegB.Append( dpPair.AnchorP() );
|
|
|
|
dummyStartSegB.Append( dpPair.AnchorP(), true );
|
|
|
|
|
|
|
|
dummyStartLineA.SetShape( dummyStartSegA );
|
|
|
|
dummyStartLineA.SetLayer( aLayer );
|
|
|
|
dummyStartLineA.SetNet( dpPair.PrimN()->Net() );
|
|
|
|
dummyStartLineA.SetWidth( m_sizes.DiffPairWidth() );
|
|
|
|
|
|
|
|
dummyStartLineB.SetShape( dummyStartSegB );
|
|
|
|
dummyStartLineB.SetLayer( aLayer );
|
|
|
|
dummyStartLineB.SetNet( dpPair.PrimP()->Net() );
|
|
|
|
dummyStartLineB.SetWidth( m_sizes.DiffPairWidth() );
|
|
|
|
|
|
|
|
if( m_world->CheckColliding( &dummyStartLineA, ITEM::ANY_T )
|
|
|
|
|| m_world->CheckColliding( &dummyStartLineB, ITEM::ANY_T ) )
|
|
|
|
{
|
|
|
|
ITEM_SET dummyStartSet;
|
|
|
|
NODE::ITEM_VECTOR highlightedItems;
|
|
|
|
|
|
|
|
dummyStartSet.Add( dummyStartLineA );
|
|
|
|
dummyStartSet.Add( dummyStartLineB );
|
|
|
|
markViolations( m_world.get(), dummyStartSet, highlightedItems );
|
|
|
|
|
|
|
|
for( ITEM* item : highlightedItems )
|
|
|
|
m_iface->HideItem( item );
|
|
|
|
|
|
|
|
SetFailureReason( _( "The routing start point violates DRC." ) );
|
|
|
|
return false;
|
|
|
|
}
|
2020-11-01 23:46:09 +00:00
|
|
|
}
|
|
|
|
|
2018-02-03 09:39:46 +00:00
|
|
|
return true;
|
|
|
|
}
|
2017-01-24 15:14:38 +00:00
|
|
|
|
2021-03-02 13:10:37 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool ROUTER::StartRouting( const VECTOR2I& aP, ITEM* aStartItem, int aLayer )
|
2021-02-08 01:06:56 +00:00
|
|
|
{
|
2022-03-03 23:58:14 +00:00
|
|
|
if( Settings().Mode() == RM_MarkObstacles )
|
|
|
|
{
|
|
|
|
m_world->SetCollisionQueryScope( NODE::CQS_ALL_RULES );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_world->SetCollisionQueryScope( NODE::CQS_IGNORE_HOLE_CLEARANCE );
|
|
|
|
}
|
|
|
|
|
2021-01-04 17:51:50 +00:00
|
|
|
if( !isStartingPointRoutable( aP, aStartItem, aLayer ) )
|
2018-02-03 09:39:46 +00:00
|
|
|
return false;
|
|
|
|
|
2017-08-03 15:53:07 +00:00
|
|
|
m_forceMarkObstaclesMode = false;
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
switch( m_mode )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2021-03-02 13:10:37 +00:00
|
|
|
case PNS_MODE_ROUTE_SINGLE:
|
|
|
|
m_placer = std::make_unique<LINE_PLACER>( this );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PNS_MODE_ROUTE_DIFF_PAIR:
|
|
|
|
m_placer = std::make_unique<DIFF_PAIR_PLACER>( this );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PNS_MODE_TUNE_SINGLE:
|
|
|
|
m_placer = std::make_unique<MEANDER_PLACER>( this );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PNS_MODE_TUNE_DIFF_PAIR:
|
|
|
|
m_placer = std::make_unique<DP_MEANDER_PLACER>( this );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PNS_MODE_TUNE_DIFF_PAIR_SKEW:
|
|
|
|
m_placer = std::make_unique<MEANDER_SKEW_PLACER>( this );
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return false;
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
2014-11-14 19:19:00 +00:00
|
|
|
|
2020-11-01 20:24:58 +00:00
|
|
|
m_placer->UpdateSizes( m_sizes );
|
2014-11-14 18:15:58 +00:00
|
|
|
m_placer->SetLayer( aLayer );
|
2021-02-25 16:18:13 +00:00
|
|
|
m_placer->SetDebugDecorator( m_iface->GetDebugDecorator() );
|
2020-04-16 22:29:28 +00:00
|
|
|
m_placer->SetLogger( m_logger );
|
|
|
|
|
|
|
|
if( m_logger )
|
2021-03-02 13:10:37 +00:00
|
|
|
{
|
|
|
|
m_logger->Clear();
|
2020-04-16 22:29:28 +00:00
|
|
|
m_logger->Log( LOGGER::EVT_START_ROUTE, aP, aStartItem );
|
2021-03-02 13:10:37 +00:00
|
|
|
}
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2021-07-09 09:25:19 +00:00
|
|
|
if( m_placer->Start( aP, aStartItem ) )
|
|
|
|
{
|
|
|
|
m_state = ROUTE_TRACK;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_state = IDLE;
|
2015-02-18 00:29:54 +00:00
|
|
|
return false;
|
2021-07-09 09:25:19 +00:00
|
|
|
}
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2022-06-03 21:02:32 +00:00
|
|
|
bool ROUTER::Move( const VECTOR2I& aP, ITEM* endItem )
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2020-04-16 22:29:28 +00:00
|
|
|
if( m_logger )
|
|
|
|
m_logger->Log( LOGGER::EVT_MOVE, aP, endItem );
|
|
|
|
|
2014-05-14 13:53:54 +00:00
|
|
|
switch( m_state )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2015-10-05 16:28:41 +00:00
|
|
|
case ROUTE_TRACK:
|
2022-06-03 21:02:32 +00:00
|
|
|
return movePlacing( aP, endItem );
|
2014-05-14 13:53:54 +00:00
|
|
|
|
2015-10-05 16:28:41 +00:00
|
|
|
case DRAG_SEGMENT:
|
2021-12-15 22:18:53 +00:00
|
|
|
case DRAG_COMPONENT:
|
2022-06-03 21:02:32 +00:00
|
|
|
return moveDragging( aP, endItem );
|
2014-05-16 11:37:31 +00:00
|
|
|
|
2015-10-05 16:28:41 +00:00
|
|
|
default:
|
|
|
|
break;
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
2022-06-05 09:44:49 +00:00
|
|
|
|
|
|
|
return false;
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
|
|
|
|
2022-06-03 21:02:32 +00:00
|
|
|
bool ROUTER::moveDragging( const VECTOR2I& aP, ITEM* aEndItem )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2016-08-15 15:16:47 +00:00
|
|
|
m_iface->EraseView();
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2022-06-03 21:02:32 +00:00
|
|
|
bool ret = m_dragger->Drag( aP );
|
2016-08-29 17:31:13 +00:00
|
|
|
ITEM_SET dragged = m_dragger->Traces();
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2019-04-08 04:24:30 +00:00
|
|
|
updateView( m_dragger->CurrentNode(), dragged, true );
|
2022-06-03 21:02:32 +00:00
|
|
|
return ret;
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2014-05-16 11:37:31 +00:00
|
|
|
|
2017-01-24 15:14:38 +00:00
|
|
|
void ROUTER::markViolations( NODE* aNode, ITEM_SET& aCurrent, NODE::ITEM_VECTOR& aRemoved )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2021-01-01 17:17:55 +00:00
|
|
|
auto updateItem =
|
|
|
|
[&]( ITEM* currentItem, ITEM* itemToMark )
|
|
|
|
{
|
|
|
|
std::unique_ptr<ITEM> tmp( itemToMark->Clone() );
|
|
|
|
|
2021-08-08 19:41:39 +00:00
|
|
|
int clearance;
|
|
|
|
bool removeOriginal = true;
|
|
|
|
bool holeOnly = ( ( itemToMark->Marker() & MK_HOLE )
|
|
|
|
&& !( itemToMark->Marker() & MK_VIOLATION ) );
|
|
|
|
|
|
|
|
if( holeOnly )
|
2021-01-01 17:17:55 +00:00
|
|
|
clearance = aNode->GetHoleClearance( currentItem, itemToMark );
|
|
|
|
else
|
|
|
|
clearance = aNode->GetClearance( currentItem, itemToMark );
|
|
|
|
|
2021-01-03 21:14:44 +00:00
|
|
|
if( itemToMark->Layers().IsMultilayer() && !currentItem->Layers().IsMultilayer() )
|
2021-02-25 23:38:54 +00:00
|
|
|
tmp->SetLayer( currentItem->Layer() );
|
2021-01-01 17:17:55 +00:00
|
|
|
|
2021-01-03 21:14:44 +00:00
|
|
|
if( itemToMark->Kind() == ITEM::SOLID_T )
|
|
|
|
{
|
2021-10-18 20:37:40 +00:00
|
|
|
if( holeOnly || !m_iface->IsFlashedOnLayer( itemToMark, currentItem->Layer() ) )
|
2021-01-03 21:14:44 +00:00
|
|
|
{
|
|
|
|
SOLID* solid = static_cast<SOLID*>( tmp.get() );
|
|
|
|
|
2021-10-19 18:24:23 +00:00
|
|
|
if( solid->Hole() )
|
|
|
|
{
|
|
|
|
solid->SetShape( solid->Hole()->Clone() );
|
|
|
|
|
|
|
|
// Leave the pad flashing around the highlighted hole
|
|
|
|
removeOriginal = false;
|
|
|
|
}
|
2021-01-03 21:14:44 +00:00
|
|
|
}
|
2021-11-25 23:41:47 +00:00
|
|
|
|
|
|
|
if( itemToMark->IsCompoundShapePrimitive() )
|
|
|
|
{
|
|
|
|
// We're only highlighting one (or more) of several primitives so we
|
|
|
|
// don't want all the other parts of the object to disappear
|
|
|
|
removeOriginal = false;
|
|
|
|
}
|
2021-01-03 21:14:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
m_iface->DisplayItem( tmp.get(), clearance );
|
|
|
|
|
|
|
|
if( removeOriginal )
|
2021-01-01 17:17:55 +00:00
|
|
|
aRemoved.push_back( itemToMark );
|
|
|
|
};
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( ITEM* item : aCurrent.Items() )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
NODE::OBSTACLES obstacles;
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
aNode->QueryColliding( item, obstacles, ITEM::ANY_T );
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
if( item->OfKind( ITEM::LINE_T ) )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
LINE* l = static_cast<LINE*>( item );
|
2014-05-16 11:37:31 +00:00
|
|
|
|
|
|
|
if( l->EndsWithVia() )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
VIA v( l->Via() );
|
|
|
|
aNode->QueryColliding( &v, obstacles, ITEM::ANY_T );
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( OBSTACLE& obs : obstacles )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2021-01-01 17:17:55 +00:00
|
|
|
obs.m_item->Mark( obs.m_item->Marker() | MK_VIOLATION );
|
|
|
|
updateItem( item, obs.m_item );
|
|
|
|
}
|
2021-01-01 00:29:05 +00:00
|
|
|
|
2021-01-01 17:17:55 +00:00
|
|
|
if( item->Kind() == ITEM::LINE_T )
|
|
|
|
{
|
|
|
|
LINE* line = static_cast<LINE*>( item );
|
2021-01-01 00:29:05 +00:00
|
|
|
|
2021-01-01 17:17:55 +00:00
|
|
|
// Show clearance on any blocking obstacles
|
|
|
|
if( line->GetBlockingObstacle() )
|
|
|
|
updateItem( item, line->GetBlockingObstacle() );
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
|
|
|
|
2019-04-08 04:24:30 +00:00
|
|
|
void ROUTER::updateView( NODE* aNode, ITEM_SET& aCurrent, bool aDragging )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
NODE::ITEM_VECTOR removed, added;
|
|
|
|
NODE::OBSTACLES obstacles;
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2014-05-16 11:37:31 +00:00
|
|
|
if( !aNode )
|
2014-05-14 13:53:54 +00:00
|
|
|
return;
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2017-08-03 15:53:07 +00:00
|
|
|
if( Settings().Mode() == RM_MarkObstacles || m_forceMarkObstaclesMode )
|
2014-11-14 19:19:00 +00:00
|
|
|
markViolations( aNode, aCurrent, removed );
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2014-05-14 13:53:54 +00:00
|
|
|
aNode->GetUpdatedItems( removed, added );
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2020-12-11 12:48:04 +00:00
|
|
|
for( ITEM* item : added )
|
2019-04-08 04:24:30 +00:00
|
|
|
{
|
2021-11-25 20:38:04 +00:00
|
|
|
GetRuleResolver()->ClearCacheForItem( item );
|
2020-10-30 21:08:38 +00:00
|
|
|
int clearance = GetRuleResolver()->Clearance( item, nullptr );
|
2021-01-03 21:14:44 +00:00
|
|
|
m_iface->DisplayItem( item, clearance, aDragging );
|
2019-04-08 04:24:30 +00:00
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2020-12-02 18:42:37 +00:00
|
|
|
for( ITEM* item : removed )
|
2016-06-21 15:06:28 +00:00
|
|
|
m_iface->HideItem( item );
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2017-01-24 15:14:38 +00:00
|
|
|
void ROUTER::UpdateSizes( const SIZES_SETTINGS& aSizes )
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2014-11-14 18:15:58 +00:00
|
|
|
m_sizes = aSizes;
|
|
|
|
|
2014-05-14 13:53:54 +00:00
|
|
|
// Change track/via size settings
|
2021-03-02 13:10:37 +00:00
|
|
|
if( m_state == ROUTE_TRACK )
|
2020-10-18 21:00:33 +00:00
|
|
|
{
|
2014-11-14 18:15:58 +00:00
|
|
|
m_placer->UpdateSizes( m_sizes );
|
2020-10-18 21:00:33 +00:00
|
|
|
}
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
|
|
|
|
2022-06-03 21:02:32 +00:00
|
|
|
bool ROUTER::movePlacing( const VECTOR2I& aP, ITEM* aEndItem )
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2016-08-15 15:16:47 +00:00
|
|
|
m_iface->EraseView();
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2022-06-03 21:02:32 +00:00
|
|
|
bool ret = m_placer->Move( aP, aEndItem );
|
2016-08-29 17:31:13 +00:00
|
|
|
ITEM_SET current = m_placer->Traces();
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( const ITEM* item : current.CItems() )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
if( !item->OfKind( ITEM::LINE_T ) )
|
2015-02-18 00:29:54 +00:00
|
|
|
continue;
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const LINE* l = static_cast<const LINE*>( item );
|
2020-10-30 21:08:38 +00:00
|
|
|
int clearance = GetRuleResolver()->Clearance( item, nullptr );
|
2017-01-25 09:33:49 +00:00
|
|
|
|
2021-01-03 21:14:44 +00:00
|
|
|
m_iface->DisplayItem( l, clearance );
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
if( l->EndsWithVia() )
|
2021-01-01 00:29:05 +00:00
|
|
|
{
|
|
|
|
const VIA& via = l->Via();
|
|
|
|
int viaClearance = GetRuleResolver()->Clearance( &via, nullptr );
|
|
|
|
int holeClearance = GetRuleResolver()->HoleClearance( &via, nullptr );
|
|
|
|
|
|
|
|
if( holeClearance + via.Drill() / 2 > viaClearance + via.Diameter() / 2 )
|
|
|
|
viaClearance = holeClearance + via.Drill() / 2 - via.Diameter() / 2;
|
|
|
|
|
2021-01-03 21:14:44 +00:00
|
|
|
m_iface->DisplayItem( &l->Via(), viaClearance );
|
2021-01-01 00:29:05 +00:00
|
|
|
}
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
//ITEM_SET tmp( ¤t );
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2015-02-18 00:29:54 +00:00
|
|
|
updateView( m_placer->CurrentNode( true ), current );
|
2022-06-03 21:02:32 +00:00
|
|
|
|
|
|
|
return ret;
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::CommitRouting( NODE* aNode )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2020-02-07 19:57:24 +00:00
|
|
|
if( m_state == ROUTE_TRACK && !m_placer->HasPlacedAnything() )
|
|
|
|
return;
|
|
|
|
|
2021-02-08 01:06:56 +00:00
|
|
|
NODE::ITEM_VECTOR removed;
|
|
|
|
NODE::ITEM_VECTOR added;
|
|
|
|
NODE::ITEM_VECTOR changed;
|
2013-09-26 21:53:54 +00:00
|
|
|
|
|
|
|
aNode->GetUpdatedItems( removed, added );
|
|
|
|
|
2020-12-02 18:42:37 +00:00
|
|
|
for( ITEM* item : removed )
|
2021-02-08 01:06:56 +00:00
|
|
|
{
|
|
|
|
bool is_changed = false;
|
|
|
|
|
|
|
|
// Items in remove/add that share the same parent are just updated versions
|
|
|
|
// We move them to the updated vector to preserve attributes such as UUID and pad data
|
|
|
|
if( item->Parent() )
|
|
|
|
{
|
|
|
|
for( NODE::ITEM_VECTOR::iterator added_it = added.begin();
|
|
|
|
added_it != added.end(); ++added_it )
|
|
|
|
{
|
|
|
|
if( ( *added_it )->Parent() && ( *added_it )->Parent() == item->Parent() )
|
|
|
|
{
|
|
|
|
changed.push_back( *added_it );
|
|
|
|
added.erase( added_it );
|
|
|
|
is_changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-03 20:36:06 +00:00
|
|
|
if( !is_changed && !item->IsVirtual() )
|
2021-02-08 01:06:56 +00:00
|
|
|
m_iface->RemoveItem( item );
|
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2020-12-02 18:42:37 +00:00
|
|
|
for( ITEM* item : added )
|
2021-06-03 20:36:06 +00:00
|
|
|
{
|
|
|
|
if( !item->IsVirtual() )
|
|
|
|
{
|
|
|
|
m_iface->AddItem( item );
|
|
|
|
}
|
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2021-02-08 01:06:56 +00:00
|
|
|
for( ITEM* item : changed )
|
2021-06-03 20:36:06 +00:00
|
|
|
{
|
|
|
|
if( !item->IsVirtual() )
|
|
|
|
{
|
|
|
|
m_iface->UpdateItem( item );
|
|
|
|
}
|
|
|
|
}
|
2021-02-08 01:06:56 +00:00
|
|
|
|
2016-08-15 15:16:47 +00:00
|
|
|
m_iface->Commit();
|
2013-09-26 21:53:54 +00:00
|
|
|
m_world->Commit( aNode );
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2018-06-19 17:29:36 +00:00
|
|
|
bool ROUTER::FixRoute( const VECTOR2I& aP, ITEM* aEndItem, bool aForceFinish )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2014-05-14 13:53:54 +00:00
|
|
|
bool rv = false;
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2020-04-16 22:29:28 +00:00
|
|
|
if( m_logger )
|
|
|
|
m_logger->Log( LOGGER::EVT_FIX, aP, aEndItem );
|
|
|
|
|
2014-05-16 11:37:31 +00:00
|
|
|
switch( m_state )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2015-10-05 16:28:41 +00:00
|
|
|
case ROUTE_TRACK:
|
2018-06-19 17:29:36 +00:00
|
|
|
rv = m_placer->FixRoute( aP, aEndItem, aForceFinish );
|
2015-10-05 16:28:41 +00:00
|
|
|
break;
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2015-10-05 16:28:41 +00:00
|
|
|
case DRAG_SEGMENT:
|
2021-12-15 22:18:53 +00:00
|
|
|
case DRAG_COMPONENT:
|
2015-10-05 16:28:41 +00:00
|
|
|
rv = m_dragger->FixRoute();
|
|
|
|
break;
|
2014-05-29 11:48:14 +00:00
|
|
|
|
2015-10-05 16:28:41 +00:00
|
|
|
default:
|
|
|
|
break;
|
2014-05-29 11:48:14 +00:00
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2014-05-14 13:53:54 +00:00
|
|
|
return rv;
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2020-02-07 19:57:24 +00:00
|
|
|
void ROUTER::UndoLastSegment()
|
|
|
|
{
|
|
|
|
if( !RoutingInProgress() )
|
|
|
|
return;
|
|
|
|
|
|
|
|
m_placer->UnfixRoute();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ROUTER::CommitRouting()
|
|
|
|
{
|
2020-02-28 22:13:25 +00:00
|
|
|
if( m_state == ROUTE_TRACK )
|
|
|
|
m_placer->CommitPlacement();
|
|
|
|
|
2020-02-07 19:57:24 +00:00
|
|
|
StopRouting();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::StopRouting()
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2014-01-07 13:22:37 +00:00
|
|
|
// Update the ratsnest with new changes
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2014-11-14 19:19:00 +00:00
|
|
|
if( m_placer )
|
2014-11-14 18:15:58 +00:00
|
|
|
{
|
2015-02-18 00:29:54 +00:00
|
|
|
std::vector<int> nets;
|
|
|
|
m_placer->GetModifiedNets( nets );
|
2014-11-14 18:15:58 +00:00
|
|
|
|
2016-08-15 15:16:47 +00:00
|
|
|
// Update the ratsnest with new changes
|
2020-12-11 12:48:04 +00:00
|
|
|
for( int n : nets )
|
2016-08-15 15:16:47 +00:00
|
|
|
m_iface->UpdateNet( n );
|
2014-11-14 18:15:58 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
if( !RoutingInProgress() )
|
|
|
|
return;
|
|
|
|
|
2016-08-29 17:48:16 +00:00
|
|
|
m_placer.reset();
|
|
|
|
m_dragger.reset();
|
2014-05-14 13:53:54 +00:00
|
|
|
|
2016-08-15 15:16:47 +00:00
|
|
|
m_iface->EraseView();
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
m_state = IDLE;
|
|
|
|
m_world->KillChildren();
|
2014-05-14 13:53:54 +00:00
|
|
|
m_world->ClearRanks();
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2021-01-04 17:51:50 +00:00
|
|
|
void ROUTER::ClearViewDecorations()
|
|
|
|
{
|
|
|
|
m_iface->EraseView();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::FlipPosture()
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2014-05-16 11:37:31 +00:00
|
|
|
if( m_state == ROUTE_TRACK )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
|
|
|
m_placer->FlipPosture();
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2020-12-02 21:16:48 +00:00
|
|
|
bool ROUTER::SwitchLayer( int aLayer )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2020-12-02 21:16:48 +00:00
|
|
|
if( m_state == ROUTE_TRACK )
|
|
|
|
return m_placer->SetLayer( aLayer );
|
|
|
|
|
|
|
|
return false;
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::ToggleViaPlacement()
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2015-02-18 16:53:46 +00:00
|
|
|
if( m_state == ROUTE_TRACK )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2015-02-18 16:53:46 +00:00
|
|
|
bool toggle = !m_placer->IsPlacingVia();
|
2014-11-14 18:15:58 +00:00
|
|
|
m_placer->ToggleVia( toggle );
|
2022-03-07 23:45:20 +00:00
|
|
|
|
|
|
|
if( m_logger )
|
|
|
|
{
|
|
|
|
m_logger->Log( LOGGER::EVT_TOGGLE_VIA );
|
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
}
|
2014-05-14 13:53:54 +00:00
|
|
|
|
2014-05-16 11:37:31 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const std::vector<int> ROUTER::GetCurrentNets() const
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2014-11-14 19:19:00 +00:00
|
|
|
if( m_placer )
|
2015-08-21 14:35:34 +00:00
|
|
|
return m_placer->CurrentNets();
|
2020-11-01 19:56:54 +00:00
|
|
|
else if( m_dragger )
|
|
|
|
return m_dragger->CurrentNets();
|
2015-08-21 14:35:34 +00:00
|
|
|
|
|
|
|
return std::vector<int>();
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
|
|
|
|
2014-05-16 11:37:31 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
int ROUTER::GetCurrentLayer() const
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2014-11-14 18:15:58 +00:00
|
|
|
if( m_placer )
|
|
|
|
return m_placer->CurrentLayer();
|
2020-11-08 17:16:00 +00:00
|
|
|
else if( m_dragger )
|
|
|
|
return m_dragger->CurrentLayer();
|
|
|
|
|
2014-11-14 18:15:58 +00:00
|
|
|
return -1;
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
2014-05-16 11:37:31 +00:00
|
|
|
|
|
|
|
|
2020-04-16 22:29:28 +00:00
|
|
|
LOGGER* ROUTER::Logger()
|
2014-05-14 13:53:54 +00:00
|
|
|
{
|
2020-04-16 22:29:28 +00:00
|
|
|
return m_logger;
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2014-11-14 18:15:58 +00:00
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool ROUTER::IsPlacingVia() const
|
2014-11-14 18:15:58 +00:00
|
|
|
{
|
2015-02-18 16:53:46 +00:00
|
|
|
if( !m_placer )
|
2015-03-09 10:06:54 +00:00
|
|
|
return false;
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2014-11-14 18:15:58 +00:00
|
|
|
return m_placer->IsPlacingVia();
|
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2021-11-03 02:14:23 +00:00
|
|
|
void ROUTER::ToggleCornerMode()
|
2019-05-17 00:13:21 +00:00
|
|
|
{
|
2021-11-03 02:14:23 +00:00
|
|
|
DIRECTION_45::CORNER_MODE mode = m_settings->GetCornerMode();
|
2020-12-30 05:06:49 +00:00
|
|
|
|
|
|
|
switch( m_settings->GetCornerMode() )
|
|
|
|
{
|
2021-11-03 02:14:23 +00:00
|
|
|
case DIRECTION_45::CORNER_MODE::MITERED_45: mode = DIRECTION_45::CORNER_MODE::ROUNDED_45; break;
|
|
|
|
case DIRECTION_45::CORNER_MODE::ROUNDED_45: mode = DIRECTION_45::CORNER_MODE::MITERED_90; break;
|
|
|
|
case DIRECTION_45::CORNER_MODE::MITERED_90: mode = DIRECTION_45::CORNER_MODE::ROUNDED_90; break;
|
|
|
|
case DIRECTION_45::CORNER_MODE::ROUNDED_90: mode = DIRECTION_45::CORNER_MODE::MITERED_45; break;
|
2020-12-30 05:06:49 +00:00
|
|
|
}
|
|
|
|
|
2021-11-03 02:14:23 +00:00
|
|
|
m_settings->SetCornerMode( mode );
|
2019-05-17 00:13:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::SetOrthoMode( bool aEnable )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2015-02-18 16:53:46 +00:00
|
|
|
if( !m_placer )
|
2015-02-18 00:29:54 +00:00
|
|
|
return;
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
m_placer->SetOrthoMode( aEnable );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::SetMode( ROUTER_MODE aMode )
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
|
|
|
m_mode = aMode;
|
|
|
|
}
|
2016-08-15 15:16:47 +00:00
|
|
|
|
2017-01-24 15:14:38 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void ROUTER::SetInterface( ROUTER_IFACE *aIface )
|
2016-08-15 15:16:47 +00:00
|
|
|
{
|
|
|
|
m_iface = aIface;
|
|
|
|
}
|
2016-08-29 14:38:11 +00:00
|
|
|
|
2017-08-03 15:53:07 +00:00
|
|
|
void ROUTER::BreakSegment( ITEM *aItem, const VECTOR2I& aP )
|
|
|
|
{
|
|
|
|
NODE *node = m_world->Branch();
|
|
|
|
|
|
|
|
LINE_PLACER placer( this );
|
|
|
|
|
2021-02-25 16:18:13 +00:00
|
|
|
if( placer.SplitAdjacentSegments( node, aItem, aP ) )
|
2017-08-03 15:53:07 +00:00
|
|
|
{
|
|
|
|
CommitRouting( node );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
delete node;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-29 14:38:11 +00:00
|
|
|
}
|