59 #define DEBUGNODEID "C1"
61 #define DEBUGCOND(obj) ((obj != 0 && (obj)->getID() == DEBUGNODEID))
80 NodeCont::iterator i =
myNodes.find(
id);
86 const float pos[2] = {(float)position.
x(), (float)position.
y()};
94 std::string
id = node->
getID();
95 NodeCont::iterator i =
myNodes.find(
id);
108 NodeCont::const_iterator i =
myNodes.find(
id);
119 const float cmin[2] = {(float)(position.
x() - extOffset), (
float)(position.
y() - extOffset)};
120 const float cmax[2] = {(float)(position.
x() + extOffset), (
float)(position.
y() + extOffset)};
121 std::set<std::string> into;
124 for (std::set<std::string>::const_iterator i = into.begin(); i != into.end(); i++) {
168 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
169 no += (*i).second->removeSelfLoops(dc, ec, tc);
180 const double distanceThreshold = 7.;
181 const double lengthThreshold = 0.10;
183 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
185 std::map<NBNode*, EdgeVector> connectionCount;
186 const EdgeVector& outgoing = (*i).second->getOutgoingEdges();
187 for (EdgeVector::const_iterator j = outgoing.begin(); j != outgoing.end(); j++) {
188 connectionCount[(*j)->getToNode()].push_back(*j);
191 std::map<NBNode*, EdgeVector>::iterator k;
192 for (k = connectionCount.begin(); k != connectionCount.end(); k++) {
194 if ((*k).second.size() < 2) {
200 const NBEdge*
const first = ev.front();
201 EdgeVector::const_iterator jci;
202 for (jci = ev.begin() + 1; jci != ev.end(); ++jci) {
205 (relativeLengthDifference > lengthThreshold) ||
206 (fabs(first->
getSpeed() - (*jci)->getSpeed()) >= 0.01) ||
214 if (jci == ev.end()) {
225 const std::vector<std::string>& edgeNames = ec.
getAllNames();
226 for (std::vector<std::string>::const_iterator it = edgeNames.begin(); it != edgeNames.end(); ++it) {
235 if (outgoingEdges.size() != 1) {
240 if (incomingEdges.size() > 1) {
243 }
else if (incomingEdges.size() == 1) {
244 NBNode* fromNodeOfIncomingEdge = incomingEdges[0]->getFromNode();
245 NBNode* toNodeOfOutgoingEdge = outgoingEdges[0]->getToNode();
246 if (fromNodeOfIncomingEdge != toNodeOfOutgoingEdge) {
254 bool hasJunction =
false;
266 adjacentNodes.clear();
267 for (EdgeVector::const_iterator itOfOutgoings = outgoingEdgesOfToNode.begin(); itOfOutgoings != outgoingEdgesOfToNode.end(); ++itOfOutgoings) {
268 if ((*itOfOutgoings)->getToNode() != from
269 && (*itOfOutgoings)->getToNode() != to
273 adjacentNodes.insert((*itOfOutgoings)->getToNode());
275 for (EdgeVector::const_iterator itOfIncomings = incomingEdgesOfToNode.begin(); itOfIncomings != incomingEdgesOfToNode.end(); ++itOfIncomings) {
276 adjacentNodes.insert((*itOfIncomings)->getFromNode());
278 adjacentNodes.erase(to);
279 if (adjacentNodes.size() > 2) {
282 }
while (!hasJunction && eOld != e);
284 std::string warningString;
285 for (EdgeVector::iterator roadIt = road.begin(); roadIt != road.end(); ++roadIt) {
286 if (roadIt == road.begin()) {
287 warningString += (*roadIt)->
getID();
289 warningString +=
"," + (*roadIt)->getID();
292 NBNode* fromNode = (*roadIt)->getFromNode();
293 NBNode* toNode = (*roadIt)->getToNode();
294 ec.
erase(dc, *roadIt);
304 WRITE_WARNINGF(
"Removed a road without junctions: %.", warningString);
312 std::vector<std::set<NBEdge*> > components;
314 std::set<std::string> edgesLeft;
315 for (std::map<std::string, NBEdge*>::const_iterator edgeIt = ec.
begin(); edgeIt != ec.
end(); ++edgeIt) {
316 edgesLeft.insert(edgeIt->first);
319 std::set<NBEdge*> toRemove;
320 while (!edgesLeft.empty()) {
321 queue.push_back(ec.
getByID(*edgesLeft.begin()));
322 std::set<NBEdge*> component;
323 while (!queue.empty()) {
324 NBEdge*
const e = queue.back();
327 std::vector<EdgeVector> edgeLists;
332 for (std::vector<EdgeVector>::const_iterator listIt = edgeLists.begin(); listIt != edgeLists.end(); ++listIt) {
333 for (EdgeVector::const_iterator edgeIt = listIt->begin(); edgeIt != listIt->end(); ++edgeIt) {
334 std::set<std::string>::iterator leftIt = edgesLeft.find((*edgeIt)->getID());
335 if (leftIt != edgesLeft.end()) {
336 queue.push_back(*edgeIt);
337 edgesLeft.erase(leftIt);
342 std::vector<std::set<NBEdge*> >::iterator cIt;
343 for (cIt = components.begin(); cIt != components.end(); ++cIt) {
344 if (cIt->size() < component.size()) {
348 components.insert(cIt, component);
349 if ((
int)components.size() > numKeep) {
350 toRemove.insert(components.back().begin(), components.back().end());
351 components.pop_back();
354 for (std::set<NBEdge*>::iterator edgeIt = toRemove.begin(); edgeIt != toRemove.end(); ++edgeIt) {
355 NBNode*
const fromNode = (*edgeIt)->getFromNode();
356 NBNode*
const toNode = (*edgeIt)->getToNode();
357 ec.
erase(dc, *edgeIt);
372 bool removeGeometryNodes) {
374 std::set<std::string> edges2keep;
375 if (removeGeometryNodes) {
377 if (oc.
isSet(
"geometry.remove.keep-edges.input-file")) {
380 if (oc.
isSet(
"geometry.remove.keep-edges.explicit")) {
381 const std::vector<std::string> edges = oc.
getStringVector(
"geometry.remove.keep-edges.explicit");
382 edges2keep.insert(edges.begin(), edges.end());
389 std::vector<NBNode*> toRemove;
390 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
391 NBNode* current = (*i).second;
393 std::vector<std::pair<NBEdge*, NBEdge*> > toJoin;
400 if (removeGeometryNodes &&
mySplit.count(current) == 0) {
408 for (EdgeVector::const_iterator it_edge = current->
getEdges().begin(); it_edge != current->
getEdges().end(); ++it_edge) {
409 if (edges2keep.find((*it_edge)->getID()) != edges2keep.end()) {
423 for (std::vector<std::pair<NBEdge*, NBEdge*> >::iterator j = toJoin.begin(); j != toJoin.end(); j++) {
425 NBEdge* continuation = (*j).second;
426 begin->append(continuation);
429 ec.
extract(dc, continuation,
true);
431 toRemove.push_back(current);
435 for (std::vector<NBNode*>::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
444 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
445 (*i).second->avoidOverlap();
452 std::set<NBNode*> visited;
453 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
454 std::vector<NodeAndDist> toProc;
455 if (visited.find((*i).second) != visited.end()) {
458 toProc.push_back(std::make_pair((*i).second, 0));
460 while (!toProc.empty()) {
462 NBNode* n = nodeAndDist.first;
463 double dist = nodeAndDist.second;
465 if (visited.find(n) != visited.end()) {
469 bool pureRail =
true;
470 bool railAndPeds =
true;
488 const double length = e->getLoadedLength();
489 #ifdef DEBUG_JOINJUNCTIONS
491 std::cout <<
"generateNodeClusters: consider s=" << s->
getID()
492 <<
" clusterNode=" << n->
getID() <<
" edge=" << e->getID() <<
" length=" << length <<
" with cluster " <<
joinNamedToString(c,
' ') <<
"\n";
496 bool railAndPeds2 =
true;
499 railAndPeds2 =
false;
510 const bool joinPedCrossings = bothCrossing && e->getPermissions() ==
SVC_PEDESTRIAN;
512 !joinPedCrossings && (
524 bool foundRail =
false;
527 if ((e2->getPermissions() & railNoTram) != 0) {
540 if (visited.find(s) != visited.end()) {
543 if (length + dist < maxDist) {
545 toProc.push_back(std::make_pair(s, dist + length));
547 toProc.push_back(std::make_pair(s, 0));
555 #ifdef DEBUG_JOINJUNCTIONS
565 for (std::vector<std::string>::const_iterator it = ids.begin(); it != ids.end(); it++) {
569 WRITE_WARNINGF(
"Ignoring join exclusion for junction '%' since it already occurred in a list of nodes to be joined.", *it);
570 }
else if (check &&
retrieve(*it) ==
nullptr) {
571 WRITE_WARNINGF(
"Ignoring join exclusion for unknown junction '%'.", *it);
582 std::set<std::string> validCluster;
583 for (std::string nodeID : cluster) {
585 WRITE_WARNINGF(
"Ignoring join-cluster because junction '%' was already excluded from joining.", nodeID);
587 }
else if (
myJoined.count(nodeID) > 0) {
588 WRITE_WARNINGF(
"Ignoring join-cluster because junction '%' already occurred in another join-cluster.", nodeID);
592 if (node !=
nullptr) {
593 validCluster.insert(nodeID);
597 std::set<std::string> subIDs;
598 for (std::string nID :
StringTokenizer(nodeID.substr(8),
"_").getVector()) {
600 validCluster.insert(nID);
602 WRITE_ERROR(
"Unknown junction '" + nodeID +
"' in join-cluster (componentID).");
606 WRITE_ERROR(
"Unknown junction '" + nodeID +
"' in join-cluster.");
611 myJoined.insert(validCluster.begin(), validCluster.end());
622 for (std::string nodeID : item.first) {
624 if (node ==
nullptr) {
625 WRITE_ERROR(
"unknown junction '" + nodeID +
"' while joining.");
627 cluster.insert(node);
630 if (cluster.size() > 1) {
643 #ifdef DEBUG_JOINJUNCTIONS
644 std::cout <<
"joinJunctions...\n";
649 for (NodeClusters::iterator i = cands.begin(); i != cands.end(); ++i) {
652 for (NodeSet::iterator j = cluster.begin(); j != cluster.end();) {
653 NodeSet::iterator check = j;
656 cluster.erase(check);
662 std::set<NBNode*> toRemove;
663 for (
NBNode* n : cluster) {
664 for (
NBEdge* edge : n->getOutgoingEdges()) {
665 if (cluster.count(edge->getToNode()) != 0 && edge->getLoadedLength() > maxDist ) {
666 #ifdef DEBUG_JOINJUNCTIONS
668 std::cout <<
"long edge " << edge->getID() <<
" (" << edge->getLoadedLength() <<
", max=" << maxDist <<
")\n";
672 toRemove.insert(edge->getToNode());
676 for (std::set<NBNode*>::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
679 if (cluster.size() < 2) {
691 WRITE_WARNINGF(
"Reducing junction cluster % (%).", origCluster, reason);
701 WRITE_WARNINGF(
"Reducing junction cluster % (%).", origCluster, reason);
712 for (
NBNode* current : cluster) {
716 newComp.insert(current);
717 for (NodeClusters::iterator it_comp = components.begin(); it_comp != components.end();) {
718 NodeClusters::iterator check = it_comp;
720 bool connected =
false;
721 for (
NBNode* k : *check) {
722 if (current->getConnectionTo(k) !=
nullptr || k->getConnectionTo(current) !=
nullptr) {
724 newComp.insert((*check).begin(), (*check).end());
725 it_comp = components.erase(check);
735 components.push_back(newComp);
737 for (NodeClusters::iterator it_comp = components.begin(); it_comp != components.end(); ++it_comp) {
738 if ((*it_comp).size() > 1) {
740 clusters.push_back(*it_comp);
745 return (
int)clusters.size();
751 #ifdef DEBUG_JOINJUNCTIONS
757 bool pruneFringe =
true;
760 while (pruneFringe) {
762 for (NodeSet::iterator j = cluster.begin(); j != cluster.end();) {
763 NodeSet::iterator check = j;
768 double clusterDist = std::numeric_limits<double>::max();
769 bool touchingCluster =
false;
771 NBNode* neighbor = (*it_edge)->getToNode();
772 if (cluster.count(neighbor) != 0) {
773 clusterDist =
MIN2(clusterDist, (*it_edge)->getLoadedLength());
778 NBNode* neighbor = (*it_edge)->getFromNode();
779 if (cluster.count(neighbor) != 0) {
780 clusterDist =
MIN2(clusterDist, (*it_edge)->getLoadedLength());
786 std::set<NBNode*> outsideNeighbors;
787 std::set<NBNode*> clusterNeighbors;
788 const double pedestrianFringeThreshold = 0.3;
790 NBNode* neighbor = e->getFromNode() == n ? e->getToNode() : e->getFromNode();
791 if (cluster.count(neighbor) == 0) {
794 || clusterDist <= pedestrianFringeThreshold
795 || touchingCluster) {
796 outsideNeighbors.insert(neighbor);
799 clusterNeighbors.insert(neighbor);
802 #ifdef DEBUG_JOINJUNCTIONS
804 <<
" clusterDist=" << clusterDist
805 <<
" cd<th=" << (clusterDist <= pedestrianFringeThreshold)
806 <<
" touching=" << touchingCluster
811 if (outsideNeighbors.size() <= 1
812 && clusterNeighbors.size() == 1
814 cluster.erase(check);
816 #ifdef DEBUG_JOINJUNCTIONS
818 std::cout <<
" pruned n=" << n->
getID() <<
"\n";
831 std::map<std::string, double> finalIncomingAngles;
832 std::map<std::string, double> finalOutgoingAngles;
833 for (NodeSet::const_iterator j = cluster.begin(); j != cluster.end(); ++j) {
834 for (EdgeVector::const_iterator it_edge = (*j)->getIncomingEdges().begin(); it_edge != (*j)->getIncomingEdges().end(); ++it_edge) {
841 for (EdgeVector::const_iterator it_edge = (*j)->getOutgoingEdges().begin(); it_edge != (*j)->getOutgoingEdges().end(); ++it_edge) {
850 #ifdef DEBUG_JOINJUNCTIONS
851 for (
NBNode* n : cluster) {
854 <<
"\n inAngles=" <<
joinToString(finalIncomingAngles,
' ',
':')
855 <<
"\n outAngles=" <<
joinToString(finalOutgoingAngles,
' ',
':')
860 if (finalIncomingAngles.size() > 4) {
861 reason =
toString(finalIncomingAngles.size()) +
" incoming edges";
865 const double PARALLEL_INCOMING_THRESHOLD = 10.0;
866 bool foundParallel =
false;
867 for (std::map<std::string, double>::const_iterator j = finalIncomingAngles.begin(); j != finalIncomingAngles.end() && !foundParallel; ++j) {
868 std::map<std::string, double>::const_iterator k = j;
869 for (++k; k != finalIncomingAngles.end() && !foundParallel; ++k) {
870 if (fabs(j->second - k->second) < PARALLEL_INCOMING_THRESHOLD) {
871 reason =
"parallel incoming " + j->first +
"," + k->first;
877 for (std::map<std::string, double>::const_iterator j = finalOutgoingAngles.begin(); j != finalOutgoingAngles.end() && !foundParallel; ++j) {
878 std::map<std::string, double>::const_iterator k = j;
879 for (++k; k != finalOutgoingAngles.end() && !foundParallel; ++k) {
880 if (fabs(j->second - k->second) < PARALLEL_INCOMING_THRESHOLD) {
881 reason =
"parallel outgoing " + j->first +
"," + k->first;
888 for (
auto it = sc.
begin(); it != sc.
end(); it++) {
890 if (edge !=
nullptr && cluster.count(edge->
getFromNode()) != 0 && cluster.count(edge->
getToNode()) != 0) {
891 reason =
"it contains stop '" + it->first +
"'";
897 for (
NBNode* n : cluster) {
898 if (n->isTLControlled()) {
902 const bool hasTLS = numTLS > 0;
904 if (cluster.size() > 2) {
907 NBEdge* maxEdge =
nullptr;
908 for (
NBNode* n1 : cluster) {
909 for (
NBNode* n2 : cluster) {
910 NBEdge* e1 = n1->getConnectionTo(n2);
911 NBEdge* e2 = n2->getConnectionTo(n1);
922 #ifdef DEBUG_JOINJUNCTIONS
923 for (
NBNode* n : cluster) {
925 std::cout <<
"feasible hasTLS=" << hasTLS <<
" maxDist=" << maxDist <<
" maxEdge=" << maxEdge->
getID() <<
"\n";
929 if (!hasTLS && maxDist > 5) {
931 std::vector<NBNode*> toCheck;
932 std::set<NBNode*> visited;
934 bool foundCircle =
false;
935 while (!toCheck.empty()) {
936 NBNode* n = toCheck.back();
945 NBNode* cand = e->getFromNode() == n ? e->getToNode() : e->getFromNode();
946 if (visited.count(cand) == 0 && cluster.count(cand) != 0) {
947 toCheck.push_back(cand);
953 reason =
"not compact (maxEdge=" + maxEdge->
getID() +
" length=" +
toString(maxDist) +
")";
959 if (!hasTLS && cluster.size() >= 2) {
962 int outsideIncoming = 0;
963 int outsideOutgoing = 0;
965 for (
NBNode* n : cluster) {
966 bool foundOutsideIncoming =
false;
968 if (cluster.count(e->getFromNode()) == 0) {
971 foundOutsideIncoming =
true;
976 if (foundOutsideIncoming) {
979 bool foundOutsideOutgoing =
false;
980 for (
NBEdge* e : n->getOutgoingEdges()) {
981 if (cluster.count(e->getToNode()) == 0) {
984 foundOutsideOutgoing =
true;
987 if (foundOutsideOutgoing) {
991 if (entryNodes < 2) {
992 reason =
"only 1 entry node";
996 reason =
"only 1 exit node";
999 if (cluster.size() == 2) {
1000 if (edgesWithin == 1 && outsideIncoming < 3 && outsideOutgoing < 3) {
1001 reason =
"only 1 edge within and no cross-traffic";
1013 assert(circleSize >= 2);
1014 if ((
int)cands.size() == circleSize) {
1015 if (cands.back()->getConnectionTo(cands.front()) !=
nullptr) {
1018 cluster.insert(cands.begin(), cands.end());
1024 if ((
int)cluster.size() <= circleSize || startNodes.size() == 0) {
1028 if (cands.size() == 0) {
1043 singleStart.insert(cands.back());
1046 std::vector<NBNode*> cands2(cands);
1059 double minDist = std::numeric_limits<double>::max();
1060 NBEdge* result =
nullptr;
1061 for (
NBNode* n : startNodes) {
1062 for (
NBEdge* e : n->getOutgoingEdges()) {
1063 NBNode* neigh = e->getToNode();
1064 if (cluster.count(neigh) != 0 && std::find(exclude.begin(), exclude.end(), neigh) == exclude.end()) {
1067 if (dist < minDist) {
1081 for (
NodeSet cluster : clusters) {
1090 assert(cluster.size() > 1);
1093 std::string
id =
"cluster";
1097 NBNode* newNode =
nullptr;
1098 if (predefined !=
nullptr) {
1099 newNode = predefined;
1108 std::string tlID = id;
1109 if (predefined !=
nullptr) {
1111 nodeType = predefined->
getType();
1124 newNode->
reinit(pos, nodeType);
1127 if (!tlc.
insert(tlDef)) {
1130 throw ProcessError(
"Could not allocate tls '" +
id +
"'.");
1135 for (
NBNode* n : cluster) {
1137 allEdges.insert(edges.begin(), edges.end());
1142 for (
NBEdge* e : allEdges) {
1143 if (cluster.count(e->getToNode()) > 0) {
1144 if (cluster.count(e->getFromNode()) > 0) {
1147 clusterIncoming.insert(e);
1151 #ifdef DEBUG_JOINJUNCTIONS
1153 <<
" incoming=" <<
toString(clusterIncoming) <<
"\n"
1154 <<
" inside=" <<
toString(inside) <<
"\n";
1158 std::map<NBEdge*, EdgeSet> reachable;
1159 for (
NBEdge* e : clusterIncoming) {
1163 while (open.size() > 0) {
1164 NBEdge* cur = open.back();
1168 if (cluster.count(cur->
getToNode()) == 0) {
1176 if (seen.count(out) == 0
1177 && allEdges.count(out) != 0
1179 open.push_back(out);
1184 for (
const auto& con : cons) {
1185 if (con.toEdge !=
nullptr
1186 && seen.count(con.toEdge) == 0
1187 && allEdges.count(con.toEdge) != 0) {
1188 open.push_back(con.toEdge);
1194 for (
NBEdge* reached : seen) {
1196 if (inside.count(reached) == 0) {
1197 reachable[e].insert(reached);
1200 #ifdef DEBUG_JOINJUNCTIONS
1201 std::cout <<
" reachable e=" << e->getID() <<
" seen=" <<
toString(seen) <<
" reachable=" <<
toString(reachable[e]) <<
"\n";
1206 for (
NBEdge* e : inside) {
1207 for (
NBEdge* e2 : allEdges) {
1209 e2->replaceInConnections(e, e->getConnections());
1217 for (
NBEdge* e : allEdges) {
1218 std::vector<NBEdge::Connection> conns = e->getConnections();
1219 const bool outgoing = cluster.count(e->getFromNode()) > 0;
1220 NBNode* from = outgoing ? newNode : e->getFromNode();
1221 NBNode* to = outgoing ? e->getToNode() : newNode;
1224 e->
setParameter(
"origFrom", e->getFromNode()->getID());
1226 e->setParameter(
"origTo", e->getToNode()->getID());
1229 e->reinitNodes(from, to);
1232 for (std::vector<NBEdge::Connection>::iterator k = conns.begin(); k != conns.end(); ++k) {
1233 e->addLane2LaneConnection((*k).fromLane, (*k).toEdge, (*k).toLane,
NBEdge::L2L_USER,
false, (*k).mayDefinitelyPass);
1234 if ((*k).fromLane >= 0 && (*k).fromLane < e->getNumLanes() && e->getLaneStruct((*k).fromLane).connectionsDone) {
1245 in->removeFromConnections(out, -1, -1,
true,
false,
true);
1252 for (
NBNode* n : cluster) {
1260 std::set<std::string> ids;
1261 for (
NBNode* n : cluster) {
1262 ids.insert(n->getID());
1273 bool ambiguousType =
false;
1274 for (
NBNode* j : cluster) {
1275 pos.
add(j->getPosition());
1277 if (j->isTLControlled()) {
1280 type = (*j->getControllingTLS().begin())->getType();
1281 }
else if (type != (*j->getControllingTLS().begin())->getType()) {
1282 ambiguousType =
true;
1288 nodeType = otherType;
1289 }
else if (nodeType != otherType) {
1301 pos.
mul(1.0 / cluster.size());
1302 if (ambiguousType) {
1304 WRITE_WARNINGF(
"Ambiguous traffic light type for node cluster '%', setting to '%'.",
id,
toString(type));
1314 bool tooFast =
false;
1316 std::set<NBEdge*> seen;
1319 for (EdgeVector::const_iterator k = edges.begin(); k != edges.end(); ++k) {
1320 if (c.find((*k)->getFromNode()) != c.end() && c.find((*k)->getToNode()) != c.end()) {
1323 if (j->hasIncoming(*k)) {
1325 f += (double)(*k)->getNumLanes() * (*k)->getLaneSpeed(0);
1329 if ((*k)->getLaneSpeed(0) * 3.6 > 79) {
1335 return !tooFast && f >= laneSpeedThreshold && c.size() != 0;
1347 nonPedIncoming.push_back(e);
1350 for (
NBEdge* e : node->getOutgoingEdges()) {
1352 nonPedOutgoing.push_back(e);
1355 if (!node->geometryLike(nonPedIncoming, nonPedOutgoing)) {
1371 if (node->isTLControlled()) {
1372 const std::string tlID = (*node->getControllingTLS().begin())->getID();
1373 if (tlID != node->getID()
1388 const double laneSpeedThreshold = oc.
getFloat(
"tls.guess.threshold");
1389 std::vector<NBNode*> ncontrolled;
1390 if (oc.
isSet(
"tls.unset")) {
1391 std::vector<std::string> notTLControlledNodes = oc.
getStringVector(
"tls.unset");
1392 for (std::vector<std::string>::const_iterator i = notTLControlledNodes.begin(); i != notTLControlledNodes.end(); ++i) {
1395 throw ProcessError(
" The junction '" + *i +
"' to set as not-controlled is not known.");
1398 for (std::set<NBTrafficLightDefinition*>::const_iterator j = tls.begin(); j != tls.end(); ++j) {
1399 (*j)->removeNode(n);
1402 ncontrolled.push_back(n);
1409 if (oc.
exists(
"tls.taz-nodes") && oc.
getBool(
"tls.taz-nodes")) {
1410 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1411 NBNode* cur = (*i).second;
1412 if (cur->
isNearDistrict() && std::find(ncontrolled.begin(), ncontrolled.end(), cur) == ncontrolled.end()) {
1420 if (oc.
exists(
"tls.guess-signals") && oc.
getBool(
"tls.guess-signals")) {
1422 const double signalDist = oc.
getFloat(
"tls.guess-signals.dist");
1423 for (std::map<std::string, NBNode*>::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
1424 NBNode* node = (*i).second;
1426 std::set<NBEdge*> seen;
1427 std::set<std::pair<NBEdge*, double> > check;
1429 double offset = edge->getLength();
1430 edge->setSignalOffset(offset, node);
1432 check.insert(std::make_pair(edge, offset));
1435 while (check.size() > 0) {
1436 NBEdge*
const edge = check.begin()->first;
1437 const double offset = check.begin()->second;
1438 check.erase(check.begin());
1442 if (seen.count(outEdge) == 0) {
1443 const double offset2 = offset + outEdge->getLength();
1444 outEdge->setSignalOffset(offset2, node);
1445 seen.insert(outEdge);
1446 check.insert(std::make_pair(outEdge, offset2));
1454 for (std::map<std::string, NBNode*>::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
1455 NBNode* node = i->second;
1456 if (find(ncontrolled.begin(), ncontrolled.end(), node) != ncontrolled.end()) {
1464 std::vector<NBNode*> signals;
1466 for (EdgeVector::const_iterator it_i = incoming.begin(); it_i != incoming.end(); ++it_i) {
1467 const NBEdge* inEdge = *it_i;
1475 if (signal !=
nullptr) {
1477 signals.push_back(signal);
1482 for (EdgeVector::const_iterator it_i = outgoing.begin(); it_i != outgoing.end(); ++it_i) {
1483 const NBEdge* outEdge = *it_i;
1487 signals.push_back(cand);
1491 for (std::vector<NBNode*>::iterator j = signals.begin(); j != signals.end(); ++j) {
1494 for (std::set<NBTrafficLightDefinition*>::iterator k = tls.begin(); k != tls.end(); ++k) {
1501 if (!tlc.
insert(tlDef)) {
1513 if (oc.
getBool(
"tls.guess.joining")) {
1518 for (NodeClusters::iterator i = cands.begin(); i != cands.end();) {
1522 for (NodeSet::iterator j = c.begin(); j != c.end();) {
1523 if ((*j)->isTLControlled() || std::find(ncontrolled.begin(), ncontrolled.end(), *j) != ncontrolled.end()) {
1539 for (NodeClusters::iterator i = cands.begin(); i != cands.end(); ++i) {
1540 std::vector<NBNode*> nodes;
1541 for (NodeSet::iterator j = (*i).begin(); j != (*i).end(); j++) {
1542 nodes.push_back(*j);
1544 std::string
id =
"joinedG_" +
toString(index++);
1546 if (!tlc.
insert(tlDef)) {
1556 if (oc.
getBool(
"tls.guess")) {
1557 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1558 NBNode* cur = (*i).second;
1564 if (find(ncontrolled.begin(), ncontrolled.end(), cur) != ncontrolled.end()) {
1584 for (NodeSet::iterator j = c.begin(); j != c.end();) {
1585 if (!(*j)->isTLControlled()) {
1597 std::string
id =
"joined";
1602 std::set<NBTrafficLightDefinition*> tls = j->getControllingTLS();
1603 j->removeTrafficLights();
1604 for (std::set<NBTrafficLightDefinition*>::iterator k = tls.begin(); k != tls.end(); ++k) {
1608 std::vector<NBNode*> nodes;
1617 if (!tlc.
insert(tlDef)) {
1634 if (!tlc.
insert(tlDef)) {
1636 WRITE_WARNINGF(
"Building a tl-logic for junction '%' twice is not possible.",
id);
1646 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1647 (*i).second->computeLanes2Lanes();
1655 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1656 (*i).second->computeLogic(ec);
1663 std::set<NBNode*> roundaboutNodes;
1664 const bool checkLaneFoesAll = oc.
getBool(
"check-lane-foes.all");
1665 const bool checkLaneFoesRoundabout = !checkLaneFoesAll && oc.
getBool(
"check-lane-foes.roundabout");
1666 if (checkLaneFoesRoundabout) {
1668 for (std::set<EdgeSet>::const_iterator i = roundabouts.begin(); i != roundabouts.end(); ++i) {
1669 for (EdgeSet::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
1670 roundaboutNodes.insert((*j)->getToNode());
1674 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1675 const bool checkLaneFoes = checkLaneFoesAll || (checkLaneFoesRoundabout && roundaboutNodes.count((*i).second) > 0);
1676 (*i).second->computeLogic2(checkLaneFoes);
1683 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1684 delete ((*i).second);
1697 std::string freeID =
"SUMOGenerated" + toString<int>(counter);
1699 while (
retrieve(freeID) !=
nullptr) {
1702 freeID =
"SUMOGenerated" + toString<int>(counter);
1710 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1711 (*i).second->computeNodeShape(mismatchThreshold);
1718 int numUnregulatedJunctions = 0;
1719 int numDeadEndJunctions = 0;
1720 int numTrafficLightJunctions = 0;
1721 int numPriorityJunctions = 0;
1722 int numRightBeforeLeftJunctions = 0;
1723 int numAllWayStopJunctions = 0;
1724 int numZipperJunctions = 0;
1725 int numDistrictJunctions = 0;
1726 int numRailCrossing = 0;
1727 int numRailSignals = 0;
1728 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1729 switch ((*i).second->getType()) {
1731 ++numUnregulatedJunctions;
1734 ++numDeadEndJunctions;
1739 ++numTrafficLightJunctions;
1743 ++numPriorityJunctions;
1746 ++numRightBeforeLeftJunctions;
1749 ++numAllWayStopJunctions;
1752 ++numZipperJunctions;
1755 ++numDistrictJunctions;
1772 if (numDeadEndJunctions > 0) {
1777 if (numTrafficLightJunctions > 0) {
1780 if (numAllWayStopJunctions > 0) {
1783 if (numZipperJunctions > 0) {
1786 if (numRailCrossing > 0) {
1789 if (numRailSignals > 0) {
1792 if (numDistrictJunctions > 0) {
1798 std::vector<std::string>
1800 std::vector<std::string> ret;
1801 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
1802 ret.push_back((*i).first);
1810 if (
myNodes.count(newID) != 0) {
1811 throw ProcessError(
"Attempt to rename node using existing id '" + newID +
"'");
1821 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
1822 NBNode* node = i->second;
1826 if (geometryLike && (*tldefs.begin())->getNodes().size() > 1) {
1833 for (EdgeVector::const_iterator it_o = outgoing.begin(); it_o != outgoing.end(); ++it_o) {
1834 (*it_o)->setSignalOffset((*it_o)->getLength(),
nullptr);
1837 for (std::set<NBTrafficLightDefinition*>::const_iterator it = tldefs.begin(); it != tldefs.end(); ++it) {
1852 NBNode* node = item.second;
1863 std::set<std::string> reserve;
1867 avoid.insert(avoid.end(), reserve.begin(), reserve.end());
1871 for (NodeCont::iterator it =
myNodes.begin(); it !=
myNodes.end(); it++) {
1876 toChange.insert(it->second);
1879 if (reservedIDs && reserve.count(it->first) > 0) {
1880 toChange.insert(it->second);
1884 for (
NBNode* node : toChange) {
1889 node->setID(idSupplier.
getNext());
1890 myNodes[node->getID()] = node;
1892 if (prefix.empty()) {
1893 return (
int)toChange.size();
1898 for (
auto item : oldNodes) {
1900 rename(item.second, prefix + item.first);