A set of gateways calculated for the cursor or starting/ending primitive pair. More...

#include <pns_diff_pair.h>

Classes
struct	DP_CANDIDATE

Public Member Functions
	DP_GATEWAYS (int aGap)

void	Clear ()

void	SetFitVias (bool aEnable, int aDiameter=0, int aViaGap=-1)

void	BuildForCursor (const VECTOR2I &aCursorPos)

void	BuildOrthoProjections (DP_GATEWAYS &aEntries, const VECTOR2I &aCursorPos, int aOrthoScore)

void	BuildGeneric (const VECTOR2I &p0_p, const VECTOR2I &p0_n, bool aBuildEntries=false, bool aViaMode=false)

void	BuildFromPrimitivePair (const DP_PRIMITIVE_PAIR &aPair, bool aPreferDiagonal)

bool	FitGateways (DP_GATEWAYS &aEntry, DP_GATEWAYS &aTarget, bool aPrefDiagonal, DIFF_PAIR &aDp)

std::vector< DP_GATEWAY > &	Gateways ()

const std::vector< DP_GATEWAY > &	CGateways () const

void	FilterByOrientation (int aAngleMask, DIRECTION_45 aRefOrientation)

Private Member Functions
bool	checkDiagonalAlignment (const VECTOR2I &a, const VECTOR2I &b) const

void	buildDpContinuation (const DP_PRIMITIVE_PAIR &aPair, bool aIsDiagonal)

void	buildEntries (const VECTOR2I &p0_p, const VECTOR2I &p0_n)

Private Attributes
int	m_gap

int	m_viaGap

int	m_viaDiameter

bool	m_fitVias

std::vector< DP_GATEWAY >	m_gateways

Detailed Description

A set of gateways calculated for the cursor or starting/ending primitive pair.

Definition at line 167 of file pns_diff_pair.h.

Constructor & Destructor Documentation

◆ DP_GATEWAYS()

PNS::DP_GATEWAYS::DP_GATEWAYS ( int aGap )

inline

Definition at line 170 of file pns_diff_pair.h.

                            :
         m_gap( aGap ),
         m_viaGap( aGap )
     {
         // Do not leave uninitialized members, and keep static analyzer quiet:
         m_viaDiameter = 0;
         m_fitVias = true;
     }

References m_fitVias, and m_viaDiameter.

Member Function Documentation

◆ buildDpContinuation()

void PNS::DP_GATEWAYS::buildDpContinuation	(	const DP_PRIMITIVE_PAIR &	aPair,
		bool	aIsDiagonal
	)

private

Definition at line 591 of file pns_diff_pair.cpp.

 {
     DP_GATEWAY gw( aPair.AnchorP(), aPair.AnchorN(), aIsDiagonal );
     gw.SetPriority( 100 );
     m_gateways.push_back( gw );
 
     if( !aPair.Directional() )
         return;
 
     DIRECTION_45 dP = aPair.DirP();
     DIRECTION_45 dN = aPair.DirN();
 
     int gap = ( aPair.AnchorP() - aPair.AnchorN() ).EuclideanNorm();
 
     VECTOR2I vdP = aPair.AnchorP() + dP.Left().ToVector();
     VECTOR2I vdN = aPair.AnchorN() + dN.Left().ToVector();
 
     SEGMENT* sP = static_cast<SEGMENT*>( aPair.PrimP() );
 
     VECTOR2I t1, t2;
 
     auto vL = makeGapVector( dP.Left().ToVector(), ( gap + 1 ) / 2 );
     auto vR = makeGapVector( dP.Right().ToVector(), ( gap + 1 ) / 2 );
 
     if( sP->Seg().Side( vdP ) == sP->Seg().Side( vdN ) )
     {
         t1 = aPair.AnchorP() + vL;
         t2 = aPair.AnchorN() + vR;
     }
     else
     {
         t1 = aPair.AnchorP() + vR;
         t2 = aPair.AnchorN() + vL;
     }
 
     DP_GATEWAY gwL( t2, aPair.AnchorN(), !aIsDiagonal );
     SHAPE_LINE_CHAIN ep = dP.BuildInitialTrace( aPair.AnchorP(), t2, !aIsDiagonal );
     gwL.SetPriority( 10 );
     gwL.SetEntryLines( ep , SHAPE_LINE_CHAIN() );
 
     m_gateways.push_back( gwL );
 
     DP_GATEWAY gwR( aPair.AnchorP(), t1, !aIsDiagonal );
     SHAPE_LINE_CHAIN en = dP.BuildInitialTrace( aPair.AnchorN(), t1, !aIsDiagonal );
     gwR.SetPriority( 10) ;
     gwR.SetEntryLines( SHAPE_LINE_CHAIN(), en );
 
     m_gateways.push_back( gwR );
 }

