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 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_iteration
 
int m_iterationLimit
 
int m_itemMask
 
bool m_forceWinding
 
bool m_forceCw
 
VECTOR2I m_cursorPos
 
NODE::OPT_OBSTACLE m_currentObstacle [2]
 
std::set< ITEM * > m_restrictedSet
 
std::vector< VECTOR2Im_restrictedVertices
 
bool m_forceLongerPath
 

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 56 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_forceWinding = false;
47
48 // Initialize other members, to avoid uninitialized variables.
49 m_iteration = 0;
50 m_forceCw = false;
51 m_forceLongerPath = false;
52 }
ALGO_BASE(ROUTER *aRouter)
Definition: pns_algo_base.h:45
static const int DefaultIterationLimit

References PNS::ITEM::ANY_T, m_forceCw, m_forceLongerPath, m_forceWinding, m_itemMask, and m_iteration.

◆ ~WALKAROUND()

PNS::WALKAROUND::~WALKAROUND ( )
inline

Definition at line 54 of file pns_walkaround.h.

54{};

Member Function Documentation

◆ Dbg()

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

◆ Logger()

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

Reimplemented in PNS::SHOVE.

Definition at line 34 of file pns_algo_base.cpp.

35{
36 return nullptr;
37}

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

44{
46 &aPath, m_itemMask, m_restrictedSet.empty() ? nullptr : &m_restrictedSet, false );
47
48 if( m_restrictedSet.empty() )
49 return obs;
50
51 else if( obs && m_restrictedSet.find ( obs->m_item ) != m_restrictedSet.end() )
52 return obs;
53
54 return NODE::OPT_OBSTACLE();
55}
OPT< OBSTACLE > OPT_OBSTACLE
Definition: pns_node.h:160
OPT_OBSTACLE NearestObstacle(const LINE *aLine, int aKindMask=ITEM::ANY_T, const std::set< ITEM * > *aRestrictedSet=nullptr, bool aUseClearanceEpsilon=true)
Follow the line in search of an obstacle that is nearest to the starting to the line's starting point...
Definition: pns_node.cpp:301
std::set< ITEM * > m_restrictedSet

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

Referenced by Route(), and singleStep().

◆ RestrictToSet()

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

Definition at line 58 of file pns_walkaround.cpp.

59{
61
62 if( aEnabled )
63 m_restrictedSet = aSet;
64 else
65 m_restrictedSet.clear();
66
67 for( auto item : aSet )
68 {
69 if( auto solid = dyn_cast<SOLID*>( item ) )
70 {
71 m_restrictedVertices.push_back( solid->Anchor( 0 ) );
72 }
73 }
74}
std::vector< VECTOR2I > m_restrictedVertices

References m_restrictedSet, and m_restrictedVertices.

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

◆ Route() [1/2]

const WALKAROUND::RESULT PNS::WALKAROUND::Route ( const LINE aInitialPath)

Definition at line 115 of file pns_walkaround.cpp.

