Perform various optimizations of the lines being routed, attempting to make the lines shorter and less cornery. More...

#include <pns_optimizer.h>

Classes
struct	CACHE_VISITOR

struct	CACHED_ITEM

Public Types
enum	OptimizationEffort { MERGE_SEGMENTS = 0x01, SMART_PADS = 0x02, MERGE_OBTUSE = 0x04, FANOUT_CLEANUP = 0x08, KEEP_TOPOLOGY = 0x10, PRESERVE_VERTEX = 0x20, RESTRICT_VERTEX_RANGE = 0x40, MERGE_COLINEAR = 0x80, RESTRICT_AREA = 0x100, LIMIT_CORNER_COUNT = 0x200 }

Public Member Functions
	OPTIMIZER (NODE *aWorld)

	~OPTIMIZER ()
	A quick shortcut to optimize a line without creating and setting up an optimizer. More...

bool	Optimize (LINE aLine, LINE aResult=nullptr, LINE *aRoot=nullptr)

bool	Optimize (DIFF_PAIR *aPair)

void	SetWorld (NODE *aNode)

void	CacheRemove (ITEM *aItem)

void	ClearCache (bool aStaticOnly=false)

void	SetCollisionMask (int aMask)

void	SetEffortLevel (int aEffort)

void	SetPreserveVertex (const VECTOR2I &aV)

void	SetRestrictVertexRange (int aStart, int aEnd)

void	SetRestrictArea (const BOX2I &aArea, bool aStrict=true)

void	ClearConstraints ()

void	AddConstraint (OPT_CONSTRAINT *aConstraint)

Static Public Member Functions
static bool	Optimize (LINE aLine, int aEffortLevel, NODE aWorld, const VECTOR2I &aV=VECTOR2I(0, 0))

Private Types
typedef std::vector< SHAPE_LINE_CHAIN >	BREAKOUT_LIST

Private Member Functions
bool	mergeObtuse (LINE *aLine)

bool	mergeFull (LINE *aLine)

bool	mergeColinear (LINE *aLine)

bool	runSmartPads (LINE *aLine)

bool	mergeStep (LINE *aLine, SHAPE_LINE_CHAIN &aCurrentLine, int step)

bool	fanoutCleanup (LINE *aLine)

bool	mergeDpSegments (DIFF_PAIR *aPair)

bool	mergeDpStep (DIFF_PAIR *aPair, bool aTryP, int step)

bool	checkColliding (ITEM *aItem, bool aUpdateCache=true)

bool	checkColliding (LINE *aLine, const SHAPE_LINE_CHAIN &aOptPath)

void	cacheAdd (ITEM *aItem, bool aIsStatic)

void	removeCachedSegments (LINE *aLine, int aStartVertex=0, int aEndVertex=-1)

bool	checkConstraints (int aVertex1, int aVertex2, LINE *aOriginLine, const SHAPE_LINE_CHAIN &aCurrentPath, const SHAPE_LINE_CHAIN &aReplacement)

BREAKOUT_LIST	circleBreakouts (int aWidth, const SHAPE *aShape, bool aPermitDiagonal) const

BREAKOUT_LIST	rectBreakouts (int aWidth, const SHAPE *aShape, bool aPermitDiagonal) const

BREAKOUT_LIST	customBreakouts (int aWidth, const ITEM *aItem, bool aPermitDiagonal) const

BREAKOUT_LIST	computeBreakouts (int aWidth, const ITEM *aItem, bool aPermitDiagonal) const

int	smartPadsSingle (LINE aLine, ITEM aPad, bool aEnd, int aEndVertex)

ITEM *	findPadOrVia (int aLayer, int aNet, const VECTOR2I &aP) const

Private Attributes
SHAPE_INDEX_LIST< ITEM * >	m_cache

std::vector< OPT_CONSTRAINT * >	m_constraints

std::unordered_map< ITEM *, CACHED_ITEM >	m_cacheTags

NODE *	m_world

int	m_collisionKindMask

int	m_effortLevel

VECTOR2I	m_preservedVertex

std::pair< int, int >	m_restrictedVertexRange

BOX2I	m_restrictArea

bool	m_restrictAreaIsStrict

Static Private Attributes
static const int	MaxCachedItems = 256

Detailed Description

Perform various optimizations of the lines being routed, attempting to make the lines shorter and less cornery.

There are 3 kinds of optimizations so far:

Merging obtuse segments (MERGE_OBTUSE): tries to join together as many obtuse segments as possible without causing collisions.
Rerouting path between pair of line corners with a 2-segment "\__" line and iteratively repeating the procedure as long as the total cost of the line keeps decreasing.
"Smart Pads" - that is, rerouting pad/via exits to make them look nice (SMART_PADS).

Definition at line 94 of file pns_optimizer.h.

Member Typedef Documentation

◆ BREAKOUT_LIST

typedef std::vector<SHAPE_LINE_CHAIN> PNS::OPTIMIZER::BREAKOUT_LIST

private

Definition at line 162 of file pns_optimizer.h.

Member Enumeration Documentation

◆ OptimizationEffort

enum PNS::OPTIMIZER::OptimizationEffort

Enumerator
MERGE_SEGMENTS	Reduce corner cost iteratively.
SMART_PADS	Reroute pad exits.
MERGE_OBTUSE	Reduce corner cost by merging obtuse segments.
FANOUT_CLEANUP	Simplify pad-pad and pad-via connections if possible.
KEEP_TOPOLOGY
PRESERVE_VERTEX
RESTRICT_VERTEX_RANGE
MERGE_COLINEAR	Merge co-linear segments.
RESTRICT_AREA
LIMIT_CORNER_COUNT	Do not attempt to optimize if the resulting line's corner count is outside the predefined range.

Definition at line 97 of file pns_optimizer.h.

     {
         MERGE_SEGMENTS        = 0x01,   
         SMART_PADS            = 0x02,   
         MERGE_OBTUSE          = 0x04,   
         FANOUT_CLEANUP        = 0x08,   
         KEEP_TOPOLOGY         = 0x10,
         PRESERVE_VERTEX       = 0x20,
         RESTRICT_VERTEX_RANGE = 0x40,
         MERGE_COLINEAR        = 0x80,    
         RESTRICT_AREA         = 0x100,
         LIMIT_CORNER_COUNT    = 0x200  
     };

Constructor & Destructor Documentation

◆ OPTIMIZER()

PNS::OPTIMIZER::OPTIMIZER ( NODE * aWorld )

Definition at line 112 of file pns_optimizer.cpp.

                                    :
     m_world( aWorld ),
     m_collisionKindMask( ITEM::ANY_T ),
     m_effortLevel( MERGE_SEGMENTS ),
     m_restrictAreaIsStrict( false )
 {
 }

