51 #define DEBUGCOND(PEDID) (PEDID == DEBUG1 || PEDID == DEBUG2) 55 for (
int i = 0; i < (int)obs.size(); ++i) {
57 <<
"(" << obs[i].description
58 <<
" x=(" << obs[i].xBack <<
"," << obs[i].xFwd
59 <<
") s=" << obs[i].speed
69 #define FAR_AWAY 10000 136 for (Pedestrians::const_iterator it_ped = pedestrians.begin(); it_ped != pedestrians.end(); ++it_ped) {
137 const PState& ped = **it_ped;
138 const SUMOReal halfVehicleWidth = 1.0;
146 if (collectBlockers == 0) {
149 collectBlockers->push_back(ped.
myPerson);
153 if (collectBlockers == 0) {
156 return collectBlockers->size() > 0;
188 if (from == 0 || to == 0) {
211 std::vector<MSLane*> lanes;
213 for (
int j = 0; j < (int)incoming.size(); ++j) {
217 for (
int j = 0; j < (int)outgoing.size(); ++j) {
221 for (
int j = 0; j < (int)lanes.size(); ++j) {
222 for (
int k = 0; k < (int)lanes.size(); ++k) {
225 const MSLane* from = lanes[j];
226 const MSLane* to = lanes[k];
235 shape.push_back(fromPos);
245 if (shape.size() < 2) {
249 assert(shape.size() == 2);
271 const MSLane* nextLane = nextRouteLane;
275 if (nextRouteLane != 0) {
280 std::cout <<
" internal\n";
285 nextLane = currentLane->
getLinkCont()[0]->getLane();
290 std::cout <<
" crossing\n";
301 prohibited.push_back(&prevLane->
getEdge());
305 <<
" nre=" << nextRouteEdge->
getID()
306 <<
" nreDir=" << nextRouteEdgeDir
307 <<
" aPos=" << arrivalPos
308 <<
" crossingRoute=" <<
toString(crossingRoute)
311 if (crossingRoute.size() > 1) {
312 const MSEdge* nextEdge = crossingRoute[1];
315 assert(nextLane != prevLane);
318 std::cout <<
" nextDir=" << nextDir <<
"\n";
333 <<
" no route from '" << (currentEdge == 0 ?
"NULL" : currentEdge->
getID())
334 <<
"' to '" << (nextRouteEdge == 0 ?
"NULL" : nextRouteEdge->
getID())
341 }
else if (currentEdge == nextRouteEdge) {
343 nextDir = -ped.
myDir;
351 std::cout <<
" next walkingArea " << (nextDir ==
FORWARD ?
"forward" :
"backward") <<
"\n";
360 #ifdef HAVE_INTERNAL_LANES 363 std::cout <<
" direct forward\n";
365 nextLane = MSLinkContHelper::getInternalFollowingLane(currentLane, nextRouteLane);
370 #ifdef HAVE_INTERNAL_LANES 373 std::cout <<
" direct backward\n";
375 nextLane = MSLinkContHelper::getInternalFollowingLane(nextRouteLane, currentLane);
382 nextLane = nextRouteLane;
384 std::cout <<
SIMTIME <<
" no next lane found for " << currentLane->
getID() <<
" dir=" << ped.
myDir <<
"\n";
388 nextLane = nextRouteLane;
395 <<
" l=" << currentLane->
getID()
396 <<
" nl=" << (nextLane == 0 ?
"NULL" : nextLane->
getID())
397 <<
" nrl=" << (nextRouteLane == 0 ?
"NULL" : nextRouteLane->
getID())
400 <<
" pedDir=" << ped.
myDir 411 for (MSLinkCont::const_iterator it = links.begin(); it != links.end(); ++it) {
412 if ((*it)->getLane()->getEdge().isWalkingArea()) {
418 const std::vector<MSLane::IncomingLaneInfo>& laneInfos = currentLane->
getIncomingLanes();
419 for (std::vector<MSLane::IncomingLaneInfo>::const_iterator it = laneInfos.begin(); it != laneInfos.end(); ++it) {
420 if ((*it).lane->getEdge().isWalkingArea()) {
421 link = (*it).viaLink;
432 const PState& ego = *pedestrians[egoIndex];
434 std::vector<bool> haveBlocker(stripes,
false);
435 for (
int index = egoIndex + 1; index < (int)pedestrians.size(); index++) {
436 const PState& p = *pedestrians[index];
443 std::cout <<
" dist=" << ego.
distanceTo(o) << std::endl;
451 haveBlocker[p.
stripe()] =
true;
454 if (!haveBlocker[p.
stripe()]) {
473 SUMOReal currentLength,
int currentDir) {
474 if (nextLanesObs.count(nextLane) == 0) {
486 if (nextStripes < stripes) {
487 int offset = (stripes - nextStripes) / 2;
488 if (currentDir == nextDir) {
490 offset += (stripes - nextStripes) % 2;
493 for (
int ii = 0; ii < stripes; ++ii) {
494 if (ii < offset || ii >= nextStripes + offset) {
495 obs[ii] =
Obstacle(nextDir ==
FORWARD ? 0 : nextLength, 0,
"stripeEnd");
504 nextDir = currentDir;
506 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
507 PState& p = *pedestrians[ii];
509 const SUMOReal newY = relPos.
y() + lateral_offset;
517 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(nextDir));
518 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
519 const PState& p = *pedestrians[ii];
524 if (nextDir != currentDir) {
528 const int stripe = p.
stripe(newY);
529 if (stripe >= 0 && stripe < stripes) {
533 if (otherStripe >= 0 && otherStripe < stripes) {
537 for (
int ii = 0; ii < stripes; ++ii) {
545 o.
xFwd += currentLength;
546 o.
xBack += currentLength;
554 nextLanesObs[nextLane] = obs;
556 return nextLanesObs[nextLane];
562 if (stripe >= 0 && stripe < numStripes) {
563 if ((dir ==
FORWARD && x - width / 2. < obs[stripe].xBack) || (dir ==
BACKWARD && x + width / 2. > obs[stripe].xFwd)) {
564 obs[stripe] =
Obstacle(x, 0,
id, width);
572 const MSLane* lane = it_lane->first;
582 std::set<const WalkingAreaPath*, walkingarea_path_sorter> paths;
583 for (Pedestrians::iterator it = pedestrians.begin(); it != pedestrians.end(); ++it) {
586 if (p->
myDir == dir) {
590 std::cout <<
SIMTIME <<
" debugging WalkingAreaPath from=" << debugPath->
from->
getID() <<
" to=" << debugPath->
to->
getID() <<
"\n";
594 for (std::set<const WalkingAreaPath*, walkingarea_path_sorter>::iterator it = paths.begin(); it != paths.end(); ++it) {
598 transformedPeds.reserve(pedestrians.size());
599 for (Pedestrians::iterator it_p = pedestrians.begin(); it_p != pedestrians.end(); ++it_p) {
604 transformedPeds.push_back(p);
605 if (path == debugPath) std::cout <<
" ped=" << p->
myPerson->
getID() <<
" relX=" << p->
myRelX <<
" relY=" << p->
myRelY <<
" (untransformed), vecCoord=" 609 const SUMOReal newY = relPos.
y() + lateral_offset;
617 toDelete.push_back(tp);
618 transformedPeds.push_back(tp);
619 if (path == debugPath) {
620 std::cout <<
" ped=" << p->
myPerson->
getID() <<
" relX=" << relPos.
x() <<
" relY=" << newY <<
" (transformed), vecCoord=" << relPos <<
"\n";
623 if (path == debugPath) {
624 std::cout <<
" ped=" << p->
myPerson->
getID() <<
" relX=" << relPos.
x() <<
" relY=" << newY <<
" (invalid), vecCoord=" << relPos <<
"\n";
631 for (Pedestrians::iterator it_p = toDelete.begin(); it_p != toDelete.end(); ++it_p) {
640 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(dir));
641 for (Pedestrians::iterator it = pedestrians.begin(); it != pedestrians.end();) {
643 if (p->
myDir != dir) {
648 it = pedestrians.erase(it);
670 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(dir));
671 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
672 PState& p = *pedestrians[ii];
695 nextLanesObs, lane, nextLane, stripes,
738 p.
walk(currentObs, currentTime);
744 for (
int coll = 0; coll < ii; ++coll) {
745 PState& c = *pedestrians[coll];
752 +
"', lane='" + lane->
getID() +
"', time=" +
time2string(currentTime) +
".");
793 myRelX(stage->getDepartPos()),
797 myWaitingToEnter(true),
799 myWalkingAreaPath(0),
804 if (route.size() == 1) {
811 std::cout <<
" initialize dir for " <<
myPerson->
getID() <<
" forward=" << mayStartForward <<
" backward=" << mayStartBackward <<
"\n";
813 if (mayStartForward && mayStartBackward) {
817 if (crossingRoute.size() > 1) {
819 const MSEdge* nextEdge = crossingRoute[1];
825 std::cout <<
" crossingRoute=" <<
toString(crossingRoute) <<
"\n";
883 const int s =
stripe(relY);
887 if (offset > threshold) {
889 }
else if (offset < -threshold) {
927 std::cout <<
SIMTIME <<
" myRelX=" <<
myRelX <<
" dist=" << dist <<
"\n";
935 const int oldDir =
myDir;
943 <<
" moveToNextLane old=" << oldLane->
getID()
945 <<
" oldDir=" << oldDir
946 <<
" newDir=" <<
myDir 985 myRelX = newLength + dist;
990 if (
myDir != oldDir) {
1005 const int stripes = (int)obs.size();
1006 const int sMax = stripes - 1;
1010 const int current =
stripe();
1013 std::vector<SUMOReal> utility(stripes);
1015 for (
int i = 0; i < stripes; ++i) {
1019 std::vector<SUMOReal> distance(stripes);
1020 for (
int i = 0; i < stripes; ++i) {
1022 if (distance[i] <= 0) {
1027 for (
int i = 0; i < stripes; ++i) {
1030 for (
int j = 0; j <= i; ++j) {
1035 for (
int j = i; j < stripes; ++j) {
1050 for (
int i = 0; i < reserved; ++i) {
1054 for (
int i = sMax; i > sMax - reserved; --i) {
1059 for (
int i = 0; i < stripes; ++i) {
1060 if (obs[i].speed < 0) {
1063 utility[i - 1] -= 0.5;
1065 utility[i + 1] -= 0.5;
1072 std::cout <<
" util=" << utility[i] <<
" exp=" << expectedDist <<
"\n";
1074 if (expectedDist >= 0) {
1075 utility[i] += expectedDist;
1085 && obs[current].speed *
myDir < 0) {
1092 && obs[current].speed *
myDir < 0) {
1097 int chosen = current;
1098 for (
int i = 0; i < stripes; ++i) {
1099 if (utility[chosen] < utility[i]) {
1104 const int next = (chosen == current ? current : (chosen < current ? current - 1 : current + 1));
1105 const SUMOReal xDist =
MIN3(distance[current], distance[other], distance[next]);
1110 std::cout <<
" xSpeedPotential=" << xSpeed <<
"\n";
1150 ySpeed = (yDist > 0 ?
1163 <<
" cur=" << current
1164 <<
" cho=" << chosen
1168 <<
" dawdle=" << dawdle
1175 <<
"\n distance=" <<
toString(distance)
1176 <<
" utility=" <<
toString(utility)
1259 if ((obs.
xFwd > maxX && obs.
xBack < maxX) || (obs.
xFwd <= maxX && obs.
xFwd > minX)) {
1263 return myDir * dist;
1269 for (
int i = 0; i < (int)into.size(); ++i) {
1285 std::set<MSPerson*> changedLane;
1290 for (ActiveLanes::const_iterator it_lane =
myModel->getActiveLanes().begin(); it_lane !=
myModel->getActiveLanes().end(); ++it_lane) {
1291 const MSLane* lane = it_lane->first;
1293 if (pedestrians.size() == 0) {
1298 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
1299 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...
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 OBSTRUCTED_PENALTY
static const SUMOReal SAFETY_GAP
SUMOReal rotationAtOffset(SUMOReal pos) const
Returns the rotation at the given length.
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
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)
sorts the persons by position on the lane. If dir is forward, higher x positions come first...
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
information regarding surround Pedestrians (and potentially other things)
SUMOReal getLength() const
Returns the lane's length.
The base class for an intersection.
SUMOReal distanceTo(const Obstacle &obs, const bool includeMinGap=true) const
calculate distance to the given obstacle, positive values mean in front of me in walking direction...
const MSStoppingPlace * getDestinationStop() const
returns the destination stop (if any)
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)
static SUMOReal rand()
Returns a random real number in [0, 1)
std::string time2string(SUMOTime t)
SUMOReal getLength() const
Get vehicle's length [m].
SUMOReal getImpatience() const
Returns this type's impatience.
MSPedestrianRouterDijkstra & getPedestrianRouter(const MSEdgeVector &prohibited=MSEdgeVector()) const
SUMOReal getWidth() const
Returns the lane's width.
static const SUMOReal ONCOMING_CONFLICT_PENALTY
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
const std::string & getID() const
returns the id of the transportable
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 ...
static void addCloserObstacle(Obstacles &obs, SUMOReal x, int stripe, int numStripes, const std::string &id, SUMOReal width, int dir)
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.
#define WRITE_WARNING(msg)
The simulated network and simulation perfomer.
bool myAmJammed
whether the person is jammed
static OptionsCont & getOptions()
Retrieves the options.
const MSEdge * getEdge() const
Returns the current edge.
static Pedestrians noPedestrians
empty pedestrian vector
static bool gCheck4Accidents
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
void mergeObstacles(Obstacles &into, const Obstacles &obs2)
replace obstacles in the first vector with obstacles from the second if they are closer to me ...
NextLaneInfo myNLI
information about the upcoming lane
const MSEdge & getDestination() const
returns the destination edge
static const SUMOReal SQUEEZE
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
SUMOReal getMinX(const bool includeMinGap=true) const
return the minimum position on the lane
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)
Position getLanePosition(const MSLane *lane, SUMOReal at, SUMOReal offset) const
get position on lane at length at with orthogonal offset
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
const MSVehicleType & getVehicleType() const
MSLane * getLogicalPredecessorLane() const
get the most likely precedecessor lane (sorted using by_connections_to_sorter). The result is cached ...
bool moveToNextEdge(MSPerson *person, SUMOTime currentTime, MSEdge *nextInternal=0)
move forward and return whether the person arrived
const MSEdge * getEdge() const
Returns the current edge.
static const SUMOReal LATERAL_SPEED_FACTOR
SUMOTime execute(SUMOTime currentTime)
Executes the command.
SUMOReal getMinGap() const
Get the free space in front of vehicles of this class.
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.
static const SUMOReal INAPPROPRIATE_PENALTY
SUMOReal xFwd
maximal position on the current lane in forward direction
StageType getCurrentStageType() const
the current stage type of the transportable
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
Position positionAtOffset(SUMOReal pos, SUMOReal lateralOffset=0) const
Returns the position at the given length.
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
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
SUMOTime myWaitingTime
the consecutive time spent at speed 0
bool isInternal() const
return whether this edge is an internal edge
int myDir
the walking direction on the current lane (1 forward, -1 backward)
SUMOTime getWaitingTime(SUMOTime now) const
the time this transportable spent waiting
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
static const SUMOReal MIN_STARTUP_DIST
abstract base class for managing callbacks to retrieve various state information from the model ...
SUMOReal getArrivalPos() const
void registerJammed()
register a jammed person
SUMOReal getWidth() const
Get the width which vehicles of this class shall have when being drawn.
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
SUMOReal getImpatience(SUMOTime now) const
returns the impatience
std::vector< PState * > Pedestrians
virtual MSPersonControl & getPersonControl()
Returns the person control.
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
SUMOReal getMaxX(const bool includeMinGap=true) const
return the maximum position on the lane
static const SUMOReal BLOCKER_LOOKAHEAD
SUMOReal xBack
maximal position on the current lane in backward direction
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
Patch the time in a way that it is at least as high as the simulation begin time. ...
const MSEdge * getNextEdge(const MSPerson::MSPersonStage_Walking &stage) const
return the list of internal edges if the pedestrian is on an intersection
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
SUMOReal getMinGap() const
return the minimum gap of the pedestrian
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 lane direction (positive means in the same direction)
const std::vector< IncomingLaneInfo > & getIncomingLanes() const
std::string description
the id / description of the obstacle
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
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
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
void extrapolate(const SUMOReal val, const bool onlyFirst=false)
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