54#define JOIN_TRAM_MAX_ANGLE 10
55#define JOIN_TRAM_MIN_LENGTH 3
59#define DEBUG_EDGE_ID ""
66 myVehicleClasses2Keep(0),
67 myVehicleClasses2Remove(0),
68 myNeedGeoTransformedPruningBoundary(false) {
83 if (oc.
isSet(
"keep-edges.input-file")) {
86 if (oc.
isSet(
"remove-edges.input-file")) {
89 if (oc.
isSet(
"keep-edges.explicit")) {
90 const std::vector<std::string> edges = oc.
getStringVector(
"keep-edges.explicit");
93 if (oc.
isSet(
"remove-edges.explicit")) {
94 const std::vector<std::string> edges = oc.
getStringVector(
"remove-edges.explicit");
97 if (oc.
exists(
"keep-edges.by-vclass") && oc.
isSet(
"keep-edges.by-vclass")) {
100 if (oc.
exists(
"remove-edges.by-vclass") && oc.
isSet(
"remove-edges.by-vclass")) {
103 if (oc.
exists(
"keep-edges.by-type") && oc.
isSet(
"keep-edges.by-type")) {
104 const std::vector<std::string> types = oc.
getStringVector(
"keep-edges.by-type");
107 if (oc.
exists(
"remove-edges.by-type") && oc.
isSet(
"remove-edges.by-type")) {
108 const std::vector<std::string> types = oc.
getStringVector(
"remove-edges.by-type");
112 if (oc.
isSet(
"keep-edges.in-boundary") || oc.
isSet(
"keep-edges.in-geo-boundary")) {
115 "keep-edges.in-boundary" :
"keep-edges.in-geo-boundary");
120 if (boundaryShape.size() < 2) {
121 throw ProcessError(
TL(
"Invalid boundary: need at least 2 coordinates"));
122 }
else if (boundaryShape.size() == 2) {
134 "keep-edges.in-boundary" :
"keep-edges.in-geo-boundary");
135 std::vector<double> poly;
136 for (std::vector<std::string>::iterator i = polyS.begin(); i != polyS.end(); ++i) {
139 if (poly.size() < 4) {
140 throw ProcessError(
TL(
"Invalid boundary: need at least 2 coordinates"));
141 }
else if (poly.size() % 2 != 0) {
143 }
else if (poly.size() == 4) {
150 for (std::vector<double>::iterator j = poly.begin(); j != poly.end();) {
164 for (
const auto& i :
myEdges) {
193 if (oc.
exists(
"dismiss-vclasses") && oc.
getBool(
"dismiss-vclasses")) {
259 WRITE_ERROR(
TL(
"Cannot prune edges using a geo-boundary because no projection has been loaded"));
280 EdgeCont::const_iterator i =
myEdges.find(
id);
282 if (retrieveExtracted) {
317 if (edge !=
nullptr) {
321 if ((
retrieve(
id +
"[0]") !=
nullptr) && (
retrieve(
id +
"[1]") !=
nullptr)) {
323 if (downstream ==
true) {
337 if (edge !=
nullptr) {
344 if (hintedge ==
nullptr) {
347 hints.push_back(hintedge);
350 for (
const NBEdge*
const currHint : hints) {
351 for (
NBEdge*
const poss_searched : candidates) {
352 const NBNode*
const node = incoming ? poss_searched->myTo : poss_searched->myFrom;
354 if (find(cont.begin(), cont.end(), currHint) != cont.end()) {
355 return poss_searched;
367 if (edge !=
nullptr) {
371 std::string tid =
id +
"[";
372 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
373 if ((*i).first.find(tid) == 0) {
374 maxLength =
MAX2(maxLength, (
int)(*i).first.length());
379 std::vector<std::string> names;
380 names.push_back(
id +
"[1]");
381 names.push_back(
id +
"[0]");
382 while (names.size() > 0) {
384 std::string cid = names.back();
389 if (edge ==
nullptr) {
390 if ((
int)cid.length() + 3 < maxLength) {
391 names.push_back(cid +
"[1]");
392 names.push_back(cid +
"[0]");
420 if (edge != prevExtracted->second) {
422 prevExtracted->second = edge;
437 if (
myEdges.count(newID) != 0) {
438 throw ProcessError(
TLF(
"Attempt to rename edge using existing id '%'", newID));
444 if (edge->
getLanes().back().oppositeID !=
"") {
446 if (oppo !=
nullptr) {
458 if (splits.empty()) {
461 const std::string origID = e->
getID();
467 maxNumLanes =
MAX2(maxNumLanes, (
int)
split.lanes.size());
470 std::vector<int> currLanes;
472 currLanes.push_back(l);
474 if (e->
getNumLanes() != (
int)splits.back().lanes.size()) {
482 std::string firstID =
"";
484 for (
const Split& exp : splits) {
485 assert(exp.lanes.size() != 0);
486 if (exp.pos > 0 && e->
getLoadedLength() + seen > exp.pos && exp.pos > seen) {
490 const std::string idBefore = exp.idBefore ==
"" ? e->
getID() : exp.idBefore;
491 const std::string idAfter = exp.idAfter ==
"" ? exp.nameID : exp.idAfter;
495 const bool ok =
splitAt(dc, e, exp.pos - seen, exp.node,
496 idBefore, idAfter, e->
getNumLanes(), (
int) exp.lanes.size(), exp.speed);
502 std::vector<int> newLanes = exp.lanes;
508 int rightMostP = currLanes[0];
509 int rightMostN = newLanes[0];
510 for (
int l = 0; l < (int) rightMostP - (
int) rightMostN; ++l) {
514 int leftMostP = currLanes.back();
515 int leftMostN = newLanes.back();
516 for (
int l = 0; l < (int) leftMostN - (
int) leftMostP; ++l) {
520 for (
int l = 0; l < maxNumLanes; ++l) {
521 if (find(currLanes.begin(), currLanes.end(), l) == currLanes.end()) {
524 if (find(newLanes.begin(), newLanes.end(), l) == newLanes.end()) {
533 if (exp.node->getIncomingEdges().size() > 1 || exp.node->getOutgoingEdges().size() > 1) {
534 for (
NBEdge* in : exp.node->getIncomingEdges()) {
535 in->invalidateConnections(
true);
540 currLanes = newLanes;
541 }
else if (exp.pos == 0) {
542 const int laneCountDiff = e->
getNumLanes() - (int)exp.lanes.size();
543 if (laneCountDiff < 0) {
548 currLanes = exp.lanes;
552 if (exp.speed != -1.) {
562 if (splits.front().pos != 0) {
566 for (
int lane = 0; lane < (int)e->
getNumLanes(); ++lane) {
567 start.
lanes.push_back(lane);
569 start.
offset = splits.front().offset;
571 splits.insert(splits.begin(), start);
574 int maxLeft =
split.lanes.back();
575 double offset =
split.offset;
576 if (maxLeft < maxNumLanes) {
583 int maxRight =
split.lanes.front();
610 const std::string& firstEdgeName,
611 const std::string& secondEdgeName,
612 int noLanesFirstEdge,
int noLanesSecondEdge,
613 const double speed,
const double friction,
614 const int changedLeft) {
625 return splitAt(dc, edge, pos, node, firstEdgeName, secondEdgeName,
626 noLanesFirstEdge, noLanesSecondEdge, speed, friction, changedLeft);
633 const std::string& firstEdgeName,
634 const std::string& secondEdgeName,
635 int noLanesFirstEdge,
int noLanesSecondEdge,
636 const double speed,
const double friction,
637 const int changedLeft) {
638 if (firstEdgeName != edge->
getID() &&
myEdges.count(firstEdgeName) != 0) {
639 WRITE_ERRORF(
TL(
"Could not insert edge '%' before split of edge '%'."), firstEdgeName, edge->
getID());
642 if (secondEdgeName == firstEdgeName || (secondEdgeName != edge->
getID() &&
myEdges.count(secondEdgeName) != 0)) {
643 WRITE_ERRORF(
TL(
"Could not insert edge '%' after split of edge '%'."), secondEdgeName, edge->
getID());
647 assert(changedLeft > -((
int)noLanesFirstEdge));
648 assert(changedLeft < (
int)noLanesSecondEdge);
651 double geomPos = pos;
655 std::pair<PositionVector, PositionVector> geoms = edge->
getGeometry().
splitAt(geomPos);
662 NBEdge* one =
new NBEdge(firstEdgeName, edge->
myFrom, node, edge, geoms.first, noLanesFirstEdge);
663 NBEdge* two =
new NBEdge(secondEdgeName, node, edge->
myTo, edge, geoms.second, noLanesSecondEdge);
666 if (firstEdgeName != origID) {
669 if (secondEdgeName != origID) {
677 if (friction != -1.) {
693 tld->replaceRemoved(edge, -1, one, -1,
false);
696 tld->replaceRemoved(edge, -1, two, -1,
true);
707 for (
int i2 = 0; i2 < (int)two->
getNumLanes(); i2++) {
726 const std::string oldID = edge->
getID();
739 std::set<EdgeSet> addLater;
740 for (std::set<EdgeSet>::iterator it = roundabouts.begin(); it != roundabouts.end(); ++it) {
742 if (roundaboutSet.count(orig) > 0) {
743 roundaboutSet.erase(orig);
744 roundaboutSet.insert(part1);
745 roundaboutSet.insert(part2);
747 addLater.insert(roundaboutSet);
750 roundabouts.insert(addLater.begin(), addLater.end());
755std::vector<std::string>
757 std::vector<std::string> ret;
758 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
759 ret.push_back((*i).first);
769 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
770 NBEdge* edge = (*i).second;
774 toRemove.push_back(edge);
777 for (EdgeVector::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
787 for (
auto& item : edges) {
788 NBEdge* edge = item.second;
793 const std::string
id = edge->
getID();
795 for (
int i = 1; i < (int)geom.size() - 1; i++) {
796 offset += geom[i - 1].distanceTo(geom[i]);
797 std::string nodeID =
id +
"." +
toString((
int)offset);
798 if (!nc.
insert(nodeID, geom[i])) {
812 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
813 (*i).second->reduceGeometry(minDist);
820 if (maxAngle > 0 || minRadius > 0) {
825 item.second->checkGeometry(maxAngle, minRadius, fix || (fixRailways &&
isRailway(item.second->getPermissions())), silent);
834 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
835 (*i).second->clearControllingTLInformation();
842 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
843 (*i).second->sortOutgoingConnectionsByAngle();
850 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
851 (*i).second->computeEdge2Edges(noLeftMovers);
858 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
859 (*i).second->computeLanes2Edges();
867 for (
const auto& edgeIt :
myEdges) {
868 NBEdge*
const edge = edgeIt.second;
874 for (
int i = 0; i < leftmostLane; i++) {
875 const std::string& oppositeID = edge->
getLanes()[i].oppositeID;
876 NBEdge* oppEdge =
retrieve(oppositeID.substr(0, oppositeID.rfind(
"_")));
877 if (oppositeID !=
"" && oppositeID !=
"-") {
878 if (edge->
getLanes().back().oppositeID ==
"" && oppEdge !=
nullptr) {
880 WRITE_WARNINGF(
TL(
"Moving opposite lane '%' from invalid lane '%' to lane index %."), oppositeID, edge->
getLaneID(i), leftmostLane);
887 const std::string& oppositeID = edge->
getLanes().back().oppositeID;
888 if (oppositeID !=
"" && oppositeID !=
"-") {
889 NBEdge* oppEdge =
retrieve(oppositeID.substr(0, oppositeID.rfind(
"_")));
890 if (oppEdge ==
nullptr) {
896 WRITE_WARNINGF(
TL(
"Adapting invalid opposite lane '%' for edge '%' to '%'."), oppositeID, edge->
getID(), oppEdgeLeftmost);
901 const std::string leftmostID = edge->
getLaneID(leftmostLane);
902 WRITE_WARNINGF(
TL(
"Adapting missing opposite lane '%' for edge '%'."), leftmostID, oppEdge->
getID());
906 if (fixOppositeLengths) {
908 WRITE_WARNINGF(
TL(
"Averaging edge lengths for lane '%' (length %) and edge '%' (length %)."),
914 ") differs in length from edge '" + edge->
getID() +
"' (length " +
921 WRITE_ERRORF(
TL(
"Opposite lane '%' does not connect the same nodes as edge '%'!"), oppositeID, edge->
getID());
932 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
933 (*i).second->appendTurnaround(noTLSControlled, noFringe, onlyDeadends, onlyTurnlane, noGeometryLike,
true);
940 for (std::set<std::string>::const_iterator it = ids.begin(); it != ids.end(); it++) {
941 myEdges[*it]->appendTurnaround(noTLSControlled,
false,
false,
false,
false,
false);
948 std::set<std::string> stopEdgeIDs;
949 for (
auto& stopItem : sc.
getStops()) {
950 stopEdgeIDs.insert(stopItem.second->getEdgeId());
953 NBEdge* edge = item.second;
955 && (stopEdgeIDs.count(item.first) > 0 ||
970 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
971 (*i).second->computeEdgeShape(smoothElevationThreshold);
974 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); i++) {
976 const std::string& oppositeID = edge->
getLanes().back().oppositeID;
977 if (oppositeID !=
"" && oppositeID !=
"-") {
978 NBEdge* oppEdge =
retrieve(oppositeID.substr(0, oppositeID.rfind(
"_")));
994 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
995 (*i).second->computeLaneShapes();
1013 bool joinEdges =
true;
1017 NBEdge* tpledge = *(edges.begin());
1020 EdgeVector::const_iterator i;
1021 int myPriority = (*edges.begin())->getPriority();
1022 for (i = edges.begin(); i != edges.end(); i++) {
1024 assert((*i)->getFromNode() == from);
1025 assert((*i)->getToNode() == to);
1027 nolanes += (*i)->getNumLanes();
1029 if (i != edges.begin()) {
1032 id += (*i)->getID();
1034 speed += (*i)->getSpeed();
1037 if (myPriority == (*i)->getPriority()) {
1038 priority = myPriority;
1045 speed /= (double)edges.size();
1052 for (i = edges.begin(); i != edges.end(); ++i) {
1053 const std::vector<NBEdge::Lane>& lanes = (*i)->getLanes();
1054 for (
int j = 0; j < (int)lanes.size(); ++j) {
1068 for (i = edges.begin(); i != edges.end(); i++) {
1070 for (EdgeVector::iterator j = ev.begin(); j != ev.end(); j++) {
1076 for (i = edges.begin(); i != edges.end(); i++) {
1078 currLane += (*i)->getNumLanes();
1082 for (i = edges.begin(); i != edges.end(); i++) {
1083 int noLanes = (*i)->getNumLanes();
1084 for (
int j = 0; j < noLanes; j++, currLane++) {
1091 for (i = edges.begin(); i != edges.end(); i++) {
1101 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1102 NBEdge* edge = i->second;
1110 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1112 if (opposite !=
nullptr) {
1124 const std::string oppositeID = edgeID[0] ==
'-' ? edgeID.substr(1) :
"-" + edgeID;
1125 EdgeCont::const_iterator it =
myEdges.find(oppositeID);
1131 EdgeCont::const_iterator it =
myEdges.find(edgeID);
1138 KeepClear keepClear,
double contPos,
double visibility,
double speed,
double friction,
double length,
1139 const PositionVector& customShape,
bool uncontrolled,
bool warnOnly,
1142 speed, friction, length, customShape, uncontrolled, warnOnly, permissions, indirectLeft, edgeType, changeLeft, changeRight));
1167 for (std::vector<PostProcessConnection>::const_iterator i = item.second.begin(); i != item.second.end(); ++i) {
1170 if (from ==
nullptr || to ==
nullptr ||
1172 (*i).keepClear, (*i).contPos, (*i).visibility, (*i).speed, (*i).friction, (*i).customLength, (*i).customShape,
1173 (*i).uncontrolled, (*i).permissions, (*i).indirectLeft, (*i).edgeType, (*i).changeLeft, (*i).changeRight,
1175 const std::string msg =
"Could not insert connection between '" + (*i).from +
"' and '" + (*i).to +
"' after build.";
1176 if (warnOnly || (*i).warnOnly) {
1186 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); ++it) {
1187 NBEdge* edge = it->second;
1190 std::vector<NBEdge::Connection> connections = edge->
getConnections();
1191 for (std::vector<NBEdge::Connection>::iterator it_con = connections.begin(); it_con != connections.end(); ++it_con) {
1195 "' to edge '" + c.
toEdge->
getID() +
"' via junction '" + to->
getID() +
"'.");
1205 int len = (int)
id.length();
1207 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1208 std::string curr = (*i).first;
1211 if ((
int)curr.length() <= len) {
1216 if (curr.substr(0, len) ==
id && curr[len] ==
'[') {
1217 ret.push_back((*i).second);
1221 std::string::size_type pos = curr.find(
id);
1223 if (pos == std::string::npos) {
1228 if (curr[pos - 1] !=
']' && curr[pos - 1] !=
'+') {
1233 if (pos +
id.length() < curr.length()) {
1234 if (curr[pos +
id.length()] !=
'[' && curr[pos +
id.length()] !=
'+') {
1239 ret.push_back((*i).second);
1248 std::set<NBEdge*> loadedRoundaboutEdges;
1250 loadedRoundaboutEdges.insert(it->begin(), it->end());
1254 std::set<NBEdge*> candidates;
1256 for (EdgeCont::const_iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1262 candidates.insert(e);
1267 std::set<NBEdge*> visited;
1268 for (std::set<NBEdge*>::const_iterator i = candidates.begin(); i != candidates.end(); ++i) {
1275 if (visited.count(e) > 0) {
1279 loopEdges.push_back(e);
1281#ifdef DEBUG_GUESS_ROUNDABOUT
1285#ifdef DEBUG_GUESS_ROUNDABOUT
1287 std::cout <<
" e=" << e->
getID() <<
" loopEdges=" <<
toString(loopEdges) <<
"\n";
1296#ifdef DEBUG_GUESS_ROUNDABOUT
1298 std::cout <<
" rbl\n";
1304 if (edges.size() < 2) {
1306#ifdef DEBUG_GUESS_ROUNDABOUT
1308 std::cout <<
" deadend\n";
1317#ifdef DEBUG_GUESS_ROUNDABOUT
1325 EdgeVector::const_iterator me = std::find(edges.begin(), edges.end(), e);
1335#ifdef DEBUG_GUESS_ROUNDABOUT
1337 std::cout <<
" noContinuation\n";
1347#ifdef DEBUG_GUESS_ROUNDABOUT
1349 std::cout <<
" e=" << e->
getID() <<
" left=" << left->
getID() <<
" nextLeft=" << nextLeft->
getID() <<
" angle=" << angle <<
" nextAngle=" << nextAngle <<
" eLength=" << e->
getLength() <<
" lLength=" << left->
getLength() <<
" dist=" << e->
getLaneShape(0).back().distanceTo2D(left->
getLaneShape(0).front()) <<
"\n";
1363#ifdef DEBUG_GUESS_ROUNDABOUT
1365 std::cout <<
" failed angle=" << angle <<
"\n";
1371 EdgeVector::const_iterator loopClosed = std::find(loopEdges.begin(), loopEdges.end(), left);
1372 const int loopSize = (int)(loopEdges.end() - loopClosed);
1377 }
else if (loopSize < (
int)loopEdges.size()) {
1379 EdgeVector(loopEdges.begin() + (loopEdges.size() - loopSize), loopEdges.end()).swap(loopEdges);
1382 int attachments = 0;
1383 for (EdgeVector::const_iterator j = loopEdges.begin(); j != loopEdges.end(); ++j) {
1384 if ((*j)->getToNode()->getEdges().size() > 2) {
1388 if (attachments < 3) {
1390#ifdef DEBUG_GUESS_ROUNDABOUT
1392 std::cout <<
" attachments=" << attachments <<
"\n";
1399 if (visited.count(left) > 0) {
1403 loopEdges.push_back(left);
1409#ifdef DEBUG_GUESS_ROUNDABOUT
1411 std::cout <<
" formFactor=" <<
formFactor(loopEdges) <<
"\n";
1416 EdgeSet guessed(loopEdges.begin(), loopEdges.end());
1417 if (loadedRoundaboutEdges.count(loopEdges.front()) != 0) {
1420 if ((*it).count(loopEdges.front()) != 0) {
1430#ifdef DEBUG_GUESS_ROUNDABOUT
1432 std::cout <<
" foundRoundabout=" <<
toString(loopEdges) <<
"\n";
1438#ifdef DEBUG_GUESS_ROUNDABOUT
1449 for (EdgeVector::const_iterator it = loopEdges.begin(); it != loopEdges.end(); ++it) {
1450 points.
append((*it)->getGeometry());
1452 double circumference = points.
length2D();
1453 return 4 *
M_PI * points.
area() / (circumference * circumference);
1457const std::set<EdgeSet>
1467 if (roundabout.size() > 0) {
1480 if (e->getToNode() == node) {
1497 std::vector<EdgeSet> rList;
1498 for (
const EdgeSet& r : roundabouts) {
1500 std::set_difference(r.begin(), r.end(), toRemove.begin(), toRemove.end(), std::inserter(r2, r2.end()));
1501 rList.push_back(r2);
1503 roundabouts.clear();
1504 roundabouts.insert(rList.begin(), rList.end());
1511 for (
NBEdge*
const edge : roundaboutSet) {
1513 NBNode*
const node = edge->getToNode();
1515 if (roundaboutSet.count(inEdge) > 0) {
1521 if (inEdge->getTurnDestination() !=
nullptr) {
1522 inEdge->removeFromConnections(inEdge->getTurnDestination(), -1);
1526 const std::vector<NBEdge::Connection> cons = inEdge->getConnections();
1528 if (con.toEdge && roundaboutSet.count(con.toEdge) == 0) {
1529 const double angle = fabs(
NBHelpers::normRelAngle(inEdge->getAngleAtNode(node), con.toEdge->getAngleAtNode(node)));
1531 inEdge->removeFromConnections(con.toEdge, -1);
1549 for (EdgeCont::iterator i =
myEdges.begin(); i !=
myEdges.end(); ++i) {
1593 int lanesCreated = 0;
1594 std::vector<std::string> edges;
1595 if (excludeOpt !=
"") {
1598 std::set<std::string> exclude(edges.begin(), edges.end());
1599 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1600 NBEdge* edge = it->second;
1602 exclude.count(edge->
getID()) == 0
1609 || (!fromPermissions && edge->
getSpeed() > minSpeed && edge->
getSpeed() <= maxSpeed)
1621 return lanesCreated;
1628 item.second->updateChangeRestrictions(ignoring);
1636 const auto nodeContainerCopy =
myEdges;
1638 for (
const auto& node : nodeContainerCopy) {
1639 node.second->setID(prefix + node.second->getID());
1640 myEdges[node.second->getID()] = node.second;
1648 if (!numericaIDs && !reservedIDs && prefix ==
"" && !startGiven) {
1651 std::vector<std::string> avoid;
1657 std::set<std::string> reserve;
1660 avoid.insert(avoid.end(), reserve.begin(), reserve.end());
1663 std::set<NBEdge*, ComparatorIdLess> toChange;
1664 for (EdgeCont::iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1666 toChange.insert(it->second);
1673 toChange.insert(it->second);
1676 if (reservedIDs && reserve.count(it->first) > 0) {
1677 toChange.insert(it->second);
1681 std::map<std::string, std::vector<std::shared_ptr<NBPTStop> > > stopsOnEdge;
1682 for (
const auto& item : sc.
getStops()) {
1683 stopsOnEdge[item.second->getEdgeId()].push_back(item.second);
1687 for (
NBEdge* edge : toChange) {
1690 for (
NBEdge* edge : toChange) {
1691 const std::string origID = edge->getID();
1693 edge->setOrigID(origID,
false);
1695 edge->setID(idSupplier.
getNext());
1696 myEdges[edge->getID()] = edge;
1697 for (std::shared_ptr<NBPTStop> stop : stopsOnEdge[origID]) {
1698 stop->setEdgeId(prefix + edge->getID(), *
this);
1701 if (prefix.empty()) {
1702 return (
int)toChange.size();
1707 for (
auto item : oldEdges) {
1709 rename(item.second, prefix + item.first);
1720 for (EdgeCont::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1721 const NBEdge* e1 = it->second;
1727 for (EdgeCont::const_iterator it2 = it; it2 !=
myEdges.end(); it2++) {
1728 const NBEdge* e2 = it2->second;
1737 const double overlap = outline1.
getOverlapWith(outline2, zThreshold);
1738 if (overlap > threshold) {
1749 for (EdgeCont::const_iterator it =
myEdges.begin(); it !=
myEdges.end(); it++) {
1750 const NBEdge* edge = it->second;
1751 for (
int i = 0; i < (int)edge->
getNumLanes(); i++) {
1754 if (maxJump > 0.01) {
1756 }
else if (grade > threshold) {
1761 const std::vector<NBEdge::Connection>& connections = edge->
getConnections();
1762 for (std::vector<NBEdge::Connection>::const_iterator it_con = connections.begin(); it_con != connections.end(); ++it_con) {
1766 if (maxJump > 0.01) {
1768 }
else if (grade > threshold) {
1779 int affectedEdges = 0;
1781 if (item.second->joinLanes(perms)) {
1785 return affectedEdges;
1791 if (a.first->getID() == b.first->getID()) {
1792 return a.second < b.second;
1794 return a.first->getID() < b.first->getID();
1801 std::vector<NBEdge*> tramEdges;
1802 std::vector<NBEdge*> targetEdges;
1805 if (
isTram(permissions)) {
1806 if (item.second->getNumLanes() == 1) {
1807 tramEdges.push_back(item.second);
1809 WRITE_WARNINGF(
TL(
"Not joining tram edge '%' with % lanes."), item.second->getID(), item.second->getNumLanes());
1812 targetEdges.push_back(item.second);
1815 if (tramEdges.empty() || targetEdges.empty()) {
1820 for (
NBEdge*
const edge : tramEdges) {
1821 const Boundary& bound = edge->getGeometry().getBoxBoundary();
1822 float min[2] = {
static_cast<float>(bound.
xmin()),
static_cast<float>(bound.
ymin()) };
1823 float max[2] = {
static_cast<float>(bound.
xmax()),
static_cast<float>(bound.
ymax()) };
1824 tramTree.
Insert(min, max, edge);
1829 for (
NBEdge* edge : targetEdges) {
1830 Boundary bound = edge->getGeometry().getBoxBoundary();
1831 bound.
grow(maxDist + edge->getTotalWidth());
1832 float min[2] = {
static_cast<float>(bound.
xmin()),
static_cast<float>(bound.
ymin()) };
1833 float max[2] = {
static_cast<float>(bound.
xmax()),
static_cast<float>(bound.
ymax()) };
1834 std::set<const Named*> nearby;
1836 tramTree.
Search(min, max, visitor);
1837 for (
const Named* namedEdge : nearby) {
1842 double minEdgeDist = maxDist + 1;
1846 for (
int i = 0; i < edge->getNumLanes(); i++) {
1847 double maxLaneDist = -1;
1851 const double dist = tramShape.
distance2D(pos,
false);
1852#ifdef DEBUG_JOIN_TRAM
1861 maxLaneDist =
MAX2(maxLaneDist, dist);
1863 if (maxLaneDist >= 0 && maxLaneDist < minEdgeDist) {
1864 minEdgeDist = maxLaneDist;
1878 if (angleOK && offset2 > offset1) {
1879 std::pair<NBEdge*, int> key = std::make_pair(edge, minLane);
1880 if (matches.count(key) == 0) {
1881 matches[key] = tramEdge;
1883 WRITE_WARNINGF(
TL(
"Ambiguous tram edges '%' and '%' for lane '%'."), matches[key]->getID(), tramEdge->
getID(), edge->getLaneID(minLane));
1885#ifdef DEBUG_JOIN_TRAM
1886 std::cout << edge->getLaneID(minLane) <<
" is close to tramEdge " << tramEdge->
getID() <<
" maxLaneDist=" << minEdgeDist <<
" tramLength=" << tramEdge->
getLength() <<
" edgeLength=" << edge->getLength() <<
" tramAngle=" << tramAngle <<
" edgeAngle=" << edge->getTotalAngle() <<
"\n";
1892 if (matches.size() == 0) {
1897 for (
NBEdge* tramEdge : tramEdges) {
1898 std::vector<std::pair<double, std::pair<NBEdge*, int> > > roads;
1899 for (
auto item : matches) {
1900 if (item.second == tramEdge) {
1901 NBEdge* road = item.first.first;
1902 int laneIndex = item.first.second;
1905 roads.push_back(std::make_pair(tramPos, item.first));
1908 if (roads.size() != 0) {
1910 sort(roads.begin(), roads.end());
1911#ifdef DEBUG_JOIN_TRAM
1912 std::cout <<
" tramEdge=" << tramEdge->getID() <<
" roads=";
1913 for (
auto item : roads) {
1914 std::cout << item.second.first->getLaneID(item.second.second) <<
",";
1916 std::cout <<
" offsets=";
1917 for (
auto item : roads) {
1918 std::cout << item.first <<
",";
1926 std::string tramEdgeID = tramEdge->getID();
1927 NBNode* tramFrom = tramEdge->getFromNode();
1929 const double tramLength = tramShape.
length();
1931 bool erasedLast =
false;
1932 for (
const auto& item : roads) {
1933 const double gap = item.first - pos;
1934 NBEdge* road = item.second.first;
1935 int laneIndex = item.second.second;
1937#ifdef DEBUG_JOIN_TRAM
1938 std::cout <<
" splitting tramEdge=" << tramEdge->
getID() <<
" at " << item.first <<
" (gap=" << gap <<
")\n";
1940 const std::string firstPartID = tramEdgeID +
"#" +
toString(tramPart++);
1946 incoming.push_back(firstPart);
1947 replacement.push_back(firstPart);
1951 replacement.push_back(road);
1954 tramEdge->reinitNodes(road->
getToNode(), tramEdge->getToNode());
1957#ifdef DEBUG_JOIN_TRAM
1958 std::cout <<
" shorted tramEdge=" << tramEdge->getID() <<
" (joined with roadEdge=" << road->
getID() <<
"\n";
1961#ifdef DEBUG_JOIN_TRAM
1962 std::cout <<
" erased tramEdge=" << tramEdge->getID() <<
"\n";
1969 road->
setOrigID(tramEdgeID,
true, laneIndex);
1971 for (
NBEdge* in : incoming) {
1972 if (
isTram(in->getPermissions()) && !in->isConnectedTo(road)) {
1974 in->reinitNodes(in->getFromNode(), road->
getFromNode());
1977#ifdef DEBUG_JOIN_TRAM
1978 std::cout <<
" erased incoming tramEdge=" << in->getID() <<
"\n";
1985 NBEdge* lastRoad = roads.back().second.first;
1989 for (
NBEdge* out : outEdges) {
1991 if (lastRoad->
getToNode() != out->getToNode()) {
1992 out->reinitNodes(lastRoad->
getToNode(), out->getToNode());
1995#ifdef DEBUG_JOIN_TRAM
1996 std::cout <<
" erased outgoing tramEdge=" << out->getID() <<
"\n";
2003 replacement.push_back(tramEdge);
2019 item.second->setNumericalID((
int)result.size());
2020 result.push_back(item.second);
2034 for (
const auto& item :
myEdges) {
2056 double maxLengthOut = 0;
2058 maxLengthOut =
MAX2(maxLengthOut, c.length + c.viaLength);
2060 double maxLengthIn = 0;
2063 maxLengthIn =
MAX2(maxLengthIn, c.length + c.viaLength);
2074 item.second->computeAngle();
2079std::set<std::string>
2081 std::set<std::string> result;
2083 if (item.second->getTypeID() !=
"") {
2084 result.insert(item.second->getTypeID());
std::vector< std::string > & split(const std::string &s, char delim, std::vector< std::string > &elems)
#define WRITE_WARNINGF(...)
#define WRITE_ERRORF(...)
#define WRITE_WARNING(msg)
std::set< NBEdge * > EdgeSet
container for unique edges
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
KeepClear
keepClear status of connections
std::vector< NBRouterEdge * > RouterEdgeVector
#define JOIN_TRAM_MIN_LENGTH
#define JOIN_TRAM_MAX_ANGLE
const SVCPermissions SVCAll
all VClasses are allowed
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
bool isTram(SVCPermissions permissions)
Returns whether an edge with the given permission is a tram edge.
bool isForbidden(SVCPermissions permissions)
Returns whether an edge with the given permission is a forbidden edge.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
bool isSidewalk(SVCPermissions permissions)
Returns whether an edge with the given permission is a sidewalk.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ 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
const std::string SUMO_PARAM_ORIGID
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
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
const double SUMO_const_halfLaneWidth
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
A class that stores a 2D geometrical boundary.
double ymin() const
Returns minimum y-coordinate.
double xmin() const
Returns minimum x-coordinate.
Boundary & grow(double by)
extends the boundary by the given amount
bool overlapsWith(const AbstractPoly &poly, double offset=0) const
Returns whether the boundary overlaps with the given polygon.
double ymax() const
Returns maximum y-coordinate.
double xmax() const
Returns maximum x-coordinate.
static GeoConvHelper & getProcessing()
the coordinate transformation to use for input conversion and processing
bool x2cartesian_const(Position &from) const
Converts the given coordinate into a cartesian using the previous initialisation.
static GeoConvHelper & getLoaded()
the coordinate transformation that was loaded fron an input file
static PositionVector parseShapeReporting(const std::string &shpdef, const std::string &objecttype, const char *objectid, bool &ok, bool allowEmpty, bool report=true)
Builds a PositionVector from a string representation, reporting occurred errors.
static const double INVALID_OFFSET
a value to signify offsets outside the range of [0, Line.length()]
static double nearest_offset_on_line_to_point2D(const Position &lineStart, const Position &lineEnd, const Position &p, bool perpendicular=true)
static double legacyDegree(const double angle, const bool positive=false)
static double getMinAngleDiff(double angle1, double angle2)
Returns the minimum distance (clockwise/counter-clockwise) between both angles.
std::string getNext()
Returns the next id.
static void nextCW(const EdgeVector &edges, EdgeVector::const_iterator &from)
A container for districts.
void removeFromSinksAndSources(NBEdge *const e)
Removes the given edge from the lists of sources and sinks in all stored districts.
Sorts splits by their position (increasing)
void patchRoundabouts(NBEdge *orig, NBEdge *part1, NBEdge *part2, std::set< EdgeSet > &roundabouts)
fix roundabout information after splitting an edge
void computeEdgeShapes(double smoothElevationThreshold=-1)
Computes the shapes of all edges stored in the container.
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
NBEdge * getByID(const std::string &edgeID) const
Returns the edge with id if it exists.
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
int guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
bool myNeedGeoTransformedPruningBoundary
whether a geo transform has been applied to the pruning boundary
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
std::set< EdgeSet > myRoundabouts
Edges marked as belonging to a roundabout by the user (each EdgeVector is a roundabout)
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
void updateAllChangeRestrictions(SVCPermissions ignoring)
modify all restrictions on lane changing for edges and connections
double myEdgesMinSpeed
The minimum speed an edge may have in order to be kept (default: -1)
void recheckPostProcessConnections()
Try to set any stored connections.
void checkGeometries(const double maxAngle, const double minRadius, bool fix, bool fixRailways, bool silent=false)
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
void processSplits(NBEdge *e, std::vector< Split > splits, NBNodeCont &nc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc)
process splits
EdgeVector getAllEdges() const
return all edges
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
EdgeCont myExtractedEdges
The extracted edges which are kept for reference.
void reduceGeometries(const double minDist)
void recheckLaneSpread()
Rechecks whether the lane spread is proper.
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
void removeRoundabout(const NBNode *node)
remove roundabout that contains the given node
void splitGeometry(NBDistrictCont &dc, NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
void addPostProcessConnection(const std::string &from, int fromLane, const std::string &to, int toLane, bool mayDefinitelyPass, KeepClear keepClear, double contPos, double visibility, double speed, double friction, double length, const PositionVector &customShape, bool uncontrolled, bool warnOnly, SVCPermissions permissions=SVC_UNSPECIFIED, bool indirectLeft=false, const std::string &edgeType="", SVCPermissions changeLeft=SVC_UNSPECIFIED, SVCPermissions changeRight=SVC_UNSPECIFIED)
Adds a connection which could not be set during loading.
std::set< std::string > getUsedTypes() const
return all edge types in used
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
RouterEdgeVector getAllRouterEdges() const
return all router edges
std::set< const NBEdge * > myWasSplit
the edges that were created as result of splitting
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
int joinTramEdges(NBDistrictCont &dc, NBPTStopCont &sc, NBPTLineCont &lc, double maxDist)
join tram edges into adjacent lanes
bool hasPostProcessConnection(const std::string &from, const std::string &to="")
add post process connections
EdgeCont myEdges
The instance of the dictionary (id->edge)
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
void generateStreetSigns()
assigns street signs to edges based on toNode types
void clearControllingTLInformation() const
Clears information about controlling traffic lights for all connenections of all edges.
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
void computeAngles()
compute all edge angles
void clear()
Deletes all edges.
void guessOpposites()
Sets opposite lane information for geometrically close edges.
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
std::set< std::string > myTypes2Remove
Set of edges types which shall be removed.
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
void removeRoundaboutEdges(const EdgeSet &toRemove)
remove edges from all stored roundabouts
PositionVector myPruningBoundary
Boundary within which an edge must be located in order to be kept.
int joinLanes(SVCPermissions perms)
join adjacent lanes with the given permissions
void checkOverlap(double threshold, double zThreshold) const
check whether edges overlap
SVCPermissions myVehicleClasses2Remove
Set of vehicle types which need not be supported (edges which allow ONLY these are removed)
int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string &excludeOpt, NBTrafficLightLogicCont &tlc)
add sidwalks to edges within the given limits or permissions and return the number of edges affected
EdgeVector getGeneratedFrom(const std::string &id) const
Returns the edges which have been built by splitting the edge of the given id.
void appendTurnarounds(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike)
Appends turnarounds to all edges stored in the container.
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
bool myRemoveEdgesAfterJoining
Whether edges shall be joined first, then removed.
std::map< std::string, NBEdge * > EdgeCont
The type of the dictionary where an edge may be found by its id.
void addPrefix(const std::string &prefix)
add prefix to all edges
void fixSplitCustomLength()
adapt custom lengths of split edges to account for intersection size
std::map< const NBEdge *, std::pair< NBEdge *, NBEdge * > > myEdgesSplit
the number of splits of edges during the building
std::map< std::string, std::vector< PostProcessConnection > > myConnections
The list of connections to recheck.
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
NBEdgeCont(NBTypeCont &tc)
Constructor.
std::set< NBEdge * > myEdgeCemetery
The edges which got extracted twice but may still be referenced somewhere TODO smart_ptr?
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBPTStopCont &sc)
remap node IDs accoring to options –numerical-ids and –reserved-ids
bool checkConsistency(const NBNodeCont &nc)
ensure that all edges have valid nodes
static double formFactor(const EdgeVector &loopEdges)
compute the form factor for a loop of edges
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
void checkGrade(double threshold) const
check whether edges are to steep
The representation of a single edge during network building.
NBEdge * guessOpposite(bool reguess=false)
set oppositeID and return opposite edge if found
double getLength() const
Returns the computed length of the edge.
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
const std::vector< Connection > & getConnections() const
Returns the connections.
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
NBNode * getToNode() const
Returns the destination node of the edge.
PositionVector getCCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going counter-clock-wise around the given node
static const double UNSPECIFIED_FRICTION
unspecified lane friction
void incLaneNo(int by)
increment lane
Lane & getLaneStruct(int lane)
void setAverageLengthWithOpposite(double val)
patch average lane length in regard to the opposite edge
bool isBidi()
return whether this edge should be a bidi edge
const PositionVector & getGeometry() const
Returns the geometry of the edge.
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
bool isBidiRail(bool ignoreSpread=false) const
whether this edge is part of a bidirectional railway
void dismissVehicleClassInformation()
dimiss vehicle class information
LaneSpreadFunction myLaneSpreadFunction
The information about how to spread the lanes.
bool hasLoadedLength() const
Returns whether a length was set explicitly.
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 setDistance(double distance)
set kilometrage at start of edge (negative value implies couting down along the edge)
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
@ LANES2LANES_USER
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
double getSpeed() const
Returns the speed allowed on this edge.
const std::string & getID() const
double getDistance() const
get distance
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
std::vector< Lane > myLanes
Lane information.
int getNumLanes() const
Returns the number of lanes.
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
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)
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
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)
void addSign(NBSign sign)
add Sign
void moveOutgoingConnectionsFrom(NBEdge *e, int laneOff)
move outgoing connection
std::string getLaneID(int lane) const
get lane ID
@ USER
The connection was given by the user.
@ VALIDATED
The connection was computed and validated.
@ COMPUTED
The connection was computed.
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.
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
const std::string & getTypeID() const
get ID of type
const std::string & getStreetName() const
Returns the street name of this edge.
NBNode * getFromNode() const
Returns the origin node of the edge.
NBEdge * getTurnDestination(bool possibleDestination=false) const
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
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
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
bool recheckLanes()
recheck whether all lanes within the edge are all right and optimises the connections once again
void setOrigID(const std::string origID, const bool append, const int laneIdx=-1)
set origID for all lanes or for a specific lane
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
void setLoadedLength(double val)
set loaded length
void decLaneNo(int by)
decrement lane
NBNode * myFrom
The source and the destination node.
double getFinalLength() const
get length that will be assigned to the lanes in the final network
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
EdgeVector getIncomingEdges() const
Returns the list of incoming edges unsorted.
static void loadPrefixedIDsFomFile(const std::string &file, const std::string prefix, std::set< std::string > &into)
Add prefixed ids defined in file.
static double relAngle(double angle1, double angle2)
computes the relative angle between the two angles
static double normRelAngle(double angle1, double angle2)
ensure that reverse relAngles (>=179.999) always count as turnarounds (-180)
static void loadEdgesFromFile(const std::string &file, std::set< std::string > &into)
Add edge ids defined in file (either ID or edge:ID per line) into the given set.
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=nullptr)
Container for nodes during the netbuilding process.
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
void markAsSplit(const NBNode *node)
mark a node as being created form a split
Represents a single node (junction) during network building.
void invalidateOutgoingConnections(bool reallowSetting=false)
invalidate outgoing connections
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 isSimpleContinuation(bool checkLaneNumbers=true, bool checkWidth=false) const
check if node is a simple continuation
SumoXMLNodeType getType() const
Returns the type of this node.
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
void replaceOutgoing(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurrences of the first edge within the list of outgoing by the second Connections are rema...
void setRoundabout()
update the type of this node as a roundabout
void invalidateTLS(NBTrafficLightLogicCont &tlCont, bool removedConnections, bool addedConnections)
causes the traffic light to be computed anew
void replaceIncoming(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurrences of the first edge within the list of incoming by the second Connections are rema...
const Position & getPosition() const
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node)
bool typeWasGuessed() const
return whether a priority road turns at this node
void removeDoubleEdges()
remove duble edges
NBEdge * getConnectionTo(NBNode *n) const
get connection to certain node
void replaceEdge(const std::string &edgeID, const EdgeVector &replacement)
replace the edge with the given edge list in all lines
Container for public transport stops during the net building process.
void replaceEdge(const std::string &edgeID, const std::vector< NBEdge * > &replacement)
replace the edge with the closes edge on the given edge list in all stops
const std::map< std::string, std::shared_ptr< NBPTStop > > & getStops() const
Returns an unmodifiable reference to the stored pt stops.
A class representing a single street sign.
@ SIGN_TYPE_RIGHT_BEFORE_LEFT
@ SIGN_TYPE_LEFT_BEFORE_RIGHT
The base class for traffic light logic definitions.
A container for traffic light definitions and built programs.
void replaceRemoved(NBEdge *removed, int removedLane, NBEdge *by, int byLane, bool incoming)
Replaces occurrences of the removed edge/lane in all definitions by the given edge.
A storage for available edgeTypes of edges.
bool getEdgeTypeShallBeDiscarded(const std::string &edgeType) const
Returns the information whether edges of this edgeType shall be discarded.
bool knows(const std::string &edgeType) const
Returns whether the named edgeType is in the container.
Allows to store the object; used as context while traveling the rtree in TraCI.
Base class for objects which have an id.
virtual void setID(const std::string &newID)
resets the id
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 RT-tree for efficient storing of SUMO's Named objects.
void Insert(const float a_min[2], const float a_max[2], Named *const &a_data)
Insert entry.
int Search(const float a_min[2], const float a_max[2], const Named::StoringVisitor &c) const
Find all within search rectangle.
A storage for options typed value containers)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
std::string getValueString(const std::string &name) const
Returns the string-value of the named option (all options)
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.
A point in 2D or 3D with translation and scaling methods.
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position
double length2D() const
Returns the length.
void append(const PositionVector &v, double sameThreshold=2.0)
double length() const
Returns the length.
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::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
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
double getOverlapWith(const PositionVector &poly, double zThreshold) const
Returns the maximum overlaps between this and the given polygon (when not separated by at least zThre...
bool partialWithin(const AbstractPoly &poly, double offset=0) const
Returns the information whether this polygon lies partially within the given polygon.
double getMaxGrade(double &maxJump) const
double area() const
Returns the area (0 for non-closed)
bool intersects(const Position &p1, const Position &p2) const
Returns the information whether this list of points interesects the given line.
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
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
static long long int toLong(const std::string &sData)
converts a string into the long value described by it by calling the char-type converter,...
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
A structure which describes a connection between edges or lanes.
NBEdge * toEdge
The edge the connections yields in.
PositionVector viaShape
shape of via
std::string getDescription(const NBEdge *parent) const
get string describing this connection
PositionVector shape
shape of Connection
An (internal) definition of a single lane of an edge.
std::string oppositeID
An opposite lane ID, if given.
bool operator()(const std::pair< NBEdge *, int > &a, const std::pair< NBEdge *, int > &b) const
A structure representing a connection between two lanes.
A structure which describes changes of lane number or speed along the road.
int offsetFactor
direction in which to apply the offset (used by netgenerate for lefthand networks)
double offset
lateral offset to edge geometry
double pos
The position of this change.
std::vector< int > lanes
The lanes after this change.