PNS Namespace Reference

Push and Shove diff pair dimensions (gap) settings dialog. More...

Classes
class	ALGO_BASE
	Class ALGO_BASE. More...
class	COST_ESTIMATOR
	Class COST_ESTIMATOR. More...
class	DEBUG_DECORATOR
class	DIFF_PAIR
	Class DIFF_PAIR. More...
class	DIFF_PAIR_PLACER
	Class LINE_PLACER. More...
class	DP_GATEWAY
	Class DP_GATEWAY. More...
class	DP_GATEWAYS
	Class DP_GATEWAYS. More...
class	DP_MEANDER_PLACER
	Class DP_MEANDER_PLACER. More...
class	DP_PRIMITIVE_PAIR
	Class DP_PRIMITIVE_PAIR. More...
class	DRAGGER
	Class DRAGGER. More...
struct	HIT_VISITOR
class	INDEX
	Class INDEX. More...
class	ITEM
	Class ITEM. More...
class	ITEM_SET
class	JOINT
	Class JOINT. More...
class	LINE
class	LINE_PLACER
	Class LINE_PLACER. More...
class	LINE_RESTRICTIONS
class	LOGGER
class	MEANDER_PLACER
	Class MEANDER_PLACER. More...
class	MEANDER_PLACER_BASE
	Class MEANDER_PLACER_BASE. More...
class	MEANDER_SETTINGS
	Class MEANDER_SETTINGS. More...
class	MEANDER_SHAPE
	Class MEANDER_SETTINGS. More...
class	MEANDER_SKEW_PLACER
	Class MEANDER_SKEW_PLACER. More...
class	MEANDERED_LINE
	Class MEANDERED_LINE. More...
class	NODE
	Class NODE. More...
struct	OBSTACLE
	Struct OBSTACLE. More...
class	OBSTACLE_VISITOR
	Struct OBSTACLE_VISITOR. More...
class	OPTIMIZER
	Class OPTIMIZER. More...
class	PLACEMENT_ALGO
	Class PLACEMENT_ALGO. More...
class	ROUTER
class	ROUTER_IFACE
	Class ROUTER. More...
class	ROUTING_SETTINGS
	Class ROUTING_SETTINGS. More...
class	RULE_RESOLVER
	Class RULE_RESOLVER. More...
class	SEGMENT
class	SHOVE
	Class SHOVE. More...
class	SIZES_SETTINGS
class	SOLID
class	TIME_LIMIT
class	TOOL_BASE
class	TOPOLOGY
class	VIA
struct	VIA_HANDLE
class	WALKAROUND

Enumerations
enum	LineMarker { MK_HEAD = ( 1 << 0 ), MK_VIOLATION = ( 1 << 3 ), MK_LOCKED = ( 1 << 4 ), MK_DP_COUPLED = ( 1 << 5 ) }
enum	MEANDER_TYPE {   MT_SINGLE, MT_START, MT_FINISH, MT_TURN,   MT_CHECK_START, MT_CHECK_FINISH, MT_CORNER, MT_EMPTY }
	Shapes of available meanders. More...
enum	MEANDER_STYLE { MEANDER_STYLE_ROUND = 1, MEANDER_STYLE_CHAMFER }
	meander corner shape More...
enum	ROUTER_MODE {   PNS_MODE_ROUTE_SINGLE = 1, PNS_MODE_ROUTE_DIFF_PAIR, PNS_MODE_TUNE_SINGLE, PNS_MODE_TUNE_DIFF_PAIR,   PNS_MODE_TUNE_DIFF_PAIR_SKEW }
enum	DRAG_MODE {   DM_CORNER = 0x1, DM_SEGMENT = 0x2, DM_VIA = 0x4, DM_FREE_ANGLE = 0x8,   DM_ANY = 0x7 }
enum	PNS_MODE { RM_MarkObstacles = 0, RM_Shove, RM_Walkaround, RM_Smart }
	Routing modes More...
enum	PNS_OPTIMIZATION_EFFORT { OE_LOW = 0, OE_MEDIUM = 1, OE_FULL = 2 }
	Optimization effort More...