◆ ~OPTIMIZER()

PNS::OPTIMIZER::~OPTIMIZER ( )

A quick shortcut to optimize a line without creating and setting up an optimizer.

Definition at line 121 of file pns_optimizer.cpp.

122 {

123 }

Member Function Documentation

◆ AddConstraint()

void PNS::OPTIMIZER::AddConstraint ( OPT_CONSTRAINT * aConstraint )

Definition at line 425 of file pns_optimizer.cpp.

 {
     m_constraints.push_back( aConstraint );
 }

References m_constraints.

Referenced by Optimize().

◆ cacheAdd()

void PNS::OPTIMIZER::cacheAdd	(	ITEM *	aItem,
		bool	aIsStatic = `false`
	)

private

Definition at line 154 of file pns_optimizer.cpp.

 {
     if( m_cacheTags.find( aItem ) != m_cacheTags.end() )
         return;
 
     m_cache.Add( aItem );
     m_cacheTags[aItem].m_hits = 1;
     m_cacheTags[aItem].m_isStatic = aIsStatic;
 }

References m_cache, and m_cacheTags.

◆ CacheRemove()

void PNS::OPTIMIZER::CacheRemove ( ITEM * aItem )

Definition at line 184 of file pns_optimizer.cpp.

 {
     if( aItem->Kind() == ITEM::LINE_T )
         removeCachedSegments( static_cast<LINE*>( aItem ) );
 }

References PNS::ITEM::Kind(), PNS::ITEM::LINE_T, and removeCachedSegments().

◆ checkColliding() [1/2]

bool PNS::OPTIMIZER::checkColliding	(	ITEM *	aItem,
		bool	aUpdateCache = `true`
	)

private

Definition at line 408 of file pns_optimizer.cpp.

 {
     CACHE_VISITOR v( aItem, m_world, m_collisionKindMask );
 
     return static_cast<bool>( m_world->CheckColliding( aItem ) );
 }

References PNS::NODE::CheckColliding(), m_collisionKindMask, and m_world.

Referenced by checkColliding(), mergeObtuse(), mergeStep(), and smartPadsSingle().

◆ checkColliding() [2/2]

bool PNS::OPTIMIZER::checkColliding	(	LINE *	aLine,
		const SHAPE_LINE_CHAIN &	aOptPath
	)

private

Definition at line 445 of file pns_optimizer.cpp.

 {
     LINE tmp( *aLine, aOptPath );
 
     return checkColliding( &tmp );
 }

References checkColliding().

◆ checkConstraints()

bool PNS::OPTIMIZER::checkConstraints	(	int	aVertex1,
		int	aVertex2,
		LINE *	aOriginLine,
		const SHAPE_LINE_CHAIN &	aCurrentPath,
		const SHAPE_LINE_CHAIN &	aReplacement
	)

private

Definition at line 431 of file pns_optimizer.cpp.

 {
     for( OPT_CONSTRAINT* c : m_constraints )
     {
         if( !c->Check( aVertex1, aVertex2, aOriginLine, aCurrentPath, aReplacement ) )
             return false;
     }
 
     return true;
 }

References m_constraints.

Referenced by mergeStep().

◆ circleBreakouts()

OPTIMIZER::BREAKOUT_LIST PNS::OPTIMIZER::circleBreakouts	(	int	aWidth,
		const SHAPE *	aShape,
		bool	aPermitDiagonal
	)		const

private

Definition at line 749 of file pns_optimizer.cpp.

 {
     BREAKOUT_LIST breakouts;
 
     for( int angle = 0; angle < 360; angle += 45 )
     {
         const SHAPE_CIRCLE* cir = static_cast<const SHAPE_CIRCLE*>( aShape );
         SHAPE_LINE_CHAIN    l;
         VECTOR2I            p0 = cir->GetCenter();
         VECTOR2I            v0( cir->GetRadius() * M_SQRT2, 0 );
 
         l.Append( p0 );
         l.Append( p0 + v0.Rotate( angle * M_PI / 180.0 ) );
         breakouts.push_back( l );
     }
 
     return breakouts;
 }

References PNS::angle(), SHAPE_LINE_CHAIN::Append(), SHAPE_CIRCLE::GetCenter(), SHAPE_CIRCLE::GetRadius(), and VECTOR2< T >::Rotate().

Referenced by computeBreakouts().

◆ ClearCache()

void PNS::OPTIMIZER::ClearCache ( bool aStaticOnly = false )

Definition at line 191 of file pns_optimizer.cpp.

 {
     if( !aStaticOnly )
     {
         m_cacheTags.clear();
         m_cache.Clear();
         return;
     }
 
     for( auto i = m_cacheTags.begin(); i!= m_cacheTags.end(); ++i )
     {
         if( i->second.m_isStatic )
         {
             m_cache.Remove( i->first );
             m_cacheTags.erase( i->first );
         }
     }
 }

References m_cache, and m_cacheTags.

◆ ClearConstraints()

void PNS::OPTIMIZER::ClearConstraints ( )

Definition at line 416 of file pns_optimizer.cpp.

 {
     for( OPT_CONSTRAINT* c : m_constraints )
         delete c;
 
     m_constraints.clear();
 }

References m_constraints.

◆ computeBreakouts()

OPTIMIZER::BREAKOUT_LIST PNS::OPTIMIZER::computeBreakouts	(	int	aWidth,
		const ITEM *	aItem,
		bool	aPermitDiagonal
	)		const

private

Definition at line 868 of file pns_optimizer.cpp.

 {
     switch( aItem->Kind() )
     {
     case ITEM::VIA_T:
     {
         const VIA* via = static_cast<const VIA*>( aItem );
         return circleBreakouts( aWidth, via->Shape(), aPermitDiagonal );
     }
 
     case ITEM::SOLID_T:
     {
         const SHAPE* shape = aItem->Shape();
 
         switch( shape->Type() )
         {
         case SH_RECT:
             return rectBreakouts( aWidth, shape, aPermitDiagonal );
 
         case SH_SEGMENT:
         {
             const SHAPE_SEGMENT* seg = static_cast<const SHAPE_SEGMENT*> (shape);
             const SHAPE_RECT rect = ApproximateSegmentAsRect ( *seg );
             return rectBreakouts( aWidth, &rect, aPermitDiagonal );
         }
 
         case SH_CIRCLE:
             return circleBreakouts( aWidth, shape, aPermitDiagonal );
 
         case SH_SIMPLE:
             return customBreakouts( aWidth, aItem, aPermitDiagonal );
 
         default:
             break;
         }
 
         break;
     }
 
     default:
         break;
     }
 
     return BREAKOUT_LIST();
 }

