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-01-27 22:15:38 +00:00
|
|
|
* Copyright (C) 2016-2021 KiCad Developers, see AUTHORS.txt for contributors.
|
|
|
|
*
|
|
|
|
* @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
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __PNS_JOINT_H
|
|
|
|
#define __PNS_JOINT_H
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include <math/vector2d.h>
|
|
|
|
|
|
|
|
#include "pns_item.h"
|
|
|
|
#include "pns_segment.h"
|
2014-11-14 18:15:58 +00:00
|
|
|
#include "pns_itemset.h"
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2016-08-29 14:38:11 +00:00
|
|
|
namespace PNS {
|
|
|
|
|
2013-09-18 17:55:16 +00:00
|
|
|
/**
|
2021-01-27 22:15:38 +00:00
|
|
|
* Represents a 2D point on a given set of layers and belonging to a certain net, that links
|
|
|
|
* together a number of board items.
|
2013-09-26 21:53:54 +00:00
|
|
|
*
|
2021-01-27 22:15:38 +00:00
|
|
|
* A hash table of joints is used by the router to follow connectivity between the items.
|
2013-09-18 17:55:16 +00:00
|
|
|
**/
|
2016-08-29 17:31:13 +00:00
|
|
|
class JOINT : public ITEM
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
|
|
|
public:
|
2016-08-29 17:31:13 +00:00
|
|
|
typedef ITEM_SET::ENTRIES LINKED_ITEMS;
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2021-01-27 22:15:38 +00:00
|
|
|
///< Joints are hashed by their position, layers and net.
|
|
|
|
///< Linked items are, obviously, not hashed.
|
2014-05-16 11:37:31 +00:00
|
|
|
struct HASH_TAG
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
|
|
|
VECTOR2I pos;
|
|
|
|
int net;
|
|
|
|
};
|
|
|
|
|
2017-11-01 11:14:16 +00:00
|
|
|
struct JOINT_TAG_HASH
|
|
|
|
{
|
|
|
|
std::size_t operator()( const JOINT::HASH_TAG& aP ) const
|
|
|
|
{
|
|
|
|
using std::size_t;
|
|
|
|
using std::hash;
|
|
|
|
using std::string;
|
|
|
|
|
|
|
|
return ( (hash<int>()( aP.pos.x )
|
|
|
|
^ (hash<int>()( aP.pos.y ) << 1) ) >> 1 )
|
|
|
|
^ (hash<int>()( aP.net ) << 1);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
JOINT() :
|
2021-05-30 23:47:57 +00:00
|
|
|
ITEM( JOINT_T ), m_tag(), m_locked( false ) {}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
JOINT( const VECTOR2I& aPos, const LAYER_RANGE& aLayers, int aNet = -1 ) :
|
|
|
|
ITEM( JOINT_T )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
|
|
|
m_tag.pos = aPos;
|
|
|
|
m_tag.net = aNet;
|
|
|
|
m_layers = aLayers;
|
2015-08-03 19:11:51 +00:00
|
|
|
m_locked = false;
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
JOINT( const JOINT& aB ) :
|
|
|
|
ITEM( JOINT_T )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2018-10-09 21:50:20 +00:00
|
|
|
m_layers = aB.m_layers;
|
2014-05-16 11:37:31 +00:00
|
|
|
m_tag.pos = aB.m_tag.pos;
|
|
|
|
m_tag.net = aB.m_tag.net;
|
|
|
|
m_linkedItems = aB.m_linkedItems;
|
2018-10-09 21:50:20 +00:00
|
|
|
m_layers = aB.m_layers;
|
2015-09-14 16:40:29 +00:00
|
|
|
m_locked = aB.m_locked;
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
2016-09-25 17:06:49 +00:00
|
|
|
ITEM* Clone( ) const override
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
|
|
|
assert( false );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-01-27 22:15:38 +00:00
|
|
|
///< Return true if the joint is a trivial line corner, connecting two
|
|
|
|
///< segments of the same net, on the same layer.
|
2013-09-26 21:53:54 +00:00
|
|
|
bool IsLineCorner() const
|
|
|
|
{
|
2019-05-17 00:13:21 +00:00
|
|
|
if( m_linkedItems.Size() != 2 || m_linkedItems.Count( SEGMENT_T | ARC_T ) != 2 )
|
2013-09-26 21:53:54 +00:00
|
|
|
return false;
|
|
|
|
|
2019-05-17 00:13:21 +00:00
|
|
|
auto seg1 = static_cast<LINKED_ITEM*>( m_linkedItems[0] );
|
|
|
|
auto seg2 = static_cast<LINKED_ITEM*>( m_linkedItems[1] );
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2014-05-14 13:53:54 +00:00
|
|
|
// joints between segments of different widths are not considered trivial.
|
|
|
|
return seg1->Width() == seg2->Width();
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
2015-02-18 16:53:46 +00:00
|
|
|
bool IsNonFanoutVia() const
|
2015-02-18 00:29:54 +00:00
|
|
|
{
|
2016-08-29 16:11:42 +00:00
|
|
|
int vias = m_linkedItems.Count( VIA_T );
|
|
|
|
int segs = m_linkedItems.Count( SEGMENT_T );
|
2019-05-17 00:13:21 +00:00
|
|
|
segs += m_linkedItems.Count( ARC_T );
|
2015-02-18 00:29:54 +00:00
|
|
|
|
2015-08-19 15:27:23 +00:00
|
|
|
return ( m_linkedItems.Size() == 3 && vias == 1 && segs == 2 );
|
2015-02-18 00:29:54 +00:00
|
|
|
}
|
|
|
|
|
2019-07-21 22:36:08 +00:00
|
|
|
bool IsStitchingVia() const
|
|
|
|
{
|
|
|
|
return ( m_linkedItems.Size() == 1 && m_linkedItems.Count( VIA_T ) == 1 );
|
|
|
|
}
|
|
|
|
|
2015-11-05 09:20:08 +00:00
|
|
|
bool IsTraceWidthChange() const
|
|
|
|
{
|
|
|
|
if( m_linkedItems.Size() != 2 )
|
|
|
|
return false;
|
|
|
|
|
2016-08-29 16:11:42 +00:00
|
|
|
if( m_linkedItems.Count( SEGMENT_T ) != 2)
|
2015-11-05 09:20:08 +00:00
|
|
|
return false;
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
SEGMENT* seg1 = static_cast<SEGMENT*>( m_linkedItems[0] );
|
|
|
|
SEGMENT* seg2 = static_cast<SEGMENT*>( m_linkedItems[1] );
|
2015-11-05 09:20:08 +00:00
|
|
|
|
|
|
|
return seg1->Width() != seg2->Width();
|
|
|
|
}
|
|
|
|
|
2021-01-27 22:15:38 +00:00
|
|
|
///< Link the joint to a given board item (when it's added to the NODE).
|
2016-08-29 17:31:13 +00:00
|
|
|
void Link( ITEM* aItem )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2014-11-14 19:19:00 +00:00
|
|
|
if( m_linkedItems.Contains( aItem ) )
|
2013-09-26 21:53:54 +00:00
|
|
|
return;
|
|
|
|
|
2014-11-14 19:19:00 +00:00
|
|
|
m_linkedItems.Add( aItem );
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
2021-01-27 22:15:38 +00:00
|
|
|
///< Unlink a given board item from the joint (upon its removal from a NODE)
|
|
|
|
///< @return true if the joint became dangling after unlinking.
|
2016-08-29 17:31:13 +00:00
|
|
|
bool Unlink( ITEM* aItem )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2014-11-14 19:19:00 +00:00
|
|
|
m_linkedItems.Erase( aItem );
|
2014-11-14 18:15:58 +00:00
|
|
|
return m_linkedItems.Size() == 0;
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
2021-01-27 22:15:38 +00:00
|
|
|
///< For trivial joints, return the segment adjacent to (aCurrent). For non-trival ones,
|
|
|
|
///< return NULL, indicating the end of line.
|
2019-05-17 00:13:21 +00:00
|
|
|
LINKED_ITEM* NextSegment( ITEM* aCurrent ) const
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
|
|
|
if( !IsLineCorner() )
|
|
|
|
return NULL;
|
|
|
|
|
2019-05-17 00:13:21 +00:00
|
|
|
return static_cast<LINKED_ITEM*>( m_linkedItems[m_linkedItems[0] == aCurrent ? 1 : 0] );
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
VIA* Via()
|
2015-08-03 19:11:51 +00:00
|
|
|
{
|
2016-08-29 17:31:13 +00:00
|
|
|
for( ITEM* item : m_linkedItems.Items() )
|
2015-08-03 19:11:51 +00:00
|
|
|
{
|
2016-08-29 16:11:42 +00:00
|
|
|
if( item->OfKind( VIA_T ) )
|
2016-08-29 17:31:13 +00:00
|
|
|
return static_cast<VIA*>( item );
|
2015-08-03 19:11:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-05-14 13:53:54 +00:00
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
/// trivial accessors
|
2014-11-14 19:19:00 +00:00
|
|
|
const HASH_TAG& Tag() const
|
|
|
|
{
|
|
|
|
return m_tag;
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2014-11-14 19:19:00 +00:00
|
|
|
|
|
|
|
const VECTOR2I& Pos() const
|
|
|
|
{
|
|
|
|
return m_tag.pos;
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2014-11-14 19:19:00 +00:00
|
|
|
|
|
|
|
int Net() const
|
|
|
|
{
|
|
|
|
return m_tag.net;
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2014-11-14 19:19:00 +00:00
|
|
|
|
2014-11-14 18:15:58 +00:00
|
|
|
const LINKED_ITEMS& LinkList() const
|
2014-11-14 19:19:00 +00:00
|
|
|
{
|
|
|
|
return m_linkedItems.CItems();
|
2014-05-14 13:53:54 +00:00
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
const ITEM_SET& CLinks() const
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2014-11-14 18:15:58 +00:00
|
|
|
return m_linkedItems;
|
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
ITEM_SET& Links()
|
2014-11-14 18:15:58 +00:00
|
|
|
{
|
|
|
|
return m_linkedItems;
|
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
|
2014-11-14 18:15:58 +00:00
|
|
|
int LinkCount( int aMask = -1 ) const
|
|
|
|
{
|
|
|
|
return m_linkedItems.Count( aMask );
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Dump() const;
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool operator==( const JOINT& rhs ) const
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
|
|
|
return m_tag.pos == rhs.m_tag.pos && m_tag.net == rhs.m_tag.net;
|
|
|
|
}
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
void Merge( const JOINT& aJoint )
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
|
|
|
if( !Overlaps( aJoint ) )
|
|
|
|
return;
|
|
|
|
|
|
|
|
m_layers.Merge( aJoint.m_layers );
|
|
|
|
|
2015-09-14 16:40:29 +00:00
|
|
|
if( aJoint.IsLocked() )
|
|
|
|
m_locked = true;
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
for( ITEM* item : aJoint.LinkList() )
|
2014-05-16 11:37:31 +00:00
|
|
|
{
|
2014-11-14 19:19:00 +00:00
|
|
|
m_linkedItems.Add( item );
|
2014-05-16 11:37:31 +00:00
|
|
|
}
|
2013-09-26 21:53:54 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
bool Overlaps( const JOINT& rhs ) const
|
2013-09-26 21:53:54 +00:00
|
|
|
{
|
2013-10-14 11:43:57 +00:00
|
|
|
return m_tag.pos == rhs.m_tag.pos &&
|
2013-09-26 21:53:54 +00:00
|
|
|
m_tag.net == rhs.m_tag.net && m_layers.Overlaps( rhs.m_layers );
|
|
|
|
}
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2015-08-03 19:11:51 +00:00
|
|
|
void Lock( bool aLock = true )
|
|
|
|
{
|
|
|
|
m_locked = aLock;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsLocked() const
|
|
|
|
{
|
|
|
|
return m_locked;
|
|
|
|
}
|
|
|
|
|
2013-09-18 17:55:16 +00:00
|
|
|
private:
|
2021-01-27 22:15:38 +00:00
|
|
|
///< hash tag for unordered_multimap
|
2014-05-16 11:37:31 +00:00
|
|
|
HASH_TAG m_tag;
|
2013-09-18 17:55:16 +00:00
|
|
|
|
2021-01-27 22:15:38 +00:00
|
|
|
///< list of items linked to this joint
|
2016-08-29 17:31:13 +00:00
|
|
|
ITEM_SET m_linkedItems;
|
2015-08-03 19:11:51 +00:00
|
|
|
|
2021-01-27 22:15:38 +00:00
|
|
|
///< locked (non-movable) flag
|
2015-08-03 19:11:51 +00:00
|
|
|
bool m_locked;
|
2013-09-18 17:55:16 +00:00
|
|
|
};
|
|
|
|
|
2016-08-29 17:31:13 +00:00
|
|
|
inline bool operator==( JOINT::HASH_TAG const& aP1, JOINT::HASH_TAG const& aP2 )
|
2013-09-18 17:55:16 +00:00
|
|
|
{
|
2014-05-16 11:37:31 +00:00
|
|
|
return aP1.pos == aP2.pos && aP1.net == aP2.net;
|
2013-09-18 17:55:16 +00:00
|
|
|
}
|
|
|
|
|
2016-08-29 14:38:11 +00:00
|
|
|
}
|
|
|
|
|
2013-09-26 21:53:54 +00:00
|
|
|
#endif // __PNS_JOINT_H
|