diff options
Diffstat (limited to 'pcbnew/router/pns_item.h')
| -rw-r--r-- | pcbnew/router/pns_item.h | 350 |
1 files changed, 350 insertions, 0 deletions
diff --git a/pcbnew/router/pns_item.h b/pcbnew/router/pns_item.h new file mode 100644 index 0000000..a7511a7 --- /dev/null +++ b/pcbnew/router/pns_item.h @@ -0,0 +1,350 @@ +/* + * KiRouter - a push-and-(sometimes-)shove PCB router + * + * Copyright (C) 2013-2014 CERN + * 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 3 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, see <http://www.gnu.org/licenses/>. + */ + +#ifndef __PNS_ITEM_H +#define __PNS_ITEM_H + +#include <math/vector2d.h> + +#include <geometry/shape.h> +#include <geometry/shape_line_chain.h> + +#include "trace.h" + +#include "pns_layerset.h" + +class BOARD_CONNECTED_ITEM; +class PNS_NODE; + +enum LineMarker { + MK_HEAD = ( 1 << 0 ), + MK_VIOLATION = ( 1 << 3 ), + MK_LOCKED = ( 1 << 4 ), + MK_DP_COUPLED = ( 1 << 5 ) +}; + + +/** + * Class PNS_ITEM + * + * Base class for PNS router board items. Implements the shared properties of all PCB items - + * net, spanned layers, geometric shape & refererence to owning model. + */ +class PNS_ITEM +{ +public: + static const int UnusedNet = INT_MAX; + + ///> Supported item types + enum PnsKind + { + SOLID = 1, + LINE = 2, + JOINT = 4, + SEGMENT = 8, + VIA = 16, + DIFF_PAIR = 32, + ANY = 0xff + }; + + PNS_ITEM( PnsKind aKind ) + { + m_net = UnusedNet; + m_movable = true; + m_kind = aKind; + m_parent = NULL; + m_owner = NULL; + m_marker = 0; + m_rank = -1; + } + + PNS_ITEM( const PNS_ITEM& aOther ) + { + m_layers = aOther.m_layers; + m_net = aOther.m_net; + m_movable = aOther.m_movable; + m_kind = aOther.m_kind; + m_parent = aOther.m_parent; + m_owner = NULL; + m_marker = aOther.m_marker; + m_rank = aOther.m_rank; + } + + virtual ~PNS_ITEM(); + + /** + * Function Clone() + * + * Returns a deep copy of the item + */ + virtual PNS_ITEM* Clone() const = 0; + + /* + * Function Hull() + * + * Returns a convex polygon "hull" of a the item, that is used as the walk-around + * path. + * @param aClearance defines how far from the body of the item the hull should be, + * @param aWalkaroundThickness is the width of the line that walks around this hull. + */ + virtual const SHAPE_LINE_CHAIN Hull( int aClearance = 0, int aWalkaroundThickness = 0 ) const + { + return SHAPE_LINE_CHAIN(); + } + + /** + * Function Kind() + * + * Returns the type (kind) of the item + */ + PnsKind Kind() const + { + return m_kind; + } + + /** + * Function OfKind() + * + * Returns true if the item's type matches the mask aKindMask. + */ + bool OfKind( int aKindMask ) const + { + return ( aKindMask & m_kind ) != 0; + } + + /** + * Function KindStr() + * + * Returns the kind of the item, as string + */ + const std::string KindStr() const; + + /** + * Function SetParent() + * + * Sets the corresponding parent object in the host application's model. + */ + void SetParent( BOARD_CONNECTED_ITEM* aParent ) + { + m_parent = aParent; + } + + /** + * Function Parent() + * + * Returns the corresponding parent object in the host application's model. + */ + BOARD_CONNECTED_ITEM* Parent() const + { + return m_parent; + } + + /** + * Function SetNet() + * + * Sets the item's net to aNet + */ + void SetNet( int aNet ) + { + m_net = aNet; + } + + /** + * Function Net() + * + * Returns the item's net. + */ + int Net() const + { + return m_net; + } + + /** + * Function SetLayers() + * + * Sets the layers spanned by the item to aLayers. + */ + void SetLayers( const PNS_LAYERSET& aLayers ) + { + m_layers = aLayers; + } + + /** + * Function SetLayer() + * + * Sets the layers spanned by the item to a single layer aLayer. + */ + void SetLayer( int aLayer ) + { + m_layers = PNS_LAYERSET( aLayer, aLayer ); + } + + /** + * Function Layers() + * + * Returns the contiguous set of layers spanned by the item. + */ + const PNS_LAYERSET& Layers() const + { + return m_layers; + } + + /** + * Function Layer() + * + * Returns the item's layer, for single-layered items only. + */ + virtual int Layer() const + { + return Layers().Start(); + } + + /** + * Function LayersOverlap() + * + * Returns true if the set of layers spanned by aOther overlaps our + * layers. + */ + bool LayersOverlap( const PNS_ITEM* aOther ) const + { + return Layers().Overlaps( aOther->Layers() ); + } + + /** + * Functon SetOwner() + * + * Sets the node that owns this item. An item can belong to a single + * PNS_NODE or stay unowned. + */ + void SetOwner( PNS_NODE* aOwner ) + { + m_owner = aOwner; + } + + /** + * Function BelongsTo() + * + * @return true if the item is owned by the node aNode. + */ + bool BelongsTo( PNS_NODE* aNode ) const + { + return m_owner == aNode; + } + + /** + * Function Owner() + * + * Returns the owner of this item, or NULL if there's none. + */ + PNS_NODE* Owner() const { return m_owner; } + + /** + * Function Collide() + * + * Checks for a collision (clearance violation) with between us and item aOther. + * Collision checking takes all PCB stuff into accound (layers, nets, DRC rules). + * Optionally returns a minimum translation vector for force propagation + * algorithm. + * + * @param aOther item to check collision against + * @param aClearance desired clearance + * @param aNeedMTV when true, the minimum translation vector is calculated + * @param aMTV the minimum translation vector + * @return true, if a collision was found. + */ + virtual bool Collide( const PNS_ITEM* aOther, int aClearance, bool aNeedMTV, + VECTOR2I& aMTV, bool aDifferentNetsOnly = true ) const; + + /** + * Function Collide() + * + * A shortcut for PNS_ITEM::Colllide() without MTV stuff. + */ + bool Collide( const PNS_ITEM* aOther, int aClearance, bool aDifferentNetsOnly = true ) const + { + VECTOR2I dummy; + + return Collide( aOther, aClearance, false, dummy, aDifferentNetsOnly ); + } + + /** + * Function Shape() + * + * Returns the geometrical shape of the item. Used + * for collision detection & spatial indexing. + */ + virtual const SHAPE* Shape() const + { + return NULL; + } + + virtual void Mark(int aMarker) + { + m_marker = aMarker; + } + + virtual void Unmark () + { + m_marker = 0; + } + + virtual int Marker() const + { + return m_marker; + } + + virtual void SetRank( int aRank ) + { + m_rank = aRank; + } + + virtual int Rank() const + { + return m_rank; + } + + virtual VECTOR2I Anchor( int n ) const + { + return VECTOR2I (); + } + + virtual int AnchorCount() const + { + return 0; + } + +private: + bool collideSimple( const PNS_ITEM* aOther, int aClearance, bool aNeedMTV, + VECTOR2I& aMTV, bool aDifferentNetsOnly ) const; + +protected: + PnsKind m_kind; + + BOARD_CONNECTED_ITEM* m_parent; + PNS_NODE* m_owner; + PNS_LAYERSET m_layers; + + bool m_movable; + int m_net; + int m_marker; + int m_rank; +}; + +#endif // __PNS_ITEM_H |