References PNS::ApproximateSegmentAsRect(), circleBreakouts(), customBreakouts(), PNS::ITEM::Kind(), rectBreakouts(), SH_CIRCLE, SH_RECT, SH_SEGMENT, SH_SIMPLE, PNS::ITEM::Shape(), PNS::ITEM::SOLID_T, SHAPE_BASE::Type(), via, and PNS::ITEM::VIA_T.

Referenced by smartPadsSingle().

◆ customBreakouts()

OPTIMIZER::BREAKOUT_LIST PNS::OPTIMIZER::customBreakouts	(	int	aWidth,
		const ITEM *	aItem,
		bool	aPermitDiagonal
	)		const

private

Definition at line 770 of file pns_optimizer.cpp.

 {
     BREAKOUT_LIST breakouts;
     const SHAPE_SIMPLE* convex = static_cast<const SHAPE_SIMPLE*>( aItem->Shape() );
 
     BOX2I bbox = convex->BBox( 0 );
     VECTOR2I p0 = static_cast<const SOLID*>( aItem )->Pos();
     // must be large enough to guarantee intersecting the convex polygon
     int length = std::max( bbox.GetWidth(), bbox.GetHeight() ) / 2 + 5;
 
     for( int angle = 0; angle < 360; angle += ( aPermitDiagonal ? 45 : 90 ) )
     {
         SHAPE_LINE_CHAIN l;
         VECTOR2I v0( p0 + VECTOR2I( length, 0 ).Rotate( angle * M_PI / 180.0 ) );
         SHAPE_LINE_CHAIN::INTERSECTIONS intersections;
         int n = convex->Vertices().Intersect( SEG( p0, v0 ), intersections );
 
         // if n == 1 intersected a segment
         // if n == 2 intersected the common point of 2 segments
         // n == 0 can not happen I think, but...
         if( n > 0 )
         {
             l.Append( p0 );
 
             // for a breakout distance relative to the distance between
             // center and polygon edge
             //l.Append( intersections[0].p + (v0 - p0).Resize( (intersections[0].p - p0).EuclideanNorm() * 0.4 ) );
 
             // for an absolute breakout distance, e.g. 0.1 mm
             //l.Append( intersections[0].p + (v0 - p0).Resize( 100000 ) );
 
             // for the breakout right on the polygon edge
             l.Append( intersections[0].p );
 
             breakouts.push_back( l );
         }
     }
 
     return breakouts;
 }

References PNS::angle(), SHAPE_LINE_CHAIN::Append(), SHAPE_SIMPLE::BBox(), SHAPE_LINE_CHAIN::Intersect(), PNS::ITEM::Shape(), and SHAPE_SIMPLE::Vertices().

Referenced by computeBreakouts().

◆ fanoutCleanup()

bool PNS::OPTIMIZER::fanoutCleanup ( LINE * aLine )

private

Definition at line 1095 of file pns_optimizer.cpp.

 {
     if( aLine->PointCount() < 3 )
         return false;
 
     VECTOR2I p_start = aLine->CPoint( 0 ), p_end = aLine->CPoint( -1 );
 
     ITEM* startPad = findPadOrVia( aLine->Layer(), aLine->Net(), p_start );
     ITEM* endPad = findPadOrVia( aLine->Layer(), aLine->Net(), p_end );
 
     int thr = aLine->Width() * 10;
     int len = aLine->CLine().Length();
 
     if( !startPad )
         return false;
 
     bool startMatch = startPad->OfKind( ITEM::VIA_T | ITEM::SOLID_T );
     bool endMatch = false;
 
     if(endPad)
     {
         endMatch = endPad->OfKind( ITEM::VIA_T | ITEM::SOLID_T );
     }
     else
     {
         endMatch = aLine->EndsWithVia();
     }
 
     if( startMatch && endMatch && len < thr )
     {
         for( int i = 0; i < 2; i++ )
         {
             SHAPE_LINE_CHAIN l2 = DIRECTION_45().BuildInitialTrace( p_start, p_end, i );
             LINE repl;
             repl = LINE( *aLine, l2 );
 
             if( !m_world->CheckColliding( &repl ) )
             {
                 aLine->SetShape( repl.CLine() );
                 return true;
             }
         }
     }
 
     return false;
 }

References DIRECTION_45::BuildInitialTrace(), PNS::NODE::CheckColliding(), PNS::LINE::CLine(), PNS::LINE::CPoint(), PNS::LINE::EndsWithVia(), findPadOrVia(), PNS::ITEM::Layer(), SHAPE_LINE_CHAIN::Length(), m_world, PNS::ITEM::Net(), PNS::ITEM::OfKind(), PNS::LINE::PointCount(), PNS::LINE::SetShape(), PNS::ITEM::SOLID_T, PNS::ITEM::VIA_T, and PNS::LINE::Width().

Referenced by Optimize().

◆ findPadOrVia()

ITEM * PNS::OPTIMIZER::findPadOrVia	(	int	aLayer,
		int	aNet,
		const VECTOR2I &	aP
	)		const

private

Definition at line 916 of file pns_optimizer.cpp.

 {
     JOINT* jt = m_world->FindJoint( aP, aLayer, aNet );
 
     if( !jt )
         return nullptr;
 
     for( ITEM* item : jt->LinkList() )
     {
         if( item->OfKind( ITEM::VIA_T | ITEM::SOLID_T ) )
             return item;
     }
 
     return nullptr;
 }

References PNS::NODE::FindJoint(), PNS::JOINT::LinkList(), m_world, PNS::ITEM::SOLID_T, and PNS::ITEM::VIA_T.

Referenced by fanoutCleanup(), and runSmartPads().

◆ mergeColinear()

bool PNS::OPTIMIZER::mergeColinear ( LINE * aLine )

private

Definition at line 574 of file pns_optimizer.cpp.

 {
     SHAPE_LINE_CHAIN&          line   = aLine->Line();
 
     int nSegs = line.SegmentCount();
 
     for( int segIdx = 0; segIdx < line.SegmentCount() - 1; ++segIdx )
     {
         SEG s1 = line.CSegment( segIdx );
         SEG s2 = line.CSegment( segIdx + 1 );
 
         // Skip zero-length segs caused by abutting arcs
         if( s1.SquaredLength() == 0 || s2.SquaredLength() == 0 )
             continue;
 
         if( s1.Collinear( s2 ) )
         {
             // We should not see a collinear vertex inside an arc
             wxASSERT( !line.IsPtOnArc( segIdx + 1 ) );
             line.Remove( segIdx + 1 );
         }
     }
 
     return line.SegmentCount() < nSegs;
 }

References SEG::Collinear(), SHAPE_LINE_CHAIN::CSegment(), SHAPE_LINE_CHAIN::IsPtOnArc(), PNS::LINE::Line(), SHAPE_LINE_CHAIN::Remove(), SHAPE_LINE_CHAIN::SegmentCount(), and SEG::SquaredLength().

