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-2022 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>
29#include <microsim/MSLane.h>
30#include "MSPerson.h"
31#include "MSPModel.h"
32
33// ===========================================================================
34// class declarations
35// ===========================================================================
36class MSNet;
37class MSLink;
38class MSJunction;
39
40
41// ===========================================================================
42// class definitions
43// ===========================================================================
50
51 friend class GUIPerson; // for debugging
52
53public:
54
56 MSPModel_Striping(const OptionsCont& oc, MSNet* net);
57
59
61 void clearState();
62
65
67 MSTransportableStateAdapter* loadState(MSTransportable* transportable, MSStageMoving* stage, std::istringstream& in);
68
71
80 bool blockedAtDist(const MSLane* lane, double vehSide, double vehWidth,
81 double oncomingGap, std::vector<const MSPerson*>* collectBlockers);
82
84 bool hasPedestrians(const MSLane* lane);
85
88 bool usingInternalLanes();
89
91 PersonDist nextBlocking(const MSLane* lane, double minPos, double minRight, double maxLeft, double stopTime = 0, bool bidi = false);
92
95
96 // @brief the width of a pedstrian stripe
97 static double stripeWidth;
98
99 // @brief the factor for random slow-down
100 static double dawdling;
101
102 // @brief the safety buffer to vehicles
103 static double minGapToVehicle;
104
105 // @brief intermediate points to smooth out lanes within the walkingarea
107
108 // @brief the time threshold before becoming jammed
112
113 // @brief use old style departPosLat interpretation
114 static bool myLegacyPosLat;
115
116 // @brief the distance (in seconds) to look ahead for changing stripes
117 static const double LOOKAHEAD_SAMEDIR;
118 // @brief the distance (in seconds) to look ahead for changing stripes (regarding oncoming pedestrians)
119 static const double LOOKAHEAD_ONCOMING;
120 // @brief the distance (in m) to look around for vehicles
121 static const double LOOKAROUND_VEHICLES;
122
123 // @brief the utility penalty for moving sideways (corresponds to meters)
124 static const double LATERAL_PENALTY;
125
126 // @brief the utility penalty for obstructed (physically blocking me) stripes (corresponds to meters)
127 static const double OBSTRUCTED_PENALTY;
128
129 // @brief the utility penalty for inappropriate (reserved for oncoming traffic or may violate my min gap) stripes (corresponds to meters)
130 static const double INAPPROPRIATE_PENALTY;
131
132 // @brief the utility penalty for oncoming conflicts on stripes (corresponds to meters)
133 static const double ONCOMING_CONFLICT_PENALTY;
134
135 // @brief the minimum utility that indicates obstruction
136 static const double OBSTRUCTION_THRESHOLD;
137
138 // @brief the factor by which pedestrian width is reduced when sqeezing past each other
139 static const double SQUEEZE;
140
141 // @brief fraction of the leftmost lanes to reserve for oncoming traffic
144
145 // @brief the time pedestrians take to reach maximum impatience
146 static const double MAX_WAIT_TOLERANCE;
147
148 // @brief the fraction of forward speed to be used for lateral movemenk
149 static const double LATERAL_SPEED_FACTOR;
150
151 // @brief the minimum distance to the next obstacle in order to start walking after stopped
152 static const double MIN_STARTUP_DIST;
153
155
156
157protected:
158 static const double DIST_FAR_AWAY;
159 static const double DIST_BEHIND;
160 static const double DIST_OVERLAP;
161
163 public:
165 bool operator()(const MSLane* l1, const MSLane* l2) const {
166 return l1->getNumericalID() < l2->getNumericalID();
167 }
168 };
169
170 struct Obstacle;
171 struct WalkingAreaPath;
172 class PState;
173 typedef std::vector<PState*> Pedestrians;
174 typedef std::map<const MSLane*, Pedestrians, lane_by_numid_sorter> ActiveLanes;
175 typedef std::vector<Obstacle> Obstacles;
176 typedef std::map<const MSLane*, Obstacles, lane_by_numid_sorter> NextLanesObstacles;
177 typedef std::map<std::pair<const MSLane*, const MSLane*>, const WalkingAreaPath> WalkingAreaPaths;
178 typedef std::map<const MSLane*, double> MinNextLengths;
179
181 NextLaneInfo(const MSLane* _lane, const MSLink* _link, int _dir) :
182 lane(_lane),
183 link(_link),
184 dir(_dir) {
185 }
186
188 lane(0),
189 link(0),
191 }
192
193 // @brief the next lane to be used
194 const MSLane* lane;
195 // @brief the link from the current lane to the next lane
196 const MSLink* link;
197 // @brief the direction on the next lane
198 int dir;
199 };
200
209 };
210
212 struct Obstacle {
214 Obstacle(int dir, double dist = DIST_FAR_AWAY);
216 Obstacle(const PState& ped);
218 Obstacle(double _x, double _speed, ObstacleType _type, const std::string& _description, const double width = 0.)
219 : xFwd(_x + width / 2.), xBack(_x - width / 2.), speed(_speed), type(_type), description(_description) {};
220
222 double xFwd;
224 double xBack;
226 double speed;
230 std::string description;
231 };
232
234 WalkingAreaPath(const MSLane* _from, const MSLane* _walkingArea, const MSLane* _to, const PositionVector& _shape, int _dir) :
235 from(_from),
236 to(_to),
237 lane(_walkingArea),
238 shape(_shape),
239 dir(_dir),
240 length(_shape.length()) {
241 }
242
243 const MSLane* const from;
244 const MSLane* const to;
245 const MSLane* const lane; // the walkingArea;
247 const int dir; // the direction when entering this path
248 const double length;
249
250 };
251
253 public:
255 bool operator()(const WalkingAreaPath* p1, const WalkingAreaPath* p2) const {
256 if (p1->from->getNumericalID() < p2->from->getNumericalID()) {
257 return true;
258 }
259 if (p1->from->getNumericalID() == p2->from->getNumericalID()) {
260 if (p1->to->getNumericalID() < p2->to->getNumericalID()) {
261 return true;
262 }
263 }
264 return false;
265 }
266 };
267
268
274 public:
275
278 double getEdgePos(const MSStageMoving& stage, SUMOTime now) const;
279 int getDirection(const MSStageMoving& stage, SUMOTime now) const;
280 Position getPosition(const MSStageMoving& stage, SUMOTime now) const;
281 double getAngle(const MSStageMoving& stage, SUMOTime now) const;
282 SUMOTime getWaitingTime(const MSStageMoving& stage, SUMOTime now) const;
283 double getSpeed(const MSStageMoving& stage) const;
284 const MSEdge* getNextEdge(const MSStageMoving& stage) const;
285 void moveTo(MSPerson* p, MSLane* lane, double lanePos, double lanePosLat, SUMOTime t);
286 void moveToXY(MSPerson* p, Position pos, MSLane* lane, double lanePos,
287 double lanePosLat, double angle, int routeOffset,
288 const ConstMSEdgeVector& edges, SUMOTime t);
290 bool isJammed() const;
291 const MSLane* getLane() const;
293
294 PState(MSPerson* person, MSStageMoving* stage, const MSLane* lane);
295
297 PState(MSPerson* person, MSStageMoving* stage, std::istringstream* in = nullptr);
298
305 double myRelX;
307 double myRelY;
309 int myDir;
311 double mySpeed;
327 mutable double myAngle;
328
330 virtual double getMinX(const bool includeMinGap = true) const;
331
333 virtual double getMaxX(const bool includeMinGap = true) const;
334
336 double getLength() const;
337
339 double getMinGap() const;
340
342 double distToLaneEnd() const;
343
345 bool moveToNextLane(SUMOTime currentTime);
346
348 void walk(const Obstacles& obs, SUMOTime currentTime);
349
351 double getImpatience(SUMOTime now) const;
352
353 int stripe() const;
354 int otherStripe() const;
355
356 static int stripe(const double relY);
357 int otherStripe(const double relY) const;
358
359 /* @brief calculate distance to the given obstacle,
360 * - non-negative values signify an obstacle in front of ego
361 * the special values DIST_OVERLAP and DIST_BEHIND are used to signify
362 * obstacles that overlap and obstacles behind ego respectively
363 * the result is the same regardless of walking direction
364 */
365 double distanceTo(const Obstacle& obs, const bool includeMinGap = true) const;
366
368 void mergeObstacles(Obstacles& into, const Obstacles& obs2);
369
371 static void mergeObstacles(Obstacles& into, const Obstacles& obs2, int dir, int offset);
372
374 bool ignoreRed(const MSLink* link) const;
375
377 virtual const std::string& getID() const;
378
380 virtual double getWidth() const;
381
382 virtual ObstacleType getOType() const {
383 return OBSTACLE_PED;
384 }
385
387 bool isRemoteControlled() const;
388
391 void saveState(std::ostringstream& out);
392
393 protected:
395 PState();
396 private:
398 PState& operator=(const PState&) = delete;
399 };
400
401 class PStateVehicle : public PState {
402 public:
403 PStateVehicle(const MSVehicle* veh, const MSLane* walkingarea, double relX, double relY, double xWidth, double yWidth);
404 const std::string& getID() const;
405 double getMinX(const bool includeMinGap = true) const;
406 double getMaxX(const bool includeMinGap = true) const;
407 double getWidth() const;
408
410 return OBSTACLE_VEHICLE;
411 }
412 private:
414 const double myXWidth;
415 const double myYWidth;
416 };
417
418
419 class MovePedestrians : public Command {
420 public:
423 SUMOTime execute(SUMOTime currentTime);
424 private:
426 private:
429 };
430
433 public:
435 by_xpos_sorter(int dir): myDir(dir) {}
436
437 public:
439 bool operator()(const PState* p1, const PState* p2) const {
440 if (p1->myRelX != p2->myRelX) {
441 return myDir * p1->myRelX > myDir * p2->myRelX;
442 }
443 return p1->getID() < p2->getID();
444 }
445
446 private:
447 const int myDir;
448 };
449
450
452 void moveInDirection(SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
453
455 void moveInDirectionOnLane(Pedestrians& pedestrians, const MSLane* lane, SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
456
458 void arriveAndAdvance(Pedestrians& pedestrians, SUMOTime currentTime, std::set<MSPerson*>& changedLane, int dir);
459
461 return myActiveLanes;
462 }
463
467 }
468
471 }
472
473private:
474 static void DEBUG_PRINT(const Obstacles& obs);
475
477 static int connectedDirection(const MSLane* from, const MSLane* to);
478
484 static NextLaneInfo getNextLane(const PState& ped, const MSLane* currentLane, const MSLane* prevLane);
485
487 static const MSLane* getNextWalkingArea(const MSLane* currentLane, const int dir, const MSLink*& link);
488
489 static void initWalkingAreaPaths(const MSNet* net);
490
491 static const WalkingAreaPath* getWalkingAreaPath(const MSEdge* walkingArea, const MSLane* before, const MSLane* after);
492
494 static const WalkingAreaPath* getArbitraryPath(const MSEdge* walkingArea);
495
496 static const WalkingAreaPath* guessPath(const MSEdge* walkingArea, const MSEdge* before, const MSEdge* after);
497
499 static int numStripes(const MSLane* lane);
500
501 static Obstacles getNeighboringObstacles(const Pedestrians& pedestrians, int egoIndex, int stripes);
502
503 const Obstacles& getNextLaneObstacles(NextLanesObstacles& nextLanesObs, const MSLane* lane, const MSLane* nextLane, int stripes,
504 int nextDir, double currentLength, int currentDir);
505
506 static void transformToCurrentLanePositions(Obstacles& o, int currentDir, int nextDir, double currentLength, double nextLength);
507
508 static void addCloserObstacle(Obstacles& obs, double x, int stripe, int numStripes, const std::string& id, double width, int dir, ObstacleType type);
509
511 Pedestrians& getPedestrians(const MSLane* lane);
512
513 /* @brief compute stripe-offset to transform relY values from a lane with origStripes into a lane wit destStrips
514 * @note this is called once for transforming nextLane peds to into the current system as obstacles and another time
515 * (in reverse) to transform the pedestrian coordinates into the nextLane-coordinates when changing lanes
516 */
517 static int getStripeOffset(int origStripes, int destStripes, bool addRemainder);
518
520 static bool addCrossingVehs(const MSLane* crossing, int stripes, double lateral_offset, int dir, Obstacles& crossingVehs, bool prio);
521
523 static Obstacles getVehicleObstacles(const MSLane* lane, int dir, PState* ped = 0);
524
525 static bool usingInternalLanesStatic();
526
527 static bool addVehicleFoe(const MSVehicle* veh, const MSLane* walkingarea, const Position& relPos, double xWidth, double yWidth, double lateral_offset,
528 double minY, double maxY, Pedestrians& toDelete, Pedestrians& transformedPeds);
529
530private:
533
536
539
542 static std::map<const MSEdge*, std::vector<const MSLane*> > myWalkingAreaFoes;
544
547
548};
549
550
551
long long int SUMOTime
Definition: GUI.h:36
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:74
std::pair< const MSPerson *, double > PersonDist
Definition: MSPModel.h:41
Base (microsim) event class.
Definition: Command.h:50
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:84
int getNumericalID() const
Returns this lane's numerical id.
Definition: MSLane.h:498
The simulated network and simulation perfomer.
Definition: MSNet.h:88
MSPModel_Striping *const myModel
MovePedestrians(MSPModel_Striping *model)
SUMOTime execute(SUMOTime currentTime)
Executes the command.
MovePedestrians & operator=(const MovePedestrians &)=delete
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
void saveState(std::ostringstream &out)
Saves the current state into the given stream.
int getDirection(const MSStageMoving &stage, SUMOTime now) const
return the walking direction (FORWARD, BACKWARD)
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 mySpeedLat
the current lateral walking speed
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
void moveTo(MSPerson *p, MSLane *lane, double lanePos, double lanePosLat, SUMOTime t)
try to move transportable to the given position
PState & operator=(const PState &)=delete
Invalidated assignment operator.
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
virtual ObstacleType getOType() const
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, double xWidth, double yWidth)
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
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
static bool addVehicleFoe(const MSVehicle *veh, const MSLane *walkingarea, const Position &relPos, double xWidth, double yWidth, double lateral_offset, double minY, double maxY, Pedestrians &toDelete, Pedestrians &transformedPeds)
MSTransportableStateAdapter * loadState(MSTransportable *transportable, MSStageMoving *stage, std::istringstream &in)
load the state of the given transportable
static SUMOTime jamTimeCrossing
bool hasPedestrians(const MSLane *lane)
whether the given lane has pedestrians on it
const ActiveLanes & getActiveLanes()
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 int myWalkingAreaDetail
static const double LOOKAHEAD_SAMEDIR
static double minGapToVehicle
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, bool bidi=false)
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 usingInternalLanesStatic()
static Obstacles getNeighboringObstacles(const Pedestrians &pedestrians, int egoIndex, int stripes)
static Pedestrians noPedestrians
empty pedestrian vector
static bool myLegacyPosLat
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
void clearState()
Resets pedestrians when quick-loading state.
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:119
abstract base class for managing callbacks to retrieve various state information from the model
Definition: MSPModel.h:148
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:37
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)