45 #define DEBUG1 "disabled"
46 #define DEBUG2 "disabled"
47 #define DEBUGCOND(PEDID) (PEDID == DEBUG1 || PEDID == DEBUG2)
51 for (
int i = 0; i < (int)obs.size(); ++i) {
53 <<
"(" << obs[i].description
55 <<
" s=" << obs[i].speed
67 #define BLOCKED_STRIPE -10000
68 #define FAR_AWAY 10000
69 #define ONCOMING_CONFLICT -1000
99 myNumActivePedestrians(0) {
132 for (Pedestrians::const_iterator it_ped = pedestrians.begin(); it_ped != pedestrians.end(); ++it_ped) {
133 const PState& ped = **it_ped;
134 const SUMOReal halfVehicleWidth = 1.0;
142 if (collectBlockers == 0) {
145 collectBlockers->push_back(ped.
myPerson);
149 if (collectBlockers == 0) {
152 return collectBlockers->size() > 0;
184 if (from == 0 || to == 0) {
207 std::vector<MSLane*> lanes;
209 for (
int j = 0; j < (int)incoming.size(); ++j) {
213 for (
int j = 0; j < (int)outgoing.size(); ++j) {
217 for (
int j = 0; j < (int)lanes.size(); ++j) {
218 for (
int k = 0; k < (int)lanes.size(); ++k) {
221 const MSLane* from = lanes[j];
222 const MSLane* to = lanes[k];
241 if (shape.size() < 2) {
245 assert(shape.size() == 2);
267 const MSLane* nextLane = nextRouteLane;
271 if (nextRouteLane != 0) {
276 std::cout <<
" internal\n";
281 nextLane = currentLane->
getLinkCont()[0]->getLane();
286 std::cout <<
" crossing\n";
297 prohibited.push_back(&prevLane->
getEdge());
301 <<
" nre=" << nextRouteEdge->
getID()
302 <<
" nreDir=" << nextRouteEdgeDir
303 <<
" aPos=" << arrivalPos
304 <<
" crossingRoute=" <<
toString(crossingRoute)
307 if (crossingRoute.size() > 1) {
308 const MSEdge* nextEdge = crossingRoute[1];
311 assert(nextLane != prevLane);
314 std::cout <<
" nextDir=" << nextDir <<
"\n";
329 <<
" no route from '" << (currentEdge == 0 ?
"NULL" : currentEdge->
getID())
330 <<
"' to '" << (nextRouteEdge == 0 ?
"NULL" : nextRouteEdge->
getID())
335 }
else if (currentEdge == nextRouteEdge) {
337 nextDir = -ped.
myDir;
345 std::cout <<
" next walkingArea " << (nextDir ==
FORWARD ?
"forward" :
"backward") <<
"\n";
353 #ifdef HAVE_INTERNAL_LANES
356 std::cout <<
" direct forward\n";
358 nextLane = MSLinkContHelper::getInternalFollowingLane(currentLane, nextRouteLane);
363 #ifdef HAVE_INTERNAL_LANES
366 std::cout <<
" direct backward\n";
368 nextLane = MSLinkContHelper::getInternalFollowingLane(nextRouteLane, currentLane);
375 nextLane = nextRouteLane;
377 std::cout <<
SIMTIME <<
" no next lane found for " << currentLane->
getID() <<
" dir=" << ped.
myDir <<
"\n";
381 nextLane = nextRouteLane;
388 <<
" l=" << currentLane->
getID()
389 <<
" nl=" << (nextLane == 0 ?
"NULL" : nextLane->
getID())
390 <<
" nrl=" << (nextRouteLane == 0 ?
"NULL" : nextRouteLane->
getID())
393 <<
" pedDir=" << ped.
myDir
404 for (MSLinkCont::const_iterator it = links.begin(); it != links.end(); ++it) {
405 if ((*it)->getLane()->getEdge().isWalkingArea()) {
411 const std::vector<MSLane::IncomingLaneInfo>& laneInfos = currentLane->
getIncomingLanes();
412 for (std::vector<MSLane::IncomingLaneInfo>::const_iterator it = laneInfos.begin(); it != laneInfos.end(); ++it) {
413 if ((*it).lane->getEdge().isWalkingArea()) {
414 link = (*it).viaLink;
425 Obstacles result(obs1.begin(), obs1.end());
426 for (
int i = 0; i < (int)obs1.size(); ++i) {
427 if ((obs2[i].x - obs1[i].x) * dir < 0) {
437 const PState& ego = *pedestrians[egoIndex];
439 int index = egoIndex + 1;
441 while (index < (
int)pedestrians.size() && ego.
myDir * (pedestrians[index]->myRelX - egoBack) > 0) {
442 const PState& p = *pedestrians[index];
461 SUMOReal currentLength,
int currentDir) {
462 if (nextLanesObs.count(nextLane) == 0) {
473 const int offset = (stripes - nextStripes) / 2;
475 if (nextStripes < stripes) {
477 for (
int ii = 0; ii < stripes; ++ii) {
478 if (ii < offset || ii >= nextStripes + offset) {
479 obs[ii] =
Obstacle(nextDir ==
FORWARD ? 0 : nextLength, 0,
"stripeEnd");
489 nextDir = currentDir;
491 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
492 PState& p = *pedestrians[ii];
494 const SUMOReal newY = relPos.
y() + lateral_offset;
495 if (newY >= 0 && newY <= maxY) {
504 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(nextDir));
505 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
506 const PState& p = *pedestrians[ii];
513 for (
int ii = 0; ii < stripes; ++ii) {
516 o.
x = nextLength - o.
x;
519 o.
x += currentLength;
525 nextLanesObs[nextLane] = obs;
527 return nextLanesObs[nextLane];
533 const int mappedStripe = (nextDir == currentDir
535 : nextStripes - 1 - stripe + offset);
536 if (mappedStripe >= 0 && mappedStripe < stripes) {
537 obs[mappedStripe] =
Obstacle(p, nextDir);
544 if (stripe < stripes && obs[stripe].x * dir > x * dir) {
552 const MSLane* lane = it_lane->first;
560 std::set<const WalkingAreaPath*, walkingarea_path_sorter> paths;
561 for (Pedestrians::iterator it = pedestrians.begin(); it != pedestrians.end(); ++it) {
564 if (p->
myDir == dir) {
568 std::cout <<
SIMTIME <<
" debugging WalkingAreaPath from=" << debugPath->
from->
getID() <<
" to=" << debugPath->
to->
getID() <<
"\n";
572 for (std::set<const WalkingAreaPath*, walkingarea_path_sorter>::iterator it = paths.begin(); it != paths.end(); ++it) {
576 transformedPeds.reserve(pedestrians.size());
577 for (Pedestrians::iterator it_p = pedestrians.begin(); it_p != pedestrians.end(); ++it_p) {
582 transformedPeds.push_back(p);
583 if (path == debugPath) std::cout <<
" ped=" << p->
myPerson->
getID() <<
" relX=" << p->
myRelX <<
" relY=" << p->
myRelY <<
" (untransformed), vecCoord="
587 const SUMOReal newY = relPos.
y() + lateral_offset;
589 newY >= 0 && newY <= lane->getWidth()) {
596 toDelete.push_back(tp);
597 transformedPeds.push_back(tp);
598 if (path == debugPath) {
599 std::cout <<
" ped=" << p->
myPerson->
getID() <<
" relX=" << relPos.
x() <<
" relY=" << newY <<
" (transformed), vecCoord=" << relPos <<
"\n";
602 if (path == debugPath) {
603 std::cout <<
" ped=" << p->
myPerson->
getID() <<
" relX=" << relPos.
x() <<
" relY=" << newY <<
" (invalid), vecCoord=" << relPos <<
"\n";
610 for (Pedestrians::iterator it_p = toDelete.begin(); it_p != toDelete.end(); ++it_p) {
619 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(dir));
620 for (Pedestrians::iterator it = pedestrians.begin(); it != pedestrians.end();) {
622 if (p->
myDir != dir) {
625 it = pedestrians.erase(it);
646 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(dir));
647 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
648 PState& p = *pedestrians[ii];
671 nextLanesObs, lane, nextLane, stripes,
709 p.
walk(currentObs, currentTime);
731 description(ped.myPerson->getID()) {
733 if (dir == ped.
myDir) {
752 myRelX(stage->getDepartPos()),
756 myWaitingToEnter(true),
758 myWalkingAreaPath(0),
763 if (route.size() == 1) {
770 std::cout <<
" initialize dir for " <<
myPerson->
getID() <<
" forward=" << mayStartForward <<
" backward=" << mayStartBackward <<
"\n";
772 if (mayStartForward && mayStartBackward) {
776 if (crossingRoute.size() > 1) {
778 const MSEdge* nextEdge = crossingRoute[1];
784 std::cout <<
" crossingRoute=" <<
toString(crossingRoute) <<
"\n";
804 return myPerson->getVehicleType().getLength();
818 const int s = stripe();
822 if (offset > threshold) {
824 }
else if (offset < -threshold) {
829 std::cout.setf(std::ios::fixed , std::ios::floatfield);
830 std::cout << std::setprecision(5);
837 return stripe(myRelY);
843 return otherStripe(myRelY);
849 if (myStage->getNextRouteEdge() == 0) {
850 return myDir * (myStage->getArrivalPos() - myRelX);
852 const SUMOReal length = myWalkingAreaPath == 0 ? myLane->getLength() : myWalkingAreaPath->length;
853 return myDir ==
FORWARD ? length - myRelX : myRelX;
860 const SUMOReal dist = distToLaneEnd();
861 if (myPerson->getID() ==
DEBUG1) {
862 std::cout <<
SIMTIME <<
" myRelX=" << myRelX <<
" dist=" << dist <<
"\n";
871 const int oldDir = myDir;
872 const MSLane* oldLane = myLane;
878 <<
" ped=" << myPerson->getID()
879 <<
" moveToNextLane old=" << oldLane->
getID()
880 <<
" new=" << (myLane == 0 ?
"NULL" : myLane->getID())
881 <<
" oldDir=" << oldDir
882 <<
" newDir=" << myDir
885 myStage->moveToNextEdge(myPerson, currentTime, normalLane ? 0 : &myLane->getEdge());
889 assert(myNLI.lane != oldLane);
891 std::cout <<
" nextLane=" << (myNLI.lane == 0 ?
"NULL" : myNLI.lane->getID()) <<
"\n";
893 if (myLane->getEdge().isWalkingArea()) {
896 assert(myWalkingAreaPath->from != 0);
897 assert(myWalkingAreaPath->to != 0);
898 assert(myWalkingAreaPath->shape.size() >= 2);
900 std::cout <<
" mWAPath shape=" << myWalkingAreaPath->shape <<
" length=" << myWalkingAreaPath->length <<
"\n";
905 myStage->moveToNextEdge(myPerson, currentTime, 0);
910 myWalkingAreaPath = 0;
912 throw ProcessError(
"Disconnected walk for person '" + myPerson->getID() +
"'.");
916 myWalkingAreaPath = 0;
920 const SUMOReal newLength = (myWalkingAreaPath == 0 ? myLane->getLength() : myWalkingAreaPath->length);
921 myRelX = newLength + dist;
926 if (myDir != oldDir) {
941 const int stripes = (int)obs.size();
942 const int sMax = stripes - 1;
944 const SUMOReal vMax = myStage->getMaxSpeed();
946 const int current = stripe();
947 const int other = otherStripe();
948 int chosen = current;
950 std::vector<SUMOReal> utility(stripes, 0);
953 for (
int i = 0; i < stripes; ++i) {
957 std::vector<SUMOReal> distance(stripes);
958 for (
int i = 0; i < stripes; ++i) {
959 distance[i] += myDir * (obs[i].x - myRelX);
962 for (
int i = 0; i < stripes; ++i) {
963 if (distance[i] <= 0) {
965 for (
int j = 0; j <= i; ++j) {
969 for (
int j = i; j < stripes; ++j) {
980 for (
int i = 0; i < reserved; ++i) {
984 for (
int i = sMax; i > sMax - reserved; --i) {
989 for (
int i = 0; i < stripes; ++i) {
990 if (obs[i].speed < 0) {
992 if (myDir ==
FORWARD && i > 0) {
993 utility[i - 1] -= 0.5;
994 }
else if (myDir ==
BACKWARD && i < sMax) {
995 utility[i + 1] -= 0.5;
1002 std::cout <<
" util=" << utility[i] <<
" exp=" << expectedDist <<
"\n";
1004 if (expectedDist >= 0) {
1005 utility[i] += expectedDist;
1013 if (((myDir ==
FORWARD && current == sMax)
1014 || (myDir ==
BACKWARD && current == 0))
1015 && obs[current].speed < 0) {
1020 if (((myDir ==
BACKWARD && current == sMax)
1021 || (myDir ==
FORWARD && current == 0))
1022 && obs[current].speed < 0) {
1027 for (
int i = 0; i < stripes; ++i) {
1028 if (utility[chosen] < utility[i]) {
1033 const int next = (chosen == current ? current : (chosen < current ? current - 1 : current + 1));
1034 const SUMOReal xDist =
MIN3(distance[current], distance[other], distance[next]);
1036 const SUMOReal preferredGap = myPerson->getVehicleType().getMinGap() + xDist * 0.5;
1039 std::cout <<
" xSpeedPotential=" << xSpeed <<
"\n";
1047 if (myWaitingTime >
jamTime || myAmJammed) {
1074 ySpeed = (yDist > 0 ?
1075 MIN2(maxYSpeed, yDist) :
1076 MAX2(-maxYSpeed, yDist));
1081 <<
" ped=" << myPerson->getID()
1082 <<
" edge=" << myStage->getEdge()->getID()
1086 <<
" pvx=" << mySpeed
1087 <<
" cur=" << current
1088 <<
" cho=" << chosen
1092 <<
" dawdle=" << dawdle
1096 <<
" vMax=" << myStage->getMaxSpeed()
1097 <<
" wTime=" << myStage->getWaitingTime(currentTime)
1098 <<
" jammed=" << myAmJammed
1099 <<
"\n distance=" <<
toString(distance)
1100 <<
" utility=" <<
toString(utility)
1108 myWaitingToEnter =
false;
1119 myPerson->getVehicleType().getImpatience()
1137 if (myWalkingAreaPath == 0) {
1140 return myWalkingAreaPath->shape.positionAtOffset(myRelX, lateral_offset);
1151 const PositionVector& shp = myWalkingAreaPath == 0 ? myLane->getShape() : myWalkingAreaPath->shape;
1162 return myWaitingTime;
1178 std::set<MSPerson*> changedLane;
1183 for (ActiveLanes::const_iterator it_lane =
myModel->getActiveLanes().begin(); it_lane !=
myModel->getActiveLanes().end(); ++it_lane) {
1184 const MSLane* lane = it_lane->first;
1186 if (pedestrians.size() == 0) {
1191 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
1192 const PState& p = *pedestrians[ii];
const Obstacles & getNextLaneObstacles(NextLanesObstacles &nextLanesObs, const MSLane *lane, const MSLane *nextLane, int stripes, SUMOReal nextLength, int nextDir, SUMOReal currentLength, int currentDir)
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...
const std::string & getID() const
returns the person id
bool blockedAtDist(const MSLane *lane, SUMOReal distToCrossing, std::vector< const MSPerson * > *collectBlockers)
whether a pedestrian is blocking the crossing of lane at offset distToCrossing
MSEdge & getEdge() const
Returns the lane's edge.
static const SUMOReal SAFETY_GAP
const MSEdge * getNextRouteEdge() const
SUMOReal distToLaneEnd() const
the absolute distance to the end of the lane in walking direction (or to the arrivalPos) ...
MSPerson::MSPersonStage_Walking * myStage
Position getLanePosition(const MSLane *lane, SUMOReal at, SUMOReal offset) const
get position on lane at length at with orthogonal offset
static SUMOReal stripeWidth
model parameters
static int numStripes(const MSLane *lane)
return the maximum number of pedestrians walking side by side
static Obstacles getNeighboringObstacles(const Pedestrians &pedestrians, int egoIndex, int stripes)
SUMOReal mySpeed
the current walking speed
static const MSLane * getNextWalkingArea(const MSLane *currentLane, const int dir, MSLink *&link)
return the next walkingArea in the given direction
static int connectedDirection(const MSLane *from, const MSLane *to)
returns the direction in which these lanes are connectioned or 0 if they are not
WalkingAreaPath * myWalkingAreaPath
the current walkingAreaPath or 0
const MSEdge * getEdge() const
Returns the current edge.
information regarding surround Pedestrians (and potentially other things)
SUMOReal getLength() const
Returns the lane's length.
The base class for an intersection.
StageType getCurrentStageType() const
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
bool isWalkingArea() const
return whether this edge is walking area
PState(MSPerson *person, MSPerson::MSPersonStage_Walking *stage, const MSLane *lane)
#define ONCOMING_CONFLICT
static SUMOReal rand()
Returns a random real number in [0, 1)
MSPedestrianRouterDijkstra & getPedestrianRouter(const MSEdgeVector &prohibited=MSEdgeVector()) const
SUMOReal getWidth() const
Returns the lane's width.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
static MSLane * getSidewalk(const MSEdge *edge)
return the appropriate lane to walk on
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary...
SUMOReal getFloat(const std::string &name) const
Returns the SUMOReal-value of the named option (only for Option_Float)
std::vector< const MSEdge * > ConstMSEdgeVector
std::map< std::pair< const MSLane *, const MSLane * >, WalkingAreaPath > WalkingAreaPaths
bool moveToNextLane(SUMOTime currentTime)
return whether this pedestrian has passed the end of the current lane and update myRelX if so ...
const MSEdgeVector & getIncomingEdges() const
Returns the list of edges from which this edge may be reached.
static MSPModel * myModel
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
static WalkingAreaPaths myWalkingAreaPaths
store for walkinArea elements
SUMOReal x() const
Returns the x-position.
The simulated network and simulation perfomer.
static OptionsCont & getOptions()
Retrieves the options.
static Pedestrians noPedestrians
empty pedestrian vector
static const SUMOReal RESERVE_FOR_ONCOMING_FACTOR
PositionVector reverse() const
void moveInDirection(SUMOTime currentTime, std::set< MSPerson * > &changedLane, int dir)
move all pedestrians forward and advance to the next lane if applicable
NextLaneInfo myNLI
information about the upcoming lane
static const SUMOReal SQUEEZE
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
const std::string & getID() const
Returns the id.
A road/street connecting two junctions.
Pedestrians & getPedestrians(const MSLane *lane)
retrieves the pedestian vector for the given lane (may be empty)
static const SUMOReal LOOKAHEAD_SAMEDIR
void compute(const E *from, const E *to, SUMOReal departPos, SUMOReal arrivalPos, SUMOReal speed, SUMOTime msTime, const N *onlyNode, std::vector< const E * > &into, bool allEdges=false)
Builds the route between the given edges using the minimum effort at the given time The definition of...
static const int UNDEFINED_DIRECTION
SUMOReal getLength() const
return the length of the edge
MSLane * getLogicalPredecessorLane() const
static const SUMOReal LATERAL_SPEED_FACTOR
SUMOTime execute(SUMOTime currentTime)
Executes the command.
void walk(const Obstacles &obs, SUMOTime currentTime)
perform position update
A point in 2D or 3D with translation and scaling methods.
static const SUMOReal LOOKAHEAD_ONCOMING
const ConstMSEdgeVector & getRoute() const
MSLane * getLane() const
Returns the connected lane.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
SUMOReal getLength() const
return the length of the pedestrian
SUMOTime getWaitingTime(const MSPerson::MSPersonStage_Walking &stage, SUMOTime now) const
return the time the person spent standing
static Obstacles mergeObstacles(const Obstacles &obs1, const Obstacles &obs2, int dir)
SUMOTime string2time(const std::string &r)
Position getPosition(const MSPerson::MSPersonStage_Walking &stage, SUMOTime now) const
return the network coordinate of the person
std::map< const MSLane *, Obstacles, lane_by_numid_sorter > NextLanesObstacles
SUMOReal getAngle(const MSPerson::MSPersonStage_Walking &stage, SUMOTime now) const
return the direction in which the person faces in degrees
SUMOReal x
position on the current lane
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
bool isInternal() const
return whether this edge is an internal edge
int myDir
the walking direction on the current lane (1 forward, -1 backward)
virtual SUMOTime addEvent(Command *operation, SUMOTime execTimeStep, AdaptType type)
Adds an Event.
SUMOReal getEdgePos(const MSPerson::MSPersonStage_Walking &stage, SUMOTime now) const
abstract methods inherited from PedestrianState
SUMOReal getSpeed(const MSPerson::MSPersonStage_Walking &stage) const
return the current speed of the person
void cleanupHelper()
remove state at simulation end
PedestrianState * add(MSPerson *person, MSPerson::MSPersonStage_Walking *stage, SUMOTime now)
register the given person as a pedestrian
abstract base class for managing callbacks to retrieve various state information from the model ...
void extrapolate(SUMOReal val)
SUMOReal getArrivalPos() const
SUMOReal rotationDegreeAtOffset(SUMOReal pos) const
Returns the rotation at the given length.
void push_back(const PositionVector &p)
Appends all positions from the given vector.
SUMOReal getImpatience(SUMOTime now) const
returns the impatience
std::vector< PState * > Pedestrians
bool myWaitingToEnter
whether the pedestrian is waiting to start its walk
static MSLink * getConnectingLink(const MSLane &from, const MSLane &to)
Returns the link connecting both lanes Both lanes have to be non-internal; 0 may be returned if no co...
The edge is a normal street.
MSLane * getViaLaneOrLane() const
return the via lane if it exists and the lane otherwise
SUMOReal y() const
Returns the y-position.
static size_t dictSize()
Returns the number of edges.
A storage for options typed value containers)
Container for pedestrian state and individual position update function.
std::vector< Obstacle > Obstacles
static const SUMOReal BLOCKER_LOOKAHEAD
static const int BACKWARD
const PositionVector & getShape() const
Returns this lane's shape.
SUMOReal distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
static void addMappedObstacle(Obstacles &obs, const PState &p, int stripe, int currentDir, int nextDir, int offset, int stripes, int nextStripes)
Patch the time in a way that it is at least as high as the simulation begin time. ...
SUMOReal myRelY
the orthogonal shift on the current lane
static const SUMOReal MAX_WAIT_TOLERANCE
bool isCrossing() const
return whether this edge is a pedestrian crossing
SUMOReal myRelX
the advancement along the current lane
const MSJunction * getFromJunction() const
const MSEdgeVector & getSuccessors() const
Returns the following edges.
MovePedestrians * myCommand
the MovePedestrians command that is registered
void push_back_noDoublePos(const Position &p)
static void DEBUG_PRINT(const Obstacles &obs)
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
std::vector< MSEdge * > MSEdgeVector
int myNumActivePedestrians
the total number of active pedestrians
SUMOReal speed
speed relative to ego direction (positive means in the same direction)
const std::vector< IncomingLaneInfo > & getIncomingLanes() const
SUMOReal getMaxSpeed() const
accessors to be used by MSPModel
static void initWalkingAreaPaths(const MSNet *net)
MSPModel_Striping(const OptionsCont &oc, MSNet *net)
Constructor (it should not be necessary to construct more than one instance)
Representation of a lane in the micro simulation.
ActiveLanes myActiveLanes
store of all lanes which have pedestrians on them
static const SUMOReal MIN_STARTUP_SPEED
const MSLane * myLane
the current lane of this pedestrian
bool opened(SUMOTime arrivalTime, SUMOReal arrivalSpeed, SUMOReal leaveSpeed, SUMOReal vehicleLength, SUMOReal impatience, SUMOReal decel, SUMOTime waitingTime, std::vector< const SUMOVehicle * > *collectFoes=0) const
Returns the information whether the link may be passed.
static const SUMOReal LATERAL_PENALTY
static void addCloserObstacle(Obstacles &obs, SUMOReal x, int stripe, const std::string &id, int stripes, int dir)
Obstacle(int dir)
create No-Obstacle
void moveInDirectionOnLane(Pedestrians &pedestrians, const MSLane *lane, SUMOTime currentTime, std::set< MSPerson * > &changedLane, int dir)
move pedestrians forward on one lane
static const Position INVALID
Position transformToVectorCoordinates(const Position &p, bool extend=false) const
return position p within the length-wise coordinate system defined by this position vector...
const MSJunction * getToJunction() const
static bool canTraverse(int dir, const ConstMSEdgeVector &route)
return whether the route may traversed with the given starting direction