Eclipse SUMO - Simulation of Urban MObility
MSPModel_Striping.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2014-2020 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
19 // The pedestrian following model (prototype)
20 /****************************************************************************/
21 #pragma once
22 #include <config.h>
23 
24 #include <string>
25 #include <limits>
26 #include <utils/common/SUMOTime.h>
27 #include <utils/common/Command.h>
29 #include <microsim/MSLane.h>
30 #include "MSPerson.h"
31 #include "MSPModel.h"
32 
33 // ===========================================================================
34 // class declarations
35 // ===========================================================================
36 class MSNet;
37 class MSLink;
38 class MSJunction;
39 
40 
41 // ===========================================================================
42 // class definitions
43 // ===========================================================================
49 class MSPModel_Striping : public MSPModel {
50 
51  friend class GUIPerson; // for debugging
52 
53 public:
54 
56  MSPModel_Striping(const OptionsCont& oc, MSNet* net);
57 
59 
62 
65 
74  bool blockedAtDist(const MSLane* lane, double vehSide, double vehWidth,
75  double oncomingGap, std::vector<const MSPerson*>* collectBlockers);
76 
78  bool hasPedestrians(const MSLane* lane);
79 
82  bool usingInternalLanes();
83 
85  PersonDist nextBlocking(const MSLane* lane, double minPos, double minRight, double maxLeft, double stopTime = 0);
86 
89 
90  // @brief the width of a pedstrian stripe
91  static double stripeWidth;
92 
93  // @brief the factor for random slow-down
94  static double dawdling;
95 
96  // @brief the time threshold before becoming jammed
97  static SUMOTime jamTime;
100 
101  // @brief the distance (in seconds) to look ahead for changing stripes
102  static const double LOOKAHEAD_SAMEDIR;
103  // @brief the distance (in seconds) to look ahead for changing stripes (regarding oncoming pedestrians)
104  static const double LOOKAHEAD_ONCOMING;
105  // @brief the distance (in m) to look around for vehicles
106  static const double LOOKAROUND_VEHICLES;
107 
108  // @brief the utility penalty for moving sideways (corresponds to meters)
109  static const double LATERAL_PENALTY;
110 
111  // @brief the utility penalty for obstructed (physically blocking me) stripes (corresponds to meters)
112  static const double OBSTRUCTED_PENALTY;
113 
114  // @brief the utility penalty for inappropriate (reserved for oncoming traffic or may violate my min gap) stripes (corresponds to meters)
115  static const double INAPPROPRIATE_PENALTY;
116 
117  // @brief the utility penalty for oncoming conflicts on stripes (corresponds to meters)
118  static const double ONCOMING_CONFLICT_PENALTY;
119 
120  // @brief the minimum utility that indicates obstruction
121  static const double OBSTRUCTION_THRESHOLD;
122 
123  // @brief the factor by which pedestrian width is reduced when sqeezing past each other
124  static const double SQUEEZE;
125 
126  // @brief fraction of the leftmost lanes to reserve for oncoming traffic
129 
130  // @brief the time pedestrians take to reach maximum impatience
131  static const double MAX_WAIT_TOLERANCE;
132 
133  // @brief the fraction of forward speed to be used for lateral movemenk
134  static const double LATERAL_SPEED_FACTOR;
135 
136  // @brief the minimum distance to the next obstacle in order to start walking after stopped
137  static const double MIN_STARTUP_DIST;
138 
140 
141 
142 protected:
143  static const double DIST_FAR_AWAY;
144  static const double DIST_BEHIND;
145  static const double DIST_OVERLAP;
146 
148  public:
150  bool operator()(const MSLane* l1, const MSLane* l2) const {
151  return l1->getNumericalID() < l2->getNumericalID();
152  }
153  };
154 
155  struct Obstacle;
156  struct WalkingAreaPath;
157  class PState;
158  typedef std::vector<PState*> Pedestrians;
159  typedef std::map<const MSLane*, Pedestrians, lane_by_numid_sorter> ActiveLanes;
160  typedef std::vector<Obstacle> Obstacles;
161  typedef std::map<const MSLane*, Obstacles, lane_by_numid_sorter> NextLanesObstacles;
162  typedef std::map<std::pair<const MSLane*, const MSLane*>, const WalkingAreaPath> WalkingAreaPaths;
163  typedef std::map<const MSLane*, double> MinNextLengths;
164 
165  struct NextLaneInfo {
166  NextLaneInfo(const MSLane* _lane, const MSLink* _link, int _dir) :
167  lane(_lane),
168  link(_link),
169  dir(_dir) {
170  }
171 
173  lane(0),
174  link(0),
176  }
177 
178  // @brief the next lane to be used
179  const MSLane* lane;
180  // @brief the link from the current lane to the next lane
181  const MSLink* link;
182  // @brief the direction on the next lane
183  int dir;
184  };
185 
194  };
195 
197  struct Obstacle {
199  Obstacle(int dir, double dist = DIST_FAR_AWAY);
201  Obstacle(const PState& ped);
203  Obstacle(double _x, double _speed, ObstacleType _type, const std::string& _description, const double width = 0.)
204  : xFwd(_x + width / 2.), xBack(_x - width / 2.), speed(_speed), type(_type), description(_description) {};
205 
207  double xFwd;
209  double xBack;
211  double speed;
215  std::string description;
216  };
217 
219  WalkingAreaPath(const MSLane* _from, const MSLane* _walkingArea, const MSLane* _to, const PositionVector& _shape, int _dir) :
220  from(_from),
221  to(_to),
222  lane(_walkingArea),
223  shape(_shape),
224  dir(_dir),
225  length(_shape.length()) {
226  }
227 
228  const MSLane* const from;
229  const MSLane* const to;
230  const MSLane* const lane; // the walkingArea;
232  const int dir; // the direction when entering this path
233  const double length;
234 
235  private:
238 
239  };
240 
242  public:
244  bool operator()(const WalkingAreaPath* p1, const WalkingAreaPath* p2) const {
245  if (p1->from->getNumericalID() < p2->from->getNumericalID()) {
246  return true;
247  }
248  if (p1->from->getNumericalID() == p2->from->getNumericalID()) {
249  if (p1->to->getNumericalID() < p2->to->getNumericalID()) {
250  return true;
251  }
252  }
253  return false;
254  }
255  };
256 
257 
263  public:
264 
267  double getEdgePos(const MSStageMoving& stage, SUMOTime now) const;
268  Position getPosition(const MSStageMoving& stage, SUMOTime now) const;
269  double getAngle(const MSStageMoving& stage, SUMOTime now) const;
270  SUMOTime getWaitingTime(const MSStageMoving& stage, SUMOTime now) const;
271  double getSpeed(const MSStageMoving& stage) const;
272  const MSEdge* getNextEdge(const MSStageMoving& stage) const;
273  void moveToXY(MSPerson* p, Position pos, MSLane* lane, double lanePos,
274  double lanePosLat, double angle, int routeOffset,
275  const ConstMSEdgeVector& edges, SUMOTime t);
277  bool isJammed() const;
278  const MSLane* getLane() const;
280 
281  PState(MSPerson* person, MSStageMoving* stage, const MSLane* lane);
282 
283 
284  ~PState() {};
288  const MSLane* myLane;
290  double myRelX;
292  double myRelY;
294  int myDir;
296  double mySpeed;
310  mutable double myAngle;
311 
313  virtual double getMinX(const bool includeMinGap = true) const;
314 
316  virtual double getMaxX(const bool includeMinGap = true) const;
317 
319  double getLength() const;
320 
322  double getMinGap() const;
323 
325  double distToLaneEnd() const;
326 
328  bool moveToNextLane(SUMOTime currentTime);
329 
331  void walk(const Obstacles& obs, SUMOTime currentTime);
332 
334  double getImpatience(SUMOTime now) const;
335 
336  int stripe() const;
337  int otherStripe() const;
338 
339  static int stripe(const double relY);
340  int otherStripe(const double relY) const;
341 
342  /* @brief calculate distance to the given obstacle,
343  * - non-negative values signify an obstacle in front of ego
344  * the special values DIST_OVERLAP and DIST_BEHIND are used to signify
345  * obstacles that overlap and obstacles behind ego respectively
346  * the result is the same regardless of walking direction
347  */
348  double distanceTo(const Obstacle& obs, const bool includeMinGap = true) const;
349 
351  void mergeObstacles(Obstacles& into, const Obstacles& obs2);
352 
354  static void mergeObstacles(Obstacles& into, const Obstacles& obs2, int dir, int offset);
355 
357  bool ignoreRed(const MSLink* link) const;
358 
360  virtual const std::string& getID() const;
361 
363  virtual double getWidth() const;
364 
366  bool isRemoteControlled() const;
367 
368  protected:
370  PState();
371  };
372 
373  class PStateVehicle : public PState {
374  public:
375  PStateVehicle(const MSVehicle* veh, const MSLane* walkingarea, double relX, double relY);
376  const std::string& getID() const;
377  double getMinX(const bool includeMinGap = true) const;
378  double getMaxX(const bool includeMinGap = true) const;
379  double getWidth() const;
380  private:
382  };
383 
384 
385  class MovePedestrians : public Command {
386  public:
389  SUMOTime execute(SUMOTime currentTime);
390  private:
392  private:
395  };
396 
399  public:
401  by_xpos_sorter(int dir): myDir(dir) {}
402 
403  public:
405  bool operator()(const PState* p1, const PState* p2) const {
406  if (p1->myRelX != p2->myRelX) {
407  return myDir * p1->myRelX > myDir * p2->myRelX;
408  }
409  return p1->getID() < p2->getID();
410  }
411 
412  private:
413  const int myDir;
414 
415  private:
418  };
419 
420 
422  void moveInDirection(SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
423 
425  void moveInDirectionOnLane(Pedestrians& pedestrians, const MSLane* lane, SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
426 
428  void arriveAndAdvance(Pedestrians& pedestrians, SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
429 
431  return myActiveLanes;
432  }
433 
436  return myNumActivePedestrians;
437  }
438 
439  void registerActive() {
441  }
442 
443 private:
444  static void DEBUG_PRINT(const Obstacles& obs);
445 
447  static int connectedDirection(const MSLane* from, const MSLane* to);
448 
454  static NextLaneInfo getNextLane(const PState& ped, const MSLane* currentLane, const MSLane* prevLane);
455 
457  static const MSLane* getNextWalkingArea(const MSLane* currentLane, const int dir, const MSLink*& link);
458 
459  static void initWalkingAreaPaths(const MSNet* net);
460 
461  static const WalkingAreaPath* getWalkingAreaPath(const MSEdge* walkingArea, const MSLane* before, const MSLane* after);
462 
464  static const WalkingAreaPath* getArbitraryPath(const MSEdge* walkingArea);
465 
466  static const WalkingAreaPath* guessPath(const MSEdge* walkingArea, const MSEdge* before, const MSEdge* after);
467 
469  static int numStripes(const MSLane* lane);
470 
471  static Obstacles getNeighboringObstacles(const Pedestrians& pedestrians, int egoIndex, int stripes);
472 
473  const Obstacles& getNextLaneObstacles(NextLanesObstacles& nextLanesObs, const MSLane* lane, const MSLane* nextLane, int stripes,
474  int nextDir, double currentLength, int currentDir);
475 
476  static void transformToCurrentLanePositions(Obstacles& o, int currentDir, int nextDir, double currentLength, double nextLength);
477 
478  static void addCloserObstacle(Obstacles& obs, double x, int stripe, int numStripes, const std::string& id, double width, int dir, ObstacleType type);
479 
481  Pedestrians& getPedestrians(const MSLane* lane);
482 
483  /* @brief compute stripe-offset to transform relY values from a lane with origStripes into a lane wit destStrips
484  * @note this is called once for transforming nextLane peds to into the current system as obstacles and another time
485  * (in reverse) to transform the pedestrian coordinates into the nextLane-coordinates when changing lanes
486  */
487  static int getStripeOffset(int origStripes, int destStripes, bool addRemainder);
488 
490  static bool addCrossingVehs(const MSLane* crossing, int stripes, double lateral_offset, int dir, Obstacles& crossingVehs, bool prio);
491 
493  static Obstacles getVehicleObstacles(const MSLane* lane, int dir, PState* ped = 0);
494 
495  static bool usingInternalLanesStatic();
496 
497  static bool addVehicleFoe(const MSVehicle* veh, const MSLane* walkingarea, const Position& relPos, double lateral_offset,
498  double minY, double maxY, Pedestrians& toDelete, Pedestrians& transformedPeds);
499 
500 private:
503 
506 
509 
512  static std::map<const MSEdge*, std::vector<const MSLane*> > myWalkingAreaFoes;
514 
517 
518 };
519 
520 
521 
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:74
std::pair< const MSPerson *, double > PersonDist
Definition: MSPModel.h:39
long long int SUMOTime
Definition: SUMOTime.h:31
Base (microsim) event class.
Definition: Command.h:49
A road/street connecting two junctions.
Definition: MSEdge.h:77
The base class for an intersection.
Definition: MSJunction.h:58
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
int getNumericalID() const
Returns this lane's numerical id.
Definition: MSLane.h:468
The simulated network and simulation perfomer.
Definition: MSNet.h:89
MSPModel_Striping *const myModel
MovePedestrians(MSPModel_Striping *model)
SUMOTime execute(SUMOTime currentTime)
Executes the command.
MovePedestrians & operator=(const MovePedestrians &)
Invalidated assignment operator.
Container for pedestrian state and individual position update function.
virtual double getMaxX(const bool includeMinGap=true) const
return the maximum position on the lane
bool isJammed() const
whether the transportable is jammed
bool myAmJammed
whether the person is jammed
Position myRemoteXYPos
remote-controlled position
bool myWaitingToEnter
whether the pedestrian is waiting to start its walk
const WalkingAreaPath * myWalkingAreaPath
the current walkingAreaPath or 0
SUMOTime getWaitingTime(const MSStageMoving &stage, SUMOTime now) const
return the time the transportable spent standing
PState()
constructor for PStateVehicle
double myRelX
the advancement along the current lane
double distToLaneEnd() const
the absolute distance to the end of the lane in walking direction (or to the arrivalPos)
int myDir
the walking direction on the current lane (1 forward, -1 backward)
double myRelY
the orthogonal shift on the current lane
void mergeObstacles(Obstacles &into, const Obstacles &obs2)
replace obstacles in the first vector with obstacles from the second if they are closer to me
bool isRemoteControlled() const
whether the person is currently being controlled via TraCI
const MSEdge * getNextEdge(const MSStageMoving &stage) const
return the list of internal edges if the transportable is on an intersection
void walk(const Obstacles &obs, SUMOTime currentTime)
perform position update
virtual double getWidth() const
return the person width
double mySpeed
the current walking speed
bool ignoreRed(const MSLink *link) const
whether the pedestrian may ignore a red light
virtual double getMinX(const bool includeMinGap=true) const
return the minimum position on the lane
bool moveToNextLane(SUMOTime currentTime)
return whether this pedestrian has passed the end of the current lane and update myRelX if so
double getMinGap() const
return the minimum gap of the pedestrian
void moveToXY(MSPerson *p, Position pos, MSLane *lane, double lanePos, double lanePosLat, double angle, int routeOffset, const ConstMSEdgeVector &edges, SUMOTime t)
try to move transportable to the given position
double myAngle
cached angle
double getSpeed(const MSStageMoving &stage) const
return the current speed of the transportable
Position getPosition(const MSStageMoving &stage, SUMOTime now) const
return the network coordinate of the transportable
NextLaneInfo myNLI
information about the upcoming lane
const MSLane * myLane
the current lane of this pedestrian
double getAngle(const MSStageMoving &stage, SUMOTime now) const
return the direction in which the transportable faces in degrees
virtual const std::string & getID() const
return the person id
double getImpatience(SUMOTime now) const
returns the impatience
SUMOTime myWaitingTime
the consecutive time spent at speed 0
double distanceTo(const Obstacle &obs, const bool includeMinGap=true) const
const MSLane * getLane() const
whether the transportable is jammed
double getEdgePos(const MSStageMoving &stage, SUMOTime now) const
abstract methods inherited from PedestrianState
double getLength() const
return the length of the pedestrian
double getWidth() const
return the person width
double getMaxX(const bool includeMinGap=true) const
return the maximum position on the lane
double getMinX(const bool includeMinGap=true) const
return the minimum position on the lane
const std::string & getID() const
return the person id
PStateVehicle(const MSVehicle *veh, const MSLane *walkingarea, double relX, double relY)
sorts the persons by position on the lane. If dir is forward, higher x positions come first.
bool operator()(const PState *p1, const PState *p2) const
comparing operation
by_xpos_sorter & operator=(const by_xpos_sorter &)
Invalidated assignment operator.
bool operator()(const MSLane *l1, const MSLane *l2) const
comparing operation
bool operator()(const WalkingAreaPath *p1, const WalkingAreaPath *p2) const
comparing operation
The pedestrian following model.
static const double MIN_STARTUP_DIST
static double RESERVE_FOR_ONCOMING_FACTOR
static MinNextLengths myMinNextLengths
const ActiveLanes & getActiveLanes()
static SUMOTime jamTimeCrossing
bool hasPedestrians(const MSLane *lane)
whether the given lane has pedestrians on it
void moveInDirection(SUMOTime currentTime, std::set< MSPerson * > &changedLane, int dir)
move all pedestrians forward and advance to the next lane if applicable
static void transformToCurrentLanePositions(Obstacles &o, int currentDir, int nextDir, double currentLength, double nextLength)
static const double LOOKAHEAD_SAMEDIR
static NextLaneInfo getNextLane(const PState &ped, const MSLane *currentLane, const MSLane *prevLane)
computes the successor lane for the given pedestrian and sets the link as well as the direction to us...
static void initWalkingAreaPaths(const MSNet *net)
std::vector< PState * > Pedestrians
std::map< const MSLane *, Pedestrians, lane_by_numid_sorter > ActiveLanes
ActiveLanes myActiveLanes
store of all lanes which have pedestrians on them
static const double LOOKAROUND_VEHICLES
static const double SQUEEZE
static SUMOTime jamTimeNarrow
static const WalkingAreaPath * getWalkingAreaPath(const MSEdge *walkingArea, const MSLane *before, const MSLane *after)
void arriveAndAdvance(Pedestrians &pedestrians, SUMOTime currentTime, std::set< MSPerson * > &changedLane, int dir)
handle arrivals and lane advancement
std::map< const MSLane *, double > MinNextLengths
static double RESERVE_FOR_ONCOMING_FACTOR_JUNCTIONS
static int getStripeOffset(int origStripes, int destStripes, bool addRemainder)
bool myAmActive
whether an event for pedestrian processing was added
static const WalkingAreaPath * guessPath(const MSEdge *walkingArea, const MSEdge *before, const MSEdge *after)
static SUMOTime jamTime
static double stripeWidth
model parameters
bool blockedAtDist(const MSLane *lane, double vehSide, double vehWidth, double oncomingGap, std::vector< const MSPerson * > *collectBlockers)
whether a pedestrian is blocking the crossing of lane for the given vehicle bondaries
static const double MAX_WAIT_TOLERANCE
static Obstacles getVehicleObstacles(const MSLane *lane, int dir, PState *ped=0)
retrieve vehicle obstacles on the given lane
static const double OBSTRUCTED_PENALTY
std::map< const MSLane *, Obstacles, lane_by_numid_sorter > NextLanesObstacles
static const MSLane * getNextWalkingArea(const MSLane *currentLane, const int dir, const MSLink *&link)
return the next walkingArea in the given direction
PersonDist nextBlocking(const MSLane *lane, double minPos, double minRight, double maxLeft, double stopTime=0)
returns the next pedestrian beyond minPos that is laterally between minRight and maxLeft or 0
MSTransportableStateAdapter * add(MSTransportable *transportable, MSStageMoving *stage, SUMOTime now)
register the given person as a pedestrian
static const double DIST_OVERLAP
static const WalkingAreaPath * getArbitraryPath(const MSEdge *walkingArea)
return an arbitrary path across the given walkingArea
static const double LATERAL_PENALTY
std::vector< Obstacle > Obstacles
void remove(MSTransportableStateAdapter *state)
remove the specified person from the pedestrian simulation
static const double DIST_BEHIND
bool usingInternalLanes()
whether movements on intersections are modelled /
void moveInDirectionOnLane(Pedestrians &pedestrians, const MSLane *lane, SUMOTime currentTime, std::set< MSPerson * > &changedLane, int dir)
move pedestrians forward on one lane
MSPModel_Striping(const OptionsCont &oc, MSNet *net)
Constructor (it should not be necessary to construct more than one instance)
static bool addVehicleFoe(const MSVehicle *veh, const MSLane *walkingarea, const Position &relPos, double lateral_offset, double minY, double maxY, Pedestrians &toDelete, Pedestrians &transformedPeds)
static bool usingInternalLanesStatic()
static Obstacles getNeighboringObstacles(const Pedestrians &pedestrians, int egoIndex, int stripes)
static Pedestrians noPedestrians
empty pedestrian vector
static void addCloserObstacle(Obstacles &obs, double x, int stripe, int numStripes, const std::string &id, double width, int dir, ObstacleType type)
Pedestrians & getPedestrians(const MSLane *lane)
retrieves the pedestian vector for the given lane (may be empty)
static double dawdling
static int numStripes(const MSLane *lane)
return the maximum number of pedestrians walking side by side
int getActiveNumber()
return the number of active objects
static const double OBSTRUCTION_THRESHOLD
static bool addCrossingVehs(const MSLane *crossing, int stripes, double lateral_offset, int dir, Obstacles &crossingVehs, bool prio)
add vehicles driving across
static int connectedDirection(const MSLane *from, const MSLane *to)
returns the direction in which these lanes are connectioned or 0 if they are not
static void DEBUG_PRINT(const Obstacles &obs)
static const double LATERAL_SPEED_FACTOR
static const double INAPPROPRIATE_PENALTY
static const double ONCOMING_CONFLICT_PENALTY
int myNumActivePedestrians
the total number of active pedestrians
static const double LOOKAHEAD_ONCOMING
static std::map< const MSEdge *, std::vector< const MSLane * > > myWalkingAreaFoes
const Obstacles & getNextLaneObstacles(NextLanesObstacles &nextLanesObs, const MSLane *lane, const MSLane *nextLane, int stripes, int nextDir, double currentLength, int currentDir)
static const double DIST_FAR_AWAY
std::map< std::pair< const MSLane *, const MSLane * >, const WalkingAreaPath > WalkingAreaPaths
static WalkingAreaPaths myWalkingAreaPaths
store for walkinArea elements
The pedestrian (and also sometimes container) movement model.
Definition: MSPModel.h:51
static const int UNDEFINED_DIRECTION
Definition: MSPModel.h:107
abstract base class for managing callbacks to retrieve various state information from the model
Definition: MSPModel.h:130
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
A storage for options typed value containers)
Definition: OptionsCont.h:89
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:36
A list of positions.
NextLaneInfo(const MSLane *_lane, const MSLink *_link, int _dir)
information regarding surround Pedestrians (and potentially other things)
double speed
speed relative to lane direction (positive means in the same direction)
double xFwd
maximal position on the current lane in forward direction
Obstacle(int dir, double dist=DIST_FAR_AWAY)
create No-Obstacle
std::string description
the id / description of the obstacle
Obstacle(double _x, double _speed, ObstacleType _type, const std::string &_description, const double width=0.)
create an obstacle from explict values
ObstacleType type
whether this obstacle denotes a border or a pedestrian
double xBack
maximal position on the current lane in backward direction
WalkingAreaPath(const MSLane *_from, const MSLane *_walkingArea, const MSLane *_to, const PositionVector &_shape, int _dir)
WalkingAreaPath & operator=(const WalkingAreaPath &s)=delete
Invalidated assignment operator.