Referenced by Optimize().

◆ mergeDpSegments()

bool PNS::OPTIMIZER::mergeDpSegments ( DIFF_PAIR * aPair )

private

Definition at line 1317 of file pns_optimizer.cpp.

 {
     int step_p = aPair->CP().SegmentCount() - 2;
     int step_n = aPair->CN().SegmentCount() - 2;
 
     while( 1 )
     {
         int n_segs_p = aPair->CP().SegmentCount();
         int n_segs_n = aPair->CN().SegmentCount();
 
         int max_step_p = n_segs_p - 2;
         int max_step_n = n_segs_n - 2;
 
         if( step_p > max_step_p )
             step_p = max_step_p;
 
         if( step_n > max_step_n )
             step_n = max_step_n;
 
         if( step_p < 1 && step_n < 1 )
             break;
 
         bool found_anything_p = false;
         bool found_anything_n = false;
 
         if( step_p > 1 )
             found_anything_p = mergeDpStep( aPair, true, step_p );
 
         if( step_n > 1 )
             found_anything_n = mergeDpStep( aPair, false, step_n );
 
         if( !found_anything_n && !found_anything_p )
         {
             step_n--;
             step_p--;
         }
     }
     return true;
 }

References PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), mergeDpStep(), and SHAPE_LINE_CHAIN::SegmentCount().

Referenced by Optimize().

◆ mergeDpStep()

bool PNS::OPTIMIZER::mergeDpStep	(	DIFF_PAIR *	aPair,
		bool	aTryP,
		int	step
	)

private

Definition at line 1254 of file pns_optimizer.cpp.

 {
     int n = 1;
 
     SHAPE_LINE_CHAIN currentPath = aTryP ? aPair->CP() : aPair->CN();
     SHAPE_LINE_CHAIN coupledPath = aTryP ? aPair->CN() : aPair->CP();
 
     int n_segs = currentPath.SegmentCount() - 1;
 
     int64_t clenPre = aPair->CoupledLength( currentPath, coupledPath );
     int64_t budget = clenPre / 10; // fixme: come up with something more intelligent here...
 
     while( n < n_segs - step )
     {
         const SEG s1    = currentPath.CSegment( n );
         const SEG s2    = currentPath.CSegment( n + step );
 
         DIRECTION_45 dir1( s1 );
         DIRECTION_45 dir2( s2 );
 
         if( dir1.IsObtuse( dir2 ) )
         {
             SHAPE_LINE_CHAIN bypass = DIRECTION_45().BuildInitialTrace( s1.A, s2.B,
                                                                         dir1.IsDiagonal() );
             SHAPE_LINE_CHAIN newRef;
             SHAPE_LINE_CHAIN newCoup;
             int64_t deltaCoupled = -1, deltaUni = -1;
 
             newRef = currentPath;
             newRef.Replace( s1.Index(), s2.Index(), bypass );
 
             deltaUni = aPair->CoupledLength ( newRef, coupledPath ) - clenPre + budget;
 
             if( coupledBypass( m_world, aPair, aTryP, newRef, bypass, coupledPath, newCoup ) )
             {
                 deltaCoupled = aPair->CoupledLength( newRef, newCoup ) - clenPre + budget;
 
                 if( deltaCoupled >= 0 )
                 {
                     newRef.Simplify();
                     newCoup.Simplify();
 
                     aPair->SetShape( newRef, newCoup, !aTryP );
                     return true;
                 }
             }
             else if( deltaUni >= 0 && verifyDpBypass( m_world, aPair, aTryP, newRef, coupledPath ) )
             {
                 newRef.Simplify();
                 coupledPath.Simplify();
 
                 aPair->SetShape( newRef, coupledPath, !aTryP );
                 return true;
             }
         }
 
         n++;
     }
 
     return false;
 }

References SEG::A, SEG::B, DIRECTION_45::BuildInitialTrace(), PNS::DIFF_PAIR::CN(), PNS::coupledBypass(), PNS::DIFF_PAIR::CoupledLength(), PNS::DIFF_PAIR::CP(), SHAPE_LINE_CHAIN::CSegment(), SEG::Index(), DIRECTION_45::IsDiagonal(), DIRECTION_45::IsObtuse(), m_world, SHAPE_LINE_CHAIN::Replace(), SHAPE_LINE_CHAIN::SegmentCount(), PNS::DIFF_PAIR::SetShape(), SHAPE_LINE_CHAIN::Simplify(), and PNS::verifyDpBypass().

Referenced by mergeDpSegments().

◆ mergeFull()

bool PNS::OPTIMIZER::mergeFull ( LINE * aLine )

private

Definition at line 534 of file pns_optimizer.cpp.

 {
     SHAPE_LINE_CHAIN& line = aLine->Line();
     int step = line.SegmentCount() - 1;
 
     int segs_pre = line.SegmentCount();
 
     line.Simplify();
 
     if( step < 0 )
         return false;
 
     SHAPE_LINE_CHAIN current_path( line );
 
     while( 1 )
     {
         int n_segs = current_path.SegmentCount();
         int max_step = n_segs - 2;
 
         if( step > max_step )
             step = max_step;
 
         if( step < 1 )
             break;
 
         bool found_anything = mergeStep( aLine, current_path, step );
 
         if( !found_anything )
             step--;
 
         if( !step )
             break;
     }
 
     aLine->SetShape( current_path );
 
     return current_path.SegmentCount() < segs_pre;
 }

References PNS::LINE::Line(), mergeStep(), SHAPE_LINE_CHAIN::SegmentCount(), PNS::LINE::SetShape(), and SHAPE_LINE_CHAIN::Simplify().

Referenced by Optimize().

◆ mergeObtuse()

bool PNS::OPTIMIZER::mergeObtuse ( LINE * aLine )

private

