pns_line.h

Go to the documentation of this file.

/*
 * KiRouter - a push-and-(sometimes-)shove PCB router
 *
 * Copyright (C) 2013-2017 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * Author: Tomasz Wlostowski <[email protected]>
 *
 * 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 <https://www.gnu.org/licenses/>.
 */
 
#ifndef __PNS_LINE_H
#define __PNS_LINE_H
 
#include <math/box2.h>
#include <math/vector2d.h>
 
#include <geometry/direction45.h>
#include <geometry/seg.h>
#include <geometry/shape.h>
#include <geometry/shape_line_chain.h>
 
#include "pns_item.h"
#include "pns_via.h"
#include "pns_link_holder.h"
 
namespace PNS {
 
class LINKED_ITEM;
class NODE;
class VIA;
class SEGMENT;
 
#define PNS_HULL_MARGIN 10

class LINE : public LINK_HOLDER
{
public:
    LINE() :
        LINK_HOLDER( LINE_T ),
        m_blockingObstacle( nullptr )
    {
        m_width = 1;        // Dummy value
        m_snapThreshhold = 0;
        m_via = nullptr;
    }
 
    LINE( const LINE& aOther );

    LINE( const LINE& aBase, const SHAPE_LINE_CHAIN& aLine ) :
        LINK_HOLDER( aBase ),
        m_line( aLine ),
        m_width( aBase.m_width ),
        m_snapThreshhold( aBase.m_snapThreshhold ),
        m_blockingObstacle( nullptr )
    {
        m_net = aBase.m_net;
        m_layers = aBase.m_layers;
        m_via = nullptr;
    }

    LINE( VIA* aVia ) :
        LINK_HOLDER( LINE_T ),
        m_blockingObstacle( nullptr )
    {
        m_via = aVia;
        // TODO(JE) Padstacks - does this matter?
        m_width = aVia->Diameter( aVia->Layers().Start() );
        m_net = aVia->Net();
        m_layers = aVia->Layers();
        m_rank = aVia->Rank();
        m_snapThreshhold = 0;
    }
 
    ~LINE();
 
    static inline bool ClassOf( const ITEM* aItem )
    {
        return aItem && LINE_T == aItem->Kind();
    }

    virtual LINE* Clone() const override;
 
    // Copy operator
    LINE& operator=( const LINE& aOther );
 
    // Move assignment operator
    LINE& operator=( LINE&& aOther ) noexcept;
 
    bool IsLinkedChecked() const
    {
        return IsLinked() && LinkCount() == ShapeCount();
    }

    SEGMENT* FindLinkedSegment( const SEG& aSeg ) const;
 

    void SetShape( const SHAPE_LINE_CHAIN& aLine )
    {
        m_line = aLine;
        m_line.SetWidth( m_width );
    }

    const SHAPE* Shape( int aLayer ) const override { return &m_line; }

    SHAPE_LINE_CHAIN& Line() { return m_line; }
    const SHAPE_LINE_CHAIN& CLine() const { return m_line; }
 
    int SegmentCount() const { return m_line.SegmentCount(); }
    int PointCount() const { return m_line.PointCount(); }
    int ArcCount() const { return m_line.ArcCount(); }
    int ShapeCount() const { return m_line.ShapeCount(); }

    const VECTOR2I& CPoint( int aIdx ) const { return m_line.CPoint( aIdx ); }
    const VECTOR2I& CLastPoint() const { return m_line.CLastPoint(); }
    const SEG CSegment( int aIdx ) const { return m_line.CSegment( aIdx ); }

    void SetWidth( int aWidth )
    {
        m_width = aWidth;
        m_line.SetWidth( aWidth );
    }

    int Width() const { return m_width; }

    bool CompareGeometry( const LINE& aOther );

    void Reverse();

    const LINE ClipToNearestObstacle( NODE* aNode ) const;

    void ClipVertexRange ( int aStart, int aEnd );

    int CountCorners( int aAngles ) const;