References PNS::DP_PRIMITIVE_PAIR::AnchorN(), PNS::DP_PRIMITIVE_PAIR::AnchorP(), DIRECTION_45::BuildInitialTrace(), PNS::DP_PRIMITIVE_PAIR::Directional(), PNS::DP_PRIMITIVE_PAIR::DirN(), PNS::DP_PRIMITIVE_PAIR::DirP(), EuclideanNorm(), DIRECTION_45::Left(), m_gateways, PNS::makeGapVector(), PNS::DP_PRIMITIVE_PAIR::PrimP(), DIRECTION_45::Right(), PNS::SEGMENT::Seg(), PNS::DP_GATEWAY::SetPriority(), SEG::Side(), and DIRECTION_45::ToVector().

Referenced by BuildFromPrimitivePair().

◆ buildEntries()

void PNS::DP_GATEWAYS::buildEntries	(	const VECTOR2I &	p0_p,
		const VECTOR2I &	p0_n
	)

private

Definition at line 575 of file pns_diff_pair.cpp.

 {
     for( DP_GATEWAY &g : m_gateways )
     {
         if( !g.HasEntryLines() )
         {
             SHAPE_LINE_CHAIN lead_p = DIRECTION_45().BuildInitialTrace ( g.AnchorP(), p0_p,
                                                                          g.IsDiagonal() ).Reverse();
             SHAPE_LINE_CHAIN lead_n = DIRECTION_45().BuildInitialTrace ( g.AnchorN(), p0_n,
                                                                          g.IsDiagonal() ).Reverse();
             g.SetEntryLines( lead_p, lead_n );
         }
     }
 }

References DIRECTION_45::BuildInitialTrace(), and m_gateways.

Referenced by BuildGeneric().

◆ BuildForCursor()

void PNS::DP_GATEWAYS::BuildForCursor ( const VECTOR2I & aCursorPos )

Definition at line 536 of file pns_diff_pair.cpp.

 {
     int gap = m_fitVias ? m_viaGap + m_viaDiameter : m_gap;
 
     for( int attempt = 0; attempt < 2; attempt++ )
     {
         for( int i = 0; i < 4; i++ )
         {
             VECTOR2I dir;
 
             if( !attempt )
             {
                 dir = makeGapVector( VECTOR2I( gap, gap ), gap );
 
                 if( i % 2 == 0 )
                     dir.x = -dir.x;
 
                 if( i / 2 == 0 )
                     dir.y = -dir.y;
             }
             else
             {
                 if( i /2 == 0 )
                     dir = VECTOR2I( (gap + 1) / 2 * ( ( i % 2 ) ? -1 : 1 ), 0 );
                 else
                     dir = VECTOR2I( 0, (gap + 1) / 2 * ( ( i % 2 ) ? -1 : 1) );
             }
 
             if( m_fitVias )
                 BuildGeneric( aCursorPos + dir, aCursorPos - dir, true, true );
             else
                 m_gateways.emplace_back( aCursorPos + dir, aCursorPos - dir,
                                          attempt ? true : false );
 
         }
     }
 }