Functions
static DIRECTION_45::AngleType	angle (const VECTOR2I &a, const VECTOR2I &b)
static bool	checkGap (const SHAPE_LINE_CHAIN &p, const SHAPE_LINE_CHAIN &n, int gap)
static VECTOR2I	makeGapVector (VECTOR2I dir, int length)
bool	commonParallelProjection (SEG p, SEG n, SEG &pClip, SEG &nClip)
template<typename T , typename S >
std::unique_ptr< T >	ItemCast (std::unique_ptr< S > aPtr)
template<typename T >
std::unique_ptr< typename std::remove_const< T >::type >	Clone (const T &aItem)
bool	operator== (JOINT::HASH_TAG const &aP1, JOINT::HASH_TAG const &aP2)
SHAPE_LINE_CHAIN	dragCornerInternal (const SHAPE_LINE_CHAIN &aOrigin, const VECTOR2I &aP)
static void	extendBox (BOX2I &aBox, bool &aDefined, const VECTOR2I &aP)
int	findCoupledVertices (const VECTOR2I &aVertex, const SEG &aOrigSeg, const SHAPE_LINE_CHAIN &aCoupled, DIFF_PAIR *aPair, int *aIndices)
bool	verifyDpBypass (NODE *aNode, DIFF_PAIR *aPair, bool aRefIsP, const SHAPE_LINE_CHAIN &aNewRef, const SHAPE_LINE_CHAIN &aNewCoupled)
bool	coupledBypass (NODE *aNode, DIFF_PAIR *aPair, bool aRefIsP, const SHAPE_LINE_CHAIN &aRef, const SHAPE_LINE_CHAIN &aRefBypass, const SHAPE_LINE_CHAIN &aCoupled, SHAPE_LINE_CHAIN &aNewCoupled)
bool	checkDpColliding (NODE *aNode, DIFF_PAIR *aPair, bool aIsP, const SHAPE_LINE_CHAIN &aPath)
static VIA *	findViaByHandle (NODE *aNode, const VIA_HANDLE &handle)
const SHAPE_LINE_CHAIN	OctagonalHull (const VECTOR2I &aP0, const VECTOR2I &aSize, int aClearance, int aChamfer)
	Various utility functions. More...
const SHAPE_LINE_CHAIN	SegmentHull (const SHAPE_SEGMENT &aSeg, int aClearance, int aWalkaroundThickness)
static void	MoveDiagonal (SEG &aDiagonal, const SHAPE_LINE_CHAIN &aVertices, int aClearance)
const SHAPE_LINE_CHAIN	ConvexHull (const SHAPE_SIMPLE &aConvex, int aClearance)
	Function ConvexHull() More...
SHAPE_RECT	ApproximateSegmentAsRect (const SHAPE_SEGMENT &aSeg)
OPT_BOX2I	ChangedArea (const ITEM *aItemA, const ITEM *aItemB)
OPT_BOX2I	ChangedArea (const LINE &aLineA, const LINE &aLineB)

Variables
static ROUTER *	theRouter
constexpr int	HULL_MARGIN = 10

Detailed Description

Push and Shove diff pair dimensions (gap) settings dialog.

Push and Shove router settings dialog.

Enumeration Type Documentation

DRAG_MODE

enum PNS::DRAG_MODE

Enumerator
DM_CORNER
DM_SEGMENT
DM_VIA
DM_FREE_ANGLE
DM_ANY

Definition at line 73 of file pns_router.h.

{
    DM_CORNER = 0x1,
    DM_SEGMENT = 0x2,
    DM_VIA = 0x4,
    DM_FREE_ANGLE = 0x8,
    DM_ANY = 0x7
};

LineMarker

enum PNS::LineMarker

Enumerator
MK_HEAD
MK_VIOLATION
MK_LOCKED
MK_DP_COUPLED

Definition at line 39 of file pns_item.h.

                {
    MK_HEAD         = ( 1 << 0 ),
    MK_VIOLATION    = ( 1 << 3 ),
    MK_LOCKED       = ( 1 << 4 ),
    MK_DP_COUPLED   = ( 1 << 5 )
};

MEANDER_STYLE

enum PNS::MEANDER_STYLE

meander corner shape

Enumerator
MEANDER_STYLE_ROUND
MEANDER_STYLE_CHAMFER

Definition at line 47 of file pns_meander.h.

                   {
    MEANDER_STYLE_ROUND = 1,          // rounded (90 degree arc)
    MEANDER_STYLE_CHAMFER             // chamfered (45 degree segment)
};

MEANDER_TYPE

enum PNS::MEANDER_TYPE

Shapes of available meanders.

Enumerator
MT_SINGLE
MT_START
MT_FINISH
MT_TURN
MT_CHECK_START
MT_CHECK_FINISH
MT_CORNER
MT_EMPTY

Definition at line 35 of file pns_meander.h.

                  {
        MT_SINGLE,          // _|^|_, single-sided
        MT_START,           // _|^|
        MT_FINISH,          // |^|_
        MT_TURN,            // |^| or |_|
        MT_CHECK_START,     // try fitting a start type, but don't produce a line
        MT_CHECK_FINISH,    // try fitting a finish type, but don't produce a line
        MT_CORNER,          // line corner
        MT_EMPTY            // no meander (straight line)
};

PNS_MODE

enum PNS::PNS_MODE

Routing modes

Enumerator
RM_MarkObstacles
RM_Shove	Ignore collisions, mark obstacles
RM_Walkaround	Only shove
RM_Smart	Only walkaround Guess what's better, try to make least mess on the PCB

Definition at line 35 of file pns_routing_settings.h.

{
    RM_MarkObstacles = 0,   
    RM_Shove,               
    RM_Walkaround,          
    RM_Smart                
};

PNS_OPTIMIZATION_EFFORT

enum PNS::PNS_OPTIMIZATION_EFFORT

Optimization effort

Enumerator
OE_LOW
OE_MEDIUM
OE_FULL

