pns_line.h

Go to the documentation of this file.

/*
 * KiRouter - a push-and-(sometimes-)shove PCB router
 *
 * Copyright (C) 2013-2017 CERN
 * Copyright (C) 2016-2021 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 <http://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;

#define PNS_HULL_MARGIN 10

class LINE : public LINK_HOLDER
{
public:
 LINE() :
 LINK_HOLDER( LINE_T ),
 m_blockingObstacle( nullptr )
 {
 m_hasVia = false;
 m_width = 1; // Dummy value
 m_snapThreshhold = 0;
 }

 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_hasVia = false;
 }

 LINE( const VIA& aVia ) :
 LINK_HOLDER( LINE_T ),
 m_blockingObstacle( nullptr )
 {
 m_hasVia = true;
 m_via = aVia;
 m_width = aVia.Diameter();
 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;

 LINE& operator=( const LINE& aOther );

 bool IsLinkedChecked() const
 {
 return IsLinked() && LinkCount() == ShapeCount();
 }

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

 const SHAPE* Shape() 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 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& aPre, 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;

 bool Is45Degree() const;

 void ShowLinks() const;

 bool EndsWithVia() const { return m_hasVia; }

 void AppendVia( const VIA& aVia );
 void RemoveVia() { m_hasVia = false; }

 const VIA& Via() const { return m_via; }

 void SetViaDiameter( int aDiameter ) { m_via.SetDiameter( aDiameter ); }
 void SetViaDrill( int aDrill ) { m_via.SetDrill( aDrill ); }

 virtual void Mark( int aMarker ) const override;
 virtual void Unmark( int aMarker = -1 ) const override;
 virtual int Marker() const override;

 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 );

 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;
 }

private:
 void dragSegment45( const VECTOR2I& aP, int aIndex );
 void dragCorner45( const VECTOR2I& aP, int aIndex );
 void dragSegmentFree( const VECTOR2I& aP, int aIndex );
 void dragCornerFree( const VECTOR2I& aP, int aIndex );

 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; 

 bool m_hasVia; 
 VIA m_via;

 ITEM* m_blockingObstacle; 
};

}

#endif // __PNS_LINE_H