    bool Walkaround( SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPrePath, SHAPE_LINE_CHAIN& aWalk,
                     SHAPE_LINE_CHAIN& aPost, bool aCw ) const;
 
    bool Walkaround( const SHAPE_LINE_CHAIN& aObstacle, SHAPE_LINE_CHAIN& aPath, bool aCw ) const;

    void ShowLinks() const;
 
    bool EndsWithVia() const { return m_via != nullptr; }
 
    int FindSegment( const SEGMENT* aSeg ) const;
 
    void AppendVia( const VIA& aVia );
    void LinkVia( VIA* aVia );
    void RemoveVia();
 
    VIA& Via() { return *m_via; }
    const VIA& Via() const { return *m_via; }
 
    void SetViaDiameter( int aDiameter )
    {
        wxCHECK( m_via, /* void */ );
        wxCHECK2_MSG( m_via->StackMode() == VIA::STACK_MODE::NORMAL,
                      m_via->SetStackMode( VIA::STACK_MODE::NORMAL ),
                      wxS( "Warning: converting a complex viastack to normal in PNS_LINE" ) );
 
        m_via->SetDiameter( VIA::ALL_LAYERS, aDiameter );
    }
    void SetViaDrill( int aDrill ) { assert(m_via); m_via->SetDrill( aDrill ); }
 
    virtual void Mark( int aMarker ) const override;
    virtual void Unmark( int aMarker = -1 ) const override;
    virtual int Marker() const override;
 
    virtual VECTOR2I Anchor( int n ) const override
    {
        if( m_line.PointCount() < 1 )
            return VECTOR2I();
 
        return ( n == 0 ) ? m_line.CPoint( 0 ) : m_line.CPoint( -1 );
    }
 
    virtual int AnchorCount() const override
    {
        return ( m_line.PointCount() >= 2 ) ? 2 : m_line.PointCount();
    }
 
    void SetBlockingObstacle( ITEM* aObstacle ) { m_blockingObstacle = aObstacle; }
    ITEM* GetBlockingObstacle() const { return m_blockingObstacle; }
 
    void DragSegment( const VECTOR2I& aP, int aIndex, bool aFreeAngle = false );
    void DragCorner( const VECTOR2I& aP, int aIndex, bool aFreeAngle = false,
                     DIRECTION_45 aPreferredEndingDirection = DIRECTION_45() );
 
    void DragArc( const VECTOR2I& aP, int aIndex );
 
    void SetRank( int aRank ) override;
    int Rank() const override;
 
    bool HasLoops() const;
    bool HasLockedSegments() const;
 
    void Clear();
 
    OPT_BOX2I ChangedArea( const LINE* aOther ) const;
 
    void SetSnapThreshhold( int aThreshhold )
    {
        m_snapThreshhold = aThreshhold;
    }
 
    int GetSnapThreshhold() const
    {
        return m_snapThreshhold;
    }
 
    SEGMENT* FindLinkContainingVertex( const VECTOR2I& aP ) const;
 
private:
    void dragSegment45( const VECTOR2I& aP, int aIndex );
    void dragCorner45( const VECTOR2I& aP, int aIndex, DIRECTION_45 aPreferredEndingDirection );
    void dragSegmentFree( const VECTOR2I& aP, int aIndex );
    void dragCornerFree( const VECTOR2I& aP, int aIndex );

    void restoreUntouchedArcs( SHAPE_LINE_CHAIN& aPath, const SHAPE_LINE_CHAIN& aOriginal ) const;
 
    VECTOR2I snapToNeighbourSegments( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I& aP,
                                      int aIndex ) const;
 
    VECTOR2I snapDraggedCorner( const SHAPE_LINE_CHAIN& aPath, const VECTOR2I& aP,
                                int aIndex ) const;
 
    SHAPE_LINE_CHAIN m_line;                
    int              m_width;               
 
 
    int              m_snapThreshhold;      
 
    VIA*             m_via;
    ITEM*            m_blockingObstacle;    
};
 
}
 
#endif    // __PNS_LINE_H