Definition at line 44 of file pns_routing_settings.h.

{
    OE_LOW = 0,
    OE_MEDIUM = 1,
    OE_FULL = 2
};

ROUTER_MODE

enum PNS::ROUTER_MODE

Enumerator
PNS_MODE_ROUTE_SINGLE
PNS_MODE_ROUTE_DIFF_PAIR
PNS_MODE_TUNE_SINGLE
PNS_MODE_TUNE_DIFF_PAIR
PNS_MODE_TUNE_DIFF_PAIR_SKEW

Definition at line 65 of file pns_router.h.

                 {
    PNS_MODE_ROUTE_SINGLE = 1,
    PNS_MODE_ROUTE_DIFF_PAIR,
    PNS_MODE_TUNE_SINGLE,
    PNS_MODE_TUNE_DIFF_PAIR,
    PNS_MODE_TUNE_DIFF_PAIR_SKEW
};

Function Documentation

angle()

static DIRECTION_45::AngleType PNS::angle ( const VECTOR2I &  a, const VECTOR2I &  b  )

static

Definition at line 180 of file pns_diff_pair.cpp.

{
    DIRECTION_45 dir_a( a );
    DIRECTION_45 dir_b( b );

    return dir_a.Angle( dir_b );
}

References DIRECTION_45::Angle().

Referenced by DXF_IMPORT_PLUGIN::addArc(), DIMENSION::AdjustDimensionDetails(), EC_45DEGREE::Apply(), EC_CIRCLE::Apply(), HPGL_PLOTTER::Arc(), BuildCornersList_S_Shape(), PNS::DP_GATEWAYS::BuildGeneric(), D_PAD::BuildPadPolygon(), PNS::OPTIMIZER::circleBreakouts(), DRAWSEGMENT::computeArcBBox(), ConvertOutlineToPolygon(), AM_PRIMITIVE::ConvertShapeToPolygon(), D_CODE::ConvertShapeToPolygon(), PCB_EDIT_FRAME::Create_MuWaveComponent(), SCH_GLOBALLABEL::CreateGraphicShape(), PNS::OPTIMIZER::customBreakouts(), DRC::doTrackDrc(), DRAWING_TOOL::DrawDimension(), AR_MATRIX::drawSegmentQcq(), GBR_TO_PCB_EXPORTER::export_non_copper_item(), export_vrml_line(), DSN::SPECCTRA_DB::FromBOARD(), C3D_RENDER_OGL_LEGACY::generate_ring_contour(), TEXTE_MODULE::GetBoundingBox(), KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetStartAngle(), KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetSubtended(), ARRAY_CIRCULAR_OPTIONS::GetTransform(), GRCSegm(), PNS::LINE_PLACER::handlePullback(), idf_export_module(), DIALOG_PAD_PROPERTIES::initValues(), DXF_IMPORT_PLUGIN::insertArc(), PNS::LINE::Is45Degree(), LEGACY_PLUGIN::loadMODULE_EDGE(), LEGACY_PLUGIN::loadPCB_LINE(), LEGACY_PLUGIN::loadPCB_TEXT(), EAGLE_PLUGIN::loadPolygon(), EAGLE_PLUGIN::loadSignals(), DSN::SPECCTRA_DB::makeIMAGE(), EAGLE_PLUGIN::packagePolygon(), GPCB_FPL_CACHE::parseMODULE(), D_PAD::PrintShape(), ZONE_CONTAINER::Rotate(), AR_AUTOPLACER::rotateModule(), RotatePoint(), TEXTE_MODULE::SetDrawCoord(), D_PAD::SetDrawCoord(), EDGE_MODULE::SetLocalCoord(), TEXTE_MODULE::SetLocalCoord(), AR_MATRIX::traceArc(), AR_MATRIX::traceCircle(), AR_MATRIX::TraceFilledRectangle(), TransformCircleToPolygon(), D_PAD::TransformShapeWithClearanceToPolygon(), and TEXTE_MODULE::ViewBBox().

ApproximateSegmentAsRect()

SHAPE_RECT PNS::ApproximateSegmentAsRect

(

const SHAPE_SEGMENT &

aSeg

)

Definition at line 157 of file pns_utils.cpp.

{
    SHAPE_RECT r;

    VECTOR2I delta( aSeg.GetWidth() / 2, aSeg.GetWidth() / 2 );
    VECTOR2I p0( aSeg.GetSeg().A - delta );
    VECTOR2I p1( aSeg.GetSeg().B + delta );

    return SHAPE_RECT( std::min( p0.x, p1.x ), std::min( p0.y, p1.y ),
                       std::abs( p1.x - p0.x ), std::abs( p1.y - p0.y ) );
}

References SEG::A, abs, SEG::B, SHAPE_SEGMENT::GetSeg(), SHAPE_SEGMENT::GetWidth(), and min.

Referenced by PNS::OPTIMIZER::computeBreakouts().

ChangedArea() [1/2]

OPT_BOX2I PNS::ChangedArea	(	const ITEM *	aItemA,
		const ITEM *	aItemB
	)

