PNS::WALKAROUND Class Reference

#include <pns_walkaround.h>

Inheritance diagram for PNS::WALKAROUND:

Classes
struct	RESULT

Public Types
enum	WALKAROUND_STATUS { IN_PROGRESS = 0, ALMOST_DONE, DONE, STUCK }

Public Member Functions
	WALKAROUND (NODE *aWorld, ROUTER *aRouter)
	~WALKAROUND ()
void	SetWorld (NODE *aNode)
void	SetIterationLimit (const int aIterLimit)
void	SetSolidsOnly (bool aSolidsOnly)
void	SetItemMask (int aMask)
void	SetSingleDirection (bool aForceSingleDirection)
void	SetSingleDirection2 (bool aForceSingleDirection)
void	SetApproachCursor (bool aEnabled, const VECTOR2I &aPos)
void	SetForceWinding (bool aEnabled, bool aCw)
void	RestrictToSet (bool aEnabled, const std::set< ITEM * > &aSet)
WALKAROUND_STATUS	Route (const LINE &aInitialPath, LINE &aWalkPath, bool aOptimize=true)
const RESULT	Route (const LINE &aInitialPath)
ROUTER *	Router () const
	Return current router settings. More...
ROUTING_SETTINGS &	Settings () const
	Return the logger object, allowing to dump geometry to a file. More...
virtual LOGGER *	Logger ()
void	SetLogger (LOGGER *aLogger)
void	SetDebugDecorator (DEBUG_DECORATOR *aDecorator)
	Assign a debug decorator allowing this algo to draw extra graphics for visual debugging. More...
DEBUG_DECORATOR *	Dbg () const
const BOX2I &	VisibleViewArea () const

Protected Attributes
DEBUG_DECORATOR *	m_debugDecorator
ROUTER *	m_router
LOGGER *	m_logger

Private Member Functions
void	start (const LINE &aInitialPath)
WALKAROUND_STATUS	singleStep (LINE &aPath, bool aWindingDirection)
NODE::OPT_OBSTACLE	nearestObstacle (const LINE &aPath)

Private Attributes
NODE *	m_world
int	m_recursiveBlockageCount
int	m_iteration
int	m_iterationLimit
int	m_itemMask
bool	m_forceSingleDirection
bool	m_forceLongerPath
bool	m_cursorApproachMode
bool	m_forceWinding
bool	m_forceCw
bool	m_forceUniqueWindingDirection
VECTOR2I	m_cursorPos
NODE::OPT_OBSTACLE	m_currentObstacle [2]
bool	m_recursiveCollision [2]
std::set< ITEM * >	m_restrictedSet

Static Private Attributes
static const int	DefaultIterationLimit = 50

Detailed Description

Definition at line 35 of file pns_walkaround.h.

Member Enumeration Documentation

WALKAROUND_STATUS

enum PNS::WALKAROUND::WALKAROUND_STATUS

Enumerator
IN_PROGRESS
ALMOST_DONE
DONE
STUCK

Definition at line 61 of file pns_walkaround.h.

    {
        IN_PROGRESS = 0,
        ALMOST_DONE,
        DONE,
        STUCK
    };

Constructor & Destructor Documentation

WALKAROUND()

PNS::WALKAROUND::WALKAROUND ( NODE *  aWorld, ROUTER *  aRouter  )

inline

Definition at line 40 of file pns_walkaround.h.

                                                :
        ALGO_BASE ( aRouter ),
        m_world( aWorld ),
        m_iterationLimit( DefaultIterationLimit )
    {
        m_forceSingleDirection = false;
        m_forceLongerPath = false;
        m_forceWinding = false;
        m_cursorApproachMode = false;
        m_itemMask = ITEM::ANY_T;

        // Initialize other members, to avoid uninitialized variables.
        m_recursiveBlockageCount = 0;
        m_recursiveCollision[0] = m_recursiveCollision[1] = false;
        m_iteration = 0;
        m_forceCw = false;
        m_forceUniqueWindingDirection = false;
    }