References BuildGeneric(), m_fitVias, m_gap, m_gateways, m_viaDiameter, m_viaGap, PNS::makeGapVector(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BuildOrthoProjections(), and PNS::DIFF_PAIR_PLACER::routeHead().

◆ BuildFromPrimitivePair()

void PNS::DP_GATEWAYS::BuildFromPrimitivePair	(	const DP_PRIMITIVE_PAIR &	aPair,
		bool	aPreferDiagonal
	)

Definition at line 425 of file pns_diff_pair.cpp.

 {
     VECTOR2I majorDirection;
     VECTOR2I p0_p, p0_n;
     int orthoFanDistance;
     int diagFanDistance;
     const SHAPE* shP = nullptr;
 
     if( aPair.PrimP() == nullptr )
     {
         BuildGeneric( aPair.AnchorP(), aPair.AnchorN(), true );
         return;
     }
 
     const int pvMask = ITEM::SOLID_T | ITEM::VIA_T;
 
     if( aPair.PrimP()->OfKind( pvMask ) && aPair.PrimN()->OfKind(  pvMask ) )
     {
         p0_p = aPair.AnchorP();
         p0_n = aPair.AnchorN();
 
         shP = aPair.PrimP()->Shape();
     }
     else if( aPair.PrimP()->OfKind( ITEM::SEGMENT_T ) && aPair.PrimN()->OfKind( ITEM::SEGMENT_T ) )
     {
         buildDpContinuation( aPair, aPreferDiagonal );
 
         return;
     }
 
     majorDirection = ( p0_p - p0_n ).Perpendicular();
 
     if( shP == nullptr )
         return;
 
     switch( shP->Type() )
     {
     case SH_RECT:
     {
         int w = static_cast<const SHAPE_RECT*>( shP )->GetWidth();
         int h = static_cast<const SHAPE_RECT*>( shP )->GetHeight();
 
         if( w < h )
             std::swap( w, h );
 
         orthoFanDistance = ( w + 1 )* 3 / 2;
         diagFanDistance = ( w - h );
         break;
     }
 
     case SH_SEGMENT:
     {
         int w = static_cast<const SHAPE_SEGMENT*>( shP )->GetWidth();
         SEG s = static_cast<const SHAPE_SEGMENT*>( shP )->GetSeg();
 
         orthoFanDistance = w + ( s.B - s.A ).EuclideanNorm();
         diagFanDistance = ( s.B - s.A ).EuclideanNorm();
         break;
     }
 
     default:
         BuildGeneric ( p0_p, p0_n, true );
         return;
     }
 
     if( checkDiagonalAlignment( p0_p, p0_n ) )
     {
         int padDist = ( p0_p - p0_n ).EuclideanNorm();
 
         for( int k = 0; k < 2; k++ )
         {
             VECTOR2I dir, dp, dv;
 
             if( k == 0 )
             {
                 dir = makeGapVector( majorDirection, orthoFanDistance );
                 int d = ( padDist - m_gap );
                 dp = makeGapVector( dir, d );
                 dv = makeGapVector( p0_n - p0_p, d );
             }
             else
             {
                 dir = makeGapVector( majorDirection, diagFanDistance );
                 int d = ( padDist - m_gap );
                 dp = makeGapVector( dir, d );
                 dv = makeGapVector( p0_n - p0_p, d );
             }
 
             for( int i = 0; i < 2; i++ )
             {
                 int sign = i ? -1 : 1;
 
                 VECTOR2I gw_p( p0_p + sign * ( dir + dp ) + dv );
                 VECTOR2I gw_n( p0_n + sign * ( dir + dp ) - dv );
 
                 SHAPE_LINE_CHAIN entryP( { p0_p, p0_p + sign * dir, gw_p } );
                 SHAPE_LINE_CHAIN entryN( { p0_n, p0_n + sign * dir, gw_n } );
 
                 DP_GATEWAY gw( gw_p, gw_n, false );
 
                 gw.SetEntryLines( entryP, entryN );
                 gw.SetPriority( 100 - k );
                 m_gateways.push_back( gw );
             }
         }
     }
 
     BuildGeneric( p0_p, p0_n, true );
 }

References SEG::A, PNS::DP_PRIMITIVE_PAIR::AnchorN(), PNS::DP_PRIMITIVE_PAIR::AnchorP(), SEG::B, buildDpContinuation(), BuildGeneric(), checkDiagonalAlignment(), EuclideanNorm(), m_gap, m_gateways, PNS::makeGapVector(), PNS::ITEM::OfKind(), PNS::DP_PRIMITIVE_PAIR::PrimN(), PNS::DP_PRIMITIVE_PAIR::PrimP(), PNS::ITEM::SEGMENT_T, SH_RECT, SH_SEGMENT, PNS::ITEM::Shape(), sign(), PNS::ITEM::SOLID_T, SHAPE_BASE::Type(), and PNS::ITEM::VIA_T.

Referenced by PNS::DIFF_PAIR_PLACER::routeHead().

◆ BuildGeneric()

void PNS::DP_GATEWAYS::BuildGeneric	(	const VECTOR2I &	p0_p,
		const VECTOR2I &	p0_n,
		bool	aBuildEntries = `false`,
		bool	aViaMode = `false`
	)

Definition at line 642 of file pns_diff_pair.cpp.

 {
     SEG st_p[2], st_n[2];
     SEG d_n[2], d_p[2];
 
     const int padToGapThreshold = 3;
     int padDist = ( p0_n - p0_p ).EuclideanNorm();
 
     st_p[0] = SEG(p0_p + VECTOR2I( -100, 0 ), p0_p + VECTOR2I( 100, 0 ) );
     st_n[0] = SEG(p0_n + VECTOR2I( -100, 0 ), p0_n + VECTOR2I( 100, 0 ) );
     st_p[1] = SEG(p0_p + VECTOR2I( 0, -100 ), p0_p + VECTOR2I( 0, 100 ) );
     st_n[1] = SEG(p0_n + VECTOR2I( 0, -100 ), p0_n + VECTOR2I( 0, 100 ) );
     d_p[0] = SEG( p0_p + VECTOR2I( -100, -100 ), p0_p + VECTOR2I( 100, 100 ) );
     d_p[1] = SEG( p0_p + VECTOR2I( 100, -100 ), p0_p + VECTOR2I( -100, 100 ) );
     d_n[0] = SEG( p0_n + VECTOR2I( -100, -100 ), p0_n + VECTOR2I( 100, 100 ) );
     d_n[1] = SEG( p0_n + VECTOR2I( 100, -100 ), p0_n + VECTOR2I( -100, 100 ) );
 
     // midpoint exit & side-by exits
     for( int i = 0; i < 2; i++ )
     {
         bool straightColl = st_p[i].Collinear( st_n[i] );
         bool diagColl = d_p[i].Collinear( d_n[i] );
 
         if( straightColl || diagColl )
         {
             VECTOR2I dir = makeGapVector( p0_n - p0_p, m_gap / 2 );
             VECTOR2I m = ( p0_p + p0_n ) / 2;
             int prio = ( padDist > padToGapThreshold * m_gap ? 2 : 1);
 
             if( !aViaMode )
             {
                 m_gateways.emplace_back( m - dir, m + dir, diagColl, DIRECTION_45::ANG_RIGHT,
                                          prio );
 
                 dir = makeGapVector( p0_n - p0_p, 2 * m_gap );
                 m_gateways.emplace_back( p0_p - dir, p0_p - dir + dir.Perpendicular(), diagColl );
                 m_gateways.emplace_back( p0_p - dir, p0_p - dir - dir.Perpendicular(), diagColl );
                 m_gateways.emplace_back( p0_n + dir + dir.Perpendicular(), p0_n + dir, diagColl );
                 m_gateways.emplace_back( p0_n + dir - dir.Perpendicular(), p0_n + dir, diagColl );
             }
         }
     }
 
     for( int i = 0; i < 2; i++ )
     {
         for( int j = 0; j < 2; j++ )
         {
             OPT_VECTOR2I ips[2];
 
             ips[0] = d_n[i].IntersectLines( d_p[j] );
             ips[1] = st_p[i].IntersectLines( st_n[j] );
 
             if( d_n[i].Collinear( d_p[j] ) )
                 ips[0] = OPT_VECTOR2I();
 
             if( st_p[i].Collinear( st_p[j] ) )
                 ips[1] = OPT_VECTOR2I();
 
             // diagonal-diagonal and straight-straight cases - the most typical case if the pads
             // are on the same straight/diagonal line
             for( int k = 0; k < 2; k++ )
             {
                 if( ips[k] )
                 {
                     const VECTOR2I m( *ips[k] );
 
                     if( m != p0_p && m != p0_n )
                     {
                         int prio = ( padDist > padToGapThreshold * m_gap ? 10 : 20 );
                         VECTOR2I g_p( ( p0_p - m ).Resize( ceil( (double) m_gap * M_SQRT1_2 ) ) );
                         VECTOR2I g_n( ( p0_n - m ).Resize( ceil( (double) m_gap * M_SQRT1_2 ) ) );
 
                         m_gateways.emplace_back( m + g_p, m + g_n, k == 0 ? true : false,
                                                  DIRECTION_45::ANG_OBTUSE, prio );
                     }
                 }
             }
 
             ips[0] = st_n[i].IntersectLines( d_p[j] );
             ips[1] = st_p[i].IntersectLines( d_n[j] );
 
 //          diagonal-straight cases: 8 possibilities of "weirder" exists
             for( int k = 0; k < 2; k++ )
             {
                 if( ips[k] )
                 {
                     const VECTOR2I m( *ips[k] );
 
                     if( !aViaMode && m != p0_p && m != p0_n )
                     {
                         VECTOR2I g_p, g_n;
 
                         g_p = ( p0_p - m ).Resize( ceil( (double) m_gap * M_SQRT2 ) );
                         g_n = ( p0_n - m ).Resize( ceil( (double) m_gap ) );
 
                         if( angle( g_p, g_n ) != DIRECTION_45::ANG_ACUTE )
                             m_gateways.emplace_back( m + g_p, m + g_n, true );
 
                         g_p = ( p0_p - m ).Resize( m_gap );
                         g_n = ( p0_n - m ).Resize( ceil( (double) m_gap * M_SQRT2 ) );
 
                         if( angle( g_p, g_n ) != DIRECTION_45::ANG_ACUTE )
                             m_gateways.emplace_back( m + g_p, m + g_n, true );
                     }
                 }
             }
         }
     }
 
     if( aBuildEntries )
         buildEntries( p0_p, p0_n );
 }

References DIRECTION_45::ANG_ACUTE, DIRECTION_45::ANG_OBTUSE, DIRECTION_45::ANG_RIGHT, PNS::angle(), buildEntries(), SEG::Collinear(), EuclideanNorm(), SEG::IntersectLines(), m_gap, m_gateways, PNS::makeGapVector(), and VECTOR2< T >::Perpendicular().

Referenced by BuildForCursor(), and BuildFromPrimitivePair().

◆ BuildOrthoProjections()

void PNS::DP_GATEWAYS::BuildOrthoProjections	(	DP_GATEWAYS &	aEntries,
		const VECTOR2I &	aCursorPos,
		int	aOrthoScore
	)

Definition at line 304 of file pns_diff_pair.cpp.

 {
     for( const DP_GATEWAY& g : aEntries.Gateways() )
     {
         VECTOR2I midpoint( ( g.AnchorP() + g.AnchorN() ) / 2 );
         SEG guide_s( midpoint, midpoint + VECTOR2I( 1, 0 ) );
         SEG guide_d( midpoint, midpoint + VECTOR2I( 1, 1 ) );
 
         VECTOR2I proj_s = guide_s.LineProject( aCursorPos );
         VECTOR2I proj_d = guide_d.LineProject( aCursorPos );
 
         int dist_s = ( proj_s - aCursorPos ).EuclideanNorm();
         int dist_d = ( proj_d - aCursorPos ).EuclideanNorm();
 
         VECTOR2I proj = ( dist_s < dist_d ? proj_s : proj_d );
 
         DP_GATEWAYS targets( m_gap );
 
         targets.m_viaGap = m_viaGap;
         targets.m_viaDiameter = m_viaDiameter;
         targets.m_fitVias = m_fitVias;
 
         targets.BuildForCursor( proj );
 
         for( DP_GATEWAY t : targets.Gateways() )
         {
             t.SetPriority( aOrthoScore );
             m_gateways.push_back( t );
         }
     }
 }

References BuildForCursor(), EuclideanNorm(), Gateways(), SEG::LineProject(), m_fitVias, m_gap, m_gateways, m_viaDiameter, and m_viaGap.

◆ CGateways()

const std::vector<DP_GATEWAY>& PNS::DP_GATEWAYS::CGateways ( ) const

inline

Definition at line 205 of file pns_diff_pair.h.

205 { return m_gateways; }

PNS::DP_GATEWAYS::m_gateways

std::vector< DP_GATEWAY > m_gateways

Definition: pns_diff_pair.h:226

References m_gateways.

◆ checkDiagonalAlignment()

bool PNS::DP_GATEWAYS::checkDiagonalAlignment	(	const VECTOR2I &	a,
		const VECTOR2I &	b
	)		const

private

Definition at line 388 of file pns_diff_pair.cpp.

 {
     VECTOR2I dir( std::abs (a.x - b.x), std::abs ( a.y - b.y ) );
 
     return (dir.x == 0 && dir.y != 0) || (dir.x == dir.y) || (dir.y == 0 && dir.x != 0);
 }

References VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BuildFromPrimitivePair().

◆ Clear()

void PNS::DP_GATEWAYS::Clear ( )

inline

Definition at line 179 of file pns_diff_pair.h.

179 { m_gateways.clear(); }

PNS::DP_GATEWAYS::m_gateways

std::vector< DP_GATEWAY > m_gateways

Definition: pns_diff_pair.h:226

References m_gateways.

◆ FilterByOrientation()

void PNS::DP_GATEWAYS::FilterByOrientation	(	int	aAngleMask,
		DIRECTION_45	aRefOrientation
	)

Definition at line 396 of file pns_diff_pair.cpp.

 {
     m_gateways.erase(
         std::remove_if( m_gateways.begin(), m_gateways.end(),
                         [aAngleMask, aRefOrientation]( const DP_GATEWAY& dp)
                         {
                             DIRECTION_45 orient( dp.AnchorP() - dp.AnchorN() );
                             return ( orient.Angle( aRefOrientation ) & aAngleMask );
                         } ), m_gateways.end()
         );
 }

References m_gateways.

Referenced by PNS::DIFF_PAIR_PLACER::routeHead().

◆ FitGateways()

bool PNS::DP_GATEWAYS::FitGateways	(	DP_GATEWAYS &	aEntry,
		DP_GATEWAYS &	aTarget,
		bool	aPrefDiagonal,
		DIFF_PAIR &	aDp
	)

Definition at line 338 of file pns_diff_pair.cpp.

 {
     DP_CANDIDATE best;
 
     int n = 0;
     int bestScore = -1000;
     bool found = false;
 
     for( const DP_GATEWAY& g_entry : aEntry.Gateways() )
     {
         for( const DP_GATEWAY& g_target : aTarget.Gateways() )
         {
             n++;
 
             for( int attempt = 0; attempt < 2; attempt++ )
             {
                 int score = ( attempt == 1 ? -3 : 0 );
                 score += g_entry.Priority();
                 score += g_target.Priority();
 
                 if( score < bestScore )
                     continue;
 
                 DIFF_PAIR l( m_gap );
 
                 if( l.BuildInitial( g_entry, g_target,
                                     aPrefDiagonal ^ ( attempt ? true : false ) ) )
                 {
                     best.p = l.CP();
                     best.n = l.CN();
                     bestScore = score;
                     found = true;
                 }
             }
         }
     }
 
 
     if( found )
     {
         aDp.SetGap( m_gap );
         aDp.SetShape( best.p, best.n );
         return true;
     }
 
     return false;
 }

References PNS::DIFF_PAIR::BuildInitial(), PNS::DIFF_PAIR::CN(), PNS::DIFF_PAIR::CP(), Gateways(), m_gap, PNS::DP_GATEWAYS::DP_CANDIDATE::n, PNS::DP_GATEWAYS::DP_CANDIDATE::p, PNS::DIFF_PAIR::SetGap(), and PNS::DIFF_PAIR::SetShape().

Referenced by PNS::DIFF_PAIR_PLACER::routeHead().

◆ Gateways()

std::vector<DP_GATEWAY>& PNS::DP_GATEWAYS::Gateways ( )

inline

Definition at line 203 of file pns_diff_pair.h.

203 { return m_gateways; }

PNS::DP_GATEWAYS::m_gateways

std::vector< DP_GATEWAY > m_gateways

Definition: pns_diff_pair.h:226

References m_gateways.

Referenced by BuildOrthoProjections(), and FitGateways().

◆ SetFitVias()

void PNS::DP_GATEWAYS::SetFitVias	(	bool	aEnable,
		int	aDiameter = `0`,
		int	aViaGap = `-1`
	)

inline

Definition at line 181 of file pns_diff_pair.h.

     {
         m_fitVias = aEnable;
         m_viaDiameter = aDiameter;
 
         if( aViaGap < 0 )
             m_viaGap = m_gap;
         else
             m_viaGap = aViaGap;
     }

References m_fitVias, m_gap, m_viaDiameter, and m_viaGap.

Referenced by PNS::DIFF_PAIR_PLACER::routeHead().

Member Data Documentation

◆ m_fitVias

bool PNS::DP_GATEWAYS::m_fitVias

private

Definition at line 224 of file pns_diff_pair.h.

Referenced by BuildForCursor(), BuildOrthoProjections(), DP_GATEWAYS(), and SetFitVias().

◆ m_gap

int PNS::DP_GATEWAYS::m_gap

private

Definition at line 221 of file pns_diff_pair.h.

Referenced by BuildForCursor(), BuildFromPrimitivePair(), BuildGeneric(), BuildOrthoProjections(), FitGateways(), and SetFitVias().

◆ m_gateways

std::vector<DP_GATEWAY> PNS::DP_GATEWAYS::m_gateways

private

Definition at line 226 of file pns_diff_pair.h.

Referenced by buildDpContinuation(), buildEntries(), BuildForCursor(), BuildFromPrimitivePair(), BuildGeneric(), BuildOrthoProjections(), CGateways(), Clear(), FilterByOrientation(), and Gateways().

◆ m_viaDiameter

int PNS::DP_GATEWAYS::m_viaDiameter

private

Definition at line 223 of file pns_diff_pair.h.

Referenced by BuildForCursor(), BuildOrthoProjections(), DP_GATEWAYS(), and SetFitVias().

◆ m_viaGap

int PNS::DP_GATEWAYS::m_viaGap

private

Definition at line 222 of file pns_diff_pair.h.

Referenced by BuildForCursor(), BuildOrthoProjections(), and SetFitVias().

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DP_GATEWAYS()

Member Function Documentation

◆ buildDpContinuation()

◆ buildEntries()

◆ BuildForCursor()

◆ BuildFromPrimitivePair()

◆ BuildGeneric()

◆ BuildOrthoProjections()

◆ CGateways()

◆ checkDiagonalAlignment()

◆ Clear()

◆ FilterByOrientation()

◆ FitGateways()

◆ Gateways()

◆ SetFitVias()

Member Data Documentation

◆ m_fitVias

◆ m_gap

◆ m_gateways

◆ m_viaDiameter

◆ m_viaGap