Definition at line 453 of file pns_optimizer.cpp.

 {
     SHAPE_LINE_CHAIN& line = aLine->Line();
 
     int step = line.PointCount() - 3;
     int iter = 0;
     int segs_pre = line.SegmentCount();
 
     if( step < 0 )
         return false;
 
     SHAPE_LINE_CHAIN current_path( line );
 
     while( 1 )
     {
         iter++;
         int n_segs = current_path.SegmentCount();
         int max_step = n_segs - 2;
 
         if( step > max_step )
             step = max_step;
 
         if( step < 2 )
         {
             line = current_path;
             return current_path.SegmentCount() < segs_pre;
         }
 
         bool found_anything = false;
 
         for( int n = 0; n < n_segs - step; n++ )
         {
             const SEG s1 = current_path.CSegment( n );
             const SEG s2 = current_path.CSegment( n + step );
             SEG s1opt, s2opt;
 
             if( DIRECTION_45( s1 ).IsObtuse( DIRECTION_45( s2 ) ) )
             {
                 VECTOR2I ip = *s1.IntersectLines( s2 );
 
                 s1opt = SEG( s1.A, ip );
                 s2opt = SEG( ip, s2.B );
 
                 if( DIRECTION_45( s1opt ).IsObtuse( DIRECTION_45( s2opt ) ) )
                 {
                     SHAPE_LINE_CHAIN opt_path;
                     opt_path.Append( s1opt.A );
                     opt_path.Append( s1opt.B );
                     opt_path.Append( s2opt.B );
 
                     LINE opt_track( *aLine, opt_path );
 
                     if( !checkColliding( &opt_track ) )
                     {
                         current_path.Replace( s1.Index() + 1, s2.Index(), ip );
 
                         // removeCachedSegments(aLine, s1.Index(), s2.Index());
                         n_segs = current_path.SegmentCount();
                         found_anything = true;
                         break;
                     }
                 }
             }
          }
 
         if( !found_anything )
         {
             if( step <= 2 )
             {
                 line = current_path;
                 return line.SegmentCount() < segs_pre;
             }
 
             step--;
         }
     }
 
     return line.SegmentCount() < segs_pre;
 }

References SEG::A, SHAPE_LINE_CHAIN::Append(), SEG::B, checkColliding(), SHAPE_LINE_CHAIN::CSegment(), SEG::Index(), SEG::IntersectLines(), PNS::LINE::Line(), SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN::Replace(), and SHAPE_LINE_CHAIN::SegmentCount().

Referenced by Optimize().

◆ mergeStep()

bool PNS::OPTIMIZER::mergeStep	(	LINE *	aLine,
		SHAPE_LINE_CHAIN &	aCurrentLine,
		int	step
	)

private

Definition at line 681 of file pns_optimizer.cpp.

 {
     int n_segs = aCurrentPath.SegmentCount();
 
     int cost_orig = COST_ESTIMATOR::CornerCost( aCurrentPath );
 
     if( aLine->SegmentCount() < 2 )
         return false;
 
     DIRECTION_45 orig_start( aLine->CSegment( 0 ) );
     DIRECTION_45 orig_end( aLine->CSegment( -1 ) );
 
 
     for( int n = 0; n < n_segs - step; n++ )
     {
         // Do not attempt to merge false segments that are part of an arc
         if( aCurrentPath.IsArcSegment( n )
             || aCurrentPath.IsArcSegment( static_cast<std::size_t>( n ) + step ) )
         {
             continue;
         }
 
         const SEG s1    = aCurrentPath.CSegment( n );
         const SEG s2    = aCurrentPath.CSegment( n + step );
 
         SHAPE_LINE_CHAIN path[2];
         SHAPE_LINE_CHAIN* picked = nullptr;
         int cost[2];
 
         for( int i = 0; i < 2; i++ )
         {
             SHAPE_LINE_CHAIN bypass = DIRECTION_45().BuildInitialTrace( s1.A, s2.B, i );
             cost[i] = INT_MAX;
 
             bool ok = false;
 
             if( !checkColliding( aLine, bypass ) )
             {
                 //printf("Chk-constraints: %d %d\n", n, n+step+1 );
                 ok = checkConstraints ( n, n + step + 1, aLine, aCurrentPath, bypass );
             }
 
             if( ok )
             {
                 path[i] = aCurrentPath;
                 path[i].Replace( s1.Index(), s2.Index(), bypass );
                 path[i].Simplify();
                 cost[i] = COST_ESTIMATOR::CornerCost( path[i] );
             }
         }
 
         if( cost[0] < cost_orig && cost[0] < cost[1] )
             picked = &path[0];
         else if( cost[1] < cost_orig )
             picked = &path[1];
 
         if( picked )
         {
             n_segs = aCurrentPath.SegmentCount();
             aCurrentPath = *picked;
             return true;
         }
     }
 
     return false;
 }

References SEG::A, SEG::B, DIRECTION_45::BuildInitialTrace(), checkColliding(), checkConstraints(), PNS::COST_ESTIMATOR::CornerCost(), PNS::LINE::CSegment(), SHAPE_LINE_CHAIN::CSegment(), SEG::Index(), SHAPE_LINE_CHAIN::IsArcSegment(), path, PNS::LINE::SegmentCount(), and SHAPE_LINE_CHAIN::SegmentCount().

Referenced by mergeFull().

◆ Optimize() [1/3]

bool PNS::OPTIMIZER::Optimize	(	LINE *	aLine,
		int	aEffortLevel,
		NODE *	aWorld,
		const VECTOR2I &	aV = `VECTOR2I(0, 0)`
	)

static

Definition at line 1081 of file pns_optimizer.cpp.

 {
     OPTIMIZER opt( aWorld );
 
     opt.SetEffortLevel( aEffortLevel );
     opt.SetCollisionMask( -1 );
 
     if( aEffortLevel & OPTIMIZER::PRESERVE_VERTEX )
         opt.SetPreserveVertex( aV );
 
     return opt.Optimize( aLine );
 }

References Optimize(), PRESERVE_VERTEX, SetCollisionMask(), SetEffortLevel(), and SetPreserveVertex().