References PNS::ITEM::ANY_T, m_cursorApproachMode, m_forceCw, m_forceLongerPath, m_forceSingleDirection, m_forceUniqueWindingDirection, m_forceWinding, m_itemMask, m_iteration, m_recursiveBlockageCount, and m_recursiveCollision.

~WALKAROUND()

PNS::WALKAROUND::~WALKAROUND ( )

inline

Definition at line 59 of file pns_walkaround.h.

{};

Member Function Documentation

Dbg()

DEBUG_DECORATOR* PNS::ALGO_BASE::Dbg ( ) const

inlineinherited

Definition at line 78 of file pns_algo_base.h.

    {
        return m_debugDecorator;
    }

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::MEANDER_PLACER::doMove(), PNS::COMPONENT_DRAGGER::Drag(), PNS::MEANDER_SKEW_PLACER::Move(), PNS::DP_MEANDER_PLACER::Move(), PNS::SHOVE::onCollidingArc(), PNS::SHOVE::onCollidingLine(), PNS::SHOVE::onCollidingSegment(), PNS::SHOVE::onCollidingSolid(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::SHOVE::replaceLine(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::SHOVE::runOptimizer(), PNS::SHOVE::shoveIteration(), PNS::SHOVE::ShoveLines(), PNS::SHOVE::shoveLineToHullSet(), PNS::SHOVE::ShoveObstacleLine(), singleStep(), PNS::DRAGGER::Start(), and PNS::DRAGGER::tryWalkaround().

Logger()

LOGGER * PNS::ALGO_BASE::Logger ( )

virtualinherited

Reimplemented in PNS::SHOVE.

Definition at line 34 of file pns_algo_base.cpp.

{
    return NULL;
}

References NULL.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::DRAGGER::Start(), and PNS::DRAGGER::tryWalkaround().

nearestObstacle()

NODE::OPT_OBSTACLE PNS::WALKAROUND::nearestObstacle ( const LINE &  aPath )

private

Definition at line 41 of file pns_walkaround.cpp.

{
    NODE::OPT_OBSTACLE obs = m_world->NearestObstacle( &aPath, m_itemMask, m_restrictedSet.empty() ? NULL : &m_restrictedSet );

    if( m_restrictedSet.empty() )
        return obs;

    else if( obs && m_restrictedSet.find ( obs->m_item ) != m_restrictedSet.end() )
        return obs;

    return NODE::OPT_OBSTACLE();
}

References m_itemMask, m_restrictedSet, m_world, PNS::NODE::NearestObstacle(), and NULL.

Referenced by Route(), and singleStep().

RestrictToSet()

void PNS::WALKAROUND::RestrictToSet ( bool  aEnabled, const std::set< ITEM * > &  aSet  )

inline

Definition at line 129 of file pns_walkaround.h.

    {
        if( aEnabled )
            m_restrictedSet = aSet;
        else
            m_restrictedSet.clear();
    }

References m_restrictedSet.

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

Route() [1/2]

WALKAROUND::WALKAROUND_STATUS PNS::WALKAROUND::Route	(	const LINE &	aInitialPath,
		LINE &	aWalkPath,
		bool	aOptimize = true
	)

Definition at line 286 of file pns_walkaround.cpp.

{
    LINE path_cw( aInitialPath ), path_ccw( aInitialPath );
    WALKAROUND_STATUS s_cw = IN_PROGRESS, s_ccw = IN_PROGRESS;
    SHAPE_LINE_CHAIN best_path;

    // special case for via-in-the-middle-of-track placement
    if( aInitialPath.PointCount() <= 1 )
    {
        if( aInitialPath.EndsWithVia() && m_world->CheckColliding( &aInitialPath.Via(), m_itemMask ) )
            return STUCK;

        aWalkPath = aInitialPath;
        return DONE;
    }

    start( aInitialPath );

    m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath );
    m_recursiveBlockageCount = 0;

    aWalkPath = aInitialPath;

    if( m_forceWinding )
    {
        s_cw = m_forceCw ? IN_PROGRESS : STUCK;
        s_ccw = m_forceCw ? STUCK : IN_PROGRESS;
        m_forceSingleDirection = true;
    } else {
        m_forceSingleDirection = false;
    }

    while( m_iteration < m_iterationLimit )
    {
        if( s_cw != STUCK )
            s_cw = singleStep( path_cw, true );

        if( s_ccw != STUCK )
            s_ccw = singleStep( path_ccw, false );

        if( ( s_cw == DONE && s_ccw == DONE ) || ( s_cw == STUCK && s_ccw == STUCK ) )
        {
            int len_cw  = path_cw.CLine().Length();
            int len_ccw = path_ccw.CLine().Length();

            if( m_forceLongerPath )
                aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
            else
                aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );

            break;
        }
        else if( s_cw == DONE && !m_forceLongerPath )
        {
            aWalkPath = path_cw;
            break;
        }
        else if( s_ccw == DONE && !m_forceLongerPath )
        {
            aWalkPath = path_ccw;
            break;
        }

        m_iteration++;
    }

    if( m_iteration == m_iterationLimit )
    {
        int len_cw  = path_cw.CLine().Length();
        int len_ccw = path_ccw.CLine().Length();

        if( m_forceLongerPath )
            aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
        else
            aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );
    }

    if( m_cursorApproachMode )
    {
        // int len_cw = path_cw.GetCLine().Length();
        // int len_ccw = path_ccw.GetCLine().Length();
        bool found = false;

        SHAPE_LINE_CHAIN l = aWalkPath.CLine();

        for( int i = 0; i < l.SegmentCount(); i++ )
        {
            const SEG s = l.Segment( i );

            VECTOR2I nearest = s.NearestPoint( m_cursorPos );
            VECTOR2I::extended_type dist_a = ( s.A - m_cursorPos ).SquaredEuclideanNorm();
            VECTOR2I::extended_type dist_b = ( s.B - m_cursorPos ).SquaredEuclideanNorm();
            VECTOR2I::extended_type dist_n = ( nearest - m_cursorPos ).SquaredEuclideanNorm();

            if( dist_n <= dist_a && dist_n < dist_b )
            {
                l.Remove( i + 1, -1 );
                l.Append( nearest );
                l.Simplify();
                found = true;
                break;
            }
        }

        if( found )
        {
            aWalkPath = aInitialPath;
            aWalkPath.SetShape( l );
        }
    }

    aWalkPath.Line().Simplify();

    if( aWalkPath.SegmentCount() < 1 )
        return STUCK;
    if( aWalkPath.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
        return ALMOST_DONE;
    if( aWalkPath.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
        return STUCK;

    WALKAROUND_STATUS st = s_ccw == DONE || s_cw == DONE ? DONE : STUCK;

    if( st == DONE )
    {
        if( aOptimize )
            OPTIMIZER::Optimize( &aWalkPath, OPTIMIZER::MERGE_OBTUSE, m_world );
    }

    return st;
}

References SEG::A, ALMOST_DONE, SHAPE_LINE_CHAIN::Append(), SEG::B, PNS::NODE::CheckColliding(), PNS::LINE::CLine(), PNS::LINE::CPoint(), DONE, PNS::LINE::EndsWithVia(), IN_PROGRESS, SHAPE_LINE_CHAIN::Length(), PNS::LINE::Line(), m_currentObstacle, m_cursorApproachMode, m_cursorPos, m_forceCw, m_forceLongerPath, m_forceSingleDirection, m_forceWinding, m_itemMask, m_iteration, m_iterationLimit, m_recursiveBlockageCount, m_world, PNS::OPTIMIZER::MERGE_OBTUSE, nearestObstacle(), SEG::NearestPoint(), PNS::OPTIMIZER::Optimize(), PNS::LINE::PointCount(), SHAPE_LINE_CHAIN::Remove(), SHAPE_LINE_CHAIN::Segment(), PNS::LINE::SegmentCount(), SHAPE_LINE_CHAIN::SegmentCount(), PNS::LINE::SetShape(), SHAPE_LINE_CHAIN::Simplify(), singleStep(), start(), STUCK, and PNS::LINE::Via().

Referenced by PNS::DIFF_PAIR_PLACER::attemptWalk(), PNS::SHOVE::onCollidingSolid(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), and PNS::DRAGGER::tryWalkaround().

Route() [2/2]

const WALKAROUND::RESULT PNS::WALKAROUND::Route

(

const LINE &

aInitialPath

)

Definition at line 178 of file pns_walkaround.cpp.

{
    LINE path_cw( aInitialPath ), path_ccw( aInitialPath );
    WALKAROUND_STATUS s_cw = IN_PROGRESS, s_ccw = IN_PROGRESS;
    SHAPE_LINE_CHAIN best_path;
    RESULT result;

    // special case for via-in-the-middle-of-track placement
    if( aInitialPath.PointCount() <= 1 )
    {
        if( aInitialPath.EndsWithVia() && m_world->CheckColliding( &aInitialPath.Via(), m_itemMask ) )
            return RESULT( STUCK, STUCK );

        return RESULT( DONE, DONE, aInitialPath, aInitialPath );
    }

    start( aInitialPath );

    m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath );
    m_recursiveBlockageCount = 0;

    result.lineCw = aInitialPath;
    result.lineCcw = aInitialPath;

    if( m_forceWinding )
    {
        s_cw = m_forceCw ? IN_PROGRESS : STUCK;
        s_ccw = m_forceCw ? STUCK : IN_PROGRESS;
        m_forceSingleDirection = true;
    } else {
        m_forceSingleDirection = false;
    }

    while( m_iteration < m_iterationLimit )
    {
        if( s_cw != STUCK )
            s_cw = singleStep( path_cw, true );

        if( s_ccw != STUCK )
            s_ccw = singleStep( path_ccw, false );

        auto old = path_cw.CLine();

        if( clipToLoopStart( path_cw.Line() ) )
            s_cw = ALMOST_DONE;

        if( clipToLoopStart( path_ccw.Line() ) )
            s_ccw = ALMOST_DONE;


        if( s_cw != IN_PROGRESS )
        {
            result.lineCw = path_cw;
            result.statusCw = s_cw;
        }

        if( s_ccw != IN_PROGRESS )
        {
            result.lineCcw = path_ccw;
            result.statusCcw = s_ccw;
        }

        if( s_cw != IN_PROGRESS && s_ccw != IN_PROGRESS )
            break;

        m_iteration++;
    }

    if( s_cw == IN_PROGRESS )
    {
        result.lineCw = path_cw;
        result.statusCw = ALMOST_DONE;
    }

    if( s_ccw == IN_PROGRESS )
    {
        result.lineCcw = path_ccw;
        result.statusCcw = ALMOST_DONE;
    }

    result.lineCw.Line().Simplify();
    result.lineCcw.Line().Simplify();

    if( result.lineCw.SegmentCount() < 1 || result.lineCw.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
    {
        result.statusCw = STUCK;
    }

    if( result.lineCw.PointCount() > 0 && result.lineCw.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
    {
        result.statusCw = ALMOST_DONE;
    }

    if( result.lineCcw.SegmentCount() < 1 || result.lineCcw.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
    {
        result.statusCcw = STUCK;
    }

    if( result.lineCcw.PointCount() > 0 && result.lineCcw.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
    {
        result.statusCcw = ALMOST_DONE;
    }

    return result;
}

References ALMOST_DONE, PNS::NODE::CheckColliding(), PNS::clipToLoopStart(), PNS::LINE::CPoint(), DONE, PNS::LINE::EndsWithVia(), IN_PROGRESS, PNS::LINE::Line(), PNS::WALKAROUND::RESULT::lineCcw, PNS::WALKAROUND::RESULT::lineCw, m_currentObstacle, m_forceCw, m_forceSingleDirection, m_forceWinding, m_itemMask, m_iteration, m_iterationLimit, m_recursiveBlockageCount, m_world, nearestObstacle(), PNS::LINE::PointCount(), PNS::LINE::SegmentCount(), SHAPE_LINE_CHAIN::Simplify(), singleStep(), start(), PNS::WALKAROUND::RESULT::statusCcw, PNS::WALKAROUND::RESULT::statusCw, STUCK, and PNS::LINE::Via().

Router()

ROUTER* PNS::ALGO_BASE::Router ( ) const

inlineinherited

Return current router settings.

Definition at line 54 of file pns_algo_base.h.

References PNS::ALGO_BASE::m_router.

Referenced by PNS::DIFF_PAIR_PLACER::attemptWalk(), PNS::MEANDER_PLACER::CommitPlacement(), PNS::DP_MEANDER_PLACER::CommitPlacement(), PNS::DIFF_PAIR_PLACER::CommitPlacement(), PNS::LINE_PLACER::CommitPlacement(), PNS::COMPONENT_DRAGGER::FixRoute(), PNS::DRAGGER::FixRoute(), PNS::DIFF_PAIR_PLACER::initPlacement(), PNS::LINE_PLACER::initPlacement(), PNS::SHOVE::onCollidingSolid(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::MEANDER_SKEW_PLACER::Start(), PNS::MEANDER_PLACER::Start(), PNS::DP_MEANDER_PLACER::Start(), PNS::DRAGGER::Start(), PNS::DIFF_PAIR_PLACER::Start(), and PNS::DRAGGER::tryWalkaround().

SetApproachCursor()

void PNS::WALKAROUND::SetApproachCursor ( bool  aEnabled, const VECTOR2I &  aPos  )

inline

Definition at line 117 of file pns_walkaround.h.

    {
        m_cursorPos = aPos;
        m_cursorApproachMode = aEnabled;
    }

References m_cursorApproachMode, and m_cursorPos.

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

SetDebugDecorator()

void PNS::ALGO_BASE::SetDebugDecorator ( DEBUG_DECORATOR *  aDecorator )

inlineinherited

Assign a debug decorator allowing this algo to draw extra graphics for visual debugging.

Definition at line 73 of file pns_algo_base.h.

    {
        m_debugDecorator = aDecorator;
    }

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::SHOVE::SHOVE(), and PNS::DRAGGER::tryWalkaround().

SetForceWinding()

void PNS::WALKAROUND::SetForceWinding ( bool  aEnabled, bool  aCw  )

inline

Definition at line 123 of file pns_walkaround.h.

    {
        m_forceCw = aCw;
        m_forceWinding = aEnabled;
    }

References m_forceCw, and m_forceWinding.

SetItemMask()

void PNS::WALKAROUND::SetItemMask ( int  aMask )

inline

Definition at line 101 of file pns_walkaround.h.

    {
        m_itemMask = aMask;
    }

References m_itemMask.

SetIterationLimit()

void PNS::WALKAROUND::SetIterationLimit ( const int  aIterLimit )

inline

Definition at line 88 of file pns_walkaround.h.

    {
        m_iterationLimit = aIterLimit;
    }

References m_iterationLimit.

Referenced by PNS::DIFF_PAIR_PLACER::attemptWalk(), PNS::SHOVE::onCollidingSolid(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), and PNS::DRAGGER::tryWalkaround().

SetLogger()

void PNS::ALGO_BASE::SetLogger ( LOGGER *  aLogger )

inlineinherited

Definition at line 65 of file pns_algo_base.h.

    {
        m_logger = aLogger;
    }

References PNS::ALGO_BASE::m_logger.

Referenced by PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), and PNS::DRAGGER::tryWalkaround().

SetSingleDirection()

void PNS::WALKAROUND::SetSingleDirection ( bool  aForceSingleDirection )

inline

Definition at line 106 of file pns_walkaround.h.

    {
        m_forceSingleDirection = aForceSingleDirection;
        m_forceLongerPath = aForceSingleDirection;
    }

References m_forceLongerPath, and m_forceSingleDirection.

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

SetSingleDirection2()

void PNS::WALKAROUND::SetSingleDirection2 ( bool  aForceSingleDirection )

inline

Definition at line 112 of file pns_walkaround.h.

    {
        m_forceSingleDirection = aForceSingleDirection;
    }

References m_forceSingleDirection.

SetSolidsOnly()

void PNS::WALKAROUND::SetSolidsOnly ( bool  aSolidsOnly )

inline

Definition at line 93 of file pns_walkaround.h.

    {
        if( aSolidsOnly )
            m_itemMask = ITEM::SOLID_T;
        else
            m_itemMask = ITEM::ANY_T;
    }

References PNS::ITEM::ANY_T, m_itemMask, and PNS::ITEM::SOLID_T.

Referenced by PNS::DIFF_PAIR_PLACER::attemptWalk(), PNS::SHOVE::onCollidingSolid(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), and PNS::DRAGGER::tryWalkaround().

Settings()

ROUTING_SETTINGS & PNS::ALGO_BASE::Settings ( ) const

inherited

Return the logger object, allowing to dump geometry to a file.

Definition at line 28 of file pns_algo_base.cpp.

{
    return m_router->Settings();
}

References PNS::ALGO_BASE::m_router, and PNS::ROUTER::Settings().

Referenced by PNS::DIFF_PAIR_PLACER::attemptWalk(), PNS::LINE_PLACER::buildInitialLine(), PNS::DRAGGER::dragMarkObstacles(), PNS::DRAGGER::dragShove(), PNS::DRAGGER::dragWalkaround(), PNS::COMPONENT_DRAGGER::FixRoute(), PNS::DRAGGER::FixRoute(), PNS::DIFF_PAIR_PLACER::FixRoute(), PNS::LINE_PLACER::FixRoute(), PNS::DIFF_PAIR_PLACER::initPlacement(), PNS::LINE_PLACER::initPlacement(), PNS::LINE_PLACER::Move(), PNS::SHOVE::onCollidingSolid(), PNS::DRAGGER::optimizeAndUpdateDraggedLine(), PNS::LINE_PLACER::rhMarkObstacles(), PNS::LINE_PLACER::rhShoveOnly(), PNS::LINE_PLACER::rhWalkOnly(), PNS::LINE_PLACER::routeStep(), PNS::SHOVE::runOptimizer(), PNS::SHOVE::shoveMainLoop(), PNS::DRAGGER::Start(), PNS::LINE_PLACER::Start(), and PNS::DRAGGER::tryWalkaround().

SetWorld()

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

inline

Definition at line 83 of file pns_walkaround.h.

    {
        m_world = aNode;
    }

References m_world.

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

singleStep()

WALKAROUND::WALKAROUND_STATUS PNS::WALKAROUND::singleStep ( LINE &  aPath, bool  aWindingDirection  )

private

Definition at line 55 of file pns_walkaround.cpp.

{
    OPT<OBSTACLE>& current_obs =
        aWindingDirection ? m_currentObstacle[0] : m_currentObstacle[1];

    if( !current_obs )
        return DONE;

    SHAPE_LINE_CHAIN path_walk[2];

    if( aPath.PointCount() > 1 )
    {
        VECTOR2I last = aPath.CPoint( -1 );

        if( ( current_obs->m_hull ).PointInside( last ) || ( current_obs->m_hull ).PointOnEdge( last ) )
        {
            m_recursiveBlockageCount++;

            if( m_recursiveBlockageCount < 3 )
                aPath.Line().Append( current_obs->m_hull.NearestPoint( last ) );
            else
            {
                aPath = aPath.ClipToNearestObstacle( m_world );
                return DONE;
            }
        }
    }

    aPath.Walkaround( current_obs->m_hull, path_walk[0],
                      aWindingDirection );
    aPath.Walkaround( current_obs->m_hull, path_walk[1],
                      !aWindingDirection );

    if( !aPath.Walkaround( current_obs->m_hull, path_walk[1], !aWindingDirection ) )
        return STUCK;

    auto l =aPath.CLine();

#if 0
    if( m_logger )
    {
        m_logger->NewGroup( aWindingDirection ? "walk-cw" : "walk-ccw", m_iteration );
        m_logger->Log( &path_walk[0], 0, "path_walk" );
        m_logger->Log( &path_pre[0], 1, "path_pre" );
        m_logger->Log( &path_post[0], 4, "path_post" );
        m_logger->Log( &current_obs->m_hull, 2, "hull" );
        m_logger->Log( current_obs->m_item, 3, "item" );
    }
#endif

    if ( Dbg() )
    {
        Dbg()->BeginGroup("hull/walk");
        char name[128];
        snprintf(name, sizeof(name), "hull-%s-%d", aWindingDirection ? "cw" : "ccw", m_iteration );
        Dbg()->AddLine( current_obs->m_hull, 1, 1, name);
        snprintf(name, sizeof(name), "path-%s-%d", aWindingDirection ? "cw" : "ccw", m_iteration );
        Dbg()->AddLine( aPath.CLine(), 2, 1, name );
        Dbg()->EndGroup();
    }

    int len_pre = path_walk[0].Length();
    int len_alt = path_walk[1].Length();

    LINE walk_path( aPath, path_walk[1] );

    bool alt_collides = static_cast<bool>( m_world->CheckColliding( &walk_path, m_itemMask ) );

    SHAPE_LINE_CHAIN pnew;

    /*if( !m_forceLongerPath && len_alt < len_pre && !alt_collides && !prev_recursive )
    {
        pnew = path_pre[1];
        pnew.Append( path_walk[1] );
        pnew.Append( path_post[1] );

        if( !path_post[1].PointCount() || !path_walk[1].PointCount() )
            current_obs = nearestObstacle( LINE( aPath, path_pre[1] ) );
        else
            current_obs = nearestObstacle( LINE( aPath, path_post[1] ) );
    }
    else*/
    {
        pnew = path_walk[0];
        current_obs = nearestObstacle( LINE( aPath, path_walk[0] ) );
    }

    pnew.Simplify();
    aPath.SetShape( pnew );

    return IN_PROGRESS;
}

References PNS::DEBUG_DECORATOR::AddLine(), SHAPE_LINE_CHAIN::Append(), PNS::DEBUG_DECORATOR::BeginGroup(), PNS::NODE::CheckColliding(), PNS::LINE::CLine(), PNS::LINE::ClipToNearestObstacle(), PNS::LINE::CPoint(), PNS::ALGO_BASE::Dbg(), DONE, PNS::DEBUG_DECORATOR::EndGroup(), IN_PROGRESS, SHAPE_LINE_CHAIN::Length(), PNS::LINE::Line(), PNS::LOGGER::Log(), m_currentObstacle, m_itemMask, m_iteration, PNS::ALGO_BASE::m_logger, m_recursiveBlockageCount, m_world, name, nearestObstacle(), PNS::LINE::PointCount(), PNS::LINE::SetShape(), STUCK, and PNS::LINE::Walkaround().

Referenced by Route().

start()

void PNS::WALKAROUND::start ( const LINE &  aInitialPath )

private

Definition at line 34 of file pns_walkaround.cpp.

{
    m_iteration = 0;
    m_iterationLimit = 50;
}

References m_iteration, and m_iterationLimit.

Referenced by Route().

VisibleViewArea()

const BOX2I & PNS::ALGO_BASE::VisibleViewArea ( ) const

inherited

Definition at line 39 of file pns_algo_base.cpp.

{
    auto bb = m_router->VisibleViewArea();
    return m_router->VisibleViewArea();
}

References PNS::ALGO_BASE::m_router, and PNS::ROUTER::VisibleViewArea().

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

Member Data Documentation

DefaultIterationLimit

const int PNS::WALKAROUND::DefaultIterationLimit = 50

staticprivate

Definition at line 37 of file pns_walkaround.h.

m_currentObstacle

NODE::OPT_OBSTACLE PNS::WALKAROUND::m_currentObstacle[2]

private

Definition at line 160 of file pns_walkaround.h.

Referenced by Route(), and singleStep().

m_cursorApproachMode

bool PNS::WALKAROUND::m_cursorApproachMode

private

Definition at line 155 of file pns_walkaround.h.

Referenced by Route(), SetApproachCursor(), and WALKAROUND().

m_cursorPos

VECTOR2I PNS::WALKAROUND::m_cursorPos

private

Definition at line 159 of file pns_walkaround.h.

Referenced by Route(), and SetApproachCursor().

m_debugDecorator

DEBUG_DECORATOR* PNS::ALGO_BASE::m_debugDecorator

protectedinherited

Definition at line 86 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::Dbg(), and PNS::ALGO_BASE::SetDebugDecorator().

m_forceCw

bool PNS::WALKAROUND::m_forceCw

private

Definition at line 157 of file pns_walkaround.h.

Referenced by Route(), SetForceWinding(), and WALKAROUND().

m_forceLongerPath

bool PNS::WALKAROUND::m_forceLongerPath

private

Definition at line 154 of file pns_walkaround.h.

Referenced by Route(), SetSingleDirection(), and WALKAROUND().

m_forceSingleDirection

bool PNS::WALKAROUND::m_forceSingleDirection

private

Definition at line 154 of file pns_walkaround.h.

Referenced by Route(), SetSingleDirection(), SetSingleDirection2(), and WALKAROUND().

m_forceUniqueWindingDirection

bool PNS::WALKAROUND::m_forceUniqueWindingDirection

private

Definition at line 158 of file pns_walkaround.h.

Referenced by WALKAROUND().

m_forceWinding

bool PNS::WALKAROUND::m_forceWinding

private

Definition at line 156 of file pns_walkaround.h.

Referenced by Route(), SetForceWinding(), and WALKAROUND().

m_itemMask

int PNS::WALKAROUND::m_itemMask

private

Definition at line 153 of file pns_walkaround.h.

Referenced by nearestObstacle(), Route(), SetItemMask(), SetSolidsOnly(), singleStep(), and WALKAROUND().

m_iteration

int PNS::WALKAROUND::m_iteration

private

Definition at line 151 of file pns_walkaround.h.

Referenced by Route(), singleStep(), start(), and WALKAROUND().

m_iterationLimit

int PNS::WALKAROUND::m_iterationLimit

private

Definition at line 152 of file pns_walkaround.h.

Referenced by Route(), SetIterationLimit(), and start().

m_logger

LOGGER* PNS::ALGO_BASE::m_logger

protectedinherited

Definition at line 88 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::SetLogger(), and singleStep().

m_recursiveBlockageCount

int PNS::WALKAROUND::m_recursiveBlockageCount

private

Definition at line 150 of file pns_walkaround.h.

Referenced by Route(), singleStep(), and WALKAROUND().

m_recursiveCollision

bool PNS::WALKAROUND::m_recursiveCollision[2]

private

Definition at line 161 of file pns_walkaround.h.

Referenced by WALKAROUND().

m_restrictedSet

std::set<ITEM*> PNS::WALKAROUND::m_restrictedSet

private

Definition at line 162 of file pns_walkaround.h.

Referenced by nearestObstacle(), and RestrictToSet().

m_router

ROUTER* PNS::ALGO_BASE::m_router

protectedinherited

Definition at line 87 of file pns_algo_base.h.

Referenced by PNS::ALGO_BASE::Router(), PNS::ALGO_BASE::Settings(), PNS::DIFF_PAIR_PLACER::updateLeadingRatLine(), PNS::LINE_PLACER::updateLeadingRatLine(), and PNS::ALGO_BASE::VisibleViewArea().

m_world

NODE* PNS::WALKAROUND::m_world

private

Definition at line 148 of file pns_walkaround.h.

Referenced by nearestObstacle(), Route(), SetWorld(), and singleStep().

---

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

• pns_walkaround.h
• pns_walkaround.cpp