58#define DEBUGCOND (getID() == DEBUGID)
61#define DEBUGCOND2(obj) ((obj != 0 && (obj)->getID() == DEBUGID))
106 mayDefinitelyPass(mayDefinitelyPass_),
123 connectionsDone(false) {
136 assert((
int)myTransitions.size() > virtEdge);
138 NBEdge* succEdge = myTransitions[virtEdge];
139 std::vector<int> lanes;
143 std::map<NBEdge*, std::vector<int> >::iterator i =
myConnections.find(succEdge);
151 std::vector<int>::iterator j = std::find(lanes.begin(), lanes.end(), lane);
152 if (j == lanes.end()) {
154 lanes.push_back(lane);
167 const NBEdge* straight =
nullptr;
168 for (
const NBEdge*
const out : outgoing) {
170 for (
const int l : availableLanes) {
171 if ((parent->
myLanes[l].permissions & outPerms) != 0) {
172 if (straight ==
nullptr || sorter(out, straight)) {
179 if (straight ==
nullptr) {
182 myStraightest = (int)std::distance(outgoing.begin(), std::find(outgoing.begin(), outgoing.end(), straight));
185 assert(outgoing.size() > 0);
187#ifdef DEBUG_CONNECTION_GUESSING
189 std::cout <<
" MainDirections edge=" << parent->
getID() <<
" straightest=" << straight->
getID() <<
" dir=" <<
toString(straightestDir) <<
"\n";
201 if (outgoing.back()->getJunctionPriority(to) == 1) {
205 if (outgoing.back()->getPriority() > straight->
getPriority() ||
206 outgoing.back()->getNumLanes() > straight->
getNumLanes()) {
223 return myDirs.empty();
229 return std::find(myDirs.begin(), myDirs.end(), d) != myDirs.end();
249 std::string type,
double speed,
double friction,
int nolanes,
250 int priority,
double laneWidth,
double endOffset,
272 init(nolanes,
false,
"");
277 std::string type,
double speed,
double friction,
int nolanes,
278 int priority,
double laneWidth,
double endOffset,
281 const std::string& streetName,
282 const std::string& origID,
283 bool tryIgnoreNodePositions) :
287 myFrom(from), myTo(to),
288 myStartAngle(0), myEndAngle(0), myTotalAngle(0),
289 myPriority(priority), mySpeed(speed), myFriction(friction),
291 myTurnDestination(nullptr),
292 myPossibleTurnDestination(nullptr),
293 myFromJunctionPriority(-1), myToJunctionPriority(-1),
294 myGeom(geom), myLaneSpreadFunction(spread), myEndOffset(endOffset),
295 myLaneWidth(laneWidth),
296 myLoadedLength(UNSPECIFIED_LOADED_LENGTH),
297 myAmInTLS(false), myAmMacroscopicConnector(false),
298 myStreetName(streetName),
300 mySignalNode(nullptr),
304 init(nolanes, tryIgnoreNodePositions, origID);
311 myType(tpl->getTypeID()),
312 myFrom(from), myTo(to),
313 myStartAngle(0), myEndAngle(0), myTotalAngle(0),
314 myPriority(tpl->getPriority()), mySpeed(tpl->getSpeed()),
315 myFriction(tpl->getFriction()),
317 myTurnDestination(nullptr),
318 myPossibleTurnDestination(nullptr),
319 myFromJunctionPriority(-1), myToJunctionPriority(-1),
321 myLaneSpreadFunction(tpl->getLaneSpreadFunction()),
322 myEndOffset(tpl->getEndOffset()),
323 myEdgeStopOffset(tpl->getEdgeStopOffset()),
324 myLaneWidth(tpl->getLaneWidth()),
325 myLoadedLength(UNSPECIFIED_LOADED_LENGTH),
327 myAmMacroscopicConnector(false),
328 myStreetName(tpl->getStreetName()),
329 mySignalPosition(to == tpl->myTo ? tpl->mySignalPosition :
Position::
INVALID),
330 mySignalNode(to == tpl->myTo ? tpl->mySignalNode : nullptr),
342 myLanes[i].updateParameters(tpl->
myLanes[tplIndex].getParametersMap());
343 if (to == tpl->
myTo) {
358 myFrom(nullptr), myTo(nullptr),
359 myStartAngle(0), myEndAngle(0), myTotalAngle(0),
360 myPriority(0), mySpeed(0), myFriction(UNSPECIFIED_FRICTION),
362 myTurnDestination(nullptr),
363 myPossibleTurnDestination(nullptr),
364 myFromJunctionPriority(-1), myToJunctionPriority(-1),
369 myLoadedLength(UNSPECIFIED_LOADED_LENGTH),
371 myAmMacroscopicConnector(false),
373 mySignalNode(nullptr) {
379 double speed,
double friction,
int nolanes,
int priority,
381 const std::string& streetName,
383 bool tryIgnoreNodePositions) {
405 const std::vector<Lane> oldLanes =
myLanes;
406 init(nolanes, tryIgnoreNodePositions, oldLanes.empty() ?
"" : oldLanes[0].getParameter(
SUMO_PARAM_ORIGID));
407 for (
int i = 0; i < (int)nolanes; ++i) {
409 myLanes[i] = oldLanes[
MIN2(i, (
int)oldLanes.size() - 1)];
431 if (from ==
nullptr || to ==
nullptr) {
455NBEdge::init(
int noLanes,
bool tryIgnoreNodePositions,
const std::string& origID) {
478 if (!tryIgnoreNodePositions ||
myGeom.size() < 2) {
501 assert(
myGeom.size() >= 2);
503 if ((
int)
myLanes.size() > noLanes) {
505 for (
int lane = noLanes; lane < (int)
myLanes.size(); ++lane) {
510 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
511 for (
int lane = noLanes; lane < (int)
myLanes.size(); ++lane) {
512 (*i)->removeFromConnections(
this, -1, lane);
517 for (
int i = 0; i < noLanes; i++) {
523#ifdef DEBUG_CONNECTION_GUESSING
525 std::cout <<
"init edge=" <<
getID() <<
"\n";
527 std::cout <<
" conn " << c.getDescription(
this) <<
"\n";
530 std::cout <<
" connToDelete " << c.getDescription(
this) <<
"\n";
545 lane.customShape.add(xoff, yoff, 0);
549 (*i).customShape.add(xoff, yoff, 0);
564 for (
int i = 0; i < (int)
myLanes.size(); i++) {
566 myLanes[i].customShape.mirrorX();
570 c.viaShape.mirrorX();
571 c.customShape.mirrorX();
606 assert(node ==
myTo);
648 assert(node ==
myTo);
677 if (rectangularCut) {
678 const double extend = 100;
682 border.push_back(p2);
684 if (border.size() == 2) {
689 assert(node ==
myTo);
693#ifdef DEBUG_NODE_BORDER
696 <<
" rect=" << rectangularCut
697 <<
" p=" << p <<
" p2=" << p2
698 <<
" border=" << border
711 assert(node ==
myTo);
722 assert(node ==
myTo);
775 if (shape.size() < 2) {
777 const double oldLength = old.
length();
778 shape = old.
getSubpart(oldLength - 2 * POSITION_EPS, oldLength);
782 if (shape.
length() < POSITION_EPS) {
783 if (old.
length() < 2 * POSITION_EPS) {
786 const double midpoint = old.
length() / 2;
788 shape = old.
getSubpart(midpoint - POSITION_EPS, midpoint + POSITION_EPS);
789 assert(shape.size() >= 2);
790 assert(shape.
length() > 0);
798 tmp.push_back(shape[0]);
799 tmp.push_back(shape[-1]);
801 if (tmp.
length() < POSITION_EPS) {
803 if (old.
length() < 2 * POSITION_EPS) {
806 const double midpoint = old.
length() / 2;
808 shape = old.
getSubpart(midpoint - POSITION_EPS, midpoint + POSITION_EPS);
809 assert(shape.size() >= 2);
810 assert(shape.
length() > 0);
813 const double midpoint = shape.
length() / 2;
815 shape = shape.
getSubpart(midpoint - POSITION_EPS, midpoint + POSITION_EPS);
816 if (shape.
length() < POSITION_EPS) {
823 const double z = (shape[0].z() + shape[1].z()) / 2;
839 const double d = cut[0].distanceTo2D(cut[1]);
840 const double dZ = fabs(cut[0].z() - cut[1].z());
841 if (dZ / smoothElevationThreshold > d) {
847 const double d = cut[-1].distanceTo2D(cut[-2]);
848 const double dZ = fabs(cut[-1].z() - cut[-2].z());
849 if (dZ / smoothElevationThreshold > d) {
860 for (
int i = 0; i < (int)
myLanes.size(); i++) {
864 double avgLength = 0;
865 for (
int i = 0; i < (int)
myLanes.size(); i++) {
866 avgLength +=
myLanes[i].shape.length();
875 if (nodeShape.size() == 0) {
884 assert(pbv.size() > 0);
892 const double delta = ns[0].z() - laneShape[0].z();
894 if (fabs(delta) > 2 * POSITION_EPS && (!startNode->
geometryLike() || pb < 1)) {
899 assert(ns.size() >= 2);
904 assert(pbv.size() > 0);
909 const double delta = np.
z() - laneShape[0].z();
911 if (fabs(delta) > 2 * POSITION_EPS && !startNode->
geometryLike()) {
970 reverse = lane.customShape.
reverse();
972 lane.customShape = reverse.
reverse();
977 lane.customShape.removeDoublePoints(minDist,
true, 0, 0,
true);
989 std::vector<double> angles;
991 for (
int i = 0; i < (int)
myGeom.size() - 1; ++i) {
996 for (
int i = 0; i < (int)angles.size() - 1; ++i) {
999 if (maxAngle > 0 && relAngle > maxAngle && !silent) {
1005 if (i == 0 || i == (
int)angles.size() - 2) {
1006 const bool start = i == 0;
1008 const double r = tan(0.5 * (
M_PI - relAngle)) * dist;
1010 if (minRadius > 0 && r < minRadius) {
1013 (start ?
"start" :
"end") +
" of edge '" +
getID() +
"'.");
1017 }
else if (!silent) {
1019 toString(start ?
"start" :
"end") +
" of edge '%'.", r,
getID());
1037 if (dest !=
nullptr &&
myTo != dest->
myFrom) {
1040 if (dest ==
nullptr) {
1047 if (overrideRemoval) {
1050 if (it->toEdge == dest) {
1067 bool mayUseSameDestination,
1068 bool mayDefinitelyPass,
1079 const std::string& edgeType,
1095 return setConnection(from, dest, toLane, type, mayUseSameDestination, mayDefinitelyPass, keepClear, contPos, visibility, speed, friction, length,
1096 customShape, uncontrolled, permissions, indirectLeft, edgeType, changeLeft, changeRight, postProcess);
1102 NBEdge* dest,
int toLane,
1104 bool invalidatePrevious,
1105 bool mayDefinitelyPass) {
1106 if (invalidatePrevious) {
1110 for (
int i = 0; i < no && ok; i++) {
1120 bool mayUseSameDestination,
1121 bool mayDefinitelyPass,
1132 const std::string& edgeType,
1160 if ((*i).toEdge == destEdge && ((*i).fromLane == -1 || (*i).toLane == -1)) {
1164 permissions = (*i).permissions;
1172 if (mayDefinitelyPass) {
1205 if ((it->fromLane < 0 || it->fromLane == lane)
1206 && (it->toEdge ==
nullptr || it->toEdge == destEdge)
1207 && (it->toLane < 0 || it->toLane == destLane)) {
1218std::vector<NBEdge::Connection>
1220 std::vector<NBEdge::Connection> ret;
1222 if ((lane < 0 || c.fromLane == lane)
1223 && (to ==
nullptr || to == c.toEdge)
1224 && (toLane < 0 || toLane == c.toLane)) {
1235 if (c.fromLane == fromLane && c.toEdge == to && c.toLane == toLane) {
1240 +
" to " + to->
getID() +
"_" +
toString(toLane) +
" not found");
1247 if (c.fromLane == fromLane && c.toEdge == to && c.toLane == toLane) {
1252 +
" to " + to->
getID() +
"_" +
toString(toLane) +
" not found");
1283 if (find(outgoing.begin(), outgoing.end(), (*i).toEdge) == outgoing.end()) {
1284 outgoing.push_back((*i).toEdge);
1289 if (it->fromLane < 0 && it->toLane < 0) {
1291 EdgeVector::iterator forbidden = std::find(outgoing.begin(), outgoing.end(), it->toEdge);
1292 if (forbidden != outgoing.end()) {
1293 outgoing.erase(forbidden);
1298 int size = (int) outgoing.size();
1300 edges->reserve(size);
1301 for (EdgeVector::const_iterator i = outgoing.begin(); i != outgoing.end(); i++) {
1304 edges->push_back(outedge);
1316 if (find(ret.begin(), ret.end(), (*i).toEdge) == ret.end()) {
1317 ret.push_back((*i).toEdge);
1328 for (EdgeVector::const_iterator i = candidates.begin(); i != candidates.end(); i++) {
1329 if ((*i)->isConnectedTo(
this)) {
1339 std::vector<int> ret;
1343 ret.push_back(c.fromLane);
1366 for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
1371 for (EdgeVector::iterator j = connected.begin(); j != connected.end(); j++) {
1381 const bool keepPossibleTurns) {
1383 const int fromLaneRemoved = adaptToLaneRemoval && fromLane >= 0 ? fromLane : -1;
1384 const int toLaneRemoved = adaptToLaneRemoval && toLane >= 0 ? toLane : -1;
1387 if ((toEdge ==
nullptr || c.
toEdge == toEdge)
1388 && (fromLane < 0 || c.
fromLane == fromLane)
1389 && (toLane < 0 || c.
toLane == toLane)) {
1392 for (std::set<NBTrafficLightDefinition*>::iterator it = tldefs.begin(); it != tldefs.end(); it++) {
1399 if (fromLaneRemoved >= 0 && c.
fromLane > fromLaneRemoved) {
1402 for (std::set<NBTrafficLightDefinition*>::iterator it = tldefs.begin(); it != tldefs.end(); it++) {
1403 for (NBConnectionVector::iterator tlcon = (*it)->getControlledLinks().begin(); tlcon != (*it)->getControlledLinks().end(); ++tlcon) {
1414 if (toLaneRemoved >= 0 && c.
toLane > toLaneRemoved && (toEdge ==
nullptr || c.
toEdge == toEdge)) {
1430#ifdef DEBUG_CONNECTION_GUESSING
1432 std::cout <<
"removeFromConnections " <<
getID() <<
"_" << fromLane <<
"->" << toEdge->
getID() <<
"_" << toLane <<
"\n";
1434 std::cout <<
" conn " << c.getDescription(
this) <<
"\n";
1437 std::cout <<
" connToDelete " << c.getDescription(
this) <<
"\n";
1449 if ((i->toEdge == connectionToRemove.
toEdge) && (i->fromLane == connectionToRemove.
fromLane) && (i->toLane == connectionToRemove.
toLane)) {
1464 if (reallowSetting) {
1476 if ((*i).toEdge == which) {
1478 (*i).toLane += laneOff;
1489 std::map<int, int> laneMap;
1493 bool wasConnected =
false;
1495 if ((*i).toEdge != which) {
1498 wasConnected =
true;
1499 if ((*i).fromLane != -1) {
1500 int fromLane = (*i).fromLane;
1501 laneMap[(*i).toLane] = fromLane;
1502 if (minLane == -1 || minLane > fromLane) {
1505 if (maxLane == -1 || maxLane < fromLane) {
1510 if (!wasConnected) {
1514 std::vector<NBEdge::Connection> conns = origConns;
1516 for (std::vector<NBEdge::Connection>::iterator i = conns.begin(); i != conns.end(); ++i) {
1517 if ((*i).toEdge == which || (*i).toEdge ==
this
1519 || std::find(origTargets.begin(), origTargets.end(), (*i).toEdge) != origTargets.end()) {
1520#ifdef DEBUG_REPLACECONNECTION
1522 std::cout <<
" replaceInConnections edge=" <<
getID() <<
" which=" << which->
getID()
1523 <<
" origTargets=" <<
toString(origTargets) <<
" newTarget=" << i->toEdge->getID() <<
" skipped\n";
1533 int fromLane = (*i).fromLane;
1535 if (laneMap.find(fromLane) == laneMap.end()) {
1536 if (fromLane >= 0 && fromLane <= minLane) {
1539 for (
auto& item : laneMap) {
1540 if (item.first < fromLane) {
1541 item.second =
MIN2(item.second, minLane);
1545 if (fromLane >= 0 && fromLane >= maxLane) {
1548 for (
auto& item : laneMap) {
1549 if (item.first > fromLane) {
1550 item.second =
MAX2(item.second, maxLane);
1555 toUse = laneMap[fromLane];
1560#ifdef DEBUG_REPLACECONNECTION
1562 std::cout <<
" replaceInConnections edge=" <<
getID() <<
" which=" << which->
getID() <<
" origTargets=" <<
toString(origTargets)
1563 <<
" origFrom=" << fromLane <<
" laneMap=" <<
joinToString(laneMap,
":",
",") <<
" minLane=" << minLane <<
" maxLane=" << maxLane
1564 <<
" newTarget=" << i->toEdge->getID() <<
" fromLane=" << toUse <<
" toLane=" << i->toLane <<
"\n";
1568 i->contPos, i->visibility, i->speed, i->friction, i->customLength, i->customShape, i->uncontrolled);
1599 std::vector<Connection>::iterator i =
myConnections.begin() + index;
1622 const int numPoints = oc.
getInt(
"junctions.internal-link-detail");
1623 const bool joinTurns = oc.
getBool(
"junctions.join-turns");
1624 const double limitTurnSpeed = oc.
getFloat(
"junctions.limit-turn-speed");
1625 const double limitTurnSpeedMinAngle =
DEG2RAD(oc.
getFloat(
"junctions.limit-turn-speed.min-angle"));
1626 const double limitTurnSpeedMinAngleRail =
DEG2RAD(oc.
getFloat(
"junctions.limit-turn-speed.min-angle.railway"));
1627 const double limitTurnSpeedWarnStraight = oc.
getFloat(
"junctions.limit-turn-speed.warn.straight");
1628 const double limitTurnSpeedWarnTurn = oc.
getFloat(
"junctions.limit-turn-speed.warn.turn");
1629 const bool higherSpeed = oc.
getBool(
"junctions.higher-speed");
1630 const double interalJunctionVehicleWidth = oc.
getFloat(
"internal-junctions.vehicle-width");
1632 std::string innerID =
":" + n.
getID();
1633 NBEdge* toEdge =
nullptr;
1634 int edgeIndex = linkIndex;
1635 int internalLaneIndex = 0;
1637 double lengthSum = 0;
1638 int avoidedIntersectingLeftOriginLane = std::numeric_limits<int>::max();
1639 bool averageLength =
true;
1640 double maxCross = 0.;
1644 if (con.
toEdge ==
nullptr) {
1651 if (con.
toEdge != toEdge) {
1654 edgeIndex = linkIndex;
1656 internalLaneIndex = 0;
1661 averageLength = !isTurn || joinTurns;
1665 std::vector<int> foeInternalLinks;
1672 std::pair<double, std::vector<int> > crossingPositions(-1, std::vector<int>());
1673 std::set<std::string> tmpFoeIncomingLanes;
1676 std::vector<PositionVector> otherShapes;
1678 const double width1OppositeLeft = 0;
1680 for (
const Connection& k2 : i2->getConnections()) {
1681 if (k2.toEdge ==
nullptr) {
1686 double width2 = k2.toEdge->getLaneWidth(k2.toLane);
1687 if (k2.toEdge->getPermissions(k2.toLane) !=
SVC_BICYCLE) {
1690 const bool foes = n.
foes(
this, con.
toEdge, i2, k2.toEdge);
1693 const bool avoidIntersectCandidate = !foes &&
bothLeftTurns(dir, i2, dir2);
1694 bool oppositeLeftIntersect = avoidIntersectCandidate &&
haveIntersection(n, shape, i2, k2, numPoints, width1OppositeLeft, width2);
1699 && k2.customShape.size() == 0
1700 && (oppositeLeftIntersect || (avoidedIntersectingLeftOriginLane < con.
fromLane && avoidIntersectCandidate))
1701 && ((i2->getPermissions(k2.fromLane) & warn) != 0
1702 && (k2.toEdge->getPermissions(k2.toLane) & warn) != 0)) {
1708 oppositeLeftIntersect =
haveIntersection(n, shape, i2, k2, numPoints, width1OppositeLeft, width2, shapeFlag);
1709 if (oppositeLeftIntersect
1714 if (avoidedIntersectingLeftOriginLane == std::numeric_limits<int>::max()
1715 || avoidedIntersectingLeftOriginLane < con.
fromLane) {
1718 const double minDV =
firstIntersection(shape, otherShape, width1OppositeLeft, width2,
1719 "Could not compute intersection of conflicting internal lanes at node '" +
myTo->
getID() +
"'", secondIntersection);
1720 if (minDV < shape.
length() - POSITION_EPS && minDV > POSITION_EPS) {
1722 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1723 crossingPositions.first = minDV;
1729 avoidedIntersectingLeftOriginLane = con.
fromLane;
1735 const bool isBicycleLeftTurn = k2.indirectLeft || (dir2 ==
LinkDirection::LEFT && (i2->getPermissions(k2.fromLane) & k2.toEdge->getPermissions(k2.toLane)) ==
SVC_BICYCLE);
1738 crossingPositions.second.push_back(index);
1740 otherShapes.push_back(otherShape);
1743 "Could not compute intersection of conflicting internal lanes at node '" +
myTo->
getID() +
"'", secondIntersection);
1744 if (minDV < shape.
length() - POSITION_EPS && minDV > POSITION_EPS) {
1746 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1747 crossingPositions.first = minDV;
1757 if (foes || rightTurnConflict || oppositeLeftIntersect || mergeConflict || indirectTurnConflit) {
1758 foeInternalLinks.push_back(index);
1761 if (oppositeLeftIntersect &&
getID() > i2->getID()
1764 && (i2->getPermissions(k2.fromLane) & warn) != 0
1765 && (k2.toEdge->getPermissions(k2.toLane) & warn) != 0
1769 WRITE_WARNINGF(
TL(
"Intersecting left turns at junction '%' from lane '%' and lane '%' (increase junction radius to avoid this)."),
1774 if ((n.
forbids(i2, k2.toEdge,
this, con.
toEdge, signalised) || rightTurnConflict || indirectTurnConflit || mergeResponse)
1776 tmpFoeIncomingLanes.insert(i2->getID() +
"_" +
toString(k2.fromLane));
1778 if (bothPrio && oppositeLeftIntersect &&
getID() < i2->getID()) {
1782 tmpFoeIncomingLanes.insert(
":" +
toString(index));
1788 std::vector<NBNode::Crossing*> crossings = n.
getCrossings();
1789 for (
auto c : crossings) {
1791 for (EdgeVector::const_iterator it_e = crossing.
edges.begin(); it_e != crossing.
edges.end(); ++it_e) {
1792 const NBEdge* edge = *it_e;
1794 if (
this == edge || con.
toEdge == edge) {
1795 foeInternalLinks.push_back(index);
1796 if (con.
toEdge == edge &&
1802 if (minDV < shape.
length() - POSITION_EPS && minDV > POSITION_EPS) {
1804 if (crossingPositions.first < 0 || crossingPositions.first > minDV) {
1805 crossingPositions.first = minDV;
1814 if (dir ==
LinkDirection::TURN && crossingPositions.first < 0 && crossingPositions.second.size() != 0 && shape.
length() > 2. * POSITION_EPS) {
1824 crossingPositions.first = -1;
1827 crossingPositions.first = con.
contPos;
1846 if (limitTurnSpeed > 0) {
1851 const double angle =
MAX2(0.0, angleRaw - (fromRail ? limitTurnSpeedMinAngleRail : limitTurnSpeedMinAngle));
1852 const double length = shape.
length2D();
1855 if (angle > 0 && length > 1) {
1858 const double limit = sqrt(limitTurnSpeed * radius);
1859 const double reduction = con.
vmax - limit;
1867 dirType =
"roundabout";
1869 WRITE_WARNINGF(
TL(
"Speed of % connection '%' reduced by % due to turning radius of % (length=%, angle=%)."),
1876 assert(con.
vmax > 0);
1891 assert(shape.size() >= 2);
1893 con.
id = innerID +
"_" +
toString(edgeIndex);
1894 const double shapeLength = shape.
length();
1895 double firstLength = shapeLength;
1896 if (crossingPositions.first >= 0 && crossingPositions.first < shapeLength) {
1897 std::pair<PositionVector, PositionVector>
split = shape.
splitAt(crossingPositions.first);
1899 con.
foeIncomingLanes = std::vector<std::string>(tmpFoeIncomingLanes.begin(), tmpFoeIncomingLanes.end());
1901 con.
viaID = innerID +
"_" +
toString(splitIndex + noInternalNoSplits);
1910 ++internalLaneIndex;
1915 lengthSum += firstLength / shapeLength * con.
customLength;
1917 lengthSum += firstLength;
1929 double maxCross = 0.;
1931 for (
int prevIndex = 1; prevIndex <= numLanes; prevIndex++) {
1945 if (!averageLength) {
1966 double intersect = std::numeric_limits<double>::max();
1967 if (v2.
length() < POSITION_EPS) {
1984 bool skip = secondIntersection;
1990 intersect =
MIN2(intersect, cand);
1992 skip = secondIntersection;
1998 intersect =
MIN2(intersect, cand);
2000 skip = secondIntersection;
2006 intersect =
MIN2(intersect, cand);
2008 skip = secondIntersection;
2014 intersect =
MIN2(intersect, cand);
2030 if (otherFrom ==
this) {
2039 double width1,
double width2,
int shapeFlag)
const {
2042 return minDV < shape.
length() - POSITION_EPS && minDV > POSITION_EPS;
2061#ifdef DEBUG_JUNCTIONPRIO
2066#ifdef DEBUG_JUNCTIONPRIO
2079 assert(atNode ==
myTo);
2091 assert(atNode ==
myTo);
2110 assert(atNode ==
myTo);
2118 if (!onlyPossible) {
2133 return myLanes[lane].friction;
2146 if (lane.changeLeft !=
SVCAll) {
2147 lane.changeLeft = ignoring;
2149 if (lane.changeRight !=
SVCAll) {
2150 lane.changeRight = ignoring;
2155 con.changeLeft = ignoring;
2158 con.changeRight = ignoring;
2171 std::vector<double> offsets(
myLanes.size(), 0.);
2173 for (
int i = (
int)
myLanes.size() - 2; i >= 0; --i) {
2175 offsets[i] = offset;
2179 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
2185 offset = laneWidth / 2.;
2196 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
2197 offsets[i] += offset;
2201 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
2202 if (
myLanes[i].customShape.size() != 0) {
2238 if ((hasFromShape || hasToShape) &&
getNumLanes() > 0) {
2271 if (suspiciousFromShape) {
2272 std::cout <<
"suspiciousFromShape len=" << shape.
length() <<
" startA=" <<
myStartAngle <<
" startA2=" << myStartAngle2 <<
" startA3=" << myStartAngle3
2274 <<
" fromCenter=" << fromCenter
2276 <<
" refStart=" << referencePosStart
2279 if (suspiciousToShape) {
2280 std::cout <<
"suspiciousToShape len=" << shape.
length() <<
" endA=" <<
myEndAngle <<
" endA2=" << myEndAngle2 <<
" endA3=" << myEndAngle3
2282 <<
" toCenter=" << toCenter
2284 <<
" refEnd=" << referencePosEnd
2290 if (suspiciousFromShape && shape.
length() > 1) {
2301 if (suspiciousToShape && shape.
length() > 1) {
2315 <<
" fromCenter=" << fromCenter <<
" toCenter=" << toCenter
2316 <<
" refStart=" << referencePosStart <<
" refEnd=" << referencePosEnd <<
" shape=" << shape
2317 <<
" hasFromShape=" << hasFromShape
2318 <<
" hasToShape=" << hasToShape
2344 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2345 if ((*i).permissions !=
SVCAll) {
2355 std::vector<Lane>::const_iterator i =
myLanes.begin();
2358 for (; i !=
myLanes.end(); ++i) {
2359 if (i->permissions != firstLanePermissions) {
2369 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2379 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2380 if (i->friction !=
myLanes.begin()->friction) {
2389 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2390 if (i->width !=
myLanes.begin()->width) {
2400 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2401 if (i->type !=
myLanes.begin()->type) {
2411 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2412 if (i->endOffset !=
myLanes.begin()->endOffset) {
2422 for (
const auto& lane :
myLanes) {
2423 if (lane.laneStopOffset.isDefined()) {
2435 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2446 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2447 if (i->customShape.size() > 0) {
2457 for (std::vector<Lane>::const_iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
2458 if (i->getParametersMap().size() > 0) {
2468 if (lane.changeLeft !=
SVCAll || lane.changeRight !=
SVCAll) {
2494#ifdef DEBUG_CONNECTION_GUESSING
2496 std::cout <<
"computeEdge2Edges edge=" <<
getID() <<
" step=" << (int)
myStep <<
" noLeftMovers=" << noLeftMovers <<
"\n";
2498 std::cout <<
" conn " << c.getDescription(
this) <<
"\n";
2501 std::cout <<
" connToDelete " << c.getDescription(
this) <<
"\n";
2516 if (fromRail &&
isRailway(out->getPermissions())) {
2520 }
else if (angle > 90) {
2528 if (radius < minRadius) {
2550#ifdef DEBUG_CONNECTION_GUESSING
2552 std::cout <<
"computeLanes2Edges edge=" <<
getID() <<
" step=" << (int)
myStep <<
"\n";
2554 std::cout <<
" conn " << c.getDescription(
this) <<
"\n";
2557 std::cout <<
" connToDelete " << c.getDescription(
this) <<
"\n";
2583std::vector<LinkDirection>
2585 std::vector<LinkDirection> result;
2586 for (
int i = 0; i < 8; i++) {
2588 if ((turnSigns & (1 << i)) != 0) {
2597#ifdef DEBUG_TURNSIGNS
2598 std::cout <<
"applyTurnSigns edge=" <<
getID() <<
"\n";
2601 std::vector<const NBEdge*> targets;
2602 std::map<const NBEdge*, std::vector<int> > toLaneMap;
2604 if (
myLanes[c.fromLane].turnSigns != 0) {
2605 if (std::find(targets.begin(), targets.end(), c.toEdge) == targets.end()) {
2606 targets.push_back(c.toEdge);
2608 toLaneMap[c.toEdge].push_back(c.toLane);
2612 for (
auto& item : toLaneMap) {
2613 std::sort(item.second.begin(), item.second.end());
2617 std::map<LinkDirection, int> signCons;
2620 allDirs |= lane.turnSigns;
2626 targets.push_back(
nullptr);
2631 std::map<LinkDirection, const NBEdge*> dirMap;
2632#ifdef DEBUG_TURNSIGNS
2633 std::cout <<
" numDirs=" << signedDirs.size() <<
" numTargets=" << targets.size() <<
"\n";
2635 if (signedDirs.size() > targets.size()) {
2636 WRITE_WARNINGF(
TL(
"Cannot apply turn sign information for edge '%' because there are % signed directions but only % targets"),
getID(), signedDirs.size(), targets.size());
2638 }
else if (signedDirs.size() < targets.size()) {
2641 std::vector<LinkDirection> sumoDirs;
2642 for (
const NBEdge* to : targets) {
2646 bool checkMore =
true;
2647 while (signedDirs.size() < targets.size() && checkMore) {
2650 if (sumoDirs.back() != signedDirs.back()) {
2652 sumoDirs.pop_back();
2658 while (signedDirs.size() < targets.size() && checkMore) {
2660 if (sumoDirs.front() != signedDirs.front()) {
2661 targets.erase(targets.begin());
2662 sumoDirs.erase(sumoDirs.begin());
2668 while (signedDirs.size() < targets.size() && i < (
int)targets.size()) {
2670 targets.erase(targets.begin() + i);
2671 sumoDirs.erase(sumoDirs.begin() + i);
2676 if (signedDirs.size() != targets.size()) {
2677 WRITE_WARNINGF(
TL(
"Cannot apply turn sign information for edge '%' because there are % signed directions and % targets (after target pruning)"),
getID(), signedDirs.size(), targets.size());
2682 for (
int i = 0; i < (int)signedDirs.size(); i++) {
2683 dirMap[signedDirs[i]] = targets[i];
2686 for (
auto item : signCons) {
2691 const NBEdge* to = dirMap[dir];
2692 std::vector<int>& knownTargets = toLaneMap[to];
2693 if ((
int)knownTargets.size() < item.second) {
2695 if (candidates < item.second) {
2696 WRITE_WARNINGF(
TL(
"Cannot apply turn sign information for edge '%' because there are % signed connections with directions '%' but target edge '%' has only % suitable lanes"),
2714 while ((
int)knownTargets.size() < item.second && i != iEnd) {
2716 if (std::find(knownTargets.begin(), knownTargets.end(), i) == knownTargets.end()) {
2717 knownTargets.push_back(i);
2722 if ((
int)knownTargets.size() != item.second) {
2723 WRITE_WARNINGF(
TL(
"Cannot apply turn sign information for edge '%' because not enough target lanes could be determined for direction '%'"),
getID(),
toString(dir));
2726 std::sort(knownTargets.begin(), knownTargets.end());
2729 std::map<const NBEdge*, int> toLaneIndex;
2731 const int turnSigns =
myLanes[i].turnSigns;
2733 if (turnSigns != 0) {
2736 if (it->fromLane == i) {
2745 if (to !=
nullptr) {
2746 if (toLaneIndex.count(to) == 0) {
2758#ifdef DEBUG_TURNSIGNS
2759 std::cout <<
" could not find passenger lane for target=" << to->
getID() <<
"\n";
2764#ifdef DEBUG_TURNSIGNS
2765 std::cout <<
" target=" << to->
getID() <<
" initial toLane=" << toLane <<
"\n";
2767 toLaneIndex[to] = toLane;
2782#ifdef DEBUG_CONNECTION_GUESSING
2784 std::cout <<
"recheckLanes (initial) edge=" <<
getID() <<
"\n";
2786 std::cout <<
" conn " << c.getDescription(
this) <<
"\n";
2789 std::cout <<
" connToDelete " << c.getDescription(
this) <<
"\n";
2797 std::vector<int> connNumbersPerLane(
myLanes.size(), 0);
2799 if ((*i).toEdge ==
nullptr || (*i).fromLane < 0 || (*i).toLane < 0) {
2802 if ((*i).fromLane >= 0) {
2803 ++connNumbersPerLane[(*i).fromLane];
2818 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2821 bool hasDeadEnd =
true;
2823 for (
int i2 = i - 1; hasDeadEnd && i2 >= 0; i2--) {
2827 if (connNumbersPerLane[i2] > 1) {
2828 connNumbersPerLane[i2]--;
2829 for (
int i3 = i2; i3 != i; i3++) {
2839 for (
int i2 = i + 1; hasDeadEnd && i2 <
getNumLanes(); i2++) {
2843 if (connNumbersPerLane[i2] > 1) {
2844 connNumbersPerLane[i2]--;
2845 for (
int i3 = i2; i3 != i; i3--) {
2855 int passengerLanes = 0;
2856 int passengerTargetLanes = 0;
2864 for (
const Lane& lane : out->getLanes()) {
2866 passengerTargetLanes++;
2871 if (passengerLanes > 0 && passengerLanes <= passengerTargetLanes) {
2876 if (rightCons.size() > 0) {
2879 int toLane = rc.
toLane + 1;
2908 if (leftCons.size() > 0) {
2909 NBEdge* to = leftCons.front().toEdge;
2910 int toLane = leftCons.front().toLane - 1;
2921#ifdef ADDITIONAL_WARNINGS
2937 }
else if (common == 0) {
2940 const int origToLane = c.
toLane;
2942 int toLane = origToLane;
2955 toLane = origToLane;
2987 if (incoming.size() > 1) {
2988 for (
int i = 0; i < (int)
myLanes.size(); i++) {
2990 bool connected =
false;
2991 for (std::vector<NBEdge*>::const_iterator in = incoming.begin(); in != incoming.end(); ++in) {
2992 if ((*in)->hasConnectionTo(
this, i)) {
3006 for (
int i = 0; i < (int)
myLanes.size(); i++) {
3008 if ((connNumbersPerLane[i] == 0 || ((lane.
accelRamp || (i > 0 &&
myLanes[i - 1].accelRamp && connNumbersPerLane[i - 1] > 0))
3013 if (forbiddenLeft && (i == 0 || forbiddenRight)) {
3016 }
else if (forbiddenRight && (i ==
getNumLanes() - 1 || (i > 0 &&
myLanes[i - 1].accelRamp))) {
3023#ifdef ADDITIONAL_WARNINGS
3030 bool hasAlternative =
false;
3032 if (c.fromLane == c2.fromLane && c.toEdge == c2.toEdge
3033 && (c.toEdge->getPermissions(c2.toLane) &
SVC_PASSENGER) != 0) {
3034 hasAlternative =
true;
3037 if (!hasAlternative) {
3038 WRITE_WARNING(
"Road lane ends on bikeLane for connection " + c.getDescription(
this));
3044#ifdef DEBUG_CONNECTION_GUESSING
3046 std::cout <<
"recheckLanes (final) edge=" <<
getID() <<
"\n";
3048 std::cout <<
" conn " << c.getDescription(
this) <<
"\n";
3058 if (outgoing->size() == 0) {
3064#ifdef DEBUG_CONNECTION_GUESSING
3066 std::cout <<
" divideOnEdges " <<
getID() <<
" outgoing=" <<
toString(*outgoing) <<
"\n";
3071 std::vector<int> availableLanes;
3072 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
3074 availableLanes.push_back(i);
3077 if (availableLanes.size() > 0) {
3081 availableLanes.clear();
3082 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
3087 availableLanes.push_back(i);
3089 if (availableLanes.size() > 0) {
3093 availableLanes.clear();
3094 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
3099 availableLanes.push_back(i);
3101 if (availableLanes.size() > 0) {
3105 availableLanes.clear();
3106 for (
int i = 0; i < (int)
myLanes.size(); ++i) {
3111 availableLanes.push_back(i);
3113 if (availableLanes.size() > 0) {
3117 bool explicitTurnaround =
false;
3120 if ((*i).fromLane == -1) {
3122 explicitTurnaround =
true;
3123 turnaroundPermissions = (*i).permissions;
3127 if (c.toLane == -1 && c.toEdge == (*i).toEdge) {
3129 c.permissions = (*i).permissions;
3138 if (explicitTurnaround) {
3149 if (priorities.empty()) {
3152#ifdef DEBUG_CONNECTION_GUESSING
3154 std::cout <<
"divideSelectedLanesOnEdges " <<
getID() <<
" out=" <<
toString(*outgoing) <<
" prios=" <<
toString(priorities) <<
" avail=" <<
toString(availableLanes) <<
"\n";
3158 const int numOutgoing = (int)outgoing->size();
3159 std::vector<int> resultingLanesFactor;
3160 resultingLanesFactor.reserve(numOutgoing);
3161 int minResulting = std::numeric_limits<int>::max();
3162 for (
int i = 0; i < numOutgoing; i++) {
3164 const int res = priorities[i] * (int)availableLanes.size();
3165 resultingLanesFactor.push_back(res);
3166 if (minResulting > res && res > 0) {
3178 transition.reserve(numOutgoing);
3179 for (
int i = 0; i < numOutgoing; i++) {
3181 assert(i < (
int)resultingLanesFactor.size());
3182 const int tmpNum = (resultingLanesFactor[i] + minResulting - 1) / minResulting;
3183 numVirtual += tmpNum;
3184 for (
int j = 0; j < tmpNum; j++) {
3185 transition.push_back((*outgoing)[i]);
3188#ifdef DEBUG_CONNECTION_GUESSING
3190 std::cout <<
" minResulting=" << minResulting <<
" numVirtual=" << numVirtual <<
" availLanes=" <<
toString(availableLanes) <<
" resLanes=" <<
toString(resultingLanesFactor) <<
" transition=" <<
toString(transition) <<
"\n";
3199 for (
NBEdge*
const target : *outgoing) {
3200 assert(l2eConns.find(target) != l2eConns.end());
3201 for (
const int j : l2eConns.find(target)->second) {
3202 const int fromIndex = availableLanes[j];
3203 if ((
getPermissions(fromIndex) & target->getPermissions()) == 0) {
3217 int targetLanes = target->getNumLanes();
3221 if (numConsToTarget >= targetLanes) {
3224 if (
myLanes[fromIndex].connectionsDone) {
3227#ifdef DEBUG_CONNECTION_GUESSING
3229 std::cout <<
" connectionsDone from " <<
getID() <<
"_" << fromIndex <<
": ";
3231 std::cout << c.getDescription(
this) <<
", ";
3239#ifdef DEBUG_CONNECTION_GUESSING
3241 std::cout <<
" request connection from " <<
getID() <<
"_" << fromIndex <<
" to " << target->getID() <<
"\n";
3254 const int numOutgoing = (int) outgoing->size();
3255 NBEdge* target =
nullptr;
3256 NBEdge* rightOfTarget =
nullptr;
3257 NBEdge* leftOfTarget =
nullptr;
3259 for (
int i = 0; i < numOutgoing; i++) {
3260 if (maxPrio < priorities[i]) {
3263 maxPrio = priorities[i];
3264 target = (*outgoing)[i];
3265 rightOfTarget = i == 0 ? outgoing->back() : (*outgoing)[i - 1];
3266 leftOfTarget = i + 1 == numOutgoing ? outgoing->front() : (*outgoing)[i + 1];
3270 if (target ==
nullptr) {
3278 const int numDesiredConsToTarget =
MIN2(targetLanes, (
int)availableLanes.size());
3279#ifdef DEBUG_CONNECTION_GUESSING
3281 std::cout <<
" checking extra lanes for target=" << target->
getID() <<
" cons=" << numConsToTarget <<
" desired=" << numDesiredConsToTarget <<
"\n";
3284 std::vector<int>::const_iterator it_avail = availableLanes.begin();
3285 while (numConsToTarget < numDesiredConsToTarget && it_avail != availableLanes.end()) {
3286 const int fromIndex = *it_avail;
3295 && !
myLanes[fromIndex].connectionsDone
3297#ifdef DEBUG_CONNECTION_GUESSING
3299 std::cout <<
" candidate from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
3308#ifdef DEBUG_CONNECTION_GUESSING
3310 std::cout <<
" request additional connection from " <<
getID() <<
"_" << fromIndex <<
" to " << target->
getID() <<
"\n";
3316#ifdef DEBUG_CONNECTION_GUESSING
3321 <<
" rightOfTarget=" << rightOfTarget->
getID()
3322 <<
" leftOfTarget=" << leftOfTarget->
getID()
3333const std::vector<int>
3335 std::vector<int> priorities;
3342 priorities.reserve(outgoing->size());
3343 for (
const NBEdge*
const out : *outgoing) {
3345 assert((prio + 1) * 2 > 0);
3346 prio = (prio + 1) * 2;
3347 priorities.push_back(prio);
3352#ifdef DEBUG_CONNECTION_GUESSING
3354 <<
" outgoing=" <<
toString(*outgoing)
3355 <<
" priorities1=" <<
toString(priorities)
3360 assert(priorities.size() > 0);
3362#ifdef DEBUG_CONNECTION_GUESSING
3364 std::cout <<
" priorities2=" <<
toString(priorities) <<
"\n";
3371 if (mainDirections.
empty()) {
3372 assert(dist < (
int)priorities.size());
3373 priorities[dist] *= 2;
3374#ifdef DEBUG_CONNECTION_GUESSING
3376 std::cout <<
" priorities3=" <<
toString(priorities) <<
"\n";
3381 priorities[dist] += 1;
3386 priorities[(int)priorities.size() - 1] /= 2;
3387#ifdef DEBUG_CONNECTION_GUESSING
3389 std::cout <<
" priorities6=" <<
toString(priorities) <<
"\n";
3393 && outgoing->size() > 2
3394 && availableLanes.size() == 2
3395 && (*outgoing)[dist]->getPriority() == (*outgoing)[0]->getPriority()) {
3397 priorities.back() /= 2;
3398#ifdef DEBUG_CONNECTION_GUESSING
3400 std::cout <<
" priorities7=" <<
toString(priorities) <<
"\n";
3407 priorities[dist] *= 2;
3408#ifdef DEBUG_CONNECTION_GUESSING
3410 std::cout <<
" priorities4=" <<
toString(priorities) <<
"\n";
3414 priorities[dist] *= 3;
3415#ifdef DEBUG_CONNECTION_GUESSING
3417 std::cout <<
" priorities5=" <<
toString(priorities) <<
"\n";
3427NBEdge::appendTurnaround(
bool noTLSControlled,
bool noFringe,
bool onlyDeadends,
bool onlyTurnlane,
bool noGeometryLike,
bool checkPermissions) {
3440 bool isDeadEnd =
true;
3442 if ((c.toEdge->getPermissions(c.toLane)
3450 if (onlyDeadends && !isDeadEnd) {
3463 if (checkPermissions) {
3487 if (noGeometryLike && !isDeadEnd) {
3496 if (turnIncoming.size() > 1) {
3522 if (pos < tolerance) {
3536 for (
int i = 0; i < lanes; i++) {
3538 assert(el.tlID ==
"");
3560 if (c.fromLane == fromLane && c.toEdge == toEdge && c.toLane == toLane && c.uncontrolled) {
3580 assert(fromLane < 0 || fromLane < (
int)
myLanes.size());
3582 if (fromLane >= 0 && toLane >= 0) {
3584 std::vector<Connection>::iterator i =
3592 connection.
tlID = tlID;
3601 bool hadError =
false;
3603 if ((*i).toEdge != toEdge) {
3606 if (fromLane >= 0 && fromLane != (*i).fromLane) {
3609 if (toLane >= 0 && toLane != (*i).toLane) {
3612 if ((*i).tlID ==
"") {
3614 (*i).tlLinkIndex = tlIndex;
3615 (*i).tlLinkIndex2 = tlIndex2;
3618 if ((*i).tlID != tlID && (*i).tlLinkIndex == tlIndex) {
3619 WRITE_WARNINGF(
TL(
"The lane '%' on edge '%' already had a traffic light signal."), i->fromLane,
getID());
3624 if (hadError && no == 0) {
3625 WRITE_WARNINGF(
TL(
"Could not set any signal of the tlLogic '%' (unknown group)."), tlID);
3650 ret =
myLanes[lane].shape.reverse();
3668 ret =
myLanes[lane].shape.reverse();
3679 reason =
"laneNumber";
3689 reason =
"bidi-rail";
3703 if (find(conn.begin(), conn.end(), possContinuation) == conn.end()) {
3704 reason =
"disconnected";
3715 reason =
"disconnected";
3721 if (conns.size() <
myLanes.size() - offset) {
3722 reason =
"some lanes disconnected";
3736 reason =
"priority";
3746 reason =
"spreadType";
3750 for (
int i = 0; i < (int)
myLanes.size(); i++) {
3752 reason =
"lane " +
toString(i) +
" speed";
3754 }
else if (
myLanes[i].permissions != possContinuation->
myLanes[i].permissions) {
3755 reason =
"lane " +
toString(i) +
" permissions";
3757 }
else if (
myLanes[i].changeLeft != possContinuation->
myLanes[i].changeLeft ||
myLanes[i].changeRight != possContinuation->
myLanes[i].changeRight) {
3758 reason =
"lane " +
toString(i) +
" change restrictions";
3760 }
else if (
myLanes[i].width != possContinuation->
myLanes[i].width &&
3762 reason =
"lane " +
toString(i) +
" width";
3783 for (
int i = 0; i < (int)
myLanes.size(); i++) {
3789 if (origID != origID2) {
3799 for (
int i = 0; i < (int)
myLanes.size(); i++) {
3835 if ((*i).toEdge == e && (*i).tlID !=
"") {
3861 assert(distances.size() > 0);
3867NBEdge::addLane(
int index,
bool recomputeShape,
bool recomputeConnections,
bool shiftIndices) {
3868 assert(index <= (
int)
myLanes.size());
3872 int templateIndex = index > 0 ? index - 1 : index + 1;
3882 if (recomputeShape) {
3885 if (recomputeConnections) {
3886 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
3887 (*i)->invalidateConnections(
true);
3890 }
else if (shiftIndices) {
3893 if (c.fromLane >= index) {
3912 int newLaneNo = (int)
myLanes.size() + by;
3913 while ((
int)
myLanes.size() < newLaneNo) {
3923 assert(index < (
int)
myLanes.size());
3928 for (EdgeVector::const_iterator i = incs.begin(); i != incs.end(); ++i) {
3929 (*i)->invalidateConnections(
true);
3932 }
else if (shiftIndices) {
3935 inc->removeFromConnections(
this, -1, index,
false,
true);
3943 int newLaneNo = (int)
myLanes.size() - by;
3944 assert(newLaneNo > 0);
3945 while ((
int)
myLanes.size() > newLaneNo) {
3963 for (
int i = 0; i < (int)
myLanes.size(); i++) {
3967 assert(lane < (
int)
myLanes.size());
3968 myLanes[lane].permissions |= vclass;
3976 for (
int i = 0; i < (int)
myLanes.size(); i++) {
3980 assert(lane < (
int)
myLanes.size());
3981 myLanes[lane].permissions &= ~vclass;
3989 for (
int i = 0; i < (int)
myLanes.size(); i++) {
3993 assert(lane < (
int)
myLanes.size());
3994 myLanes[lane].permissions |= vclasses;
3995 myLanes[lane].preferred |= vclasses;
4005 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4011 assert(lane < (
int)
myLanes.size());
4018 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4024 assert(lane < (
int)
myLanes.size());
4055 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4078 return myLanes[lane].laneStopOffset;
4088 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4094 assert(lane < (
int)
myLanes.size());
4095 myLanes[lane].endOffset = offset;
4113 }
else if (lane < (
int)
myLanes.size()) {
4114 if (!
myLanes[lane].laneStopOffset.isDefined() || overwrite) {
4119 myLanes[lane].laneStopOffset = offset;
4134 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4140 assert(lane < (
int)
myLanes.size());
4150 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4156 assert(lane < (
int)
myLanes.size());
4157 myLanes[lane].friction = friction;
4164 assert(lane < (
int)
myLanes.size());
4165 myLanes[lane].accelRamp = accelRamp;
4172 assert(lane < (
int)
myLanes.size());
4173 myLanes[lane].customShape = shape;
4180 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4185 assert(lane < (
int)
myLanes.size());
4186 myLanes[lane].permissions = permissions;
4194 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4199 assert(lane < (
int)
myLanes.size());
4200 myLanes[lane].preferred = permissions;
4208 assert(lane < (
int)
myLanes.size());
4209 myLanes[lane].changeLeft = changeLeft;
4210 myLanes[lane].changeRight = changeRight;
4218 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4223 assert(lane < (
int)
myLanes.size());
4224 return myLanes[lane].permissions;
4242 for (std::vector<Lane>::iterator i =
myLanes.begin(); i !=
myLanes.end(); ++i) {
4243 (*i).permissions =
SVCAll;
4279 for (
int i = start; i != end; i += direction) {
4295 for (
int i = start; i != end; i += direction) {
4309 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4310 if (
myLanes[i].permissions == permissions) {
4322 for (
int i = start; i != end; i += direction) {
4323 if (
myLanes[i].permissions != 0) {
4327 return end - direction;
4331std::set<SVCPermissions>
4333 std::set<SVCPermissions> result;
4337 for (
int i = iStart; i < iEnd; ++i) {
4347 if ((lane.permissions & permissions) == permissions) {
4376 std::cout <<
getID() <<
" angle=" <<
getAngleAtNode(node) <<
" convAngle=" << angle <<
"\n";
4394 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4399 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4433 if (lane.permissions == vclass) {
4457 myLanes[newIndex].permissions = vclass;
4458 myLanes[newIndex].width = fabs(width);
4468 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
4469 (*it)->shiftToLanesToEdge(
this, 1);
4480 if (
myLanes[0].permissions != vclass) {
4490 for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) {
4491 (*it)->shiftToLanesToEdge(
this, 0);
4504 if ((*it).toEdge == to && (*it).toLane >= 0) {
4505 (*it).toLane += laneOff;
4514 const int i = (node ==
myTo ? -1 : 0);
4515 const int i2 = (node ==
myTo ? 0 : -1);
4520 const double neededOffset2 = neededOffset + (other->
getTotalWidth()) / 2;
4521 if (dist < neededOffset && dist2 < neededOffset2) {
4556 double avgEndOffset = 0;
4558 avgEndOffset += lane.endOffset;
4563 avgEndOffset /= (double)
myLanes.size();
4564 return MAX2(result - avgEndOffset, POSITION_EPS);
4570 if (laneIdx == -1) {
4571 for (
int i = 0; i < (int)
myLanes.size(); i++) {
4578 if (std::find(oldIDs.begin(), oldIDs.end(), origID) == oldIDs.end()) {
4579 oldIDs.push_back(origID);
4599 if (con.fromLane >= 0 && con.toLane >= 0 && con.toEdge !=
nullptr &&
4601 & con.toEdge->getPermissions(con.toLane) & vClass) != 0)
4616 std::pair<const NBEdge*, const Connection*> pair(con.toEdge,
nullptr);
4620 }
else if ((con.fromLane >= 0) && (con.toLane >= 0) &&
4621 (con.toEdge !=
nullptr) &&
4622 ((
getPermissions(con.fromLane) & con.toEdge->getPermissions(con.toLane) & vClass) == vClass)) {
4624 if (con.getLength() > 0) {
4638 std::cout <<
" " <<
getID() <<
"_" << c.fromLane <<
"->" << c.toEdge->getID() <<
"_" << c.toLane <<
"\n";
4660 bool haveJoined =
false;
4665 const std::string newType =
myLanes[i].type +
"|" +
myLanes[i + 1].type;
4681 for (
NBEdge* edge : edges) {
4682 if ((edge->getPermissions() & permissions) != 0) {
4683 result.push_back(edge);
4692 if (cands.size() == 0) {
4696 NBEdge* best = cands.front();
4707 if (cands.size() == 0) {
4711 NBEdge* best = cands.front();
4722 NBEdge* opposite =
nullptr;
4728 if (cand->getToNode() ==
getFromNode() && !cand->getLanes().empty()) {
4729 const double lastWidthCand = cand->getLaneWidth(cand->getNumLanes() - 1);
4732 const double threshold = 1.42 * 0.5 * (lastWidth + lastWidthCand) + 0.5;
4735 if (distance < threshold) {
4740 if (opposite !=
nullptr) {
std::vector< std::string > & split(const std::string &s, char delim, std::vector< std::string > &elems)
#define WRITE_WARNINGF(...)
#define WRITE_MESSAGE(msg)
#define WRITE_WARNING(msg)
std::vector< std::pair< const NBRouterEdge *, const NBRouterEdge * > > ConstRouterEdgePairVector
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
KeepClear
keepClear status of connections
const SVCPermissions SVCAll
all VClasses are allowed
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
bool isForbidden(SVCPermissions permissions)
Returns whether an edge with the given permission is a forbidden edge.
bool isBikepath(SVCPermissions permissions)
Returns whether an edge with the given permission is a bicycle edge.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_RAIL_CLASSES
classes which drive on tracks
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_DELIVERY
vehicle is a small delivery vehicle
@ SVC_TRAM
vehicle is a light rail
@ SVC_BUS
vehicle is a bus
@ SVC_PEDESTRIAN
pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ RIGHT
At the rightmost side of the lane.
const std::string SUMO_PARAM_ORIGID
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
@ PARTLEFT
The link is a partial left direction.
@ RIGHT
The link is a (hard) right direction.
@ TURN
The link is a 180 degree turn.
@ LEFT
The link is a (hard) left direction.
@ STRAIGHT
The link is a straight direction.
@ PARTRIGHT
The link is a partial right direction.
@ NODIR
The link has no direction (is a dead end link)
int gPrecision
the precision for floating point outputs
bool gDebugFlag1
global utility flags for debugging
const double SUMO_const_laneWidth
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
#define SOFT_ASSERT(expr)
define SOFT_ASSERT raise an assertion in debug mode everywhere except on the windows test server
static void compute(BresenhamCallBack *callBack, const int val1, const int val2)
static const double INVALID_OFFSET
a value to signify offsets outside the range of [0, Line.length()]
static double legacyDegree(const double angle, const bool positive=false)
static double angleDiff(const double angle1, const double angle2)
Returns the difference of the second angle to the first angle in radiants.
int getFromLane() const
returns the from-lane
int getTLIndex() const
returns the index within the controlling tls or InvalidTLIndex if this link is unontrolled
void shiftLaneIndex(NBEdge *edge, int offset, int threshold=-1)
patches lane indices refering to the given edge and above the threshold by the given offset
int getToLane() const
returns the to-lane
NBEdge * getTo() const
returns the to-edge (end of the connection)
Holds (- relative to the edge it is build from -!!!) the list of main directions a vehicle that drive...
bool empty() const
returns the information whether no following street has a higher priority
bool includes(Direction d) const
returns the information whether the street in the given direction has a higher priority
int getStraightest() const
returns the index of the straightmost among the given outgoing edges
MainDirections(const EdgeVector &outgoing, NBEdge *parent, NBNode *to, const std::vector< int > &availableLanes)
constructor
std::vector< Direction > myDirs
list of the main direction within the following junction relative to the edge
~MainDirections()
destructor
int myStraightest
the index of the straightmost among the given outgoing edges
Direction
enum of possible directions
A class that being a bresenham-callback assigns the incoming lanes to the edges.
const std::map< NBEdge *, std::vector< int > > & getBuiltConnections() const
get built connections
void execute(const int lane, const int virtEdge)
executes a bresenham - step
Class to sort edges by their angle.
int operator()(const Connection &c1, const Connection &c2) const
comparing operation
The representation of a single edge during network building.
void reinit(NBNode *from, NBNode *to, const std::string &type, double speed, double friction, int nolanes, int priority, PositionVector geom, double width, double endOffset, const std::string &streetName, LaneSpreadFunction spread, bool tryIgnoreNodePositions=false)
Resets initial values.
void addGeometryPoint(int index, const Position &p)
Adds a further geometry point.
void mirrorX()
mirror coordinates along the x-axis
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
set preferred Vehicle Class
double getLaneSpeed(int lane) const
get lane speed
NBEdge * guessOpposite(bool reguess=false)
set oppositeID and return opposite edge if found
void setPermittedChanging(int lane, SVCPermissions changeLeft, SVCPermissions changeRight)
set allowed classes for changing to the left and right from the given lane
double getLength() const
Returns the computed length of the edge.
double myLaneWidth
This width of this edge's lanes.
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
std::vector< Connection > myConnectionsToDelete
List of connections marked for delayed removal.
const EdgeVector * getConnectedSorted()
Returns the list of outgoing edges without the turnaround sorted in clockwise direction.
double getDistancAt(double pos) const
get distance at the given offset
double myEndOffset
This edges's offset to the intersection begin (will be applied to all lanes)
int myToJunctionPriority
The priority normalised for the node the edge is incoming in.
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given
StopOffset myEdgeStopOffset
A vClass specific stop offset - assumed of length 0 (unspecified) or 1. For the latter case the int i...
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
double getCrossingAngle(NBNode *node)
return the angle for computing pedestrian crossings at the given node
void addBikeLane(double width)
add a bicycle lane of the given width and shift existing connctions
bool expandableBy(NBEdge *possContinuation, std::string &reason) const
Check if Node is expandable.
double getLaneFriction(int lane) const
get lane friction of specified lane
void init(int noLanes, bool tryIgnoreNodePositions, const std::string &origID)
Initialization routines common to all constructors.
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
void reinitNodes(NBNode *from, NBNode *to)
Resets nodes but keeps all other values the same (used when joining)
double mySpeed
The maximal speed.
bool hasLaneSpecificFriction() const
whether lanes differ in friction
double getLaneWidth() const
Returns the default width of lanes of this edge.
PositionVector getCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going clock-wise around the given node
NBNode * getToNode() const
Returns the destination node of the edge.
std::vector< Connection > myConnections
List of connections to following edges.
Connection & getConnectionRef(int fromLane, const NBEdge *to, int toLane)
Returns reference to the specified connection This method goes through "myConnections" and returns th...
NBEdge()
constructor for dummy edge
void divideOnEdges(const EdgeVector *outgoing)
divides the lanes on the outgoing edges
ConstRouterEdgePairVector myViaSuccessors
PositionVector getCCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going counter-clock-wise around the given node
double buildInnerEdges(const NBNode &n, int noInternalNoSplits, int &linkIndex, int &splitIndex)
static const double UNSPECIFIED_FRICTION
unspecified lane friction
void incLaneNo(int by)
increment lane
static EdgeVector filterByPermissions(const EdgeVector &edges, SVCPermissions permissions)
return only those edges that permit at least one of the give permissions
const Connection & getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection (unmodifiable) This method goes through "myConnections" and returns ...
void addLane(int index, bool recomputeShape, bool recomputeConnections, bool shiftIndices)
add lane
bool hasLaneSpecificSpeed() const
whether lanes differ in speed
void setAverageLengthWithOpposite(double val)
patch average lane length in regard to the opposite edge
void disallowVehicleClass(int lane, SUMOVehicleClass vclass)
set disallowed class for the given lane or for all lanes if -1 is given
double getShapeStartAngle() const
Returns the angle at the start of the edge.
static const int UNSPECIFIED_INTERNAL_LANE_INDEX
internal lane computation not yet done
void appendTurnaround(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike, bool checkPermissions)
Add a connection to the previously computed turnaround, if wished and a turning direction exists (myT...
static bool connections_sorter(const Connection &c1, const Connection &c2)
connections_sorter sort by fromLane, toEdge and toLane
std::string myType
The type of the edge.
const PositionVector & getGeometry() const
Returns the geometry of the edge.
bool hasPermissions() const
whether at least one lane has restrictions
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
bool hasDefaultGeometryEndpoints() const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
std::string myTurnSignTarget
node for which turnSign information applies
bool isBidiRail(bool ignoreSpread=false) const
whether this edge is part of a bidirectional railway
static const bool UNSPECIFIED_CONNECTION_UNCONTROLLED
TLS-controlled despite its node controlled not specified.
const EdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges for the given vClass.
std::vector< LinkDirection > decodeTurnSigns(int turnSigns)
decode bitset
void dismissVehicleClassInformation()
dimiss vehicle class information
bool computeEdge2Edges(bool noLeftMovers)
computes the edge (step1: computation of approached edges)
EdgeBuildingStep getStep() const
The building step of this edge.
LaneSpreadFunction myLaneSpreadFunction
The information about how to spread the lanes.
void moveConnectionToLeft(int lane)
void updateChangeRestrictions(SVCPermissions ignoring)
modify all existing restrictions on lane changing
void restoreBikelane(std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore an previously added BikeLane
Position getEndpointAtNode(const NBNode *node) const
NBEdge * getStraightContinuation(SVCPermissions permissions) const
return the straightest follower edge for the given permissions or nullptr (never returns turn-arounds...
bool hasLoadedLength() const
Returns whether a length was set explicitly.
void restoreSidewalk(std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore an previously added sidewalk
bool addEdge2EdgeConnection(NBEdge *dest, bool overrideRemoval=false, SVCPermissions permission=SVC_UNSPECIFIED)
Adds a connection to another edge.
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, KeepClear keepClear=KEEPCLEAR_UNSPECIFIED, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, double friction=UNSPECIFIED_FRICTION, double length=myDefaultConnectionLength, const PositionVector &customShape=PositionVector::EMPTY, const bool uncontrolled=UNSPECIFIED_CONNECTION_UNCONTROLLED, SVCPermissions permissions=SVC_UNSPECIFIED, const bool indirectLeft=false, const std::string &edgeType="", SVCPermissions changeLeft=SVC_UNSPECIFIED, SVCPermissions changeRight=SVC_UNSPECIFIED, bool postProcess=false)
Adds a connection between the specified this edge's lane and an approached one.
void divideSelectedLanesOnEdges(const EdgeVector *outgoing, const std::vector< int > &availableLanes)
divide selected lanes on edges
bool setEdgeStopOffset(int lane, const StopOffset &offset, bool overwrite=false)
set lane and vehicle class specific stopOffset (negative lane implies set for all lanes)
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
bool hasLaneSpecificStopOffsets() const
whether lanes differ in stopOffsets
void setNodeBorder(const NBNode *node, const Position &p, const Position &p2, bool rectangularCut)
Set Node border.
int getFirstNonPedestrianLaneIndex(int direction, bool exclusive=false) const
return the first lane with permissions other than SVC_PEDESTRIAN and 0
void shiftToLanesToEdge(NBEdge *to, int laneOff)
modifify the toLane for all connections to the given edge
void checkGeometry(const double maxAngle, const double minRadius, bool fix, bool silent)
Check the angles of successive geometry segments.
static double myDefaultConnectionLength
bool isNearEnough2BeJoined2(NBEdge *e, double threshold) const
Check if edge is near enought to be joined to another edge.
EdgeBuildingStep myStep
The building step.
void setLaneType(int lane, const std::string &type)
set lane specific type (negative lane implies set for all lanes)
bool computeLanes2Edges()
computes the edge, step2: computation of which lanes approach the edges)
EdgeBuildingStep
Current state of the edge within the building process.
@ INIT_REJECT_CONNECTIONS
The edge has been loaded and connections shall not be added.
@ EDGE2EDGES
The relationships between edges are computed/loaded.
@ LANES2LANES_RECHECK
Lanes to lanes - relationships are computed; should be rechecked.
@ LANES2LANES_DONE
Lanes to lanes - relationships are computed; no recheck is necessary/wished.
@ LANES2EDGES
Lanes to edges - relationships are computed/loaded.
@ LANES2LANES_USER
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
@ INIT
The edge has been loaded, nothing is computed yet.
NBEdge * getStraightPredecessor(SVCPermissions permissions) const
return the straightest predecessor edge for the given permissions or nullptr (never returns turn-arou...
void remapConnections(const EdgeVector &incoming)
Remaps the connection in a way that allows the removal of it.
double getSpeed() const
Returns the speed allowed on this edge.
const std::string & getID() const
int getFirstAllowedLaneIndex(int direction) const
return the first lane that permits at least 1 vClass or the last lane if search direction of there is...
bool allowsChangingRight(int lane, SUMOVehicleClass vclass) const
Returns whether the given vehicle class may change left from this lane.
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
void resetLaneShapes()
reset lane shapes to what they would be before cutting with the junction shapes
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
bool bothLeftTurns(LinkDirection dir, const NBEdge *otherFrom, LinkDirection dir2) const
determine conflict between opposite left turns
void setAcceleration(int lane, bool accelRamp)
marks one lane as acceleration lane
const StopOffset & getEdgeStopOffset() const
Returns the stopOffset to the end of the edge.
NBNode * tryGetNodeAtPosition(double pos, double tolerance=5.0) const
Returns the node at the given edges length (using an epsilon)
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
void clearControllingTLInformation()
clears tlID for all connections
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
void addStraightConnections(const EdgeVector *outgoing, const std::vector< int > &availableLanes, const std::vector< int > &priorities)
add some straight connections
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
bool needsLaneSpecificOutput() const
whether at least one lane has values differing from the edges values
void computeAngle()
computes the angle of this edge and stores it in myAngle
std::vector< Connection > getConnectionsFromLane(int lane, NBEdge *to=nullptr, int toLane=-1) const
Returns connections from a given lane.
bool isBidiEdge(bool checkPotential=false) const
whether this edge is part of a bidirectional edge pair
static const double UNSPECIFIED_SIGNAL_OFFSET
unspecified signal offset
void addSidewalk(double width)
add a pedestrian sidewalk of the given width and shift existing connctions
bool hasSignalisedConnectionTo(const NBEdge *const e) const
Check if edge has signalised connections.
std::vector< Lane > myLanes
Lane information.
int getNumLanes() const
Returns the number of lanes.
bool hasAccelLane() const
whether one of the lanes is an acceleration lane
bool myIsBidi
whether this edge is part of a non-rail bidi edge pair
static double firstIntersection(const PositionVector &v1, const PositionVector &v2, double width1, double width2, const std::string &error="", bool secondIntersection=false)
compute the first intersection point between the given lane geometries considering their rspective wi...
PositionVector myToBorder
void extendGeometryAtNode(const NBNode *node, double maxExtent)
linearly extend the geometry at the given node
void setFriction(int lane, double friction)
set lane specific friction (negative lane implies set for all lanes)
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
static const double ANGLE_LOOKAHEAD
the distance at which to take the default angle
void reduceGeometry(const double minDist)
Removes points with a distance lesser than the given.
static NBEdge DummyEdge
Dummy edge to use when a reference must be supplied in the no-arguments constructor (FOX technicality...
bool joinLanes(SVCPermissions perms)
join adjacent lanes with the given permissions
void resetNodeBorder(const NBNode *node)
void markAsInLane2LaneState()
mark edge as in lane to state lane
bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const
return true if certain connection must be controlled by TLS
void addRestrictedLane(double width, SUMOVehicleClass vclass)
add a lane of the given width, restricted to the given class and shift existing connections
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false, const bool adaptToLaneRemoval=false, const bool keepPossibleTurns=false)
Removes the specified connection(s)
double myLength
The length of the edge.
NBEdge::Lane getFirstNonPedestrianLane(int direction) const
@brif get first non-pedestrian lane
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
const std::vector< int > prepareEdgePriorities(const EdgeVector *outgoing, const std::vector< int > &availableLanes)
recomputes the edge priorities and manipulates them for a distribution of lanes on edges which is mor...
int myIndex
the index of the edge in the list of all edges. Set by NBEdgeCont and requires re-set whenever the li...
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
PositionVector cutAtIntersection(const PositionVector &old) const
cut shape at the intersection shapes
Position geometryPositionAtOffset(double offset) const
return position taking into account loaded length
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
bool canMoveConnection(const Connection &con, int newFromLane) const
whether the connection can originate on newFromLane
double getInternalLaneWidth(const NBNode &node, const NBEdge::Connection &connection, const NBEdge::Lane &successor, bool isVia) const
Returns the width of the internal lane associated with the connection.
void allowVehicleClass(int lane, SUMOVehicleClass vclass)
set allowed class for the given lane or for all lanes if -1 is given
bool isConnectedTo(const NBEdge *e, const bool ignoreTurnaround=false) const
Returns the information whethe a connection to the given edge has been added (or computed)
double getMaxLaneOffset()
get max lane offset
void deleteLane(int index, bool recompute, bool shiftIndices)
delete lane
NBEdge * myPossibleTurnDestination
The edge that would be the turn destination if there was one.
const PositionVector & getNodeBorder(const NBNode *node) const
int getNumLanesThatAllow(SVCPermissions permissions) const
get lane indices that allow the given permissions
const NBNode * mySignalNode
bool hasLaneSpecificWidth() const
whether lanes differ in width
void moveConnectionToRight(int lane)
std::set< SVCPermissions > getPermissionVariants(int iStart, int iEnd) const
return all permission variants within the specified lane range [iStart, iEnd[
void reshiftPosition(double xoff, double yoff)
Applies an offset to the edge.
void moveOutgoingConnectionsFrom(NBEdge *e, int laneOff)
move outgoing connection
std::string getLaneID(int lane) const
get lane ID
bool myIsOffRamp
whether this edge is an Off-Ramp or leads to one
static const double UNSPECIFIED_SPEED
unspecified lane speed
Lane2LaneInfoType
Modes of setting connections between lanes.
@ USER
The connection was given by the user.
@ VALIDATED
The connection was computed and validated.
@ COMPUTED
The connection was computed.
double getFriction() const
Returns the friction on this edge.
static PositionVector startShapeAt(const PositionVector &laneShape, const NBNode *startNode, PositionVector nodeShape)
std::string getSidewalkID()
get the lane id for the canonical sidewalk lane
std::vector< int > getConnectionLanes(NBEdge *currentOutgoing, bool withBikes=true) const
Returns the list of lanes that may be used to reach the given edge.
void computeLaneShapes()
compute lane shapes
double getAngleAtNodeToCenter(const NBNode *const node) const
Returns the angle of from the node shape center to where the edge meets the node shape.
int getSpecialLane(SVCPermissions permissions) const
return index of the first lane that allows the given permissions
bool setConnection(int lane, NBEdge *destEdge, int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, KeepClear keepClear=KEEPCLEAR_UNSPECIFIED, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, double friction=UNSPECIFIED_FRICTION, double length=myDefaultConnectionLength, const PositionVector &customShape=PositionVector::EMPTY, const bool uncontrolled=UNSPECIFIED_CONNECTION_UNCONTROLLED, SVCPermissions permissions=SVC_UNSPECIFIED, bool indirectLeft=false, const std::string &edgeType="", SVCPermissions changeLeft=SVC_UNSPECIFIED, SVCPermissions changeRight=SVC_UNSPECIFIED, bool postProcess=false)
Adds a connection to a certain lane of a certain edge.
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
double myDistance
The mileage/kilometrage at the start of this edge in a linear coordination system.
bool myAmMacroscopicConnector
Information whether this edge is a (macroscopic) connector.
EdgeVector getConnectedEdges() const
Returns the list of outgoing edges unsorted.
const ConstRouterEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges for the given vClass.
const std::string & getStreetName() const
Returns the street name of this edge.
void setLaneShape(int lane, const PositionVector &shape)
sets a custom lane shape
double myLoadedLength
An optional length to use (-1 if not valid)
void sortOutgoingConnectionsByAngle()
sorts the outgoing connections by their angle relative to their junction
bool applyTurnSigns()
apply loaded turn sign information
bool haveIntersection(const NBNode &n, const PositionVector &shape, const NBEdge *otherFrom, const NBEdge::Connection &otherCon, int numPoints, double width1, double width2, int shapeFlag=0) const
void preferVehicleClass(int lane, SVCPermissions vclasses)
prefer certain vehicle classes for the given lane or for all lanes if -1 is given (ensures also permi...
const NBEdge * getBidiEdge() const
NBNode * getFromNode() const
Returns the origin node of the edge.
double myStartAngle
The angles of the edge.
double getAngleAtNodeNormalized(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node and disregards edge direction.
NBEdge * getTurnDestination(bool possibleDestination=false) const
void shiftPositionAtNode(NBNode *node, NBEdge *opposite)
shift geometry at the given node to avoid overlap
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
bool hasLaneSpecificType() const
whether lanes differ in type
PositionVector myFromBorder
intersection borders (because the node shape might be invalid)
double getSignalOffset() const
Returns the offset of a traffic signal from the end of this edge.
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
bool myAmInTLS
Information whether this is lies within a joined tls.
void setTurningDestination(NBEdge *e, bool onlyPossible=false)
Sets the turing destination at the given edge.
bool hasDefaultGeometryEndpointAtNode(const NBNode *node) const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
NBEdge * myTurnDestination
The turn destination edge (if a connection exists)
int getPriority() const
Returns the priority of the edge.
void computeEdgeShape(double smoothElevationThreshold=-1)
Recomputeds the lane shapes to terminate at the node shape For every lane the intersection with the f...
double assignInternalLaneLength(std::vector< Connection >::iterator i, int numLanes, double lengthSum, bool averageLength)
assign length to all lanes of an internal edge
static const double UNSPECIFIED_WIDTH
unspecified lane width
bool hasRestrictedLane(SUMOVehicleClass vclass) const
returns whether any lane already allows the given vclass exclusively
void copyConnectionsFrom(NBEdge *src)
copy connections from antoher edge
const StopOffset & getLaneStopOffset(int lane) const
Returns the stop offset to the specified lane's end.
void debugPrintConnections(bool outgoing=true, bool incoming=false) const
debugging helper to print all connections
Position mySignalPosition
the position of a traffic light signal on this edge
void replaceInConnections(NBEdge *which, NBEdge *by, int laneOff)
replace in current connections of edge
bool lanesWereAssigned() const
Check if lanes were assigned.
void restoreRestrictedLane(SUMOVehicleClass vclass, std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore a restricted lane
double getEndOffset() const
Returns the offset to the destination node.
bool isRailDeadEnd() const
whether this edge is a railway edge that does not continue
double myFriction
The current friction.
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
static const double UNSPECIFIED_OFFSET
unspecified lane offset
void sortOutgoingConnectionsByIndex()
sorts the outgoing connections by their from-lane-index and their to-lane-index
bool recheckLanes()
recheck whether all lanes within the edge are all right and optimises the connections once again
int myFromJunctionPriority
The priority normalised for the node the edge is outgoing of.
bool addLane2LaneConnections(int fromLane, NBEdge *dest, int toLane, int no, Lane2LaneInfoType type, bool invalidatePrevious=false, bool mayDefinitelyPass=false)
Builds no connections starting at the given lanes.
void setOrigID(const std::string origID, const bool append, const int laneIdx=-1)
set origID for all lanes or for a specific lane
PositionVector computeLaneShape(int lane, double offset) const
Computes the shape for the given lane.
bool allowsChangingLeft(int lane, SUMOVehicleClass vclass) const
Returns whether the given vehicle class may change left from this lane.
static int getLaneIndexFromLaneID(const std::string laneID)
bool hasConnectionTo(const NBEdge *destEdge, int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
bool hasCustomLaneShape() const
whether one of the lanes has a custom shape
bool hasLaneParams() const
whether one of the lanes has parameters set
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
double getShapeEndAngle() const
Returns the angle at the end of the edge.
bool prohibitsChanging() const
whether one of the lanes prohibits lane changing
void setLoadedLength(double val)
set loaded length
PositionVector myGeom
The geometry for the edge.
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
void decLaneNo(int by)
decrement lane
NBNode * myFrom
The source and the destination node.
void append(NBEdge *continuation)
append another edge
void setJunctionPriority(const NBNode *const node, int prio)
Sets the junction priority of the edge.
double getFinalLength() const
get length that will be assigned to the lanes in the final network
void shortenGeometryAtNode(const NBNode *node, double reduction)
linearly extend the geometry at the given node
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
int myPriority
The priority of the edge.
std::string myStreetName
The street name (or whatever arbitrary string you wish to attach)
EdgeVector getIncomingEdges() const
Returns the list of incoming edges unsorted.
int getFirstNonPedestrianNonBicycleLaneIndex(int direction, bool exclusive=false) const
return the first lane with permissions other than SVC_PEDESTRIAN, SVC_BICYCLE and 0
static double normRelAngle(double angle1, double angle2)
ensure that reverse relAngles (>=179.999) always count as turnarounds (-180)
A definition of a pedestrian crossing.
PositionVector shape
The crossing's shape.
EdgeVector edges
The edges being crossed.
double width
This crossing's width.
Represents a single node (junction) during network building.
void addIncomingEdge(NBEdge *edge)
adds an incoming edge
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
static const int AVOID_INTERSECTING_LEFT_TURNS
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node)
bool needsCont(const NBEdge *fromE, const NBEdge *otherFromE, const NBEdge::Connection &c, const NBEdge::Connection &otherC) const
whether an internal junction should be built at from and respect other
FringeType getFringeType() const
Returns fringe type.
static const int BACKWARD
SumoXMLNodeType getType() const
Returns the type of this node.
static bool isTrafficLight(SumoXMLNodeType type)
return whether the given type is a traffic light
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
static bool rightTurnConflict(const NBEdge *from, const NBEdge *to, int fromLane, const NBEdge *prohibitorFrom, const NBEdge *prohibitorTo, int prohibitorFromLane)
return whether the given laneToLane connection is a right turn which must yield to a bicycle crossing...
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
bool forbids(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
PositionVector computeSmoothShape(const PositionVector &begShape, const PositionVector &endShape, int numPoints, bool isTurnaround, double extrapolateBeg, double extrapolateEnd, NBNode *recordError=0, int shapeFlag=0) const
Compute a smooth curve between the given geometries.
bool isLeftMover(const NBEdge *const from, const NBEdge *const to) const
Computes whether the given connection is a left mover across the junction.
bool mergeConflict(const NBEdge *from, const NBEdge::Connection &con, const NBEdge *prohibitorFrom, const NBEdge::Connection &prohibitorCon, bool foes) const
whether multple connections from the same edge target the same lane
std::vector< Crossing * > getCrossings() const
return this junctions pedestrian crossings
void addOutgoingEdge(NBEdge *edge)
adds an outgoing edge
bool isConstantWidthTransition() const
detects whether a given junction splits or merges lanes while keeping constant road width
const Position & getPosition() const
const PositionVector & getShape() const
retrieve the junction shape
static const int FORWARD
edge directions (for pedestrian related stuff)
bool foes(const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const
Returns the information whether the given flows cross.
PositionVector computeInternalLaneShape(const NBEdge *fromE, const NBEdge::Connection &con, int numPoints, NBNode *recordError=0, int shapeFlag=0) const
Compute the shape for an internal lane.
void shiftTLConnectionLaneIndex(NBEdge *edge, int offset, int threshold=-1)
patches loaded signal plans by modifying lane indices above threshold by the given offset
bool geometryLike() const
whether this is structurally similar to a geometry node
bool isTLControlled() const
Returns whether this node is controlled by any tls.
static const int SCURVE_IGNORE
static const double MIN_SPEED_CROSSING_TIME
minimum speed for computing time to cross intersection
Base class for objects which have an id.
std::string myID
The name of the object.
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)
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.
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
const Parameterised::Map & getParametersMap() const
Returns the inner key/value map.
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
void updateParameters(const Parameterised::Map &mapArg)
Adds or updates all given parameters from the map.
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
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
void add(const Position &pos)
Adds the given position to this one.
void setz(double z)
set position z
double z() const
Returns the z-position.
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position
void sety(double y)
set position y
double y() const
Returns the y-position.
double length2D() const
Returns the length.
void append(const PositionVector &v, double sameThreshold=2.0)
double beginEndAngle() const
returns the angle in radians of the line connecting the first and the last position
double length() const
Returns the length.
void push_front_noDoublePos(const Position &p)
insert in front a non double position
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
void add(double xoff, double yoff, double zoff)
void closePolygon()
ensures that the last position equals the first
std::vector< double > intersectsAtLengths2D(const PositionVector &other) const
For all intersections between this vector and other, return the 2D-length of the subvector from this ...
double distance2D(const Position &p, bool perpendicular=false) const
closest 2D-distance to point p (or -1 if perpendicular is true and the point is beyond this vector)
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
std::vector< double > distances(const PositionVector &s, bool perpendicular=false) const
distances of all my points to s and all of s points to myself
PositionVector getOrthogonal(const Position &p, double extend, bool before, double length=1.0, double deg=90) const
return orthogonal through p (extending this vector if necessary)
std::pair< PositionVector, PositionVector > splitAt(double where, bool use2D=false) const
Returns the two lists made when this list vector is splitted at the given point.
void move2side(double amount, double maxExtension=100)
move position vector to side using certain ammount
bool almostSame(const PositionVector &v2, double maxDiv=POSITION_EPS) const
check if the two vectors have the same length and pairwise similar positions
PositionVector getSubpart2D(double beginOffset, double endOffset) const
get subpart of a position vector in two dimensions (Z is ignored)
PositionVector smoothedZFront(double dist=std::numeric_limits< double >::max()) const
returned vector that is smoothed at the front (within dist)
double angleAt2D(int pos) const
get angle in certain position of position vector
bool hasElevation() const
return whether two positions differ in z-coordinate
void extrapolate(const double val, const bool onlyFirst=false, const bool onlyLast=false)
extrapolate position vector
Position getCentroid() const
Returns the centroid (closes the polygon if unclosed)
void extrapolate2D(const double val, const bool onlyFirst=false)
extrapolate position vector in two dimensions (Z is ignored)
void push_back_noDoublePos(const Position &p)
insert in back a non double position
void removeDoublePoints(double minDist=POSITION_EPS, bool assertLength=false, int beginOffset=0, int endOffset=0, bool resample=false)
Removes positions if too near.
bool intersects(const Position &p1, const Position &p2) const
Returns the information whether this list of points interesects the given line.
PositionVector reverse() const
reverse position vector
PositionVector getSubpartByIndex(int beginIndex, int count) const
get subpart of a position vector using index and a cout
Position positionAtOffset2D(double pos, double lateralOffset=0) const
Returns the position at the given length.
PositionVector getSubpart(double beginOffset, double endOffset) const
get subpart of a position vector
bool around(const Position &p, double offset=0) const
Returns the information whether the position vector describes a polygon lying around the given point.
static bool isValidNetID(const std::string &value)
whether the given string is a valid id for a network element
bool isDefined() const
check if stopOffset was defined
double getOffset() const
get offset
std::vector< std::string > getVector()
return vector of strings
Some static methods for string processing.
static std::string convertUmlaute(std::string str)
Converts german "Umlaute" to their latin-version.
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
static T maxValue(const std::vector< T > &v)
A structure which describes a connection between edges or lanes.
bool indirectLeft
Whether this connection is an indirect left turn.
int fromLane
The lane the connections starts at.
std::string viaID
if Connection have a via, ID of it
int toLane
The lane the connections yields in.
std::vector< int > foeInternalLinks
FOE Internal links.
Connection(int fromLane_, NBEdge *toEdge_, int toLane_, const bool mayDefinitelyPass_=false)
Constructor.
double speed
custom speed for connection
NBEdge * toEdge
The edge the connections yields in.
double customLength
custom length for connection
double vmax
maximum velocity
PositionVector customShape
custom shape for connection
PositionVector viaShape
shape of via
std::string getDescription(const NBEdge *parent) const
get string describing this connection
double contPos
custom position for internal junction on this connection
std::string getInternalLaneID() const
get ID of internal lane
int internalLaneIndex
The lane index of this internal lane within the internal edge.
std::string tlID
The id of the traffic light that controls this connection.
int tlLinkIndex2
The index of the internal junction within the controlling traffic light (optional)
double length
computed length (average of all internal lane shape lengths that share an internal edge)
PositionVector shape
shape of Connection
std::string id
id of Connection
std::vector< std::string > foeIncomingLanes
FOE Incomings lanes.
bool haveVia
check if Connection have a Via
int tlLinkIndex
The index of this connection within the controlling traffic light.
double viaLength
the length of the via shape (maybe customized)
static ConstRouterEdgePairVector myViaSuccessors
An (internal) definition of a single lane of an edge.
double width
This lane's width.
std::string oppositeID
An opposite lane ID, if given.
SVCPermissions changeRight
List of vehicle types that are allowed to change right from this lane.
SVCPermissions changeLeft
List of vehicle types that are allowed to change Left from this lane.
Lane(NBEdge *e, const std::string &_origID)
constructor
bool accelRamp
Whether this lane is an acceleration lane.
PositionVector shape
The lane's shape.