51 #define DEBUGCOND(PED) ((PED).getPerson()->isSelected())
52 #define DEBUGCOND2(LANE) ((LANE)->isSelected())
57 for (
int i = 0; i < (int)obs.size(); ++i) {
59 <<
"(" << obs[i].description
60 <<
" x=(" << obs[i].xBack <<
"," << obs[i].xFwd
61 <<
") s=" << obs[i].speed
122 WRITE_WARNINGF(
TL(
"Pedestrian vType '%' width % is larger than pedestrian.striping.stripe-width and this may cause collisions with vehicles."),
169 if (lane ==
nullptr) {
170 const char* error =
TL(
"Person '%' could not find sidewalk on edge '%', time=%.");
208 if (from ==
nullptr || to ==
nullptr) {
210 }
else if (from->
getLinkTo(to) !=
nullptr) {
212 }
else if (to->
getLinkTo(from) !=
nullptr) {
230 for (
MSLink* link : lane->getLinkCont()) {
231 if (link->getWalkingAreaFoe() !=
nullptr) {
233 myWalkingAreaFoes[&link->getWalkingAreaFoe()->getEdge()].push_back(link->getLaneBefore());
236 if (link->getWalkingAreaFoeExit() !=
nullptr) {
238 myWalkingAreaFoes[&link->getWalkingAreaFoeExit()->getEdge()].push_back(link->getLaneBefore());
256 const MSLane* walkingArea = getSidewalk<MSEdge, MSLane>(edge);
260 std::vector<const MSLane*> lanes;
262 if (!in->isTazConnector()) {
263 lanes.push_back(getSidewalk<MSEdge, MSLane>(in));
264 if (lanes.back() ==
nullptr) {
265 throw ProcessError(
"Invalid connection from edge '" + in->getID() +
"' to walkingarea edge '" + edge->
getID() +
"'");
270 if (!out->isTazConnector()) {
271 lanes.push_back(getSidewalk<MSEdge, MSLane>(out));
272 if (lanes.back() ==
nullptr) {
273 throw ProcessError(
"Invalid connection from walkingarea edge '" + edge->
getID() +
"' to edge '" + out->getID() +
"'");
278 for (
int j = 0; j < (int)lanes.size(); ++j) {
279 for (
int k = 0; k < (int)lanes.size(); ++k) {
282 const MSLane*
const from = lanes[j];
283 const MSLane*
const to = lanes[k];
289 const double maxExtent = fromPos.
distanceTo2D(toPos) / 4;
290 const double extrapolateBy =
MIN2(maxExtent, walkingArea->
getWidth() / 2);
292 shape.push_back(fromPos);
293 if (extrapolateBy > POSITION_EPS) {
302 if (shape.size() < 2) {
306 assert(shape.size() == 2);
311 if (shape.size() >= 4 && shape.
length() < walkingArea->
getWidth()) {
312 const double aStart = shape.
angleAt2D(0);
313 const double aEnd = shape.
angleAt2D((
int)shape.size() - 2);
314 if (fabs(aStart - aEnd) <
DEG2RAD(10)) {
315 angleOverride = (aStart + aEnd) / 2;
323 into.insert(std::make_pair(std::make_pair(from, to), wap));
335 std::vector<const MSLane*> lanes;
337 lanes.push_back(getSidewalk<MSEdge, MSLane>(pred));
340 lanes.push_back(getSidewalk<MSEdge, MSLane>(succ));
342 if (lanes.size() < 1) {
343 throw ProcessError(
TLF(
"Invalid walkingarea '%' does not allow continuation.", walkingArea->
getID()));
351 const MSLane* swBefore = getSidewalk<MSEdge, MSLane>(before);
352 const MSLane* swAfter = getSidewalk<MSEdge, MSLane>(after);
355 return &pathIt->second;
359 bool useBefore = swBefore !=
nullptr && std::find(preds.begin(), preds.end(), before) != preds.end();
360 bool useAfter = swAfter !=
nullptr && std::find(succs.begin(), succs.end(), after) != succs.end();
364 }
else if (succs.size() > 0) {
366 return getWalkingAreaPath(walkingArea, swBefore, getSidewalk<MSEdge, MSLane>(succs.front()));
368 }
else if (useAfter && preds.size() > 0) {
370 return getWalkingAreaPath(walkingArea, getSidewalk<MSEdge, MSLane>(preds.front()), swAfter);
381 return &pathIt->second;
385 if (preds.size() > 0) {
387 const auto pathIt2 =
myWalkingAreaPaths.find(std::make_pair(getSidewalk<MSEdge, MSLane>(pred), after));
389 return &pathIt2->second;
405 const MSLane* nextLane = nextRouteLane;
406 const MSLink* link =
nullptr;
412 if (nextRouteLane ==
nullptr && nextRouteEdge !=
nullptr) {
413 std::string error =
"Person '" + ped.
getPerson()->
getID() +
"' could not find sidewalk on edge '" + nextRouteEdge->
getID() +
"', time="
417 nextRouteLane = nextRouteEdge->
getLanes().front();
423 if (nextRouteLane !=
nullptr) {
428 nextLane = currentLane->
getLinkCont()[0]->getViaLaneOrLane();
433 std::cout <<
" internal\n";
438 nextLane = currentLane->
getLinkCont()[0]->getLane();
443 std::cout <<
" crossing\n";
451 const double arrivalPos = (nextRouteEdge == ped.
getStage()->
getRoute().back()
455 if (prevLane !=
nullptr) {
456 prohibited.push_back(&prevLane->
getEdge());
461 <<
" nre=" << nextRouteEdge->
getID()
462 <<
" nreDir=" << nextRouteEdgeDir
463 <<
" aPos=" << arrivalPos
464 <<
" crossingRoute=" <<
toString(crossingRoute)
467 if (crossingRoute.size() > 1) {
468 const MSEdge* nextEdge = crossingRoute[1];
469 nextLane = getSidewalk<MSEdge, MSLane>(crossingRoute[1], ped.
getPerson()->
getVClass());
471 assert(nextLane != prevLane);
474 std::cout <<
" nextDir=" << nextDir <<
"\n";
483 link = oppositeWalkingArea->
getLinkTo(nextLane);
486 assert(link !=
nullptr);
493 <<
" no route from '" << (currentEdge ==
nullptr ?
"NULL" : currentEdge->
getID())
494 <<
"' to '" << (nextRouteEdge ==
nullptr ?
"NULL" : nextRouteEdge->
getID())
499 link = prevLane->
getLinkTo(nextRouteLane);
501 link = nextRouteLane->
getLinkTo(prevLane);
503 if (link !=
nullptr) {
508 +
"' from walkingArea '" + currentEdge->
getID()
509 +
"' to edge '" + nextRouteEdge->
getID() +
"', time=" +
512 nextLane = nextRouteLane;
515 }
else if (currentEdge == nextRouteEdge) {
522 if (nextLane !=
nullptr) {
525 std::cout <<
" next walkingArea " << (nextDir ==
FORWARD ?
"forward" :
"backward") <<
"\n";
544 std::cout <<
" nextEdge=" << nextRouteEdge->
getID() <<
" passedFwd=" << passedFwd <<
" passedBwd=" << passedBwd <<
" futureRoute=" <<
toString(futureRoute) <<
" nextDir=" << nextDir <<
"\n";
550 link = currentLane->
getLinkTo(nextRouteLane);
551 if (link !=
nullptr) {
553 std::cout <<
" direct forward\n";
558 link = nextRouteLane->
getLinkTo(currentLane);
559 if (link !=
nullptr) {
561 std::cout <<
" direct backward\n";
564 if (nextLane !=
nullptr) {
566 while (nextLane->
getLinkCont()[0]->getViaLaneOrLane()->isInternal()) {
567 nextLane = nextLane->
getLinkCont()[0]->getViaLaneOrLane();
573 if (nextLane ==
nullptr) {
575 nextLane = nextRouteLane;
577 std::cout <<
SIMTIME <<
" no next lane found for " << currentLane->
getID() <<
" dir=" << ped.
getDirection() <<
"\n";
581 +
"' from edge '" + currentEdge->
getID()
582 +
"' to edge '" + nextRouteEdge->
getID() +
"', time=" +
585 }
else if (nextLane->
getLength() <= POSITION_EPS) {
597 nextLane = nextRouteLane;
606 <<
" l=" << currentLane->
getID()
607 <<
" nl=" << (nextLane ==
nullptr ?
"NULL" : nextLane->
getID())
608 <<
" nrl=" << (nextRouteLane ==
nullptr ?
"NULL" : nextRouteLane->
getID())
614 assert(nextLane != 0 || nextRouteLane == 0);
623 if (l->getLane()->getEdge().isWalkingArea()) {
629 const std::vector<MSLane::IncomingLaneInfo>& laneInfos = currentLane->
getIncomingLanes();
630 for (std::vector<MSLane::IncomingLaneInfo>::const_iterator it = laneInfos.begin(); it != laneInfos.end(); ++it) {
631 if ((*it).lane->getEdge().isWalkingArea()) {
632 link = (*it).viaLink;
643 const PState& ego = *
static_cast<PState*
>(pedestrians[egoIndex]);
644 const int egoStripe = ego.
stripe();
646 std::vector<bool> haveBlocker(stripes,
false);
647 for (
int index = egoIndex + 1; index < (int)pedestrians.size(); index++) {
648 const PState& p = *
static_cast<PState*
>(pedestrians[index]);
650 std::cout <<
SIMTIME <<
" ped=" << ego.
getID() <<
" cur=" << egoStripe <<
" checking neighbor " << p.
getID()
656 std::cout <<
" dist=" << ego.
distanceTo(o) << std::endl;
664 haveBlocker[p.
stripe()] =
true;
675 if (!haveBlocker[p.
stripe()]) {
694 int offset = (destStripes - origStripes) / 2;
696 offset += (destStripes - origStripes) % 2;
704 MSLane* lane,
const MSLane* nextLane,
int stripes,
int nextDir,
705 double currentLength,
int currentDir) {
706 if (nextLanesObs.count(nextLane) == 0) {
713 const int offset =
getStripeOffset(nextStripes, stripes, currentDir != nextDir && nextStripes > stripes);
724 if (nextStripes < stripes) {
726 for (
int ii = 0; ii < stripes; ++ii) {
727 if (ii < offset || ii >= nextStripes + offset) {
738 if ((stripes - nextStripes) % 2 != 0) {
741 nextDir = currentDir;
743 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
744 const PState& p = *
static_cast<PState*
>(pedestrians[ii]);
753 const double newY = relPos.
y() + lateral_offset;
764 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(nextDir));
765 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
766 const PState& p = *
static_cast<PState*
>(pedestrians[ii]);
772 if (nextDir != currentDir) {
777 const int stripe = p.
stripe(newY);
778 if (stripe >= 0 && stripe < stripes) {
782 if (otherStripe >= 0 && otherStripe < stripes) {
783 obs[otherStripe] = pObs;
798 nextLanesObs[nextLane] = obs;
800 return nextLanesObs[nextLane];
808 o.xFwd += currentLength;
809 o.xBack += currentLength;
811 const double tmp = o.xFwd;
812 o.xFwd = currentLength + nextLength - o.xBack;
813 o.xBack = currentLength + nextLength - tmp;
817 const double tmp = o.xFwd;
821 o.xFwd -= nextLength;
822 o.xBack -= nextLength;
832 if ((dir ==
FORWARD && x - width / 2. < obs[stripe].xBack) || (dir ==
BACKWARD && x + width / 2. > obs[stripe].xFwd)) {
833 obs[stripe] =
Obstacle(x, 0, type,
id, width);
841 const MSLane* lane = it_lane->first;
843 if (pedestrians.size() == 0) {
849 const double minY =
stripeWidth * - 0.5 + NUMERICAL_EPS;
854 std::set<const WalkingAreaPath*, walkingarea_path_sorter> paths;
855 for (Pedestrians::iterator it = pedestrians.begin(); it != pedestrians.end(); ++it) {
862 std::cout <<
SIMTIME <<
" debugging WalkingAreaPath from=" << debugPath->from->getID() <<
" to=" << debugPath->to->getID() <<
" minY=" << minY <<
" maxY=" << maxY <<
" latOffset=" << lateral_offset <<
"\n";
867 for (std::set<const WalkingAreaPath*, walkingarea_path_sorter>::iterator it = paths.begin(); it != paths.end(); ++it) {
871 transformedPeds.reserve(pedestrians.size());
872 for (Pedestrians::iterator it_p = pedestrians.begin(); it_p != pedestrians.end(); ++it_p) {
875 transformedPeds.push_back(p);
876 if (path == debugPath) std::cout <<
" ped=" << p->
getPerson()->
getID() <<
" relX=" << p->
getEdgePos(0) <<
" relY=" << p->
getPosLat() <<
" (untransformed), vecCoord="
881 transformedPeds.push_back(p);
882 if (path == debugPath) std::cout <<
" ped=" << p->
getPerson()->
getID() <<
" relX=" << p->
getEdgePos(0) <<
" relY=" << p->
getPosLat() <<
" (untransformed), vecCoord="
888 toDelete.push_back(tp);
889 transformedPeds.push_back(tp);
890 if (path == debugPath) std::cout <<
" ped=" << p->
getPerson()->
getID() <<
" relX=" << p->
getEdgePos(0) <<
" relY=" << p->
getPosLat() <<
" (semi-transformed), vecCoord="
895 const double newY = relPos.
y() + lateral_offset;
898 tp->
reset(relPos.
x(), newY);
899 toDelete.push_back(tp);
900 transformedPeds.push_back(tp);
901 if (path == debugPath) {
902 std::cout <<
" ped=" << p->
getPerson()->
getID() <<
" relX=" << relPos.
x() <<
" relY=" << newY <<
" (transformed), vecCoord=" << relPos <<
"\n";
905 if (path == debugPath) {
906 std::cout <<
" ped=" << p->
getPerson()->
getID() <<
" relX=" << relPos.
x() <<
" relY=" << newY <<
" (invalid), vecCoord=" << relPos <<
"\n";
916 for (
const MSLane* foeLane : itFoe->second) {
924 WRITE_WARNINGF(
"Could not vehicle '%' front position % onto walkingarea '%' path=%, time=%.",
928 WRITE_WARNINGF(
"Could not vehicle '%' back position % onto walkingarea '%' path=%, time=%.",
932 relCenter.push_back(relFront);
933 relCenter.push_back(relBack);
935 relCorners.
add(relCenter[0]);
936 relCorners.
add(relCenter[1]);
938 relCorners.
add(relCenter[0]);
939 relCorners.
add(relCenter[1]);
943 const double xWidth = relCorners.
getWidth();
944 const double vehYmin =
MAX2(minY - lateral_offset, relCorners.
ymin());
945 const double vehYmax =
MIN2(maxY - lateral_offset, relCorners.
ymax());
946 const double xCenter = relCorners.
getCenter().
x();
949 const bool addFront =
addVehicleFoe(veh, lane, yMinPos, dir * xWidth, 0, lateral_offset, minY, maxY, toDelete, transformedPeds);
950 const bool addBack =
addVehicleFoe(veh, lane, yMaxPos, dir * xWidth, 0, lateral_offset, minY, maxY, toDelete, transformedPeds);
951 if (path == debugPath) {
952 std::cout <<
" veh=" << veh->
getID()
953 <<
" corners=" << relCorners
954 <<
" xWidth=" << xWidth
955 <<
" ymin=" << relCorners.
ymin()
956 <<
" ymax=" << relCorners.
ymax()
957 <<
" vehYmin=" << vehYmin
958 <<
" vehYmax=" << vehYmax
961 if (addFront && addBack) {
963 const double yDist = vehYmax - vehYmin;
965 const double relDist = dist / yDist;
966 Position between = (yMinPos * relDist) + (yMaxPos * (1 - relDist));
967 if (path == debugPath) {
968 std::cout <<
" vehBetween=" << veh->
getID() <<
" pos=" << between <<
"\n";
970 addVehicleFoe(veh, lane, between, dir * xWidth,
stripeWidth, lateral_offset, minY, maxY, toDelete, transformedPeds);
979 for (Pedestrians::iterator it_p = toDelete.begin(); it_p != toDelete.end(); ++it_p) {
995 const double newY = relPos.
y() + lateral_offset;
996 if (newY >= minY && newY <= maxY) {
999 toDelete.push_back(tp);
1000 transformedPeds.push_back(tp);
1011 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(dir));
1013 for (
int i = 0; i < (int)pedestrians.size(); i++) {
1014 PState*
const p =
static_cast<PState*
>(pedestrians[i]);
1021 pedestrians.erase(pedestrians.begin() + i);
1024 if (p->
getLane() !=
nullptr) {
1043 sort(pedestrians.begin(), pedestrians.end(),
by_xpos_sorter(dir));
1046 bool hasCrossingVehObs =
false;
1049 hasCrossingVehObs =
addCrossingVehs(lane, stripes, 0, dir, crossingVehs,
true);
1052 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
1090 nextLanesObs, lane, nextLane, stripes,
1110 const double passingLength = p.
getLength() + passingClearanceTime * speed;
1121 && !link->
opened(currentTime -
DELTA_T, speed, speed, passingLength, p.
getImpatience(currentTime), speed, 0, 0,
nullptr, p.
ignoreRed(link), p.
getPerson())) {
1162 if (hasCrossingVehObs) {
1171 p.
walk(currentObs, currentTime);
1182 for (
int coll = 0; coll < ii; ++coll) {
1190 +
"', lane='" + lane->
getID() +
"', time=" +
time2string(currentTime) +
".");
1220 bool hasCrossingVehObs =
false;
1225 if (linkLeaders.size() > 0) {
1226 for (MSLink::LinkLeaders::const_iterator it = linkLeaders.begin(); it != linkLeaders.end(); ++it) {
1228 const MSVehicle* veh = (*it).vehAndGap.first;
1229 if (veh !=
nullptr) {
1234 voBlock.
xBack = NUMERICAL_EPS;
1241 const double bGap = (prio
1243 : veh->
getSpeed() * distToCrossBeforeVeh);
1247 if ((*it).fromLeft()) {
1248 vehYmin = -(*it).vehAndGap.second + lateral_offset;
1252 vehYmax = crossing->
getWidth() + (*it).vehAndGap.second - lateral_offset;
1266 hasCrossingVehObs =
true;
1271 <<
" crossingVeh=" << veh->
getID()
1272 <<
" lane=" << crossing->
getID()
1274 <<
" latOffset=" << lateral_offset
1276 <<
" stripes=" << stripes
1277 <<
" dist=" << (*it).distToCrossing
1278 <<
" gap=" << (*it).vehAndGap.second
1279 <<
" brakeGap=" << bGap
1280 <<
" fromLeft=" << (*it).fromLeft()
1281 <<
" distToCrossBefore=" << distToCrossBeforeVeh
1282 <<
" ymin=" << vehYmin
1283 <<
" ymax=" << vehYmax
1291 if (hasCrossingVehObs) {
1294 bool allBlocked =
true;
1296 for (
int i = 0; i < (int)obs.size(); i++) {
1299 (dir ==
FORWARD && i >= reserved) ||
1300 (dir ==
BACKWARD && i < (
int)obs.size() - reserved))) {
1307 std::cout <<
SIMTIME <<
" crossing=" << crossing->
getID() <<
" allBlocked\n";
1311 o.xBack = NUMERICAL_EPS;
1313 o.xFwd = crossing->
getLength() - NUMERICAL_EPS;
1319 return hasCrossingVehObs;
1334 if (ped !=
nullptr) {
1360 double vehXMaxCheck;
1361 double vehXMinCheck;
1365 vehXMin = vehFront - clearance;
1367 vehXMaxCheck = vehBack + NUMERICAL_EPS;
1371 vehXMinCheck = vehFront - clearance;
1374 vehXMax = vehFront + clearance;
1377 vehXMaxCheck = vehFront + clearance;
1381 vehXMinCheck = vehBack - NUMERICAL_EPS;
1385 std::cout <<
SIMTIME <<
" ped=" << pID <<
" veh=" << veh->
getID() <<
" check obstacle on lane=" << lane->
getID()
1387 <<
" vehXMin=" << vehXMin
1388 <<
" vehXMax=" << vehXMax
1389 <<
" vehXMinC=" << vehXMinCheck
1390 <<
" vehXMaxC=" << vehXMaxCheck
1394 <<
" vFront=" << vehFront
1395 <<
" vBack=" << vehBack
1398 if (vehXMaxCheck > minX && vehXMinCheck && vehXMinCheck <= maxX) {
1411 if (s == current && vehFront +
SAFETY_GAP < minX) {
1413 if (pRelY - pWidth < vehYmax &&
1414 pRelY + pWidth > vehYmin && dir ==
FORWARD) {
1416 std::cout <<
" ignoring vehicle '" << veh->
getID() <<
" on stripe " << s <<
" vehFrontSG=" << vehFront +
SAFETY_GAP <<
" minX=" << minX <<
"\n";
1427 std::cout <<
SIMTIME <<
" ped=" << pID <<
" veh=" << veh->
getID() <<
" obstacle on lane=" << lane->
getID()
1429 <<
" ymin=" << vehYmin
1430 <<
" ymax=" << vehYmax
1433 <<
" relY=" << pRelY
1434 <<
" current=" << current
1435 <<
" vo.xFwd=" << vo.
xFwd
1436 <<
" vo.xBack=" << vo.
xBack
1437 <<
" vFront=" << vehFront
1438 <<
" vBack=" << vehBack
1454 type(OBSTACLE_NONE),
1460 xFwd(ped.getMaxX()),
1461 xBack(ped.getMinX()),
1462 speed(ped.getDirection() * ped.getSpeed(*ped.getStage())),
1463 type(ped.getOType()),
1464 description(ped.getID()) {
1475 return xBack <= o.
xBack;
1477 return xFwd >= o.
xFwd;
1487 myWalkingAreaPath(nullptr) {
1490 assert(!route.empty());
1492 if (route.size() == 1) {
1497 if (route.front()->isWalkingArea()) {
1506 std::cout <<
" initialize dir for " <<
myPerson->
getID() <<
" forward=" << mayStartForward <<
" backward=" << mayStartBackward <<
"\n";
1508 if (mayStartForward && mayStartBackward) {
1512 if (crossingRoute.size() > 1) {
1514 const MSEdge* nextEdge = crossingRoute[1];
1520 std::cout <<
" crossingRoute=" <<
toString(crossingRoute) <<
"\n";
1522 }
else if (!mayStartForward && !mayStartBackward) {
1523 int lastDisconnect = passedFwd >= passedBwd ? passedFwd : passedBwd;
1525 if (route.size() > 2) {
1526 dLoc =
TLF(
" between edge '%' and edge '%'", route[lastDisconnect - 1]->
getID(), route[lastDisconnect]->
getID());
1528 WRITE_WARNINGF(
TL(
"Person '%' walking from edge '%' to edge '%' has a disconnect%, time=%."),
1563 myWalkingAreaPath(nullptr) {
1564 if (in !=
nullptr) {
1566 std::string wapLaneFrom;
1567 std::string wapLaneTo;
1568 std::string nextLaneID;
1569 std::string nextLinkFrom;
1570 std::string nextLinkTo;
1575 >> wapLaneFrom >> wapLaneTo
1585 throw ProcessError(
"Unknown lane '" + laneID +
"' when loading walk for person '" +
myPerson->
getID() +
"' from state.");
1588 MSLane* nextLane =
nullptr;
1589 if (nextLaneID !=
"null") {
1591 if (nextLane ==
nullptr) {
1592 throw ProcessError(
"Unknown next lane '" + nextLaneID +
"' when loading walk for person '" +
myPerson->
getID() +
"' from state.");
1595 const MSLink* link =
nullptr;
1596 if (nextLinkFrom !=
"null") {
1599 if (from ==
nullptr) {
1600 throw ProcessError(
"Unknown link origin lane '" + nextLinkFrom +
"' when loading walk for person '" +
myPerson->
getID() +
"' from state.");
1602 if (to ==
nullptr) {
1603 throw ProcessError(
"Unknown link destination lane '" + nextLinkTo +
"' when loading walk for person '" +
myPerson->
getID() +
"' from state.");
1609 if (wapLaneFrom !=
"null") {
1612 if (from ==
nullptr) {
1613 throw ProcessError(
"Unknown walkingAreaPath origin lane '" + wapLaneFrom +
"' when loading walk for person '" +
myPerson->
getID() +
"' from state.");
1615 if (to ==
nullptr) {
1616 throw ProcessError(
"Unknown walkingAreaPath destination lane '" + wapLaneTo +
"' when loading walk for person '" +
myPerson->
getID() +
"' from state.");
1622 throw ProcessError(
"Unknown walkingAreaPath from lane '" + wapLaneFrom +
"' to lane '" + wapLaneTo +
"' when loading walk for person '" +
myPerson->
getID() +
"' from state.");
1635 std::string wapLaneFrom =
"null";
1636 std::string wapLaneTo =
"null";
1637 if (myWalkingAreaPath !=
nullptr) {
1638 wapLaneFrom = myWalkingAreaPath->from->getID();
1639 wapLaneTo = myWalkingAreaPath->to->getID();
1641 std::string nextLaneID =
"null";
1642 std::string nextLinkFrom =
"null";
1643 std::string nextLinkTo =
"null";
1644 if (myNLI.lane !=
nullptr) {
1645 nextLaneID = myNLI.lane->getID();
1647 if (myNLI.link !=
nullptr) {
1648 nextLinkFrom = myNLI.link->getLaneBefore()->getID();
1649 nextLinkTo = myNLI.link->getViaLaneOrLane()->getID();
1651 out <<
" " << myLane->getID()
1656 <<
" " << mySpeedLat
1657 <<
" " << myWaitingToEnter
1658 <<
" " << myWaitingTime
1659 <<
" " << wapLaneFrom
1661 <<
" " << myAmJammed
1662 <<
" " << nextLaneID
1663 <<
" " << nextLinkFrom
1664 <<
" " << nextLinkTo
1665 <<
" " << myNLI.dir;
1672 return myEdgePos - getLength();
1674 return myEdgePos - (includeMinGap ? getMinGap() : 0.);
1682 return myEdgePos + (includeMinGap ? getMinGap() : 0.);
1684 return myEdgePos + getLength();
1690 return myPerson->getVehicleType().getLength();
1696 return myPerson->getVehicleType().getMinGap();
1708 const int s = stripe(relY);
1712 if (offset > threshold) {
1714 }
else if (offset < -threshold) {
1739 if (myStage->getNextRouteEdge() ==
nullptr) {
1740 return myDir * (myStage->getArrivalPos() - myEdgePos) - POSITION_EPS - (
1741 (myWaitingTime >
DELTA_T && (myStage->getDestinationStop() ==
nullptr ||
1742 myStage->getDestinationStop()->getWaitingCapacity() > myStage->getDestinationStop()->getNumWaitingPersons()))
1745 const double length = myWalkingAreaPath ==
nullptr ? myLane->getLength() : myWalkingAreaPath->length;
1746 return myDir ==
FORWARD ? length - myEdgePos : myEdgePos;
1753 double dist = distToLaneEnd();
1755 std::cout <<
SIMTIME <<
" ped=" << myPerson->getID() <<
" myEdgePos=" << myEdgePos <<
" dist=" << dist <<
"\n";
1763 const int oldDir = myDir;
1764 const MSLane* oldLane = myLane;
1765 myLane = myNLI.lane;
1767 const bool normalLane = (myLane ==
nullptr || myLane->getEdge().getFunction() ==
SumoXMLEdgeFunc::NORMAL || &myLane->getEdge() == myStage->getNextRouteEdge());
1770 <<
" ped=" << myPerson->getID()
1771 <<
" moveToNextLane old=" << oldLane->
getID()
1772 <<
" new=" << (myLane ==
nullptr ?
"NULL" : myLane->getID())
1773 <<
" oldDir=" << oldDir
1774 <<
" newDir=" << myDir
1775 <<
" myEdgePos=" << myEdgePos
1779 if (myLane ==
nullptr) {
1780 myEdgePos = myStage->getArrivalPos();
1783 if (myStage->getRouteStep() == myStage->getRoute().end() - 1) {
1786 const bool arrived = myStage->moveToNextEdge(myPerson, currentTime, oldDir, normalLane ?
nullptr : &myLane->getEdge());
1792 myStage->activateEntryReminders(myPerson);
1793 assert(myNLI.lane != oldLane);
1795 std::cout <<
" nextLane=" << (myNLI.lane ==
nullptr ?
"NULL" : myNLI.lane->getID()) <<
"\n";
1797 if (myLane->getEdge().isWalkingArea()) {
1800 assert(myWalkingAreaPath->shape.size() >= 2);
1802 std::cout <<
" mWAPath shape=" << myWalkingAreaPath->shape <<
" length=" << myWalkingAreaPath->length <<
"\n";
1804 }
else if (myNLI.link !=
nullptr) {
1806 myLane = myNLI.lane;
1807 assert(!myLane->getEdge().isWalkingArea());
1808 myStage->moveToNextEdge(myPerson, currentTime, myDir, &myLane->getEdge());
1809 myWalkingAreaPath =
nullptr;
1815 const MSEdge* currRouteEdge = *myStage->getRouteStep();
1816 const MSEdge* nextRouteEdge = myStage->getNextRouteEdge();
1824 myStage->moveToNextEdge(myPerson, currentTime, oldDir,
nullptr);
1825 myLane = myNLI.lane;
1826 assert(myLane != 0);
1829 myWalkingAreaPath =
nullptr;
1831 throw ProcessError(
TLF(
"Disconnected walk for person '%'.", myPerson->getID()));
1835 myWalkingAreaPath =
nullptr;
1840 const double newLength = (myWalkingAreaPath ==
nullptr ? myLane->getLength() : myWalkingAreaPath->length);
1841 if (-dist > newLength) {
1848 myEdgePos = newLength + dist;
1853 std::cout <<
SIMTIME <<
" update myEdgePos ped=" << myPerson->getID()
1854 <<
" newLength=" << newLength
1856 <<
" myEdgePos=" << myEdgePos
1860 if (myDir != oldDir) {
1867 std::cout <<
SIMTIME <<
" transformY ped=" << myPerson->getID()
1869 <<
" newY=" << myPosLat
1871 <<
" od=" << oldDir <<
" nd=" << myDir
1872 <<
" offset=" << offset <<
"\n";
1875 myAngle = std::numeric_limits<double>::max();
1886 (
int)floor(stripes * factor),
1892 const int stripes = (int)obs.size();
1893 const int sMax = stripes - 1;
1897 const double vMax = (myStage->getConfiguredSpeed() >= 0
1898 ? myStage->getConfiguredSpeed()
1899 : (myLane->isNormal() || myLane->isInternal()
1900 ? myLane->getVehicleMaxSpeed(myPerson)
1901 : myStage->getMaxSpeed(myPerson)));
1903 const int current = stripe();
1904 const int other = otherStripe();
1906 std::vector<double> distance(stripes);
1907 for (
int i = 0; i < stripes; ++i) {
1908 distance[i] = distanceTo(obs[i], obs[i].type ==
OBSTACLE_PED);
1911 std::vector<double> utility(stripes, 0);
1913 for (
int i = 0; i < stripes; ++i) {
1915 if (i == current && (!isWaitingToEnter() || stripe() != stripe(myPosLat))) {
1919 for (
int j = 0; j <= i; ++j) {
1924 for (
int j = i; j < stripes; ++j) {
1933 const bool onJunction = myLane->getEdge().isWalkingArea() || myLane->getEdge().isCrossing();
1936 for (
int i = 0; i < reserved; ++i) {
1940 for (
int i = sMax; i > sMax - reserved; --i) {
1945 for (
int i = 0; i < stripes; ++i) {
1946 if (obs[i].speed * myDir < 0) {
1949 utility[i - 1] -= 0.5;
1950 }
else if (myDir ==
BACKWARD && i < sMax) {
1951 utility[i + 1] -= 0.5;
1955 const double walkDist =
MAX2(0., distance[i]);
1957 const double expectedDist =
MIN2(vMax *
LOOKAHEAD_SAMEDIR, walkDist + obs[i].speed * myDir * lookAhead);
1958 if (expectedDist >= 0) {
1959 utility[i] += expectedDist;
1966 if (myDir ==
FORWARD && obs[0].speed < 0) {
1968 }
else if (myDir ==
BACKWARD && obs[sMax].speed > 0) {
1972 if (distance[current] > 0 && myWaitingTime == 0) {
1973 for (
int i = 0; i < stripes; ++i) {
1979 for (
int i = 0; i < stripes; ++i) {
1987 int chosen = current;
1988 for (
int i = 0; i < stripes; ++i) {
1994 const int next = (chosen == current ? current : (chosen < current ? current - 1 : current + 1));
1995 double xDist =
MIN3(distance[current], distance[other], distance[next]);
1996 if (next != chosen) {
1999 const int nextOther = chosen < current ? current - 2 : current + 2;
2000 xDist =
MIN2(xDist, distance[nextOther]);
2003 const double preferredGap = NUMERICAL_EPS;
2005 if (xSpeed < NUMERICAL_EPS) {
2009 std::cout <<
" xSpeedPotential=" << xSpeed <<
"\n";
2016 (xDist == distance[current] && obs[current].type >=
OBSTACLE_END)
2017 || (xDist == distance[other] && obs[other].type >=
OBSTACLE_END)
2018 || (xDist == distance[next] && obs[next].type >=
OBSTACLE_END))
2026 <<
" vehWait=" <<
STEPS2TIME(obs[current].vehicle ? obs[current].vehicle->getWaitingTime() : 0)
2029 if (myWaitingTime > ((myLane->getEdge().isCrossing()
2031 || (myLane->getEdge().isWalkingArea() && obs[current].vehicle !=
nullptr && obs[current].vehicle->getWaitingTime() >
jamTimeCrossing
2033 || (sMax == 0 && obs[0].speed * myDir < 0 && myWaitingTime >
jamTimeNarrow)
2044 }
else if (myAmJammed && stripe(myPosLat) >= 0 && stripe(myPosLat) <= sMax && xDist >=
MIN_STARTUP_DIST) {
2068 if (fabs(yDist) > NUMERICAL_EPS) {
2069 ySpeed = (yDist > 0 ?
2075 && stripe() == stripe(myPosLat)
2077 && !(myLane->getEdge().isCrossing() || myLane->getEdge().isWalkingArea())) {
2079 int stepAsideDir = myDir;
2080 if (myLane->getEdge().getLanes().size() > 1 || current > sMax / 2) {
2086 ySpeed = stepAsideDir * vMax;
2092 <<
" ped=" << myPerson->getID()
2093 <<
" edge=" << myStage->getEdge()->getID()
2094 <<
" x=" << myEdgePos
2095 <<
" y=" << myPosLat
2097 <<
" pvx=" << mySpeed
2098 <<
" cur=" << current
2099 <<
" cho=" << chosen
2103 <<
" dawdle=" << dawdle
2108 <<
" wTime=" << myStage->getWaitingTime(currentTime)
2109 <<
" jammed=" << myAmJammed
2112 for (
int i = 0; i < stripes; ++i) {
2114 std::cout <<
" util=" << utility[i] <<
" dist=" << distance[i] <<
" o=" << o.
description;
2116 std::cout <<
" xF=" << o.
xFwd <<
" xB=" << o.
xBack <<
" v=" << o.
speed;
2119 std::cout <<
" current";
2121 if (i == other && i != current) {
2122 std::cout <<
" other";
2125 std::cout <<
" chosen";
2128 std::cout <<
" next";
2136 mySpeedLat = ySpeed;
2139 myWaitingToEnter =
false;
2144 myAngle = std::numeric_limits<double>::max();
2150 return MAX2(0.,
MIN2(1., myPerson->getVehicleType().getImpatience()
2158 return myRemoteXYPos;
2160 if (myLane ==
nullptr) {
2164 const double lateral_offset = -getLatOffset();
2165 if (myWalkingAreaPath ==
nullptr) {
2180 return myWalkingAreaPath->shape.positionAtOffset(myEdgePos, lateral_offset);
2182 const double rotationOffset = myDir ==
FORWARD ? 0 :
DEG2RAD(180);
2183 return myWalkingAreaPath->shape.sidePositionAtAngle(myEdgePos, lateral_offset, myWalkingAreaPath->angleOverride + rotationOffset);
2191 if (myAngle != std::numeric_limits<double>::max()) {
2194 if (myLane ==
nullptr) {
2198 if (myWalkingAreaPath !=
nullptr && myWalkingAreaPath->angleOverride !=
INVALID_DOUBLE) {
2199 return myWalkingAreaPath->angleOverride;
2201 const PositionVector& shp = myWalkingAreaPath ==
nullptr ? myLane->getShape() : myWalkingAreaPath->shape;
2202 double geomX = myWalkingAreaPath ==
nullptr ? myLane->interpolateLanePosToGeometryPos(myEdgePos) : myEdgePos;
2205 angle += atan2(mySpeedLat,
MAX2(mySpeed, NUMERICAL_EPS));
2207 angle -= atan2(mySpeedLat,
MAX2(mySpeed, NUMERICAL_EPS));
2219 return myNLI.lane ==
nullptr ? nullptr : &myNLI.lane->getEdge();
2225 return myNLI.lane !=
nullptr && myNLI.lane->
isCrossing() ? myNLI.lane :
nullptr;
2231 myEdgePos = pathLength - myEdgePos;
2232 myPosLat = usableWidth - myPosLat;
2233 myDir = -myWalkingAreaPath->dir;
2234 mySpeedLat = -mySpeedLat;
2240 myEdgePos = edgePos;
2251 int routeOffset = 0;
2252 bool laneOnRoute =
false;
2254 for (
const MSEdge* edge : myStage->getRoute()) {
2257 || edge->getFromJunction() == laneOnJunction) {
2264 throw ProcessError(
"Lane '" + lane->
getID() +
"' is not on the route of person '" + getID() +
"'.");
2267 if (lane->
getEdge().
isWalkingArea() && (myWalkingAreaPath ==
nullptr || myWalkingAreaPath->lane != lane)) {
2269 const MSEdge* prevEdge = myStage->getRoute()[routeOffset];
2270 const MSEdge* nextEdge = routeOffset + 1 < (int)myStage->getRoute().size() ? myStage->getRoute()[routeOffset + 1] :
nullptr;
2272 const double maxPos = guessed->
shape.
length() - NUMERICAL_EPS;
2273 if (lanePos > maxPos + POSITION_EPS || lanePos < -POSITION_EPS) {
2275 +
"' (fromLane='" + guessed->
from->
getID()
2276 +
"' toLane='" + guessed->
to->
getID() +
"') for person '" + getID() +
"' time=" +
time2string(t) +
".");
2279 lanePos =
MIN2(maxPos,
MAX2(NUMERICAL_EPS, lanePos));
2283 moveToXY(p, pos, lane, lanePos, lanePosLat, angle, routeOffset, newEdges, t);
2289 double lanePosLat,
double angle,
int routeOffset,
2292 assert(p == myPerson);
2293 assert(pm !=
nullptr);
2296 const double oldX = myEdgePos -
SPEED2DIST(mySpeed * myDir);
2297 const double tmp = myEdgePos;
2299 Position oldPos = getPosition(*myStage, t);
2305 #ifdef DEBUG_MOVETOXY
2309 <<
" lane=" << lane->
getID()
2310 <<
" lanePos=" << lanePos
2311 <<
" lanePosLat=" << lanePosLat
2312 <<
" angle=" << angle
2313 <<
" routeOffset=" << routeOffset
2316 <<
" path=" << (myWalkingAreaPath ==
nullptr ?
"null" : (myWalkingAreaPath->from->getID() +
"->" + myWalkingAreaPath->to->getID())) <<
"\n";
2319 if (lane != myLane && myLane !=
nullptr) {
2323 if (lane !=
nullptr &&
2326 const MSEdge* old = myStage->getEdge();
2327 const MSLane* oldLane = myLane;
2328 if (lane != myLane) {
2332 if (edges.empty()) {
2334 myStage->setRouteIndex(myPerson, routeOffset);
2336 myStage->replaceRoute(myPerson, edges, routeOffset);
2339 myStage->moveToNextEdge(myPerson, t, myDir, &lane->
getEdge());
2345 if (myWalkingAreaPath ==
nullptr || myWalkingAreaPath->lane != lane) {
2347 myWalkingAreaPath =
guessPath(&lane->
getEdge(), old, myStage->getNextRouteEdge());
2348 #ifdef DEBUG_MOVETOXY
2350 <<
" path=" << myWalkingAreaPath->from->getID() <<
"->" << myWalkingAreaPath->to->getID() <<
"\n";
2355 const Position relPos = myWalkingAreaPath->shape.transformToVectorCoordinates(pos);
2358 +
"' (fromLane='" + myWalkingAreaPath->from->getID()
2359 +
"' toLane='" + myWalkingAreaPath->to->getID() +
"') for person '" + getID() +
"' time=" +
time2string(t) +
".");
2360 myRemoteXYPos = pos;
2362 myEdgePos = relPos.
x();
2363 myPosLat = lateral_offset + relPos.
y();
2366 myWalkingAreaPath =
nullptr;
2367 myEdgePos = lanePos;
2368 myPosLat = lateral_offset - lanePosLat;
2372 if (myStage->getNextRouteEdge() !=
nullptr) {
2373 if (myStage->getEdge()->getToJunction() == myStage->getNextRouteEdge()->getFromJunction() ||
2374 myStage->getEdge()->getToJunction() == myStage->getNextRouteEdge()->getToJunction()) {
2381 if (angleDiff <= 90) {
2392 if (oldLane ==
nullptr || &oldLane->
getEdge() != &myLane->getEdge()) {
2393 const MSLane* sidewalk = getSidewalk<MSEdge, MSLane>(&myLane->getEdge(), p->
getVClass());
2396 myNLI =
getNextLane(*
this, sidewalk ==
nullptr ? myLane : sidewalk,
nullptr);
2397 myStage->activateEntryReminders(myPerson);
2398 #ifdef DEBUG_MOVETOXY
2399 std::cout <<
" myNLI=" <<
Named::getIDSecure(myNLI.lane) <<
" link=" << (myNLI.link ==
nullptr ?
"NULL" : myNLI.link->getDescription()) <<
" dir=" << myNLI.dir <<
"\n";
2402 #ifdef DEBUG_MOVETOXY
2403 std::cout <<
" newRelPos=" <<
Position(myEdgePos, myPosLat) <<
" edge=" << myPerson->getEdge()->getID() <<
" newPos=" << myPerson->getPosition()
2404 <<
" oldAngle=" << oldAngle <<
" angleDiff=" << angleDiff <<
" newDir=" << myDir <<
"\n";
2406 if (oldLane == myLane) {
2407 mySpeed =
DIST2SPEED(fabs(oldX - myEdgePos));
2414 myRemoteXYPos = pos;
2423 if (myWalkingAreaPath !=
nullptr) {
2424 return myWalkingAreaPath->length;
2433 const double maxX = getMaxX(includeMinGap);
2434 const double minX = getMinX(includeMinGap);
2438 if ((obs.
xFwd >= maxX && obs.
xBack <= maxX) || (obs.
xFwd <= maxX && obs.
xFwd >= minX)) {
2452 for (
int i = 0; i < (int)into.size(); ++i) {
2454 std::cout <<
" i=" << i <<
" maxX=" << getMaxX(
true) <<
" minX=" << getMinX(
true)
2455 <<
" into=" << into[i].description <<
" iDist=" << distanceTo(into[i], into[i].type ==
OBSTACLE_PED)
2456 <<
" obs2=" << obs2[i].description <<
" oDist=" << distanceTo(obs2[i], obs2[i].type ==
OBSTACLE_PED) <<
"\n";
2458 const double dO = distanceTo(obs2[i], obs2[i].type ==
OBSTACLE_PED);
2459 const double dI = distanceTo(into[i], into[i].type ==
OBSTACLE_PED);
2474 for (
int i = 0; i < (int)into.size(); ++i) {
2475 int i2 = i + offset;
2476 if (i2 >= 0 && i2 < (
int)obs2.size()) {
2478 if (obs2[i2].xBack < into[i].xBack) {
2482 if (obs2[i2].xFwd > into[i].xFwd) {
2495 if (ignoreRedTime >= 0) {
2498 std::cout <<
SIMTIME <<
" ignoreRedTime=" << ignoreRedTime <<
" redDuration=" << redDuration <<
"\n";
2500 return ignoreRedTime > redDuration;
2511 return myPerson->getVehicleType().getWidth();
2517 return myPerson->hasInfluencer() && myPerson->getInfluencer().isRemoteControlled();
2525 myVehicle(veh), myXWidth(xWidth), myYWidth(yWidth) {
2535 return myVehicle->getID();
2545 return myXWidth > 0 ? myEdgePos - myXWidth : myEdgePos;
2550 return myXWidth > 0 ? myEdgePos : myEdgePos - myXWidth;
2559 std::set<MSPerson*> changedLane;
2560 myModel->moveInDirection(currentTime, changedLane,
FORWARD);
2561 myModel->moveInDirection(currentTime, changedLane,
BACKWARD);
2564 for (ActiveLanes::const_iterator it_lane = myModel->getActiveLanes().begin(); it_lane != myModel->getActiveLanes().end(); ++it_lane) {
2565 const MSLane* lane = it_lane->first;
2567 if (pedestrians.size() == 0) {
2572 for (
int ii = 0; ii < (int)pedestrians.size(); ++ii) {
2573 const PState& p = *pedestrians[ii];
std::vector< const MSEdge * > ConstMSEdgeVector
std::vector< MSEdge * > MSEdgeVector
#define WRITE_WARNINGF(...)
#define WRITE_WARNING(msg)
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
const std::string DEFAULT_PEDTYPE_ID
@ SVC_PEDESTRIAN
pedestrian
@ SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
bool gDebugFlag1
global utility flags for debugging
const double INVALID_DOUBLE
invalid double
#define UNUSED_PARAMETER(x)
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
A class that stores a 2D geometrical boundary.
Position getCenter() const
Returns the center of the boundary.
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
double ymin() const
Returns minimum y-coordinate.
double getWidth() const
Returns the width of the boudary (x-axis)
void growWidth(double by)
Increases the width of the boundary (x-axis)
double ymax() const
Returns maximum y-coordinate.
static double naviDegree(const double angle)
static double fromNaviDegree(const double angle)
static double getMinAngleDiff(double angle1, double angle2)
Returns the minimum distance (clockwise/counter-clockwise) between both angles.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
double brakeGap(const double speed) const
Returns the distance the vehicle needs to halt including driver's reaction time tau (i....
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
A road/street connecting two junctions.
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
bool isCrossing() const
return whether this edge is a pedestrian crossing
const MSEdgeVector & getPredecessors() const
bool isWalkingArea() const
return whether this edge is walking area
bool isNormal() const
return whether this edge is an internal edge
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
const MSJunction * getFromJunction() const
double getLength() const
return the length of the edge
bool isInternal() const
return whether this edge is an internal edge
const MSJunction * getToJunction() const
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
static bool gCheck4Accidents
The base class for an intersection.
AnyVehicleIterator is a structure, which manages the iteration through all vehicles on the lane,...
Representation of a lane in the micro simulation.
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
AnyVehicleIterator anyVehiclesEnd() const
end iterator for iterating over all vehicles touching this lane in downstream direction
int getVehicleNumberWithPartials() const
Returns the number of vehicles on this lane (including partial occupators)
const MSLink * getLinkTo(const MSLane *const) const
returns the link to the given lane or nullptr, if it is not connected
bool isWalkingArea() const
SVCPermissions getPermissions() const
Returns the vehicle class permissions for this lane.
double getLength() const
Returns the lane's length.
const MSLane * getInternalFollowingLane(const MSLane *const) const
returns the internal lane leading to the given lane or nullptr, if there is none
MSLane * getCanonicalSuccessorLane() const
const std::vector< IncomingLaneInfo > & getIncomingLanes() const
MSLane * getLogicalPredecessorLane() const
get the most likely precedecessor lane (sorted using by_connections_to_sorter). The result is cached ...
AnyVehicleIterator anyVehiclesUpstreamEnd() const
end iterator for iterating over all vehicles touching this lane in upstream direction
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
MSEdge & getEdge() const
Returns the lane's edge.
AnyVehicleIterator anyVehiclesUpstreamBegin() const
begin iterator for iterating over all vehicles touching this lane in upstream direction
AnyVehicleIterator anyVehiclesBegin() const
begin iterator for iterating over all vehicles touching this lane in downstream direction
MSLane * getBidiLane() const
retrieve bidirectional lane or nullptr
double getWidth() const
Returns the lane's width.
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
virtual const PositionVector & getShape(bool) const
SUMOTime getLastStateChange() const
MSLane * getLane() const
Returns the connected lane.
MSLane * getViaLaneOrLane() const
return the via lane if it exists and the lane otherwise
bool opened(SUMOTime arrivalTime, double arrivalSpeed, double leaveSpeed, double vehicleLength, double impatience, double decel, SUMOTime waitingTime, double posLat=0, BlockingFoes *collectFoes=nullptr, bool ignoreRed=false, const SUMOTrafficObject *ego=nullptr, double dist=-1) const
Returns the information whether the link may be passed.
bool havePriority() const
Returns whether this link is a major link.
const LinkLeaders getLeaderInfo(const MSVehicle *ego, double dist, std::vector< const MSPerson * > *collectBlockers=0, bool isShadowLink=false) const
Returns all potential link leaders (vehicles on foeLanes) Valid during the planMove() phase.
std::vector< LinkLeader > LinkLeaders
const MSTrafficLightLogic * getTLLogic() const
Returns the TLS index.
bool haveRed() const
Returns whether this link is blocked by a red (or redyellow) traffic light.
The simulated network and simulation perfomer.
MSPedestrianRouter & getPedestrianRouter(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
virtual MSTransportableControl & getPersonControl()
Returns the person control.
std::vector< MSPModel_InteractingState * > Pedestrians
Pedestrians & getPedestrians(const MSLane *lane)
retrieves the pedestrian vector for the given lane (may be empty)
ActiveLanes myActiveLanes
store of all lanes which have pedestrians on them
bool myAmActive
whether an event for pedestrian processing was added
static bool usingInternalLanesStatic()
int myNumActivePedestrians
the total number of active pedestrians
void registerActive()
increase the number of active pedestrians
virtual void remove(MSTransportableStateAdapter *state)
remove the specified person from the pedestrian simulation
static void unregisterCrossingApproach(const MSPModel_InteractingState &ped, const MSLane *crossing)
unregister pedestrian approach with the junction model
Container for pedestrian state and individual position update function.
SUMOTime myWaitingTime
the consecutive time spent at speed 0
MSPerson * myPerson
the person who is being represented
int myDir
the walking direction on the current lane (1 forward, -1 backward)
double myEdgePos
the advancement along the current lane
double getEdgePos(SUMOTime) const
abstract methods inherited from MSTransportableStateAdapter
MSPerson * getPerson() const
return the represented person
virtual const std::string & getID() const
return ID of the person (or sometimes vehicle) being represented
const MSLane * myLane
the current lane of this pedestrian
double mySpeed
the current walking speed
MSStageMoving * myStage
the current stage of this pedestrian
const Position & getRemotePosition() const
return the remote position if being controlled by TraCI or JuPedSim
MSStageMoving * getStage() const
return the current stage
double myPosLat
the orthogonal shift on the current lane
double mySpeedLat
the current lateral walking speed
bool isWaitingToEnter() const
whether the person still waits to entere the network
const MSLane * getLane() const
the current lane of the transportable
bool myWaitingToEnter
whether the pedestrian is waiting to start its walk
int getDirection() const
return the walking direction (FORWARD, BACKWARD, UNDEFINED_DIRECTION)
bool myAmJammed
whether the person is jammed
double getSpeed(const MSStageMoving &) const
return the current speed of the transportable
bool isJammed() const
whether the transportable is jammed
SUMOTime execute(SUMOTime currentTime)
Executes the command.
Container for pedestrian state and individual position update function.
virtual double getMaxX(const bool includeMinGap=true) const
return the maximum position on the lane
const WalkingAreaPath * myWalkingAreaPath
the current walkingAreaPath or 0
PState()
constructor for PStateVehicle
double distToLaneEnd() const
the absolute distance to the end of the lane in walking direction (or to the arrivalPos)
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
const MSLane * getNextCrossing() const
placeholder function for the accessing the next crossing
void walk(const Obstacles &obs, SUMOTime currentTime)
perform position update
virtual double getWidth() const
return the person width
void saveState(std::ostringstream &out)
Saves the current state into the given stream.
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
void reverse(const double pathLength, const double usableWidth)
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
Position getPosition(const MSStageMoving &stage, SUMOTime now) const
return the network coordinate of the transportable
NextLaneInfo myNLI
information about the upcoming lane
double getAngle(const MSStageMoving &stage, SUMOTime now) const
return the current orientation in degrees
double getImpatience(SUMOTime now) const
returns the impatience
void reset(const double edgePos, const double latPos)
double distanceTo(const Obstacle &obs, const bool includeMinGap=true) const
double getLength() const
return the length of the pedestrian
double getPathLength() const
return the total length of the current lane (in particular for on a walkingarea)
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 ID of the person (or sometimes vehicle) being represented
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.
The pedestrian movement model using stripes on sidewalks.
static const double MIN_STARTUP_DIST
the minimum distance to the next obstacle in order to start walking after stopped
static void registerCrossingApproach(const PState &ped, const MSLane *crossing, const MSLane *beforeWA)
register pedestrian approach with the junction model
static double RESERVE_FOR_ONCOMING_FACTOR
fraction of the leftmost lanes to reserve for oncoming traffic
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 double posLatConversion(const double posLat, const double laneWidth)
Convert the striping to the vehicle lateral position and vice versa.
static SUMOTime jamTimeCrossing
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
intermediate points to smooth out lanes within the walkingarea
static const double LOOKAHEAD_SAMEDIR
the distance (in seconds) to look ahead for changing stripes
static double RESERVE_FOR_ONCOMING_MAX
std::map< const MSLane *, Obstacles, ComparatorNumericalIdLess > NextLanesObstacles
static double minGapToVehicle
the safety buffer to vehicles
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 const double LOOKAHEAD_ONCOMING_DIST
the distance (in m) to look ahead for obstacles on a subsequent edge
static void initWalkingAreaPaths(const MSNet *net)
static const double LOOKAROUND_VEHICLES
the distance (in m) to look around for vehicles
static const double SQUEEZE
the factor by which pedestrian width is reduced when sqeezing past each other
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)
static const WalkingAreaPath * guessPath(const MSEdge *walkingArea, const MSEdge *before, const MSEdge *after)
static int getReserved(int stripes, double factor)
static SUMOTime jamTime
the time threshold before becoming jammed
static void insertWalkArePaths(const MSEdge *edge, WalkingAreaPaths &into)
creates and inserts all paths into the given map
void moveInDirectionOnLane(Pedestrians &pedestrians, const MSLane *lane, SUMOTime currentTime, std::set< MSPerson * > &changedLane, int dir, bool debug)
move pedestrians forward on one lane
static double stripeWidth
model parameters
static const double MAX_WAIT_TOLERANCE
the time pedestrians take to reach maximum impatience
static Obstacles getVehicleObstacles(const MSLane *lane, int dir, PState *ped=0)
retrieve vehicle obstacles on the given lane
static const double OBSTRUCTED_PENALTY
the utility penalty for obstructed (physically blocking me) stripes (corresponds to meters)
static const MSLane * getNextWalkingArea(const MSLane *currentLane, const int dir, const MSLink *&link)
return the next walkingArea in the given direction
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
the utility penalty for moving sideways (corresponds to meters)
std::vector< Obstacle > Obstacles
static const double DIST_BEHIND
MSPModel_Striping(const OptionsCont &oc, MSNet *net)
Constructor (it should not be necessary to construct more than one instance)
static Obstacles getNeighboringObstacles(const Pedestrians &pedestrians, int egoIndex, int stripes)
static bool myLegacyPosLat
use old style departPosLat interpretation
static void addCloserObstacle(Obstacles &obs, double x, int stripe, int numStripes, const std::string &id, double width, int dir, ObstacleType type)
static double dawdling
the factor for random slow-down
static int numStripes(const MSLane *lane)
return the maximum number of pedestrians walking side by side
static const double OBSTRUCTION_THRESHOLD
the minimum utility that indicates obstruction
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
the fraction of forward speed to be used for lateral movemenk
static const double INAPPROPRIATE_PENALTY
the utility penalty for inappropriate (reserved for oncoming traffic or may violate my min gap) strip...
static const double ONCOMING_CONFLICT_PENALTY
the utility penalty for oncoming conflicts on stripes (corresponds to meters)
static const double LOOKAHEAD_ONCOMING
the distance (in seconds) to look ahead for changing stripes (regarding oncoming pedestrians)
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
static const int BACKWARD
static int canTraverse(int dir, const ConstMSEdgeVector &route, int &passedEdges)
static const double RANDOM_POS_LAT
magic value to encode randomized lateral offset for persons when starting a walk
static const double SIDEWALK_OFFSET
the offset for computing person positions when walking on edges without a sidewalk
static const int UNDEFINED_DIRECTION
static const double UNSPECIFIED_POS_LAT
the default lateral offset for persons when starting a walk
static const double SAFETY_GAP
const MSEdge * getDestination() const
returns the destination edge
virtual double getArrivalPos() const
MSStoppingPlace * getDestinationStop() const
returns the destination stop (if any)
Position getLanePosition(const MSLane *lane, double at, double offset) const
get position on lane at length at with orthogonal offset
virtual int getRoutePosition() const
return index of current edge within route
static const MSLane * checkDepartLane(const MSEdge *edge, SUMOVehicleClass svc, int laneIndex, const std::string &id)
interpret custom depart lane
int getDepartLane() const
virtual const MSEdge * getNextRouteEdge() const =0
const std::vector< const MSEdge * > & getRoute() const
virtual bool moveToNextEdge(MSTransportable *transportable, SUMOTime currentTime, int prevDir, MSEdge *nextInternal=nullptr, const bool isReplay=false)=0
move forward and return whether the transportable arrived
virtual double getMaxSpeed(const MSTransportable *const transportable=nullptr) const =0
the maximum speed of the transportable
int getNumWaitingPersons() const
get number of persons waiting at this stop
int getWaitingCapacity() const
get number of persons that can wait at this stop
MSPModel * getMovementModel()
Returns the default movement model for this kind of transportables.
void registerJammed()
register a jammed transportable
SUMOVehicleClass getVClass() const
Returns the object's access class.
const MSVehicleType & getVehicleType() const
Returns the object's "vehicle" type.
bool isPerson() const
Whether it is a person.
Position getPosition(const double) const
Return current position (x/y, cartesian)
MSStageType getCurrentStageType() const
the current stage type of the transportable
const MSEdge * getEdge() const
Returns the current edge.
abstract base class for managing callbacks to retrieve various state information from the model
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, SumoRNG *rng=nullptr, bool readOnly=false)
Returns the named vehicle type or a sample from the named distribution.
Representation of a vehicle in the micro simulation.
SUMOTime getWaitingTime(const bool accumulated=false) const
Returns the SUMOTime waited (speed was lesser than 0.1m/s)
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
double getBackPositionOnLane(const MSLane *lane) const
Get the vehicle's position relative to the given lane.
double getLateralPositionOnLane() const
Get the vehicle's lateral position on the lane.
const Position getBackPosition() const
double getSpeed() const
Returns the vehicle's current speed.
const MSLane * getLane() const
Returns the lane the vehicle is on.
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
The car-following model and parameter.
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
double getLength() const
Get vehicle's length [m].
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
const std::string & getID() const
Returns the id.
A storage for options typed value containers)
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
static OptionsCont & getOptions()
Retrieves the options.
double compute(const E *from, const E *to, double departPos, double arrivalPos, double 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...
A point in 2D or 3D with translation and scaling methods.
static const Position INVALID
used to indicate that a position is valid
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
double x() const
Returns the x-position.
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position (in radians bet...
double y() const
Returns the y-position.
double length() const
Returns the length.
double rotationAtOffset(double pos) const
Returns the rotation at the given length.
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
void move2side(double amount, double maxExtension=100)
move position vector to side using certain amount
double angleAt2D(int pos) const
get angle in certain position of position vector (in radians between -M_PI and M_PI)
void extrapolate(const double val, const bool onlyFirst=false, const bool onlyLast=false)
extrapolate position vector
PositionVector bezier(int numPoints)
return a bezier interpolation
void push_back_noDoublePos(const Position &p)
insert in back a non double position
PositionVector reverse() const
reverse position vector
Position transformToVectorCoordinates(const Position &p, bool extend=false) const
return position p within the length-wise coordinate system defined by this position vector....
static double rand(SumoRNG *rng=nullptr)
Returns a random real number in [0, 1)
double getFloatParam(const std::string ¶mName, const bool required=false, const double deflt=INVALID_DOUBLE) const
Retrieve a floating point parameter for the traffic object.
int dir
the direction on the next lane
const MSLink * link
the link from the current lane to the next lane
const MSLane * lane
the next lane to be used
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
bool closer(const Obstacle &o, int dir)
std::string description
the id / description of the obstacle
const SUMOVehicle * vehicle
a pointer to the vehicle if this obstacle is one
ObstacleType type
whether this obstacle denotes a border, a vehicle or a pedestrian
double xBack
maximal position on the current lane in backward direction
const PositionVector shape