KiCad PCB EDA Suite
PNS::WALKAROUND Class Reference

#include <pns_walkaround.h>

Inheritance diagram for PNS::WALKAROUND:
PNS::ALGO_BASE

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)
 
ROUTERRouter () const
 Return current router settings. More...
 
ROUTING_SETTINGSSettings () const
 Return the logger object, allowing to dump geometry to a file. More...
 
virtual LOGGERLogger ()
 
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_DECORATORDbg () const
 
const BOX2IVisibleViewArea () const
 

Protected Attributes

DEBUG_DECORATORm_debugDecorator
 
ROUTERm_router
 
LOGGERm_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

NODEm_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

Enumerator
IN_PROGRESS 
ALMOST_DONE 
DONE 
STUCK 

Definition at line 61 of file pns_walkaround.h.

Constructor & Destructor Documentation

◆ WALKAROUND()

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

Definition at line 40 of file pns_walkaround.h.

40  :
41  ALGO_BASE ( aRouter ),
42  m_world( aWorld ),
44  {
45  m_forceSingleDirection = false;
46  m_forceLongerPath = false;
47  m_forceWinding = false;
48  m_cursorApproachMode = false;
50 
51  // Initialize other members, to avoid uninitialized variables.
54  m_iteration = 0;
55  m_forceCw = false;
57  }
static const int DefaultIterationLimit
ALGO_BASE(ROUTER *aRouter)
Definition: pns_algo_base.h:45
bool m_recursiveCollision[2]
bool m_forceUniqueWindingDirection

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.

59 {};

Member Function Documentation

◆ Dbg()

◆ Logger()

LOGGER * PNS::ALGO_BASE::Logger ( )
virtualinherited

Reimplemented in PNS::SHOVE.

Definition at line 34 of file pns_algo_base.cpp.

35 {
36  return NULL;
37 }
#define 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.

42 {
44 
45  if( m_restrictedSet.empty() )
46  return obs;
47 
48  else if( obs && m_restrictedSet.find ( obs->m_item ) != m_restrictedSet.end() )
49  return obs;
50 
51  return NODE::OPT_OBSTACLE();
52 }
OPT_OBSTACLE NearestObstacle(const LINE *aLine, int aKindMask=ITEM::ANY_T, const std::set< ITEM * > *aRestrictedSet=NULL)
Follow the line in search of an obstacle that is nearest to the starting to the line's starting point...
Definition: pns_node.cpp:281
std::set< ITEM * > m_restrictedSet
#define NULL
OPT< OBSTACLE > OPT_OBSTACLE
Definition: pns_node.h:147

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.

130  {
131  if( aEnabled )
132  m_restrictedSet = aSet;
133  else
134  m_restrictedSet.clear();
135  }
std::set< ITEM * > m_restrictedSet

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 204 of file pns_walkaround.cpp.