Referenced by Optimize(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::LINE_PLACER::optimizeTailHeadTransition(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::WALKAROUND::Route(), PNS::SHOVE::runOptimizer(), PNS::LINE_PLACER::simplifyNewLine(), and PNS::DIFF_PAIR_PLACER::tryWalkDp().

◆ Optimize() [2/3]

bool PNS::OPTIMIZER::Optimize	(	LINE *	aLine,
		LINE *	aResult = `nullptr`,
		LINE *	aRoot = `nullptr`
	)

Definition at line 601 of file pns_optimizer.cpp.

 {
     DEBUG_DECORATOR* dbg = ROUTER::GetInstance()->GetInterface()->GetDebugDecorator();
 
     if( aRoot )
     {
         PNS_DBG( dbg, AddLine, aRoot->CLine(), BLUE, 100000, "root-line" );
     }
 
 
     if( !aResult )
     {
         aResult = aLine;
     }
     else
     {
         *aResult = *aLine;
         aResult->ClearLinks();
     }
 
     bool hasArcs = aLine->ArcCount();
     bool rv = false;
 
     if( (m_effortLevel & LIMIT_CORNER_COUNT) && aRoot )
     {
         const int angleMask = DIRECTION_45::ANG_OBTUSE;
         int rootObtuseCorners = aRoot->CountCorners( angleMask );
         auto c = new CORNER_COUNT_LIMIT_CONSTRAINT( m_world, rootObtuseCorners,
                                                     aLine->SegmentCount(), angleMask );
         AddConstraint( c );
     }
 
     if( m_effortLevel & PRESERVE_VERTEX )
     {
         auto c = new PRESERVE_VERTEX_CONSTRAINT( m_world, m_preservedVertex );
         AddConstraint( c );
     }
 
     if( m_effortLevel & RESTRICT_VERTEX_RANGE )
     {
         auto c = new RESTRICT_VERTEX_RANGE_CONSTRAINT( m_world, m_restrictedVertexRange.first,
                                                        m_restrictedVertexRange.second );
         AddConstraint( c );
     }
 
     if( m_effortLevel & RESTRICT_AREA )
     {
         auto c = new AREA_CONSTRAINT( m_world, m_restrictArea, m_restrictAreaIsStrict );
         AddConstraint( c );
     }
 
     if( m_effortLevel & KEEP_TOPOLOGY )
     {
         auto c = new KEEP_TOPOLOGY_CONSTRAINT( m_world );
         AddConstraint( c );
     }
 
     // TODO: Fix for arcs
     if( !hasArcs && m_effortLevel & MERGE_SEGMENTS )
         rv |= mergeFull( aResult );
 
     // TODO: Fix for arcs
     if( !hasArcs && m_effortLevel & MERGE_OBTUSE )
         rv |= mergeObtuse( aResult );
 
     if( m_effortLevel & MERGE_COLINEAR )
         rv |= mergeColinear( aResult );
 
     // TODO: Fix for arcs
     if( !hasArcs && m_effortLevel & SMART_PADS )
         rv |= runSmartPads( aResult );
 
     // TODO: Fix for arcs
     if( !hasArcs && m_effortLevel & FANOUT_CLEANUP )
         rv |= fanoutCleanup( aResult );
 
     return rv;
 }

References AddConstraint(), DIRECTION_45::ANG_OBTUSE, PNS::LINE::ArcCount(), BLUE, PNS::LINK_HOLDER::ClearLinks(), PNS::LINE::CLine(), PNS::LINE::CountCorners(), FANOUT_CLEANUP, fanoutCleanup(), PNS::ROUTER_IFACE::GetDebugDecorator(), PNS::ROUTER::GetInstance(), PNS::ROUTER::GetInterface(), KEEP_TOPOLOGY, LIMIT_CORNER_COUNT, m_effortLevel, m_preservedVertex, m_restrictArea, m_restrictAreaIsStrict, m_restrictedVertexRange, m_world, MERGE_COLINEAR, MERGE_OBTUSE, MERGE_SEGMENTS, mergeColinear(), mergeFull(), mergeObtuse(), PNS_DBG, PRESERVE_VERTEX, RESTRICT_AREA, RESTRICT_VERTEX_RANGE, runSmartPads(), PNS::LINE::SegmentCount(), and SMART_PADS.

◆ Optimize() [3/3]

bool PNS::OPTIMIZER::Optimize ( DIFF_PAIR * aPair )

Definition at line 1358 of file pns_optimizer.cpp.

 {
     return mergeDpSegments( aPair );
 }

References mergeDpSegments().

◆ rectBreakouts()

OPTIMIZER::BREAKOUT_LIST PNS::OPTIMIZER::rectBreakouts	(	int	aWidth,
		const SHAPE *	aShape,
		bool	aPermitDiagonal
	)		const

private

Definition at line 813 of file pns_optimizer.cpp.

 {
     const SHAPE_RECT* rect = static_cast<const SHAPE_RECT*>(aShape);
     VECTOR2I s = rect->GetSize();
     VECTOR2I c = rect->GetPosition() + VECTOR2I( s.x / 2, s.y / 2 );
     BREAKOUT_LIST breakouts;
 
     VECTOR2I d_offset;
 
     d_offset.x = ( s.x > s.y ) ? ( s.x - s.y ) / 2 : 0;
     d_offset.y = ( s.x < s.y ) ? ( s.y - s.x ) / 2 : 0;
 
     VECTOR2I d_vert  = VECTOR2I( 0, s.y / 2 + aWidth );
     VECTOR2I d_horiz = VECTOR2I( s.x / 2 + aWidth, 0 );
 
     breakouts.emplace_back( SHAPE_LINE_CHAIN( { c, c + d_horiz } ) );
     breakouts.emplace_back( SHAPE_LINE_CHAIN( { c, c - d_horiz } ) );
     breakouts.emplace_back( SHAPE_LINE_CHAIN( { c, c + d_vert } ) );
     breakouts.emplace_back( SHAPE_LINE_CHAIN( { c, c - d_vert } ) );
 
     if( aPermitDiagonal )
     {
         int l = aWidth + std::min( s.x, s.y ) / 2;
         VECTOR2I d_diag;
 
         if( s.x >= s.y )
         {
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c + d_offset, c + d_offset + VECTOR2I( l, l ) } ) );
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c + d_offset, c + d_offset - VECTOR2I( -l, l ) } ) );
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c - d_offset, c - d_offset + VECTOR2I( -l, l ) } ) );
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c - d_offset, c - d_offset - VECTOR2I( l, l ) } ) );
         }
         else
         {
             // fixme: this could be done more efficiently
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c + d_offset, c + d_offset + VECTOR2I( l, l ) } ) );
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c - d_offset, c - d_offset - VECTOR2I( -l, l ) } ) );
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c + d_offset, c + d_offset + VECTOR2I( -l, l ) } ) );
             breakouts.emplace_back(
                     SHAPE_LINE_CHAIN( { c, c - d_offset, c - d_offset - VECTOR2I( l, l ) } ) );
         }
     }
 
     return breakouts;
 }