116{
117 LINE path_cw( aInitialPath ), path_ccw( aInitialPath );
119 SHAPE_LINE_CHAIN best_path;
120 RESULT result;
121
122 // special case for via-in-the-middle-of-track placement
123 if( aInitialPath.PointCount() <= 1 )
124 {
125 if( aInitialPath.EndsWithVia() && m_world->CheckColliding( &aInitialPath.Via(),
126 m_itemMask ) )
127 return RESULT( STUCK, STUCK );
128
129 return RESULT( DONE, DONE, aInitialPath, aInitialPath );
130 }
131
132 start( aInitialPath );
133
134 m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath );
135
136 result.lineCw = aInitialPath;
137 result.lineCcw = aInitialPath;
138
139 if( m_forceWinding )
140 {
141 s_cw = m_forceCw ? IN_PROGRESS : STUCK;
142 s_ccw = m_forceCw ? STUCK : IN_PROGRESS;
143 }
144
145 // In some situations, there isn't a trivial path (or even a path at all). Hitting the
146 // iteration limit causes lag, so we can exit out early if the walkaround path gets very long
147 // compared with the initial path. If the length exceeds the initial length times this factor,
148 // fail out.
149 const int maxWalkDistFactor = 10;
150 long long lengthLimit = aInitialPath.CLine().Length() * maxWalkDistFactor;
151
153 {
154 if( s_cw != STUCK && s_cw != ALMOST_DONE )
155 s_cw = singleStep( path_cw, true );
156
157 if( s_ccw != STUCK && s_ccw != ALMOST_DONE )
158 s_ccw = singleStep( path_ccw, false );
159
160 if( s_cw != IN_PROGRESS )
161 {
162 result.lineCw = path_cw;
163 result.statusCw = s_cw;
164 }
165
166 if( s_ccw != IN_PROGRESS )
167 {
168 result.lineCcw = path_ccw;
169 result.statusCcw = s_ccw;
170 }
171
172 if( s_cw != IN_PROGRESS && s_ccw != IN_PROGRESS )
173 break;
174
175 // Safety valve
176 if( path_cw.Line().Length() > lengthLimit && path_ccw.Line().Length() > lengthLimit )
177 break;
178
179 m_iteration++;
180 }
181
182 if( s_cw == IN_PROGRESS )
183 {
184 result.lineCw = path_cw;
185 result.statusCw = ALMOST_DONE;
186 }
187
188 if( s_ccw == IN_PROGRESS )
189 {
190 result.lineCcw = path_ccw;
191 result.statusCcw = ALMOST_DONE;
192 }
193
194 if( result.lineCw.SegmentCount() < 1 || result.lineCw.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
195 {
196 result.statusCw = STUCK;
197 }
198
199 if( result.lineCw.PointCount() > 0 && result.lineCw.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
200 {
201 result.statusCw = ALMOST_DONE;
202 }
203
204 if( result.lineCcw.SegmentCount() < 1 ||
205 result.lineCcw.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
206 {
207 result.statusCcw = STUCK;
208 }
209
210 if( result.lineCcw.PointCount() > 0 &&
211 result.lineCcw.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
212 {
213 result.statusCcw = ALMOST_DONE;
214 }
215
216 result.lineCw.ClearLinks();
217 result.lineCcw.ClearLinks();
218
219 return result;
220}
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:468
WALKAROUND_STATUS singleStep(LINE &aPath, bool aWindingDirection)
NODE::OPT_OBSTACLE m_currentObstacle[2]
NODE::OPT_OBSTACLE nearestObstacle(const LINE &aPath)
void start(const LINE &aInitialPath)
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...

References ALMOST_DONE, PNS::NODE::CheckColliding(), PNS::LINK_HOLDER::ClearLinks(), 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_forceWinding, m_itemMask, m_iteration, m_iterationLimit, m_world, nearestObstacle(), PNS::LINE::PointCount(), PNS::LINE::SegmentCount(), singleStep(), start(), PNS::WALKAROUND::RESULT::statusCcw, PNS::WALKAROUND::RESULT::statusCw, STUCK, and PNS::LINE::Via().

◆ Route() [2/2]

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

Definition at line 223 of file pns_walkaround.cpp.

225{
226 LINE path_cw( aInitialPath ), path_ccw( aInitialPath );
228 SHAPE_LINE_CHAIN best_path;
229
230 // special case for via-in-the-middle-of-track placement
231 if( aInitialPath.PointCount() <= 1 )
232 {
233 if( aInitialPath.EndsWithVia() && m_world->CheckColliding( &aInitialPath.Via(),
234 m_itemMask ) )
235 return STUCK;
236
237 aWalkPath = aInitialPath;
238 return DONE;
239 }
240
241 start( aInitialPath );
242
243 m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath );
244
245 aWalkPath = aInitialPath;
246
247 if( m_forceWinding )
248 {
249 s_cw = m_forceCw ? IN_PROGRESS : STUCK;
250 s_ccw = m_forceCw ? STUCK : IN_PROGRESS;
251 }
252
254 {
255 if( path_cw.PointCount() == 0 )
256 s_cw = STUCK; // cw path is empty, can't continue
257
258 if( path_ccw.PointCount() == 0 )
259 s_ccw = STUCK; // ccw path is empty, can't continue
260
261 if( s_cw != STUCK )
262 s_cw = singleStep( path_cw, true );
263
264 if( s_ccw != STUCK )
265 s_ccw = singleStep( path_ccw, false );
266
267 if( ( s_cw == DONE && s_ccw == DONE ) || ( s_cw == STUCK && s_ccw == STUCK ) )
268 {
269 int len_cw = path_cw.CLine().Length();
270 int len_ccw = path_ccw.CLine().Length();
271
273 aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
274 else
275 aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );
276
277 break;
278 }
279 else if( s_cw == DONE && !m_forceLongerPath )
280 {
281 aWalkPath = path_cw;
282 break;
283 }
284 else if( s_ccw == DONE && !m_forceLongerPath )
285 {
286 aWalkPath = path_ccw;
287 break;
288 }
289
290 m_iteration++;
291 }
292
294 {
295 int len_cw = path_cw.CLine().Length();
296 int len_ccw = path_ccw.CLine().Length();
297
299 aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
300 else
301 aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );
302 }
303
304 aWalkPath.Line().Simplify();
305
306 if( aWalkPath.SegmentCount() < 1 )
307 return STUCK;
308
309 if( aWalkPath.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
310 return ALMOST_DONE;
311
312 if( aWalkPath.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
313 return STUCK;
314
315 WALKAROUND_STATUS st = s_ccw == DONE || s_cw == DONE ? DONE : STUCK;
316
317 if( st == DONE )
318 {
319 if( aOptimize )
321 }
322
323 return st;
324}
static bool Optimize(LINE *aLine, int aEffortLevel, NODE *aWorld, const VECTOR2I &aV=VECTOR2I(0, 0))
@ MERGE_OBTUSE
Reduce corner cost by merging obtuse segments.

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_forceWinding, m_itemMask, m_iteration, m_iterationLimit, 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().

◆ Router()

◆ 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 }

References PNS::ALGO_BASE::m_debugDecorator.

Referenced by PNS::SHOVE::onCollidingSolid(), 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 101 of file pns_walkaround.h.

102 {
103 m_forceCw = aCw;
104 m_forceWinding = aEnabled;
105 }

References m_forceCw, and m_forceWinding.

◆ SetItemMask()

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

Definition at line 96 of file pns_walkaround.h.

97 {
98 m_itemMask = aMask;
99 }

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().

◆ SetSolidsOnly()

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

◆ Settings()

◆ SetWorld()

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

Definition at line 78 of file pns_walkaround.h.

79 {
80 m_world = aNode;
81 }

References m_world.

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

◆ singleStep()

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

Definition at line 77 of file pns_walkaround.cpp.

78{
79 OPT<OBSTACLE>& current_obs =
80 aWindingDirection ? m_currentObstacle[0] : m_currentObstacle[1];
81
82 if( !current_obs )
83 return DONE;
84
85 VECTOR2I initialLast = aPath.CPoint( -1 );
86
87 SHAPE_LINE_CHAIN path_walk;
88
89 bool s_cw = aPath.Walkaround( current_obs->m_hull, path_walk, aWindingDirection );
90
91 PNS_DBG( Dbg(), BeginGroup, "hull/walk", 1 );
92 PNS_DBG( Dbg(), AddShape, &current_obs->m_hull, RED, 0, wxString::Format( "hull-%s-%d", aWindingDirection ? wxT( "cw" ) : wxT( "ccw" ), m_iteration ) );
93 PNS_DBG( Dbg(), AddShape, &aPath.CLine(), GREEN, 0, wxString::Format( "path-%s-%d", aWindingDirection ? wxT( "cw" ) : wxT( "ccw" ), m_iteration ) );
94 PNS_DBG( Dbg(), AddShape, &path_walk, BLUE, 0, wxString::Format( "result-%s-%d", aWindingDirection ? wxT( "cw" ) : wxT( "ccw" ), m_iteration ) );
95 PNS_DBG( Dbg(), Message, wxString::Format( wxT( "Stat cw %d" ), !!s_cw ) );
96 PNS_DBGN( Dbg(), EndGroup );
97
98 path_walk.Simplify();
99 aPath.SetShape( path_walk );
100
101 // If the end of the line is inside an obstacle, additional walkaround iterations are not
102 // going to help. Exit now to prevent pegging the iteration limiter and causing lag.
103 if( current_obs && current_obs->m_hull.PointInside( initialLast ) &&
104 !current_obs->m_hull.PointOnEdge( initialLast ) )
105 {
106 return ALMOST_DONE;
107 }
108
109 current_obs = nearestObstacle( LINE( aPath, path_walk ) );
110
111 return IN_PROGRESS;
112}
DEBUG_DECORATOR * Dbg() const
Definition: pns_algo_base.h:78
SHAPE_LINE_CHAIN & Simplify(bool aRemoveColinear=true)
Simplify the line chain by removing colinear adjacent segments and duplicate vertices.
@ BLUE
Definition: color4d.h:56
@ GREEN
Definition: color4d.h:57
@ RED
Definition: color4d.h:59
boost::optional< T > OPT
Definition: optional.h:7
#define PNS_DBG(dbg, method,...)
#define PNS_DBGN(dbg, method)
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

References ALMOST_DONE, BLUE, PNS::LINE::CLine(), PNS::LINE::CPoint(), PNS::ALGO_BASE::Dbg(), DONE, Format(), GREEN, IN_PROGRESS, m_currentObstacle, m_iteration, 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 36 of file pns_walkaround.cpp.

37{
38 m_iteration = 0;
40}

References m_iteration, and m_iterationLimit.

Referenced by Route().

◆ VisibleViewArea()

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

Definition at line 40 of file pns_algo_base.cpp.

41{
42 return m_router->VisibleViewArea();
43}
const BOX2I & VisibleViewArea() const
Definition: pns_router.h:211

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 128 of file pns_walkaround.h.

Referenced by Route(), and singleStep().

◆ m_cursorPos

VECTOR2I PNS::WALKAROUND::m_cursorPos
private

Definition at line 127 of file pns_walkaround.h.

◆ 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 126 of file pns_walkaround.h.

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

◆ m_forceLongerPath

bool PNS::WALKAROUND::m_forceLongerPath
private

Definition at line 131 of file pns_walkaround.h.

Referenced by Route(), and WALKAROUND().

◆ m_forceWinding

bool PNS::WALKAROUND::m_forceWinding
private

Definition at line 125 of file pns_walkaround.h.

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

◆ m_itemMask

int PNS::WALKAROUND::m_itemMask
private

Definition at line 124 of file pns_walkaround.h.

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

◆ m_iteration

int PNS::WALKAROUND::m_iteration
private

Definition at line 122 of file pns_walkaround.h.

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

◆ m_iterationLimit

int PNS::WALKAROUND::m_iterationLimit
private

Definition at line 123 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_restrictedSet

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

Definition at line 129 of file pns_walkaround.h.

Referenced by nearestObstacle(), and RestrictToSet().

◆ m_restrictedVertices

std::vector<VECTOR2I> PNS::WALKAROUND::m_restrictedVertices
private

Definition at line 130 of file pns_walkaround.h.

Referenced by RestrictToSet().

◆ m_router

◆ m_world

NODE* PNS::WALKAROUND::m_world
private

Definition at line 120 of file pns_walkaround.h.

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


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