79 NodeCont::iterator i =
myNodes.find(
id);
85 const float pos[2] = {(float)position.
x(), (float)position.
y()};
93 std::string
id = node->
getID();
94 NodeCont::iterator i =
myNodes.find(
id);
107 NodeCont::const_iterator i =
myNodes.find(
id);
118 const float cmin[2] = {(float)(position.
x() - extOffset), (
float)(position.
y() - extOffset)};
119 const float cmax[2] = {(float)(position.
x() + extOffset), (
float)(position.
y() + extOffset)};
120 std::set<std::string> into;
123 for (std::set<std::string>::const_iterator i = into.begin(); i != into.end(); i++) {
167 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
168 no += (*i).second->removeSelfLoops(dc, ec, tc);
179 const double distanceThreshold = 7.;
180 const double lengthThreshold = 0.10;
182 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
184 std::map<NBNode*, EdgeVector> connectionCount;
185 const EdgeVector& outgoing = (*i).second->getOutgoingEdges();
186 for (EdgeVector::const_iterator j = outgoing.begin(); j != outgoing.end(); j++) {
187 connectionCount[(*j)->getToNode()].push_back(*j);
190 std::map<NBNode*, EdgeVector>::iterator k;
191 for (k = connectionCount.begin(); k != connectionCount.end(); k++) {
193 if ((*k).second.size() < 2) {
199 const NBEdge*
const first = ev.front();
200 EdgeVector::const_iterator jci;
201 for (jci = ev.begin() + 1; jci != ev.end(); ++jci) {
204 (relativeLengthDifference > lengthThreshold) ||
205 (fabs(first->
getSpeed() - (*jci)->getSpeed()) >= 0.01) ||
213 if (jci == ev.end()) {
226 const std::vector<std::string>& edgeNames = ec.
getAllNames();
227 for (std::vector<std::string>::const_iterator it = edgeNames.begin(); it != edgeNames.end(); ++it) {
236 if (outgoingEdges.size() != 1) {
241 if (incomingEdges.size() > 1) {
244 }
else if (incomingEdges.size() == 1) {
245 NBNode* fromNodeOfIncomingEdge = incomingEdges[0]->getFromNode();
246 NBNode* toNodeOfOutgoingEdge = outgoingEdges[0]->getToNode();
247 if (fromNodeOfIncomingEdge != toNodeOfOutgoingEdge) {
255 bool hasJunction =
false;
259 std::set<NBNode*> adjacentNodes;
267 adjacentNodes.clear();
268 for (EdgeVector::const_iterator itOfOutgoings = outgoingEdgesOfToNode.begin(); itOfOutgoings != outgoingEdgesOfToNode.end(); ++itOfOutgoings) {
269 if ((*itOfOutgoings)->getToNode() != from
270 && (*itOfOutgoings)->getToNode() != to
274 adjacentNodes.insert((*itOfOutgoings)->getToNode());
276 for (EdgeVector::const_iterator itOfIncomings = incomingEdgesOfToNode.begin(); itOfIncomings != incomingEdgesOfToNode.end(); ++itOfIncomings) {
277 adjacentNodes.insert((*itOfIncomings)->getFromNode());
279 adjacentNodes.erase(to);
280 if (adjacentNodes.size() > 2) {
283 }
while (!hasJunction && eOld != e);
285 edgeCounter += int(road.size());
286 std::string warningString =
"Removed a road without junctions: ";
287 for (EdgeVector::iterator roadIt = road.begin(); roadIt != road.end(); ++roadIt) {
288 if (roadIt == road.begin()) {
289 warningString += (*roadIt)->
getID();
291 warningString +=
", " + (*roadIt)->getID();
294 NBNode* fromNode = (*roadIt)->getFromNode();
295 NBNode* toNode = (*roadIt)->getToNode();
296 ec.
erase(dc, *roadIt);
310 WRITE_WARNING(
"Detected isolated roads. Use the option --remove-edges.isolated to get a list of all affected edges.");
318 bool removeGeometryNodes) {
320 std::set<std::string> edges2keep;
321 if (removeGeometryNodes) {
323 if (oc.
isSet(
"geometry.remove.keep-edges.input-file")) {
326 if (oc.
isSet(
"geometry.remove.keep-edges.explicit")) {
327 const std::vector<std::string> edges = oc.
getStringVector(
"geometry.remove.keep-edges.explicit");
328 edges2keep.insert(edges.begin(), edges.end());
332 std::vector<NBNode*> toRemove;
333 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
334 NBNode* current = (*i).second;
336 std::vector<std::pair<NBEdge*, NBEdge*> > toJoin;
343 if (removeGeometryNodes &&
mySplit.count(current) == 0) {
351 for (EdgeVector::const_iterator it_edge = current->
getEdges().begin(); it_edge != current->
getEdges().end(); ++it_edge) {
352 if (edges2keep.find((*it_edge)->getID()) != edges2keep.end()) {
366 for (std::vector<std::pair<NBEdge*, NBEdge*> >::iterator j = toJoin.begin(); j != toJoin.end(); j++) {
368 NBEdge* continuation = (*j).second;
369 begin->
append(continuation);
372 ec.
extract(dc, continuation,
true);
374 toRemove.push_back(current);
378 for (std::vector<NBNode*>::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
387 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
388 (*i).second->avoidOverlap();
395 std::set<NBNode*> visited;
396 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
397 std::vector<NodeAndDist> toProc;
398 if (visited.find((*i).second) != visited.end()) {
401 toProc.push_back(std::make_pair((*i).second, 0));
403 while (!toProc.empty()) {
405 NBNode* n = nodeAndDist.first;
406 double dist = nodeAndDist.second;
408 if (visited.find(n) != visited.end()) {
414 for (EdgeVector::const_iterator j = edges.begin(); j != edges.end(); ++j) {
425 if (visited.find(s) != visited.end()) {
432 toProc.push_back(std::make_pair(s, 0));
447 for (std::vector<std::string>::const_iterator it = ids.begin(); it != ids.end(); it++) {
451 WRITE_WARNING(
"Ignoring join exclusion for junction '" + *it +
"' since it already occured in a list of nodes to be joined");
452 }
else if (check &&
retrieve(*it) == 0) {
453 WRITE_WARNING(
"Ignoring join exclusion for unknown junction '" + *it +
"'");
464 for (std::set<std::string>::const_iterator it = cluster.begin(); it != cluster.end(); it++) {
466 WRITE_WARNING(
"Ignoring join-cluster because junction '" + *it +
"' was already excluded from joining");
468 }
else if (
myJoined.count(*it) > 0) {
469 WRITE_WARNING(
"Ignoring join-cluster because junction '" + *it +
"' already occured in another join-cluster");
484 std::set<NBNode*> cluster;
485 for (std::set<std::string>::iterator it_id = it->begin(); it_id != it->end(); it_id++) {
488 WRITE_WARNING(
"Ignoring unknown junction '" + *it_id +
"' while joining");
490 cluster.insert(node);
493 if (cluster.size() > 1) {
494 clusters.push_back(cluster);
499 return (
int)clusters.size();
508 for (NodeClusters::iterator i = cands.begin(); i != cands.end(); ++i) {
509 std::set<NBNode*> cluster = (*i);
511 for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end();) {
512 std::set<NBNode*>::iterator check = j;
515 cluster.erase(check);
519 bool pruneFringe =
true;
520 while (pruneFringe) {
522 for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end();) {
523 std::set<NBNode*>::iterator check = j;
530 NBNode* neighbor = (*it_edge)->getToNode();
531 if (cluster.count(neighbor) != 0) {
532 clusterDist =
MIN2(clusterDist, (*it_edge)->getLoadedLength());
536 NBNode* neighbor = (*it_edge)->getFromNode();
537 if (cluster.count(neighbor) != 0) {
538 clusterDist =
MIN2(clusterDist, (*it_edge)->getLoadedLength());
543 std::set<NBNode*> neighbors;
544 std::set<NBNode*> clusterNeigbors;
545 const double pedestrianFringeThreshold = 1.0;
547 NBNode* neighbor = (*it_edge)->getToNode();
548 if (cluster.count(neighbor) == 0) {
549 if ((*it_edge)->getPermissions() !=
SVC_PEDESTRIAN || clusterDist < pedestrianFringeThreshold) {
550 neighbors.insert(neighbor);
553 clusterNeigbors.insert(neighbor);
557 NBNode* neighbor = (*it_edge)->getFromNode();
558 if (cluster.count(neighbor) == 0) {
559 if ((*it_edge)->getPermissions() !=
SVC_PEDESTRIAN || clusterDist < pedestrianFringeThreshold) {
560 neighbors.insert(neighbor);
563 clusterNeigbors.insert(neighbor);
566 if (neighbors.size() <= 1 && clusterNeigbors.size() == 1) {
567 cluster.erase(check);
573 std::set<NBNode*> toRemove;
574 for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end(); ++j) {
577 for (EdgeVector::const_iterator it_edge = edges.begin(); it_edge != edges.end(); ++it_edge) {
586 for (std::set<NBNode*>::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
589 if (cluster.size() < 2) {
594 std::map<std::string, double> finalIncomingAngles;
595 std::map<std::string, double> finalOutgoingAngles;
596 std::vector<std::string> nodeIDs;
597 for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); ++j) {
598 nodeIDs.push_back((*j)->getID());
599 for (EdgeVector::const_iterator it_edge = (*j)->getIncomingEdges().begin(); it_edge != (*j)->getIncomingEdges().end(); ++it_edge) {
606 for (EdgeVector::const_iterator it_edge = (*j)->getOutgoingEdges().begin(); it_edge != (*j)->getOutgoingEdges().end(); ++it_edge) {
615 if (finalIncomingAngles.size() > 4) {
616 std::sort(nodeIDs.begin(), nodeIDs.end());
621 const double PARALLEL_INCOMING_THRESHOLD = 10.0;
622 bool foundParallel =
false;
623 for (std::map<std::string, double>::const_iterator j = finalIncomingAngles.begin(); j != finalIncomingAngles.end() && !foundParallel; ++j) {
624 std::map<std::string, double>::const_iterator k = j;
625 for (++k; k != finalIncomingAngles.end() && !foundParallel; ++k) {
626 if (fabs(j->second - k->second) < PARALLEL_INCOMING_THRESHOLD) {
628 + j->first +
"," + k->first +
")");
629 foundParallel =
true;
634 for (std::map<std::string, double>::const_iterator j = finalOutgoingAngles.begin(); j != finalOutgoingAngles.end() && !foundParallel; ++j) {
635 std::map<std::string, double>::const_iterator k = j;
636 for (++k; k != finalOutgoingAngles.end() && !foundParallel; ++k) {
637 if (fabs(j->second - k->second) < PARALLEL_INCOMING_THRESHOLD) {
639 + j->first +
"," + k->first +
")");
640 foundParallel =
true;
650 for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end(); ++j) {
652 std::set<NBNode*> newComp;
655 newComp.insert(current);
656 for (NodeClusters::iterator it_comp = components.begin(); it_comp != components.end();) {
657 NodeClusters::iterator check = it_comp;
659 bool connected =
false;
660 for (std::set<NBNode*>::iterator k = (*check).begin(); k != (*check).end(); ++k) {
661 if (current->
getConnectionTo(*k) != 0 || (*k)->getConnectionTo(current) != 0) {
663 newComp.insert((*check).begin(), (*check).end());
664 it_comp = components.erase(check);
674 components.push_back(newComp);
676 for (NodeClusters::iterator it_comp = components.begin(); it_comp != components.end(); ++it_comp) {
677 if ((*it_comp).size() > 1) {
679 clusters.push_back(*it_comp);
684 return (
int)clusters.size();
691 for (NodeClusters::iterator i = clusters.begin(); i != clusters.end(); ++i) {
692 std::set<NBNode*> cluster = *i;
693 assert(cluster.size() > 1);
710 throw ProcessError(
"Could not allocate tls '" +
id +
"'.");
714 std::set<NBEdge*> allEdges;
715 for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); ++j) {
717 allEdges.insert(edges.begin(), edges.end());
721 for (std::set<NBEdge*>::iterator j = allEdges.begin(); j != allEdges.end();) {
725 if (cluster.count(from) > 0 && cluster.count(to) > 0) {
726 for (std::set<NBEdge*>::iterator l = allEdges.begin(); l != allEdges.end(); ++l) {
739 for (std::set<NBEdge*>::iterator j = allEdges.begin(); j != allEdges.end(); ++j) {
742 const bool outgoing = cluster.count(e->
getFromNode()) > 0;
748 for (std::vector<NBEdge::Connection>::iterator k = conns.begin(); k != conns.end(); ++k) {
758 for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); ++j) {
767 std::set<std::string> ids;
768 for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); j++) {
769 ids.insert((*j)->getID());
780 std::vector<std::string> member_ids;
781 bool ambiguousType =
false;
782 for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); j++) {
783 member_ids.push_back((*j)->getID());
784 pos.
add((*j)->getPosition());
786 if ((*j)->isTLControlled()) {
789 type = (*(*j)->getControllingTLS().begin())->getType();
790 }
else if (type != (*(*j)->getControllingTLS().begin())->getType()) {
791 ambiguousType =
true;
796 pos.
mul(1.0 / cluster.size());
798 sort(member_ids.begin(), member_ids.end());
799 for (std::vector<std::string>::iterator j = member_ids.begin(); j != member_ids.end(); j++) {
800 id =
id +
"_" + (*j);
804 WRITE_WARNING(
"Ambiguous traffic light type for node cluster '" +
id +
"' set to '" +
toString(type) +
"'");
814 bool tooFast =
false;
816 std::set<NBEdge*> seen;
817 for (std::set<NBNode*>::const_iterator j = c.begin(); j != c.end(); ++j) {
819 for (EdgeVector::const_iterator k = edges.begin(); k != edges.end(); ++k) {
820 if (c.find((*k)->getFromNode()) != c.end() && c.find((*k)->getToNode()) != c.end()) {
823 if ((*j)->hasIncoming(*k)) {
825 f += (double)(*k)->getNumLanes() * (*k)->getLaneSpeed(0);
829 if ((*k)->getLaneSpeed(0) * 3.6 > 79) {
834 return !tooFast && f >= 150. / 3.6 && c.size() != 0;
841 std::vector<NBNode*> ncontrolled;
842 if (oc.
isSet(
"tls.unset")) {
843 std::vector<std::string> notTLControlledNodes = oc.
getStringVector(
"tls.unset");
844 for (std::vector<std::string>::const_iterator i = notTLControlledNodes.begin(); i != notTLControlledNodes.end(); ++i) {
847 throw ProcessError(
" The junction '" + *i +
"' to set as not-controlled is not known.");
850 for (std::set<NBTrafficLightDefinition*>::const_iterator j = tls.begin(); j != tls.end(); ++j) {
854 ncontrolled.push_back(n);
861 if (oc.
exists(
"tls.taz-nodes") && oc.
getBool(
"tls.taz-nodes")) {
862 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
863 NBNode* cur = (*i).second;
864 if (cur->
isNearDistrict() && find(ncontrolled.begin(), ncontrolled.end(), cur) == ncontrolled.end()) {
872 if (oc.
exists(
"tls.guess-signals") && oc.
getBool(
"tls.guess-signals")) {
874 const double signalDist = oc.
getFloat(
"tls.guess-signals.dist");
875 for (std::map<std::string, NBNode*>::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
876 NBNode* node = (*i).second;
879 for (EdgeVector::const_iterator it_o = outgoing.begin(); it_o != outgoing.end(); ++it_o) {
880 (*it_o)->setSignalOffset((*it_o)->getLength());
885 for (std::map<std::string, NBNode*>::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
887 if (find(ncontrolled.begin(), ncontrolled.end(), node) != ncontrolled.end()) {
893 std::vector<NBNode*> signals;
895 for (EdgeVector::const_iterator it_i = incoming.begin(); it_i != incoming.end(); ++it_i) {
896 const NBEdge* inEdge = *it_i;
907 for (EdgeVector::const_iterator it_i = outgoing.begin(); it_i != outgoing.end(); ++it_i) {
908 const NBEdge* outEdge = *it_i;
911 signals.push_back(cand);
915 for (std::vector<NBNode*>::iterator j = signals.begin(); j != signals.end(); ++j) {
918 for (std::set<NBTrafficLightDefinition*>::iterator k = tls.begin(); k != tls.end(); ++k) {
936 if (!oc.
getBool(
"tls.guess")) {
943 std::vector<std::set<NBNode*> > cands;
946 for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end();) {
947 std::set<NBNode*>& c = (*i);
950 for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) {
951 if ((*j)->isTLControlled() || find(ncontrolled.begin(), ncontrolled.end(), *j) != ncontrolled.end()) {
966 for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) {
967 std::vector<NBNode*> nodes;
968 for (std::set<NBNode*>::iterator j = (*i).begin(); j != (*i).end(); j++) {
971 std::string
id =
"joinedG_" +
toString(index++);
983 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
984 NBNode* cur = (*i).second;
990 if (find(ncontrolled.begin(), ncontrolled.end(), cur) != ncontrolled.end()) {
1005 std::vector<std::set<NBNode*> > cands;
1008 for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) {
1009 std::set<NBNode*>& c = (*i);
1010 for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) {
1011 if (!(*j)->isTLControlled()) {
1023 std::string dummyId;
1026 for (std::set<NBNode*>::iterator j = c.begin(); j != c.end(); ++j) {
1027 std::set<NBTrafficLightDefinition*> tls = (*j)->getControllingTLS();
1028 (*j)->removeTrafficLights();
1029 for (std::set<NBTrafficLightDefinition*>::iterator k = tls.begin(); k != tls.end(); ++k) {
1033 std::string
id =
"joinedS_" +
toString(index++);
1034 std::vector<NBNode*> nodes;
1035 for (std::set<NBNode*>::iterator j = c.begin(); j != c.end(); j++) {
1036 nodes.push_back(*j);
1039 if (!tlc.
insert(tlDef)) {
1056 if (!tlc.
insert(tlDef)) {
1058 WRITE_WARNING(
"Building a tl-logic for junction '" +
id +
"' twice is not possible.");
1068 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1069 (*i).second->computeLanes2Lanes();
1077 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1078 (*i).second->computeLogic(ec, oc);
1085 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1086 delete((*i).second);
1099 std::string freeID =
"SUMOGenerated" + toString<int>(counter);
1104 freeID =
"SUMOGenerated" + toString<int>(counter);
1112 for (NodeCont::iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1113 (*i).second->computeNodeShape(mismatchThreshold);
1120 int numUnregulatedJunctions = 0;
1121 int numDeadEndJunctions = 0;
1122 int numPriorityJunctions = 0;
1123 int numRightBeforeLeftJunctions = 0;
1124 int numAllWayStopJunctions = 0;
1125 int numZipperJunctions = 0;
1126 int numRailSignals = 0;
1127 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); i++) {
1128 switch ((*i).second->getType()) {
1131 ++numUnregulatedJunctions;
1134 ++numDeadEndJunctions;
1141 ++numPriorityJunctions;
1144 ++numRightBeforeLeftJunctions;
1147 ++numAllWayStopJunctions;
1150 ++numZipperJunctions;
1153 ++numRightBeforeLeftJunctions;
1166 if (numDeadEndJunctions > 0) {
1171 if (numAllWayStopJunctions > 0) {
1174 if (numZipperJunctions > 0) {
1177 if (numRailSignals > 0) {
1183 std::vector<std::string>
1185 std::vector<std::string> ret;
1186 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
1187 ret.push_back((*i).first);
1195 if (
myNodes.count(newID) != 0) {
1196 throw ProcessError(
"Attempt to rename node using existing id '" + newID +
"'");
1206 for (NodeCont::const_iterator i =
myNodes.begin(); i !=
myNodes.end(); ++i) {
1207 NBNode* node = i->second;
1214 for (EdgeVector::const_iterator it_o = outgoing.begin(); it_o != outgoing.end(); ++it_o) {
1215 (*it_o)->setSignalOffset((*it_o)->getLength());
1218 for (std::set<NBTrafficLightDefinition*>::const_iterator it = tldefs.begin(); it != tldefs.end(); ++it) {
1232 std::set<std::string> reserve;
1235 avoid.insert(avoid.end(), reserve.begin(), reserve.end());
1238 std::set<NBNode*, Named::ComparatorIdLess> toChange;
1239 for (NodeCont::iterator it =
myNodes.begin(); it !=
myNodes.end(); it++) {
1244 toChange.insert(it->second);
1247 if (reservedIDs && reserve.count(it->first) > 0) {
1248 toChange.insert(it->second);
1251 for (std::set<NBNode*, Named::ComparatorIdLess>::iterator it = toChange.begin(); it != toChange.end(); ++it) {
1257 return (
int)toChange.size();
std::string getFreeID()
generates a new node ID
std::set< std::string > myJoinExclusions
set of node ids which should not be joined
NodeCont myNodes
The map of names to nodes.
void Insert(const float a_min[2], const float a_max[2], Named *const &a_data)
Insert entry.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
void joinSimilarEdges(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins edges connecting the same nodes.
double getLength() const
Returns the computed length of the edge.
void removeSelfLoops(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes self-loop edges (edges where the source and the destination node are the same) ...
void registerJoinedCluster(const std::set< NBNode *> &cluster)
gets all joined clusters (see doc for myClusters2Join)
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
void addJoinExclusion(const std::vector< std::string > &ids, bool check=false)
static void loadPrefixedIDsFomFile(const std::string &file, const std::string prefix, std::set< std::string > &into)
Add prefixed ids defined in file.
void add(const Position &pos)
Adds the given position to this one.
int removeUnwishedNodes(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc, bool removeGeometryNodes)
Removes "unwished" nodes.
A container for traffic light definitions and built programs.
void joinTLS(NBTrafficLightLogicCont &tlc, double maxdist)
Builds clusters of tls-controlled junctions and joins the control if possible.
void reinit(const Position &position, SumoXMLNodeType type, bool updateEdgeGeometries=false)
Resets initial values.
double getSignalOffset() const
Returns the offset of a traffic signal from the end of this edge.
std::vector< std::set< std::string > > myJoinedClusters
sets of node ids which were joined
double y() const
Returns the y-position.
The representation of a single edge during network building.
void reinitNodes(NBNode *from, NBNode *to)
Resets nodes but keeps all other values the same (used when joining)
static const double UNSPECIFIED_SIGNAL_OFFSET
unspecified signal offset
double x() const
Returns the x-position.
A container for districts.
The base class for traffic light logic definitions.
int joinLoadedClusters(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins loaded junction clusters (see NIXMLNodesHandler)
NamedRTree myRTree
node positions for faster lookup
static long long int _str2long(const std::string &sData)
converts a string into the long value described by it by calling the char-type converter, which
void guessTLs(OptionsCont &oc, NBTrafficLightLogicCont &tlc)
Guesses which junctions or junction clusters shall be controlled by tls.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
bool connectionsDone
Whether connection information for this lane is already completed.
void avoidOverlap()
fix overlap
const std::string & getID() const
Returns the id.
Lane & getLaneStruct(int lane)
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.
void removeTrafficLight(NBTrafficLightDefinition *tlDef)
Removes the given traffic light from this node.
void extract(NBTrafficLightDefinition *definition)
Extracts a traffic light definition from myDefinitions but keeps it in myExtracted for eventual * del...
#define UNUSED_PARAMETER(x)
#define WRITE_WARNING(msg)
static OptionsCont & getOptions()
Retrieves the options.
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
The edge has been loaded, nothing is computed yet.
void computeLogics(const NBEdgeCont &ec, OptionsCont &oc)
build the list of outgoing edges and lanes
A class representing a single district.
NBEdge * getConnectionTo(NBNode *n) const
get connection to certain node
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
void Remove(const float a_min[2], const float a_max[2], Named *const &a_data)
Remove entry.
bool isTLControlled() const
Returns whether this node is controlled by any tls.
bool shouldBeTLSControlled(const std::set< NBNode *> &c) const
Returns whethe the given node cluster should be controlled by a tls.
std::string getNext()
Returns the next id.
void computeLanes2Lanes()
divides the incoming lanes on outgoing lanes
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
int getNumLanes() const
Returns the number of lanes.
A point in 2D or 3D with translation and scaling methods.
std::pair< NBNode *, double > NodeAndDist
void generateNodeClusters(double maxDist, NodeClusters &into) const
Builds node clusters.
T get(const std::string &str) const
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node) ...
bool exists(const std::string &name) const
Returns the information whether the named option is known.
void removeTrafficLights()
Removes all references to traffic lights that control this tls.
bool geometryLike() const
whether this is structurally similar to a geometry node
Storage for edges, including some functionality operating on multiple edges.
std::vector< std::string > getStringVector(const std::string &name) const
Returns the list of string-vector-value of the named option (only for Option_String) ...
void computeNodeShapes(double mismatchThreshold=-1)
Compute the junction shape for this node.
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
void joinNodeClusters(NodeClusters clusters, NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
joins the given node clusters
std::set< NBNode * > myExtractedNodes
The extracted nodes which are kept for reference.
int joinJunctions(double maxDist, NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins junctions that are very close together.
The connection was given by the user.
void analyzeCluster(std::set< NBNode *> cluster, std::string &id, Position &pos, bool &hasTLS, TrafficLightType &type)
int Search(const float a_min[2], const float a_max[2], const Named::StoringVisitor &c) const
Find all within search rectangle.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
void rename(NBNode *node, const std::string &newID)
Renames the node. Throws exception if newID already exists.
bool hasIncoming(const NBEdge *const e) const
Returns whether the given edge ends at this node.
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
double getSpeed() const
Returns the speed allowed on this edge.
void setAsTLControlled(NBNode *node, NBTrafficLightLogicCont &tlc, TrafficLightType type, std::string id="")
Sets the given node as being controlled by a tls.
Allows to store the object; used as context while traveling the rtree in TraCI.
std::vector< std::string > getAllNames() const
get all node names
void setID(const std::string &newID)
resets the id
void addCluster2Join(std::set< std::string > cluster)
add ids of nodes which shall be joined into a single node
int remapIDs(bool numericaIDs, bool reservedIDs)
remap node IDs accoring to options –numerical-ids and –reserved-ids
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
const std::vector< Connection > & getConnections() const
Returns the connections.
void replaceIncoming(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurences of the first edge within the list of incoming by the second Connections are remap...
bool isNearDistrict() const
if node is near district
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node) ...
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
void removeIsolatedRoads(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes sequences of edges that are not connected with a junction. Simple roads without junctions som...
std::set< std::string > myJoined
ids found in loaded join clusters used for error checking
A storage for options typed value containers)
std::vector< std::set< NBNode * > > NodeClusters
Definition of a node cluster container.
std::string joinToStringSorting(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
bool insert(const std::string &id, const Position &position, NBDistrict *district=0)
Inserts a node into the map.
void clear()
deletes all nodes
void append(NBEdge *continuation)
append another edge
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, bool keepClear=true, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE)
Adds a connection between the specified this edge's lane and an approached one.
std::vector< std::set< std::string > > myClusters2Join
loaded sets of node ids to join (cleared after use)
void discardTrafficLights(NBTrafficLightLogicCont &tlc, bool geometryLike, bool guessSignals)
void declareConnectionsAsLoaded(EdgeBuildingStep step=LANES2LANES_USER)
declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has ...
const Position & getPosition() const
Represents a single node (junction) during network building.
bool removeFully(const std::string id)
Removes a logic definition (and all programs) from the dictionary.
bool insert(NBTrafficLightDefinition *logic, bool forceInsert=false)
Adds a logic definition to the dictionary.
std::set< const NBNode * > mySplit
nodes that were created when splitting an edge
void printBuiltNodesStatistics() const
Prints statistics about built nodes.
NBNode * getFromNode() const
Returns the origin node of the edge.
void mul(double val)
Multiplies both positions with the given value.
void replaceRemoved(NBEdge *removed, int removedLane, NBEdge *by, int byLane)
Replaces occurences of the removed edge/lane in all definitions by the given edge.
A traffic light logics which must be computed (only nodes/edges are given)
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
bool extract(NBNode *node, bool remember=false)
Removes the given node but does not delete it.
#define WRITE_MESSAGE(msg)
bool erase(NBNode *node)
Removes the given node, deleting it.
bool checkIsRemovable() const
check if node is removable
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
std::vector< std::pair< NBEdge *, NBEdge * > > getEdgesToJoin() const
get edges to join
bool isNearEnough2BeJoined2(NBEdge *e, double threshold) const
Check if edge is near enought to be joined to another edge.
NBNode * getToNode() const
Returns the destination node of the edge.