References SHAPE_RECT::GetPosition(), SHAPE_RECT::GetSize(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by computeBreakouts().

◆ removeCachedSegments()

void PNS::OPTIMIZER::removeCachedSegments	(	LINE *	aLine,
		int	aStartVertex = `0`,
		int	aEndVertex = `-1`
	)

private

Definition at line 165 of file pns_optimizer.cpp.

 {
     if( !aLine->IsLinked() )
         return;
 
     auto links = aLine->Links();
 
     if( aEndVertex < 0 )
         aEndVertex += aLine->PointCount();
 
     for( int i = aStartVertex; i < aEndVertex - 1; i++ )
     {
         LINKED_ITEM* s = links[i];
         m_cacheTags.erase( s );
         m_cache.Remove( s );
     }
 }

References PNS::LINK_HOLDER::IsLinked(), PNS::LINK_HOLDER::Links(), m_cache, m_cacheTags, and PNS::LINE::PointCount().

Referenced by CacheRemove().

◆ runSmartPads()

bool PNS::OPTIMIZER::runSmartPads ( LINE * aLine )

private

Definition at line 1054 of file pns_optimizer.cpp.

 {
     SHAPE_LINE_CHAIN& line = aLine->Line();
 
     if( line.PointCount() < 3 )
         return false;
 
     VECTOR2I p_start = line.CPoint( 0 ), p_end = line.CPoint( -1 );
 
     ITEM* startPad = findPadOrVia( aLine->Layer(), aLine->Net(), p_start );
     ITEM* endPad = findPadOrVia( aLine->Layer(), aLine->Net(), p_end );
 
     int vtx = -1;
 
     if( startPad )
         vtx = smartPadsSingle( aLine, startPad, false, 3 );
 
     if( endPad )
         smartPadsSingle( aLine, endPad, true,
                          vtx < 0 ? line.PointCount() - 1 : line.PointCount() - 1 - vtx );
 
     aLine->Line().Simplify();
 
     return true;
 }

References SHAPE_LINE_CHAIN::CPoint(), findPadOrVia(), PNS::ITEM::Layer(), PNS::LINE::Line(), PNS::ITEM::Net(), SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN::Simplify(), and smartPadsSingle().

Referenced by Optimize().

◆ SetCollisionMask()

void PNS::OPTIMIZER::SetCollisionMask ( int aMask )

inline

Definition at line 127 of file pns_optimizer.h.

     {
         m_collisionKindMask = aMask;
     }

References m_collisionKindMask.

Referenced by Optimize(), PNS::LINE_PLACER::rhShoveOnly(), and PNS::SHOVE::runOptimizer().

◆ SetEffortLevel()

void PNS::OPTIMIZER::SetEffortLevel ( int aEffort )

inline

Definition at line 132 of file pns_optimizer.h.

     {
         m_effortLevel = aEffort;
     }

References m_effortLevel.

Referenced by Optimize(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::LINE_PLACER::rhShoveOnly(), and PNS::SHOVE::runOptimizer().

◆ SetPreserveVertex()

void PNS::OPTIMIZER::SetPreserveVertex ( const VECTOR2I & aV )

inline

Definition at line 137 of file pns_optimizer.h.

     {
         m_preservedVertex = aV;
         m_effortLevel |= OPTIMIZER::PRESERVE_VERTEX;
     }

References m_effortLevel, m_preservedVertex, and PRESERVE_VERTEX.

Referenced by Optimize(), and PNS::DRAGGER::optimizeAndUpdateDraggedLine().

◆ SetRestrictArea()

void PNS::OPTIMIZER::SetRestrictArea	(	const BOX2I &	aArea,
		bool	aStrict = `true`
	)

inline

Definition at line 150 of file pns_optimizer.h.

     {
         m_restrictArea = aArea;
         m_restrictAreaIsStrict = aStrict;
     }

References m_restrictArea, and m_restrictAreaIsStrict.

Referenced by PNS::DRAGGER::optimizeAndUpdateDraggedLine(), and PNS::SHOVE::runOptimizer().

◆ SetRestrictVertexRange()

void PNS::OPTIMIZER::SetRestrictVertexRange	(	int	aStart,
		int	aEnd
	)

inline

Definition at line 143 of file pns_optimizer.h.

     {
         m_restrictedVertexRange.first = aStart;
         m_restrictedVertexRange.second = aEnd;
         m_effortLevel |= OPTIMIZER::RESTRICT_VERTEX_RANGE;
     }

References m_effortLevel, m_restrictedVertexRange, and RESTRICT_VERTEX_RANGE.

◆ SetWorld()

void PNS::OPTIMIZER::SetWorld ( NODE * aNode )

inline

Definition at line 123 of file pns_optimizer.h.

123 { m_world = aNode; }

PNS::OPTIMIZER::m_world

NODE * m_world

Definition: pns_optimizer.h:205

References m_world.

Referenced by PNS::LINE_PLACER::rhShoveOnly().

◆ smartPadsSingle()

int PNS::OPTIMIZER::smartPadsSingle	(	LINE *	aLine,
		ITEM *	aPad,
		bool	aEnd,
		int	aEndVertex
	)

private

Definition at line 933 of file pns_optimizer.cpp.

 {
     DIRECTION_45 dir;
 
     const int ForbiddenAngles = DIRECTION_45::ANG_ACUTE | DIRECTION_45::ANG_RIGHT |
                                 DIRECTION_45::ANG_HALF_FULL | DIRECTION_45::ANG_UNDEFINED;
 
     typedef std::tuple<int, long long int, SHAPE_LINE_CHAIN> RtVariant;
     std::vector<RtVariant> variants;
 
     SOLID* solid = dyn_cast<SOLID*>( aPad );
 
     // don't do optimized connections for offset pads
     if( solid && solid->Offset() != VECTOR2I( 0, 0 ) )
         return -1;
 
     // don't do optimization on vias, they are always round at the moment and the optimizer
     // will possibly mess up an intended via exit posture
     if( aPad->Kind() == ITEM::VIA_T )
         return -1;
 
     BREAKOUT_LIST    breakouts = computeBreakouts( aLine->Width(), aPad, true );
     SHAPE_LINE_CHAIN line = ( aEnd ? aLine->CLine().Reverse() : aLine->CLine() );
     int              p_end = std::min( aEndVertex, std::min( 3, line.PointCount() - 1 ) );
 
     // Start at 1 to find a potentially better breakout (0 is the pad connection)
     for( int p = 1; p <= p_end; p++ )
     {
         // If the line is contained inside the pad, don't optimize
         if( solid && solid->Shape() && !solid->Shape()->Collide(
                 SEG( line.CPoint( 0 ), line.CPoint( p ) ), aLine->Width() / 2 ) )
         {
             continue;
         }
 
         for( SHAPE_LINE_CHAIN & breakout : breakouts )
         {
             for( int diag = 0; diag < 2; diag++ )
             {
                 SHAPE_LINE_CHAIN v;
                 SHAPE_LINE_CHAIN connect = dir.BuildInitialTrace(
                         breakout.CPoint( -1 ), line.CPoint( p ), diag == 0 );
 
                 DIRECTION_45 dir_bkout( breakout.CSegment( -1 ) );
 
                 if( !connect.SegmentCount() )
                     continue;
 
                 int ang1 = dir_bkout.Angle( DIRECTION_45( connect.CSegment( 0 ) ) );
 
                 if( ang1 & ForbiddenAngles )
                     continue;
 
                 if( breakout.Length() > line.Length() )
                     continue;
 
                 v = breakout;
                 v.Append( connect );
 
                 for( int i = p + 1; i < line.PointCount(); i++ )
                     v.Append( line.CPoint( i ) );
 
                 LINE tmp( *aLine, v );
                 int cc = tmp.CountCorners( ForbiddenAngles );
 
                 if( cc == 0 )
                 {
                     RtVariant vp;
                     std::get<0>( vp ) = p;
                     std::get<1>( vp ) = breakout.Length();
                     std::get<2>( vp ) = aEnd ? v.Reverse() : v;
                     std::get<2>( vp ).Simplify();
                     variants.push_back( vp );
                 }
             }
         }
     }
 
     // We attempt to minimize the corner cost (minimizes the segments and types of corners)
     // but given two, equally valid costs, we want to pick the longer pad exit.  The logic
     // here is that if the pad is oblong, the track should not exit the shorter side and parallel
     // the pad but should follow the pad's preferential direction before exiting.
     // The baseline guess is to start with the existing line the user has drawn.
     int              min_cost   = COST_ESTIMATOR::CornerCost( *aLine );
     long long int    max_length = 0;
     bool             found      = false;
     int              p_best     = -1;
     SHAPE_LINE_CHAIN l_best;
 
     for( RtVariant& vp : variants )
     {
         LINE tmp( *aLine, std::get<2>( vp ) );
         int cost = COST_ESTIMATOR::CornerCost( std::get<2>( vp ) );
         long long int len = std::get<1>( vp );
 
         if( !checkColliding( &tmp ) )
         {
             if( cost < min_cost || ( cost == min_cost && len > max_length ) )
             {
                 l_best = std::get<2>( vp );
                 p_best = std::get<0>( vp );
                 found  = true;
 
                 if( cost <= min_cost )
                     max_length = std::max<int>( len, max_length );
 
                 min_cost = std::min( cost, min_cost );
             }
         }
     }
 
     if( found )
     {
         aLine->SetShape( l_best );
         return p_best;
     }
 
     return -1;
 }

References DIRECTION_45::ANG_ACUTE, DIRECTION_45::ANG_HALF_FULL, DIRECTION_45::ANG_RIGHT, DIRECTION_45::ANG_UNDEFINED, DIRECTION_45::Angle(), SHAPE_LINE_CHAIN::Append(), DIRECTION_45::BuildInitialTrace(), checkColliding(), PNS::LINE::CLine(), SHAPE::Collide(), computeBreakouts(), PNS::COST_ESTIMATOR::CornerCost(), PNS::LINE::CountCorners(), SHAPE_LINE_CHAIN::CSegment(), PNS::ITEM::Kind(), PNS::SOLID::Offset(), SHAPE_LINE_CHAIN::Reverse(), SHAPE_LINE_CHAIN::SegmentCount(), PNS::LINE::SetShape(), PNS::SOLID::Shape(), SHAPE_LINE_CHAIN::Simplify(), PNS::ITEM::VIA_T, and PNS::LINE::Width().

Referenced by runSmartPads().

Member Data Documentation

◆ m_cache

SHAPE_INDEX_LIST<ITEM*> PNS::OPTIMIZER::m_cache

private

Definition at line 201 of file pns_optimizer.h.

Referenced by cacheAdd(), ClearCache(), and removeCachedSegments().

◆ m_cacheTags

std::unordered_map<ITEM*, CACHED_ITEM> PNS::OPTIMIZER::m_cacheTags

private

Definition at line 203 of file pns_optimizer.h.

Referenced by cacheAdd(), ClearCache(), and removeCachedSegments().

◆ m_collisionKindMask

int PNS::OPTIMIZER::m_collisionKindMask

private

Definition at line 206 of file pns_optimizer.h.

Referenced by checkColliding(), and SetCollisionMask().

◆ m_constraints

std::vector<OPT_CONSTRAINT*> PNS::OPTIMIZER::m_constraints

private

Definition at line 202 of file pns_optimizer.h.

Referenced by AddConstraint(), checkConstraints(), and ClearConstraints().

◆ m_effortLevel

int PNS::OPTIMIZER::m_effortLevel

private

Definition at line 207 of file pns_optimizer.h.

Referenced by Optimize(), SetEffortLevel(), SetPreserveVertex(), and SetRestrictVertexRange().

◆ m_preservedVertex

VECTOR2I PNS::OPTIMIZER::m_preservedVertex

private

Definition at line 209 of file pns_optimizer.h.

Referenced by Optimize(), and SetPreserveVertex().

◆ m_restrictArea

BOX2I PNS::OPTIMIZER::m_restrictArea

private

Definition at line 211 of file pns_optimizer.h.

Referenced by Optimize(), and SetRestrictArea().

◆ m_restrictAreaIsStrict

bool PNS::OPTIMIZER::m_restrictAreaIsStrict

private

Definition at line 212 of file pns_optimizer.h.

Referenced by Optimize(), and SetRestrictArea().

◆ m_restrictedVertexRange

std::pair<int, int> PNS::OPTIMIZER::m_restrictedVertexRange

private

Definition at line 210 of file pns_optimizer.h.

Referenced by Optimize(), and SetRestrictVertexRange().

◆ m_world

NODE* PNS::OPTIMIZER::m_world

private

Definition at line 205 of file pns_optimizer.h.

Referenced by checkColliding(), fanoutCleanup(), findPadOrVia(), mergeDpStep(), Optimize(), and SetWorld().

◆ MaxCachedItems

const int PNS::OPTIMIZER::MaxCachedItems = 256

staticprivate

Definition at line 160 of file pns_optimizer.h.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ BREAKOUT_LIST

Member Enumeration Documentation

◆ OptimizationEffort

Constructor & Destructor Documentation

◆ OPTIMIZER()

◆ ~OPTIMIZER()

Member Function Documentation

◆ AddConstraint()

◆ cacheAdd()

◆ CacheRemove()

◆ checkColliding() [1/2]

◆ checkColliding() [2/2]

◆ checkConstraints()

◆ circleBreakouts()

◆ ClearCache()

◆ ClearConstraints()

◆ computeBreakouts()

◆ customBreakouts()

◆ fanoutCleanup()

◆ findPadOrVia()

◆ mergeColinear()

◆ mergeDpSegments()

◆ mergeDpStep()

◆ mergeFull()

◆ mergeObtuse()

◆ mergeStep()

◆ Optimize() [1/3]

◆ Optimize() [2/3]

◆ Optimize() [3/3]

◆ rectBreakouts()

◆ removeCachedSegments()

◆ runSmartPads()

◆ SetCollisionMask()

◆ SetEffortLevel()

◆ SetPreserveVertex()

◆ SetRestrictArea()

◆ SetRestrictVertexRange()

◆ SetWorld()

◆ smartPadsSingle()

Member Data Documentation

◆ m_cache

◆ m_cacheTags

◆ m_collisionKindMask

◆ m_constraints

◆ m_effortLevel

◆ m_preservedVertex

◆ m_restrictArea

◆ m_restrictAreaIsStrict

◆ m_restrictedVertexRange

◆ m_world

◆ MaxCachedItems