206 {
207  LINE path_cw( aInitialPath ), path_ccw( aInitialPath );
208  WALKAROUND_STATUS s_cw = IN_PROGRESS, s_ccw = IN_PROGRESS;
209  SHAPE_LINE_CHAIN best_path;
210 
211  // special case for via-in-the-middle-of-track placement
212  if( aInitialPath.PointCount() <= 1 )
213  {
214  if( aInitialPath.EndsWithVia() && m_world->CheckColliding( &aInitialPath.Via(), m_itemMask ) )
215  return STUCK;
216 
217  aWalkPath = aInitialPath;
218  return DONE;
219  }
220 
221  start( aInitialPath );
222 
223  m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath );
225 
226  aWalkPath = aInitialPath;
227 
228  if( m_forceWinding )
229  {
230  s_cw = m_forceCw ? IN_PROGRESS : STUCK;
231  s_ccw = m_forceCw ? STUCK : IN_PROGRESS;
232  m_forceSingleDirection = true;
233  } else {
234  m_forceSingleDirection = false;
235  }
236 
237  while( m_iteration < m_iterationLimit )
238  {
239  if( s_cw != STUCK )
240  s_cw = singleStep( path_cw, true );
241 
242  if( s_ccw != STUCK )
243  s_ccw = singleStep( path_ccw, false );
244 
245  if( ( s_cw == DONE && s_ccw == DONE ) || ( s_cw == STUCK && s_ccw == STUCK ) )
246  {
247  int len_cw = path_cw.CLine().Length();
248  int len_ccw = path_ccw.CLine().Length();
249 
250  if( m_forceLongerPath )
251  aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
252  else
253  aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );
254 
255  break;
256  }
257  else if( s_cw == DONE && !m_forceLongerPath )
258  {
259  aWalkPath = path_cw;
260  break;
261  }
262  else if( s_ccw == DONE && !m_forceLongerPath )
263  {
264  aWalkPath = path_ccw;
265  break;
266  }
267 
268  m_iteration++;
269  }
270 
272  {
273  int len_cw = path_cw.CLine().Length();
274  int len_ccw = path_ccw.CLine().Length();
275 
276  if( m_forceLongerPath )
277  aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
278  else
279  aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );
280  }
281 
282  aWalkPath.Line().Simplify();
283 
284  if( aWalkPath.SegmentCount() < 1 )
285  return STUCK;
286  if( aWalkPath.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
287  return ALMOST_DONE;
288  if( aWalkPath.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
289  return STUCK;
290 
291  WALKAROUND_STATUS st = s_ccw == DONE || s_cw == DONE ? DONE : STUCK;
292 
293  if( st == DONE )
294  {
295  if( aOptimize )
297  }
298 
299  return st;
300 }
WALKAROUND_STATUS singleStep(LINE &aPath, bool aWindingDirection)
NODE::OPT_OBSTACLE m_currentObstacle[2]
static bool Optimize(LINE *aLine, int aEffortLevel, NODE *aWorld, const VECTOR2I aV=VECTOR2I(0, 0))
void start(const LINE &aInitialPath)
NODE::OPT_OBSTACLE nearestObstacle(const LINE &aPath)
Reduce corner cost by merging obtuse segments.
SHAPE_LINE_CHAIN.
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Check if the item collides with anything else in the world, and if found, returns the obstacle.
Definition: pns_node.cpp:433

References ALMOST_DONE, 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_forceCw, m_forceLongerPath, m_forceSingleDirection, m_forceWinding, m_itemMask, m_iteration, m_iterationLimit, m_recursiveBlockageCount, m_world, PNS::OPTIMIZER::MERGE_OBTUSE, nearestObstacle(), PNS::OPTIMIZER::Optimize(), PNS::LINE::PointCount(), PNS::LINE::SegmentCount(), 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 97 of file pns_walkaround.cpp.

98 {
99  LINE path_cw( aInitialPath ), path_ccw( aInitialPath );
100  WALKAROUND_STATUS s_cw = IN_PROGRESS, s_ccw = IN_PROGRESS;
101  SHAPE_LINE_CHAIN best_path;
102  RESULT result;
103 
104  // special case for via-in-the-middle-of-track placement
105  if( aInitialPath.PointCount() <= 1 )
106  {
107  if( aInitialPath.EndsWithVia() && m_world->CheckColliding( &aInitialPath.Via(), m_itemMask ) )
108  return RESULT( STUCK, STUCK );
109 
110  return RESULT( DONE, DONE, aInitialPath, aInitialPath );
111  }
112 
113  start( aInitialPath );
114 
115  m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath );
117 
118  result.lineCw = aInitialPath;
119  result.lineCcw = aInitialPath;
120 
121  if( m_forceWinding )
122  {
123  s_cw = m_forceCw ? IN_PROGRESS : STUCK;
124  s_ccw = m_forceCw ? STUCK : IN_PROGRESS;
125  m_forceSingleDirection = true;
126  } else {
127  m_forceSingleDirection = false;
128  }
129 
130  // In some situations, there isn't a trivial path (or even a path at all). Hitting the
131  // iteration limit causes lag, so we can exit out early if the walkaround path gets very long
132  // compared with the initial path. If the length exceeds the initial length times this factor,
133  // fail out.
134  const int maxWalkDistFactor = 10;
135  long long lengthLimit = aInitialPath.CLine().Length() * maxWalkDistFactor;
136 
137  while( m_iteration < m_iterationLimit )
138  {
139  if( s_cw != STUCK && s_cw != ALMOST_DONE )
140  s_cw = singleStep( path_cw, true );
141 
142  if( s_ccw != STUCK && s_ccw != ALMOST_DONE )
143  s_ccw = singleStep( path_ccw, false );
144 
145  if( s_cw != IN_PROGRESS )
146  {
147  result.lineCw = path_cw;
148  result.statusCw = s_cw;
149  }
150 
151  if( s_ccw != IN_PROGRESS )
152  {
153  result.lineCcw = path_ccw;
154  result.statusCcw = s_ccw;
155  }
156 
157  if( s_cw != IN_PROGRESS && s_ccw != IN_PROGRESS )
158  break;
159 
160  // Safety valve
161  if( path_cw.Line().Length() > lengthLimit && path_ccw.Line().Length() > lengthLimit )
162  break;
163 
164  m_iteration++;
165  }
166 
167  if( s_cw == IN_PROGRESS )
168  {
169  result.lineCw = path_cw;
170  result.statusCw = ALMOST_DONE;
171  }
172 
173  if( s_ccw == IN_PROGRESS )
174  {
175  result.lineCcw = path_ccw;
176  result.statusCcw = ALMOST_DONE;
177  }
178 
179  if( result.lineCw.SegmentCount() < 1 || result.lineCw.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
180  {
181  result.statusCw = STUCK;
182  }
183 
184  if( result.lineCw.PointCount() > 0 && result.lineCw.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
185  {
186  result.statusCw = ALMOST_DONE;
187  }
188 
189  if( result.lineCcw.SegmentCount() < 1 || result.lineCcw.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
190  {
191  result.statusCcw = STUCK;
192  }
193 
194  if( result.lineCcw.PointCount() > 0 && result.lineCcw.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
195  {
196  result.statusCcw = ALMOST_DONE;
197  }
198 
199  return result;
200 }
WALKAROUND_STATUS singleStep(LINE &aPath, bool aWindingDirection)
NODE::OPT_OBSTACLE m_currentObstacle[2]
void start(const LINE &aInitialPath)
NODE::OPT_OBSTACLE nearestObstacle(const LINE &aPath)
SHAPE_LINE_CHAIN.
OPT_OBSTACLE CheckColliding(const ITEM *aItem, int aKindMask=ITEM::ANY_T)
Check if the item collides with anything else in the world, and if found, returns the obstacle.
Definition: pns_node.cpp:433

References ALMOST_DONE, PNS::NODE::CheckColliding(), PNS::LINE::CLine(), PNS::LINE::CPoint(), DONE, PNS::LINE::EndsWithVia(), IN_PROGRESS, SHAPE_LINE_CHAIN::Length(), 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(), singleStep(), start(), PNS::WALKAROUND::RESULT::statusCcw, PNS::WALKAROUND::RESULT::statusCw, STUCK, and PNS::LINE::Via().

◆ Router()

◆ SetApproachCursor()

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

Definition at line 117 of file pns_walkaround.h.

118  {
119  m_cursorPos = aPos;
120  m_cursorApproachMode = aEnabled;
121  }
VECTOR2I m_cursorPos

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.

74  {
75  m_debugDecorator = aDecorator;
76  }
DEBUG_DECORATOR * m_debugDecorator
Definition: pns_algo_base.h:86

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.

124  {
125  m_forceCw = aCw;
126  m_forceWinding = aEnabled;
127  }

References m_forceCw, and m_forceWinding.

◆ SetItemMask()

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

Definition at line 101 of file pns_walkaround.h.

102  {
103  m_itemMask = aMask;
104  }

References m_itemMask.

◆ SetIterationLimit()

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

◆ SetLogger()

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

Definition at line 65 of file pns_algo_base.h.

66  {
67  m_logger = aLogger;
68  }
LOGGER * m_logger
Definition: pns_algo_base.h:88

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.

107  {
108  m_forceSingleDirection = aForceSingleDirection;
109  m_forceLongerPath = aForceSingleDirection;
110  }

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.

113  {
114  m_forceSingleDirection = aForceSingleDirection;
115  }

References m_forceSingleDirection.

◆ SetSolidsOnly()

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

◆ Settings()

◆ SetWorld()

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

Definition at line 83 of file pns_walkaround.h.

84  {
85  m_world = aNode;
86  }

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.

56 {
57  OPT<OBSTACLE>& current_obs =
58  aWindingDirection ? m_currentObstacle[0] : m_currentObstacle[1];
59 
60  if( !current_obs )
61  return DONE;
62 
63  VECTOR2I initialLast = aPath.CPoint( -1 );
64 
65  SHAPE_LINE_CHAIN path_walk;
66 
67  bool s_cw = aPath.Walkaround( current_obs->m_hull, path_walk, aWindingDirection );
68 
69  PNS_DBG( Dbg(), BeginGroup, "hull/walk" );
70  char name[128];
71  snprintf(name, sizeof(name), "hull-%s-%d", aWindingDirection ? "cw" : "ccw", m_iteration );
72  PNS_DBG( Dbg(), AddLine, current_obs->m_hull, RED, 1, name);
73  snprintf(name, sizeof(name), "path-%s-%d", aWindingDirection ? "cw" : "ccw", m_iteration );
74  PNS_DBG( Dbg(), AddLine, aPath.CLine(), GREEN, 1, name );
75  snprintf(name, sizeof(name), "result-%s-%d", aWindingDirection ? "cw" : "ccw", m_iteration );
76  PNS_DBG( Dbg(), AddLine, path_walk, BLUE, 10000, name );
77  PNS_DBG( Dbg(), Message, wxString::Format( "Stat cw %d", !!s_cw ) );
78  PNS_DBGN( Dbg(), EndGroup );
79 
80  path_walk.Simplify();
81  aPath.SetShape( path_walk );
82 
83  // If the end of the line is inside an obstacle, additional walkaround iterations are not
84  // going to help. Exit now to prevent pegging the iteration limiter and causing lag.
85  if( current_obs && current_obs->m_hull.PointInside( initialLast ) &&
86  !current_obs->m_hull.PointOnEdge( initialLast ) )
87  {
88  return ALMOST_DONE;
89  }
90 
91  current_obs = nearestObstacle( LINE( aPath, path_walk ) );
92 
93  return IN_PROGRESS;
94 }
#define PNS_DBGN(dbg, method)
SHAPE_LINE_CHAIN & Simplify(bool aRemoveColinear=true)
Function Simplify()
NODE::OPT_OBSTACLE m_currentObstacle[2]
Definition: color4d.h:57
#define PNS_DBG(dbg, method,...)
DEBUG_DECORATOR * Dbg() const
Definition: pns_algo_base.h:78
Definition: color4d.h:59
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
Definition: color4d.h:56
NODE::OPT_OBSTACLE nearestObstacle(const LINE &aPath)
const char * name
Definition: DXF_plotter.cpp:59
SHAPE_LINE_CHAIN.
boost::optional< T > OPT
Definition: optional.h:7

References ALMOST_DONE, BLUE, PNS::LINE::CLine(), PNS::LINE::CPoint(), PNS::ALGO_BASE::Dbg(), DONE, Format(), GREEN, IN_PROGRESS, m_currentObstacle, m_iteration, name, nearestObstacle(), PNS_DBG, PNS_DBGN, RED, PNS::LINE::SetShape(), SHAPE_LINE_CHAIN::Simplify(), 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.

35 {
36  m_iteration = 0;
37  m_iterationLimit = 50;
38 }

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.

40 {
41  return m_router->VisibleViewArea();
42 }
ROUTER * m_router
Definition: pns_algo_base.h:87
const BOX2I & VisibleViewArea() const
Definition: pns_router.h:220

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

Referenced by PNS::DRAGGER::optimizeAndUpdateDraggedLine(), and 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 SetApproachCursor(), and WALKAROUND().

◆ m_cursorPos

VECTOR2I PNS::WALKAROUND::m_cursorPos
private

Definition at line 159 of file pns_walkaround.h.

Referenced by 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(), 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().

◆ m_recursiveBlockageCount

int PNS::WALKAROUND::m_recursiveBlockageCount
private

Definition at line 150 of file pns_walkaround.h.

Referenced by Route(), 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

◆ m_world

NODE* PNS::WALKAROUND::m_world
private

Definition at line 148 of file pns_walkaround.h.

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


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