void NBNodeCont::joinTLS(NBTrafficLightLogicCont& tlc, SUMOReal maxdist) { std::vector<std::set<NBNode*> > cands; generateNodeClusters(maxdist, cands); unsigned int index = 0; for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) { std::set<NBNode*>& c = (*i); for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) { if (!(*j)->isTLControlled()) { c.erase(j++); } else { ++j; } } if (c.size() < 2) { continue; } // figure out type of the joined TLS Position dummyPos; bool dummySetTL; std::string dummyId; TrafficLightType type; analyzeCluster(c, dummyId, dummyPos, dummySetTL, type); for (std::set<NBNode*>::iterator j = c.begin(); j != c.end(); ++j) { std::set<NBTrafficLightDefinition*> tls = (*j)->getControllingTLS(); (*j)->removeTrafficLights(); for (std::set<NBTrafficLightDefinition*>::iterator k = tls.begin(); k != tls.end(); ++k) { tlc.removeFully((*j)->getID()); } } std::string id = "joinedS_" + toString(index++); std::vector<NBNode*> nodes; for (std::set<NBNode*>::iterator j = c.begin(); j != c.end(); j++) { nodes.push_back(*j); } NBTrafficLightDefinition* tlDef = new NBOwnTLDef(id, nodes, 0, type); if (!tlc.insert(tlDef)) { // actually, nothing should fail here WRITE_WARNING("Could not build a joined tls."); delete tlDef; return; } } }
void NBNodeCont::guessTLs(OptionsCont& oc, NBTrafficLightLogicCont& tlc) { // build list of definitely not tls-controlled junctions std::vector<NBNode*> ncontrolled; if (oc.isSet("tls.unset")) { std::vector<std::string> notTLControlledNodes = oc.getStringVector("tls.unset"); for (std::vector<std::string>::const_iterator i = notTLControlledNodes.begin(); i != notTLControlledNodes.end(); ++i) { NBNode* n = NBNodeCont::retrieve(*i); if (n == 0) { throw ProcessError(" The node '" + *i + "' to set as not-controlled is not known."); } std::set<NBTrafficLightDefinition*> tls = n->getControllingTLS(); for (std::set<NBTrafficLightDefinition*>::const_iterator j = tls.begin(); j != tls.end(); ++j) { (*j)->removeNode(n); } n->removeTrafficLights(); ncontrolled.push_back(n); } } TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(OptionsCont::getOptions().getString("tls.default-type")); // loop#1 checking whether the node shall be tls controlled, // because it is assigned to a district if (oc.exists("tls.taz-nodes") && oc.getBool("tls.taz-nodes")) { for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; if (cur->isNearDistrict() && find(ncontrolled.begin(), ncontrolled.end(), cur) == ncontrolled.end()) { setAsTLControlled(cur, tlc, type); } } } // maybe no tls shall be guessed if (!oc.getBool("tls.guess")) { return; } // guess joined tls first, if wished if (oc.getBool("tls.join")) { // get node clusters std::vector<std::set<NBNode*> > cands; generateNodeClusters(oc.getFloat("tls.join-dist"), cands); // check these candidates (clusters) whether they should be controlled by a tls for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end();) { std::set<NBNode*>& c = (*i); // regard only junctions which are not yet controlled and are not // forbidden to be controlled for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) { if ((*j)->isTLControlled() || find(ncontrolled.begin(), ncontrolled.end(), *j) != ncontrolled.end()) { c.erase(j++); } else { ++j; } } // check whether the cluster should be controlled if (!shouldBeTLSControlled(c)) { i = cands.erase(i); } else { ++i; } } // cands now only contain sets of junctions that shall be joined into being tls-controlled unsigned int index = 0; for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) { std::vector<NBNode*> nodes; for (std::set<NBNode*>::iterator j = (*i).begin(); j != (*i).end(); j++) { nodes.push_back(*j); } std::string id = "joinedG_" + toString(index++); NBTrafficLightDefinition* tlDef = new NBOwnTLDef(id, nodes, 0, type); if (!tlc.insert(tlDef)) { // actually, nothing should fail here WRITE_WARNING("Could not build guessed, joined tls"); delete tlDef; return; } } } // guess tls for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; // do nothing if already is tl-controlled if (cur->isTLControlled()) { continue; } // do nothing if in the list of explicit non-controlled junctions if (find(ncontrolled.begin(), ncontrolled.end(), cur) != ncontrolled.end()) { continue; } std::set<NBNode*> c; c.insert(cur); if (!shouldBeTLSControlled(c) || cur->getIncomingEdges().size() < 3) { continue; } setAsTLControlled((*i).second, tlc, type); } }
void NBNodeCont::guessTLs(OptionsCont& oc, NBTrafficLightLogicCont& tlc) { // build list of definitely not tls-controlled junctions std::vector<NBNode*> ncontrolled; if (oc.isSet("tls.unset")) { std::vector<std::string> notTLControlledNodes = oc.getStringVector("tls.unset"); for (std::vector<std::string>::const_iterator i = notTLControlledNodes.begin(); i != notTLControlledNodes.end(); ++i) { NBNode* n = NBNodeCont::retrieve(*i); if (n == 0) { throw ProcessError(" The node '" + *i + "' to set as not-controlled is not known."); } std::set<NBTrafficLightDefinition*> tls = n->getControllingTLS(); for (std::set<NBTrafficLightDefinition*>::const_iterator j = tls.begin(); j != tls.end(); ++j) { (*j)->removeNode(n); } n->removeTrafficLights(); ncontrolled.push_back(n); } } TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(OptionsCont::getOptions().getString("tls.default-type")); // loop#1 checking whether the node shall be tls controlled, // because it is assigned to a district if (oc.exists("tls.taz-nodes") && oc.getBool("tls.taz-nodes")) { for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; if (cur->isNearDistrict() && find(ncontrolled.begin(), ncontrolled.end(), cur) == ncontrolled.end()) { setAsTLControlled(cur, tlc, type); } } } // figure out which nodes mark the locations of TLS signals // This assumes nodes are already joined if (oc.exists("tls.guess-signals") && oc.getBool("tls.guess-signals")) { // prepare candidate edges const SUMOReal signalDist = oc.getFloat("tls.guess-signals.dist"); for (std::map<std::string, NBNode*>::const_iterator i = myNodes.begin(); i != myNodes.end(); ++i) { NBNode* node = (*i).second; if (node->isTLControlled() && node->geometryLike()) { const EdgeVector& outgoing = node->getOutgoingEdges(); for (EdgeVector::const_iterator it_o = outgoing.begin(); it_o != outgoing.end(); ++it_o) { (*it_o)->setSignalOffset((*it_o)->getLength()); } } } // check which nodes should be controlled for (std::map<std::string, NBNode*>::const_iterator i = myNodes.begin(); i != myNodes.end(); ++i) { NBNode* node = i->second; const EdgeVector& incoming = node->getIncomingEdges(); if (!node->isTLControlled() && incoming.size() > 1 && !node->geometryLike()) { std::vector<NBNode*> signals; bool isTLS = true; for (EdgeVector::const_iterator it_i = incoming.begin(); it_i != incoming.end(); ++it_i) { const NBEdge* inEdge = *it_i; if (inEdge->getSignalOffset() == NBEdge::UNSPECIFIED_SIGNAL_OFFSET || inEdge->getSignalOffset() > signalDist) { isTLS = false; break; } if (inEdge->getSignalOffset() == inEdge->getLength()) { signals.push_back(inEdge->getFromNode()); } } if (isTLS) { for (std::vector<NBNode*>::iterator j = signals.begin(); j != signals.end(); ++j) { std::set<NBTrafficLightDefinition*> tls = (*j)->getControllingTLS(); (*j)->removeTrafficLights(); for (std::set<NBTrafficLightDefinition*>::iterator k = tls.begin(); k != tls.end(); ++k) { tlc.removeFully((*j)->getID()); } } NBTrafficLightDefinition* tlDef = new NBOwnTLDef("GS_" + node->getID(), node, 0, TLTYPE_STATIC); // @todo patch endOffset for all incoming lanes according to the signal positions if (!tlc.insert(tlDef)) { // actually, nothing should fail here WRITE_WARNING("Could not build joined tls '" + node->getID() + "'."); delete tlDef; return; } } } } } // maybe no tls shall be guessed if (!oc.getBool("tls.guess")) { return; } // guess joined tls first, if wished if (oc.getBool("tls.join")) { // get node clusters std::vector<std::set<NBNode*> > cands; generateNodeClusters(oc.getFloat("tls.join-dist"), cands); // check these candidates (clusters) whether they should be controlled by a tls for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end();) { std::set<NBNode*>& c = (*i); // regard only junctions which are not yet controlled and are not // forbidden to be controlled for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) { if ((*j)->isTLControlled() || find(ncontrolled.begin(), ncontrolled.end(), *j) != ncontrolled.end()) { c.erase(j++); } else { ++j; } } // check whether the cluster should be controlled if (!shouldBeTLSControlled(c)) { i = cands.erase(i); } else { ++i; } } // cands now only contain sets of junctions that shall be joined into being tls-controlled unsigned int index = 0; for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) { std::vector<NBNode*> nodes; for (std::set<NBNode*>::iterator j = (*i).begin(); j != (*i).end(); j++) { nodes.push_back(*j); } std::string id = "joinedG_" + toString(index++); NBTrafficLightDefinition* tlDef = new NBOwnTLDef(id, nodes, 0, type); if (!tlc.insert(tlDef)) { // actually, nothing should fail here WRITE_WARNING("Could not build guessed, joined tls"); delete tlDef; return; } } } // guess tls for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) { NBNode* cur = (*i).second; // do nothing if already is tl-controlled if (cur->isTLControlled()) { continue; } // do nothing if in the list of explicit non-controlled junctions if (find(ncontrolled.begin(), ncontrolled.end(), cur) != ncontrolled.end()) { continue; } std::set<NBNode*> c; c.insert(cur); if (!shouldBeTLSControlled(c) || cur->getIncomingEdges().size() < 3) { continue; } setAsTLControlled((*i).second, tlc, type); } }
unsigned int NBNodeCont::joinJunctions(SUMOReal maxdist, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc) { NodeClusters cands; NodeClusters clusters; generateNodeClusters(maxdist, cands); for (NodeClusters::iterator i = cands.begin(); i != cands.end(); ++i) { std::set<NBNode*> cluster = (*i); // remove join exclusions for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end();) { std::set<NBNode*>::iterator check = j; ++j; if (myJoinExclusions.count((*check)->getID()) > 0) { cluster.erase(check); } } // iteratively remove the fringe bool pruneFringe = true; while (pruneFringe) { pruneFringe = false; for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end();) { std::set<NBNode*>::iterator check = j; NBNode* n = *check; ++j; // remove nodes with degree <= 2 at fringe of the cluster (at least one edge leads to a non-cluster node) if ( (n->getIncomingEdges().size() <= 1 && n->getOutgoingEdges().size() <= 1) && ((n->getIncomingEdges().size() == 0 || (n->getIncomingEdges().size() == 1 && cluster.count(n->getIncomingEdges()[0]->getFromNode()) == 0)) || (n->getOutgoingEdges().size() == 0 || (n->getOutgoingEdges().size() == 1 && cluster.count(n->getOutgoingEdges()[0]->getToNode()) == 0))) ) { cluster.erase(check); pruneFringe = true; // other nodes could belong to the fringe now } } } if (cluster.size() > 1) { // check for clusters which are to complex and probably won't work very well // we count the incoming edges of the final junction std::set<NBEdge*> finalIncoming; std::vector<std::string> nodeIDs; for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); ++j) { nodeIDs.push_back((*j)->getID()); const EdgeVector& edges = (*j)->getIncomingEdges(); for (EdgeVector::const_iterator it_edge = edges.begin(); it_edge != edges.end(); ++it_edge) { NBEdge* edge = *it_edge; if (cluster.count(edge->getFromNode()) == 0) { // incoming edge, does not originate in the cluster finalIncoming.insert(edge); } } } if (finalIncoming.size() > 4) { WRITE_WARNING("Not joining junctions " + joinToString(nodeIDs, ',') + " because the cluster is too complex"); } else { clusters.push_back(cluster); } } } joinNodeClusters(clusters, dc, ec, tlc); return (int)clusters.size(); }
unsigned int NBNodeCont::joinJunctions(SUMOReal maxDist, NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc) { NodeClusters cands; NodeClusters clusters; generateNodeClusters(maxDist, cands); for (NodeClusters::iterator i = cands.begin(); i != cands.end(); ++i) { std::set<NBNode*> cluster = (*i); // remove join exclusions for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end();) { std::set<NBNode*>::iterator check = j; ++j; if (myJoinExclusions.count((*check)->getID()) > 0) { cluster.erase(check); } } // iteratively remove the fringe bool pruneFringe = true; while (pruneFringe) { pruneFringe = false; for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end();) { std::set<NBNode*>::iterator check = j; NBNode* n = *check; ++j; // remove geometry-like nodes at fringe of the cluster // (they have 1 neighbor in the cluster and at most 1 neighbor outside the cluster) std::set<NBNode*> neighbors; std::set<NBNode*> clusterNeigbors; for (EdgeVector::const_iterator it_edge = n->getOutgoingEdges().begin(); it_edge != n->getOutgoingEdges().end(); ++it_edge) { NBNode* neighbor = (*it_edge)->getToNode(); if (cluster.count(neighbor) == 0) { neighbors.insert(neighbor); } else { clusterNeigbors.insert(neighbor); } } for (EdgeVector::const_iterator it_edge = n->getIncomingEdges().begin(); it_edge != n->getIncomingEdges().end(); ++it_edge) { NBNode* neighbor = (*it_edge)->getFromNode(); if (cluster.count(neighbor) == 0) { neighbors.insert(neighbor); } else { clusterNeigbors.insert(neighbor); } } if (neighbors.size() <= 1 && clusterNeigbors.size() == 1) { cluster.erase(check); pruneFringe = true; // other nodes could belong to the fringe now } } } // exclude the fromNode of a long edge if the toNode is in the cluster (and they were both added via an alternative path). std::set<NBNode*> toRemove; for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end(); ++j) { NBNode* n = *j; const EdgeVector& edges = n->getOutgoingEdges(); for (EdgeVector::const_iterator it_edge = edges.begin(); it_edge != edges.end(); ++it_edge) { NBEdge* edge = *it_edge; if (cluster.count(edge->getToNode()) != 0 && edge->getLoadedLength() > maxDist) { //std::cout << "long edge " << edge->getID() << " (" << edge->getLoadedLength() << ", max=" << maxDist << ")\n"; toRemove.insert(n); toRemove.insert(edge->getToNode()); } } } for (std::set<NBNode*>::iterator j = toRemove.begin(); j != toRemove.end(); ++j) { cluster.erase(*j); } if (cluster.size() > 1) { // check for clusters which are to complex and probably won't work very well // we count the incoming edges of the final junction std::set<NBEdge*> finalIncoming; std::set<NBEdge*> finalOutgoing; std::vector<std::string> nodeIDs; for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); ++j) { nodeIDs.push_back((*j)->getID()); for (EdgeVector::const_iterator it_edge = (*j)->getIncomingEdges().begin(); it_edge != (*j)->getIncomingEdges().end(); ++it_edge) { NBEdge* edge = *it_edge; if (cluster.count(edge->getFromNode()) == 0) { // incoming edge, does not originate in the cluster finalIncoming.insert(edge); } } for (EdgeVector::const_iterator it_edge = (*j)->getOutgoingEdges().begin(); it_edge != (*j)->getOutgoingEdges().end(); ++it_edge) { NBEdge* edge = *it_edge; if (cluster.count(edge->getToNode()) == 0) { // outgoing edge, does not end in the cluster finalOutgoing.insert(edge); } } } if (finalIncoming.size() > 4) { std::sort(nodeIDs.begin(), nodeIDs.end()); WRITE_WARNING("Not joining junctions " + joinToStringSorting(nodeIDs, ',') + " because the cluster is too complex (" + toString(finalIncoming.size()) + " incoming edges)"); } else { // check for incoming parallel edges const SUMOReal PARALLEL_INCOMING_THRESHOLD = 10.0; bool foundParallel = false; for (std::set<NBEdge*>::const_iterator j = finalIncoming.begin(); j != finalIncoming.end() && !foundParallel; ++j) { for (std::set<NBEdge*>::const_iterator k = finalIncoming.begin(); k != finalIncoming.end() && !foundParallel; ++k) { if ((*j) != (*k) && fabs((*j)->getAngleAtNode((*j)->getToNode()) - (*k)->getAngleAtNode((*k)->getToNode())) < PARALLEL_INCOMING_THRESHOLD) { std::vector<std::string> parallelEdgeIDs; parallelEdgeIDs.push_back((*j)->getID()); parallelEdgeIDs.push_back((*k)->getID()); std::sort(parallelEdgeIDs.begin(), parallelEdgeIDs.end()); WRITE_WARNING("Not joining junctions " + joinToStringSorting(nodeIDs, ',') + " because the cluster is too complex (parallel incoming " + joinToString(parallelEdgeIDs, ',') + ")"); foundParallel = true; } } } // check for outgoing parallel edges for (std::set<NBEdge*>::const_iterator j = finalOutgoing.begin(); j != finalOutgoing.end() && !foundParallel; ++j) { for (std::set<NBEdge*>::const_iterator k = finalOutgoing.begin(); k != finalOutgoing.end() && !foundParallel; ++k) { if ((*j) != (*k) && fabs((*j)->getAngleAtNode((*j)->getFromNode()) - (*k)->getAngleAtNode((*k)->getFromNode())) < PARALLEL_INCOMING_THRESHOLD) { std::vector<std::string> parallelEdgeIDs; parallelEdgeIDs.push_back((*j)->getID()); parallelEdgeIDs.push_back((*k)->getID()); std::sort(parallelEdgeIDs.begin(), parallelEdgeIDs.end()); WRITE_WARNING("Not joining junctions " + joinToStringSorting(nodeIDs, ',') + " because the cluster is too complex (parallel outgoing " + joinToStringSorting(parallelEdgeIDs, ',') + ")"); foundParallel = true; } } } if (!foundParallel && cluster.size() > 1) { // compute all connected components of this cluster // (may be more than 1 if intermediate nodes were removed) NodeClusters components; for (std::set<NBNode*>::iterator j = cluster.begin(); j != cluster.end(); ++j) { // merge all connected components into newComp std::set<NBNode*> newComp; NBNode* current = *j; //std::cout << "checking connectivity for " << current->getID() << "\n"; newComp.insert(current); for (NodeClusters::iterator it_comp = components.begin(); it_comp != components.end();) { NodeClusters::iterator check = it_comp; //std::cout << " connected with " << toString(*check) << "?\n"; bool connected = false; for (std::set<NBNode*>::iterator k = (*check).begin(); k != (*check).end(); ++k) { if (current->getConnectionTo(*k) != 0 || (*k)->getConnectionTo(current) != 0) { //std::cout << "joining with connected component " << toString(*check) << "\n"; newComp.insert((*check).begin(), (*check).end()); it_comp = components.erase(check); connected = true; break; } } if (!connected) { it_comp++; } } //std::cout << "adding new component " << toString(newComp) << "\n"; components.push_back(newComp); } for (NodeClusters::iterator it_comp = components.begin(); it_comp != components.end(); ++it_comp) { if ((*it_comp).size() > 1) { //std::cout << "adding cluster " << toString(*it_comp) << "\n"; clusters.push_back(*it_comp); } } } } } } joinNodeClusters(clusters, dc, ec, tlc); return (int)clusters.size(); }