Definition at line 231 of file pns_utils.cpp.

{
    if( aItemA->OfKind( ITEM::VIA_T ) && aItemB->OfKind( ITEM::VIA_T ) )
    {
        const VIA* va = static_cast<const VIA*>( aItemA );
        const VIA* vb = static_cast<const VIA*>( aItemB );

        return va->ChangedArea( vb );
    }
    else if( aItemA->OfKind( ITEM::LINE_T ) && aItemB->OfKind( ITEM::LINE_T ) )
    {
        const LINE* la = static_cast<const LINE*> ( aItemA );
        const LINE* lb = static_cast<const LINE*> ( aItemB );

        return la->ChangedArea( lb );
    }

    return OPT_BOX2I();
}

References PNS::VIA::ChangedArea(), PNS::LINE::ChangedArea(), PNS::ITEM::LINE_T, PNS::ITEM::OfKind(), and PNS::ITEM::VIA_T.

Referenced by PNS::SHOVE::replaceItems(), and PNS::SHOVE::replaceLine().

ChangedArea() [2/2]

OPT_BOX2I PNS::ChangedArea	(	const LINE &	aLineA,
		const LINE &	aLineB
	)

Definition at line 251 of file pns_utils.cpp.

{
    return aLineA.ChangedArea( &aLineB );
}

References PNS::LINE::ChangedArea().

checkDpColliding()

bool PNS::checkDpColliding	(	NODE *	aNode,
		DIFF_PAIR *	aPair,
		bool	aIsP,
		const SHAPE_LINE_CHAIN &	aPath
	)

Definition at line 1116 of file pns_optimizer.cpp.

{
    LINE tmp ( aIsP ? aPair->PLine() : aPair->NLine(), aPath );

    return static_cast<bool>( aNode->CheckColliding( &tmp ) );
}

References PNS::NODE::CheckColliding(), PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

checkGap()

static bool PNS::checkGap ( const SHAPE_LINE_CHAIN &  p, const SHAPE_LINE_CHAIN &  n, int  gap  )

static

Definition at line 189 of file pns_diff_pair.cpp.

{
    int i, j;

    for( i = 0; i < p.SegmentCount(); i++ )
    {
        for( j = 0; j < n.SegmentCount() ; j++ )
        {
            int dist = p.CSegment( i ).Distance( n.CSegment( j ) );

            if( dist < gap - 100 )
                return false;
        }
    }

    return true;
}

References SHAPE_LINE_CHAIN::CSegment(), dist, SEG::Distance(), i, and SHAPE_LINE_CHAIN::SegmentCount().

Referenced by PNS::DIFF_PAIR::BuildInitial().

Clone()

template<typename T >

std::unique_ptr< typename std::remove_const< T >::type > PNS::Clone

(

const T &

aItem

)

Definition at line 270 of file pns_item.h.

{
    static_assert(std::is_base_of< ITEM, T >::value, "Need to be handed an ITEM!");
    return std::unique_ptr< typename std::remove_const< T >::type >( aItem.Clone() );
}

Referenced by PNS::DRAGGER::dumbDragVia(), PNS::LINE_PLACER::FixRoute(), PNS::DIFF_PAIR_PLACER::FixRoute(), PNS::SHOVE::pushOrShoveVia(), PNS::SHOVE::ShoveLines(), PNS::SHOVE::ShoveMultiLines(), and PNS::LINE_PLACER::SplitAdjacentSegments().

commonParallelProjection()

bool PNS::commonParallelProjection	(	SEG	p,
		SEG	n,
		SEG &	pClip,
		SEG &	nClip
	)

Definition at line 774 of file pns_diff_pair.cpp.

{
    SEG n_proj_p( p.LineProject( n.A ), p.LineProject( n.B ) );

    int64_t t_a = 0;
    int64_t t_b = p.TCoef( p.B );

    int64_t tproj_a = p.TCoef( n_proj_p.A );
    int64_t tproj_b = p.TCoef( n_proj_p.B );

    if( t_b < t_a )
        std::swap( t_b, t_a );

    if( tproj_b < tproj_a )
        std::swap( tproj_b, tproj_a );

    if( t_b <= tproj_a )
        return false;

    if( t_a >= tproj_b )
        return false;

    int64_t t[4] = { 0, p.TCoef( p.B ), p.TCoef( n_proj_p.A ), p.TCoef( n_proj_p.B ) };
    std::vector<int64_t> tv( t, t + 4 );
    std::sort( tv.begin(), tv.end() ); // fixme: awful and disgusting way of finding 2 midpoints

    int64_t pLenSq = p.SquaredLength();

    VECTOR2I dp = p.B - p.A;
    pClip.A.x = p.A.x + rescale( (int64_t)dp.x, tv[1], pLenSq );
    pClip.A.y = p.A.y + rescale( (int64_t)dp.y, tv[1], pLenSq );

    pClip.B.x = p.A.x + rescale( (int64_t)dp.x, tv[2], pLenSq );
    pClip.B.y = p.A.y + rescale( (int64_t)dp.y, tv[2], pLenSq );

    nClip.A = n.LineProject( pClip.A );
    nClip.B = n.LineProject( pClip.B );

    return true;
}

References SEG::A, SEG::B, SEG::LineProject(), numEval::rescale(), SEG::SquaredLength(), SEG::TCoef(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PNS::TOPOLOGY::AssembleDiffPair(), PNS::DIFF_PAIR::CoupledLength(), and PNS::DIFF_PAIR::CoupledSegmentPairs().

ConvexHull()

const SHAPE_LINE_CHAIN PNS::ConvexHull	(	const SHAPE_SIMPLE &	aConvex,
		int	aClearance
	)

Function ConvexHull()

Creates an octagonal hull around a convex polygon.

Parameters

aConvex	The convex polygon.
aClearance	The minimum distance between polygon and hull.

Returns

A closed line chain describing the octagon.

Definition at line 101 of file pns_utils.cpp.

{
    // this defines the horizontal and vertical lines in the hull octagon
    BOX2I box = aConvex.BBox( aClearance + HULL_MARGIN );
    box.Normalize();

    SEG topline = SEG( VECTOR2I( box.GetX(), box.GetY() + box.GetHeight() ),
                       VECTOR2I( box.GetX() + box.GetWidth(), box.GetY() + box.GetHeight() ) );
    SEG rightline = SEG( VECTOR2I( box.GetX() + box.GetWidth(), box.GetY() + box.GetHeight() ),
                         VECTOR2I( box.GetX() + box.GetWidth(), box.GetY() ) );
    SEG bottomline = SEG( VECTOR2I( box.GetX() + box.GetWidth(), box.GetY() ),
             box.GetOrigin() );
    SEG leftline = SEG( box.GetOrigin(), VECTOR2I( box.GetX(), box.GetY() + box.GetHeight() ) );

    const SHAPE_LINE_CHAIN& vertices = aConvex.Vertices();

    // top right diagonal
    VECTOR2I corner = box.GetOrigin() + box.GetSize();
    SEG toprightline = SEG( corner,
                            corner + VECTOR2I( box.GetHeight(), -box.GetHeight() ) );
    MoveDiagonal( toprightline, vertices, aClearance );

    // bottom right diagonal
    corner = box.GetOrigin() + VECTOR2I( box.GetWidth(), 0 );
    SEG bottomrightline = SEG( corner + VECTOR2I( box.GetHeight(), box.GetHeight() ),
                               corner );
    MoveDiagonal( bottomrightline, vertices, aClearance );

    // bottom left diagonal
    corner = box.GetOrigin();
    SEG bottomleftline = SEG( corner,
                              corner + VECTOR2I( -box.GetHeight(), box.GetHeight() ) );
    MoveDiagonal( bottomleftline, vertices, aClearance );

    // top left diagonal
    corner = box.GetOrigin() + VECTOR2I( 0, box.GetHeight() );
    SEG topleftline = SEG( corner + VECTOR2I( -box.GetHeight(), -box.GetHeight() ),
                           corner );
    MoveDiagonal( topleftline, vertices, aClearance );

    SHAPE_LINE_CHAIN octagon;
    octagon.SetClosed( true );

    octagon.Append( *leftline.IntersectLines( bottomleftline ) );
    octagon.Append( *bottomline.IntersectLines( bottomleftline ) );
    octagon.Append( *bottomline.IntersectLines( bottomrightline ) );
    octagon.Append( *rightline.IntersectLines( bottomrightline ) );
    octagon.Append( *rightline.IntersectLines( toprightline ) );
    octagon.Append( *topline.IntersectLines( toprightline ) );
    octagon.Append( *topline.IntersectLines( topleftline ) );
    octagon.Append( *leftline.IntersectLines( topleftline ) );

    return octagon;
}

References SHAPE_LINE_CHAIN::Append(), SHAPE_SIMPLE::BBox(), BOX2< Vec >::GetHeight(), BOX2< Vec >::GetOrigin(), BOX2< Vec >::GetSize(), BOX2< Vec >::GetWidth(), BOX2< Vec >::GetX(), BOX2< Vec >::GetY(), HULL_MARGIN, SEG::IntersectLines(), MoveDiagonal(), BOX2< Vec >::Normalize(), SHAPE_LINE_CHAIN::SetClosed(), and SHAPE_SIMPLE::Vertices().

Referenced by PNS::SOLID::Hull().

coupledBypass()

bool PNS::coupledBypass	(	NODE *	aNode,
		DIFF_PAIR *	aPair,
		bool	aRefIsP,
		const SHAPE_LINE_CHAIN &	aRef,
		const SHAPE_LINE_CHAIN &	aRefBypass,
		const SHAPE_LINE_CHAIN &	aCoupled,
		SHAPE_LINE_CHAIN &	aNewCoupled
	)

Definition at line 1063 of file pns_optimizer.cpp.

{
    int vStartIdx[1024]; // fixme: possible overflow

    int nStarts = findCoupledVertices( aRefBypass.CPoint( 0 ), aRefBypass.CSegment( 0 ), aCoupled, aPair, vStartIdx );
    DIRECTION_45 dir( aRefBypass.CSegment( 0 ) );

    int64_t bestLength = -1;
    bool found = false;
    SHAPE_LINE_CHAIN bestBypass;
    int si, ei;

    for( int i=0; i< nStarts; i++ )
    {
        for( int j = 1; j < aCoupled.PointCount() - 1; j++ )
        {
            int delta = std::abs ( vStartIdx[i] - j );

            if( delta > 1 )
            {
                const VECTOR2I& vs = aCoupled.CPoint( vStartIdx[i] );
                SHAPE_LINE_CHAIN bypass = dir.BuildInitialTrace( vs, aCoupled.CPoint(j), dir.IsDiagonal() );

                int64_t coupledLength = aPair->CoupledLength( aRef, bypass );

                SHAPE_LINE_CHAIN newCoupled = aCoupled;

                si = vStartIdx[i];
                ei = j;

                if(si < ei)
                    newCoupled.Replace( si, ei, bypass );
                else
                    newCoupled.Replace( ei, si, bypass.Reverse() );

                if(coupledLength > bestLength && verifyDpBypass( aNode, aPair, aRefIsP, aRef, newCoupled) )
                {
                    bestBypass = newCoupled;
                    bestLength = coupledLength;
                    found = true;
                }
            }
        }
    }


    if( found )
        aNewCoupled = bestBypass;

    return found;
}

References abs, SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::CSegment(), findCoupledVertices(), i, SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN::Replace(), SHAPE_LINE_CHAIN::Reverse(), and verifyDpBypass().

Referenced by PNS::OPTIMIZER::mergeDpStep().

dragCornerInternal()

SHAPE_LINE_CHAIN PNS::dragCornerInternal	(	const SHAPE_LINE_CHAIN &	aOrigin,
		const VECTOR2I &	aP
	)

Definition at line 369 of file pns_line.cpp.

{
    OPT<SHAPE_LINE_CHAIN> picked;
    int i;
    int d = 2;

    if( aOrigin.SegmentCount() == 1)
    {
        DIRECTION_45 dir( aOrigin.CPoint( 0 ) - aOrigin.CPoint( 1 ) );

        return DIRECTION_45().BuildInitialTrace( aOrigin.CPoint( 0 ), aP, dir.IsDiagonal() );
    }

    if( aOrigin.CSegment( -1 ).Length() > 100000 * 30 ) // fixme: constant/parameter?
        d = 1;

    for( i = aOrigin.SegmentCount() - d; i >= 0; i-- )
    {
        DIRECTION_45 d_start( aOrigin.CSegment( i ) );
        VECTOR2I p_start = aOrigin.CPoint( i );
        SHAPE_LINE_CHAIN paths[2];
        DIRECTION_45 dirs[2];
        DIRECTION_45 d_prev = ( i > 0 ? DIRECTION_45( aOrigin.CSegment( i-1 ) ) : DIRECTION_45() );
        int dirCount = 0;

        for( int j = 0; j < 2; j++ )
        {
            paths[j] = d_start.BuildInitialTrace( p_start, aP, j );

            if( paths[j].SegmentCount() < 1 )
                continue;

            assert( dirCount < int( sizeof( dirs ) / sizeof( dirs[0] ) ) );

            dirs[dirCount] = DIRECTION_45( paths[j].CSegment( 0 ) );
            ++dirCount;
        }

        for( int j = 0; j < dirCount; j++ )
        {
            if( dirs[j] == d_start )
            {
                picked = paths[j];
                break;
            }
        }

        if( picked )
            break;

        for( int j = 0; j < dirCount; j++ )
        {
            if( dirs[j].IsObtuse( d_prev ) )
            {
                picked = paths[j];
                break;
            }
        }

        if( picked )
            break;
    }

    if( picked )
    {
        SHAPE_LINE_CHAIN path = aOrigin.Slice( 0, i );
        path.Append( *picked );

        return path;
    }

    DIRECTION_45 dir( aOrigin.CPoint( -1 ) - aOrigin.CPoint( -2 ) );

    return DIRECTION_45().BuildInitialTrace( aOrigin.CPoint( 0 ), aP, dir.IsDiagonal() );
}

References SHAPE_LINE_CHAIN::Append(), DIRECTION_45::BuildInitialTrace(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::CSegment(), i, SEG::Length(), SHAPE_LINE_CHAIN::SegmentCount(), and SHAPE_LINE_CHAIN::Slice().

Referenced by PNS::LINE::dragCorner45().

extendBox()

static void PNS::extendBox ( BOX2I &  aBox, bool &  aDefined, const VECTOR2I &  aP  )

static

Definition at line 860 of file pns_line.cpp.

{
    if( aDefined )
    {
        aBox.Merge( aP );
    }
    else
    {
        aBox = BOX2I( aP, VECTOR2I( 0, 0 ) );
        aDefined = true;
    }
}

References BOX2< Vec >::Merge().

Referenced by PNS::LINE::ChangedArea().

findCoupledVertices()

int PNS::findCoupledVertices	(	const VECTOR2I &	aVertex,
		const SEG &	aOrigSeg,
		const SHAPE_LINE_CHAIN &	aCoupled,
		DIFF_PAIR *	aPair,
		int *	aIndices
	)

Definition at line 1021 of file pns_optimizer.cpp.

{
    int count = 0;
    for ( int i = 0; i < aCoupled.SegmentCount(); i++ )
    {
        SEG s = aCoupled.CSegment( i );
        VECTOR2I projOverCoupled = s.LineProject ( aVertex );

        if( s.ApproxParallel ( aOrigSeg ) )
        {
            int64_t dist = ( projOverCoupled - aVertex ).EuclideanNorm() - aPair->Width();

            if( aPair->GapConstraint().Matches( dist ) )
            {
               *aIndices++ = i;
               count++;
            }
        }
    }

    return count;
}

References SEG::ApproxParallel(), SHAPE_LINE_CHAIN::CSegment(), dist, EuclideanNorm(), PNS::DIFF_PAIR::GapConstraint(), i, SEG::LineProject(), RANGED_NUM< T >::Matches(), SHAPE_LINE_CHAIN::SegmentCount(), and PNS::DIFF_PAIR::Width().

Referenced by coupledBypass().

findViaByHandle()

static VIA* PNS::findViaByHandle ( NODE *  aNode, const VIA_HANDLE &  handle  )

static

Definition at line 1340 of file pns_shove.cpp.

{
    JOINT* jt = aNode->FindJoint( handle.pos, handle.layers.Start(), handle.net );

    if( !jt )
        return nullptr;

    for( ITEM* item : jt->LinkList() )
    {
        if ( item->OfKind( ITEM::VIA_T )) 
        {
            if( item->Net() == handle.net && item->Layers().Overlaps(handle.layers) )
                return static_cast<VIA*>( item );
        }
    }

    return nullptr;
}

References PNS::NODE::FindJoint(), PNS::VIA_HANDLE::layers, PNS::JOINT::LinkList(), PNS::VIA_HANDLE::net, PNS::VIA_HANDLE::pos, LAYER_RANGE::Start(), and PNS::ITEM::VIA_T.

Referenced by PNS::SHOVE::ShoveDraggingVia().

ItemCast()

template<typename T , typename S >

std::unique_ptr< T > PNS::ItemCast

(

std::unique_ptr< S >

aPtr

)

Definition at line 262 of file pns_item.h.

{
    static_assert(std::is_base_of< ITEM, S >::value, "Need to be handed a ITEM!");
    static_assert(std::is_base_of< ITEM, T >::value, "Need to cast to an ITEM!");
    return std::unique_ptr< T >( static_cast<T*>(aPtr.release()) );
}

makeGapVector()

static VECTOR2I PNS::makeGapVector ( VECTOR2I  dir, int  length  )

static

Definition at line 411 of file pns_diff_pair.cpp.

{
    int l = length / 2;
    VECTOR2I rv;

    if( dir.EuclideanNorm() == 0 )
        return dir;

    do
    {
        rv = dir.Resize( l );
        l++;
    } while( ( rv * 2 ).EuclideanNorm() < length );

    return rv;
}

References EuclideanNorm(), VECTOR2< T >::EuclideanNorm(), and VECTOR2< T >::Resize().

Referenced by PNS::DP_GATEWAYS::buildDpContinuation(), PNS::DP_GATEWAYS::BuildForCursor(), PNS::DP_GATEWAYS::BuildFromPrimitivePair(), and PNS::DP_GATEWAYS::BuildGeneric().

MoveDiagonal()

static void PNS::MoveDiagonal ( SEG &  aDiagonal, const SHAPE_LINE_CHAIN &  aVertices, int  aClearance  )

static

Definition at line 89 of file pns_utils.cpp.

{
    int dist;

    aVertices.NearestPoint( aDiagonal, dist );
    dist -= HULL_MARGIN;
    VECTOR2I moveBy = ( aDiagonal.A - aDiagonal.B ).Perpendicular().Resize( dist - aClearance );
    aDiagonal.A += moveBy;
    aDiagonal.B += moveBy;
}

References SEG::A, SEG::B, dist, HULL_MARGIN, SHAPE_LINE_CHAIN::NearestPoint(), and VECTOR2< T >::Resize().

Referenced by ConvexHull().

OctagonalHull()

const SHAPE_LINE_CHAIN PNS::OctagonalHull	(	const VECTOR2I &	aP0,
		const VECTOR2I &	aSize,
		int	aClearance,
		int	aChamfer
	)

Various utility functions.

Definition at line 33 of file pns_utils.cpp.

{
    SHAPE_LINE_CHAIN s;

    s.SetClosed( true );

    s.Append( aP0.x - aClearance, aP0.y - aClearance + aChamfer );
    s.Append( aP0.x - aClearance + aChamfer, aP0.y - aClearance );
    s.Append( aP0.x + aSize.x + aClearance - aChamfer, aP0.y - aClearance );
    s.Append( aP0.x + aSize.x + aClearance, aP0.y - aClearance + aChamfer );
    s.Append( aP0.x + aSize.x + aClearance, aP0.y + aSize.y + aClearance - aChamfer );
    s.Append( aP0.x + aSize.x + aClearance - aChamfer, aP0.y + aSize.y + aClearance );
    s.Append( aP0.x - aClearance + aChamfer, aP0.y + aSize.y + aClearance );
    s.Append( aP0.x - aClearance, aP0.y + aSize.y + aClearance - aChamfer );

    return s;
}

References SHAPE_LINE_CHAIN::Append(), SHAPE_LINE_CHAIN::SetClosed(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PNS::SOLID::Hull(), and PNS::VIA::Hull().

operator==()

bool PNS::operator== ( JOINT::HASH_TAG const &  aP1, JOINT::HASH_TAG const &  aP2  )

inline

Definition at line 265 of file pns_joint.h.

{
    return aP1.pos == aP2.pos && aP1.net == aP2.net;
}

References PNS::JOINT::HASH_TAG::net, and PNS::JOINT::HASH_TAG::pos.

SegmentHull()

const SHAPE_LINE_CHAIN PNS::SegmentHull	(	const SHAPE_SEGMENT &	aSeg,
		int	aClearance,
		int	aWalkaroundThickness
	)

Definition at line 53 of file pns_utils.cpp.

{
    int d = aSeg.GetWidth() / 2 + aClearance + aWalkaroundThickness / 2 + HULL_MARGIN;
    int x = (int)( 2.0 / ( 1.0 + M_SQRT2 ) * d );

    const VECTOR2I a = aSeg.GetSeg().A;
    const VECTOR2I b = aSeg.GetSeg().B;

    VECTOR2I dir = b - a;
    VECTOR2I p0 = dir.Perpendicular().Resize( d );
    VECTOR2I ds = dir.Perpendicular().Resize( x / 2 );
    VECTOR2I pd = dir.Resize( x / 2 );
    VECTOR2I dp = dir.Resize( d );

    SHAPE_LINE_CHAIN s;

    s.SetClosed( true );

    s.Append( b + p0 + pd );
    s.Append( b + dp + ds );
    s.Append( b + dp - ds );
    s.Append( b - p0 + pd );
    s.Append( a - p0 - pd );
    s.Append( a - dp - ds );
    s.Append( a - dp + ds );
    s.Append( a + p0 - pd );

    // make sure the hull outline is always clockwise
    if( s.CSegment( 0 ).Side( a ) < 0 )
        return s.Reverse();
    else
        return s;
}

References SEG::A, SHAPE_LINE_CHAIN::Append(), SEG::B, SHAPE_LINE_CHAIN::CSegment(), SHAPE_SEGMENT::GetSeg(), SHAPE_SEGMENT::GetWidth(), HULL_MARGIN, VECTOR2< T >::Perpendicular(), VECTOR2< T >::Resize(), SHAPE_LINE_CHAIN::Reverse(), SHAPE_LINE_CHAIN::SetClosed(), and SEG::Side().

Referenced by PNS::SOLID::Hull(), and PNS::SEGMENT::Hull().

verifyDpBypass()

bool PNS::verifyDpBypass	(	NODE *	aNode,
		DIFF_PAIR *	aPair,
		bool	aRefIsP,
		const SHAPE_LINE_CHAIN &	aNewRef,
		const SHAPE_LINE_CHAIN &	aNewCoupled
	)

Definition at line 1045 of file pns_optimizer.cpp.

{
    LINE refLine ( aRefIsP ? aPair->PLine() : aPair->NLine(), aNewRef );
    LINE coupledLine ( aRefIsP ? aPair->NLine() : aPair->PLine(), aNewCoupled );

    if( aNode->CheckColliding( &refLine, &coupledLine, ITEM::ANY_T, aPair->Gap() - 10 ) )
        return false;

    if( aNode->CheckColliding ( &refLine ) )
        return false;

    if( aNode->CheckColliding ( &coupledLine ) )
        return false;

    return true;
}

References PNS::ITEM::ANY_T, PNS::NODE::CheckColliding(), PNS::DIFF_PAIR::Gap(), PNS::DIFF_PAIR::NLine(), and PNS::DIFF_PAIR::PLine().

Referenced by coupledBypass(), and PNS::OPTIMIZER::mergeDpStep().

Variable Documentation

HULL_MARGIN

constexpr int PNS::HULL_MARGIN = 10

Definition at line 34 of file pns_utils.h.

Referenced by ConvexHull(), MoveDiagonal(), and SegmentHull().

theRouter

ROUTER* PNS::theRouter

static

Definition at line 57 of file pns_router.cpp.

Referenced by PNS::ROUTER::GetInstance(), EDIT_TOOL::invokeInlineRouter(), EDIT_TOOL::isInteractiveDragEnabled(), PNS::ROUTER::ROUTER(), and PNS::ROUTER::~ROUTER().