void
NIImporter_VISUM::parse_Turns() {
if (myLineParser.know("VSYSSET") && myLineParser.get("VSYSSET") == "") {
// no vehicle allowed; don't add
return;
}
// retrieve the nodes
NBNode* from = getNamedNode("VonKnot", "VonKnotNr");
NBNode* via = getNamedNode("UeberKnot", "UeberKnotNr");
NBNode* to = getNamedNode("NachKnot", "NachKnotNr");
if (from == 0 || via == 0 || to == 0) {
return;
}
// all nodes are known
std::string type = myLineParser.know("VSysCode")
? myLineParser.get("VSysCode")
: myLineParser.get("VSYSSET");
if (myVSysTypes.find(type) != myVSysTypes.end() && myVSysTypes.find(type)->second == "IV") {
// try to set the turning definition
NBEdge* src = from->getConnectionTo(via);
NBEdge* dest = via->getConnectionTo(to);
// check both
if (src == 0) {
// maybe it was removed due to something
if (OptionsCont::getOptions().isSet("keep-edges.min-speed")
||
OptionsCont::getOptions().isSet("keep-edges.explicit")) {
WRITE_WARNING("Could not set connection from node '" + from->getID() + "' to node '" + via->getID() + "'.");
} else {
if (OptionsCont::getOptions().getBool("visum.verbose-warnings")) {
WRITE_WARNING("There is no edge from node '" + from->getID() + "' to node '" + via->getID() + "'.");
}
}
return;
}
if (dest == 0) {
if (OptionsCont::getOptions().isSet("keep-edges.min-speed")
||
OptionsCont::getOptions().isSet("keep-edges.explicit")) {
WRITE_WARNING("Could not set connection from node '" + via->getID() + "' to node '" + to->getID() + "'.");
} else {
if (OptionsCont::getOptions().getBool("visum.verbose-warnings")) {
WRITE_WARNING("There is no edge from node '" + via->getID() + "' to node '" + to->getID() + "'.");
}
}
return;
}
// both edges found
// set them into the edge
src->addEdge2EdgeConnection(dest);
}
}
void
NIImporter_VISUM::parse_EdgePolys() {
// get the from- & to-node and validate them
NBNode* from = getNamedNode("VonKnot", "VonKnotNr");
NBNode* to = getNamedNode("NachKnot", "NachKnotNr");
if (!checkNodes(from, to)) {
return;
}
bool failed = false;
int index;
SUMOReal x, y;
try {
index = TplConvert::_2int(myLineParser.get("INDEX").c_str());
x = getNamedFloat("XKoord");
y = getNamedFloat("YKoord");
} catch (NumberFormatException&) {
WRITE_ERROR("Error in geometry description from node '" + from->getID() + "' to node '" + to->getID() + "'.");
return;
}
Position pos(x, y);
if (!NILoader::transformCoordinates(pos)) {
WRITE_ERROR("Unable to project coordinates for node '" + from->getID() + "'.");
return;
}
NBEdge* e = from->getConnectionTo(to);
if (e != 0) {
e->addGeometryPoint(index, pos);
} else {
failed = true;
}
e = to->getConnectionTo(from);
if (e != 0) {
e->addGeometryPoint(-index, pos);
failed = false;
}
// check whether the operation has failed
if (failed) {
// we should report this to the warning instance only if we have removed
// some nodes or edges...
if (OptionsCont::getOptions().isSet("keep-edges.min-speed") || OptionsCont::getOptions().isSet("keep-edges.explicit")) {
WRITE_WARNING("Could not set geometry between node '" + from->getID() + "' and node '" + to->getID() + "'.");
} else {
// ... in the other case we report this to the error instance
if (OptionsCont::getOptions().getBool("visum.verbose-warnings")) {
WRITE_WARNING("There is no edge from node '" + from->getID() + "' to node '" + to->getID() + "'.");
}
}
}
}
void
NGNet::toNB() const {
std::vector<NBNode*> nodes;
for (NGNodeList::const_iterator i1 = myNodeList.begin(); i1 != myNodeList.end(); i1++) {
NBNode* node = (*i1)->buildNBNode(myNetBuilder);
nodes.push_back(node);
myNetBuilder.getNodeCont().insert(node);
}
for (NGEdgeList::const_iterator i2 = myEdgeList.begin(); i2 != myEdgeList.end(); i2++) {
NBEdge* edge = (*i2)->buildNBEdge(myNetBuilder);
myNetBuilder.getEdgeCont().insert(edge);
}
// now, let's append the reverse directions...
SUMOReal bidiProb = OptionsCont::getOptions().getFloat("rand.bidi-probability");
for (std::vector<NBNode*>::const_iterator i = nodes.begin(); i != nodes.end(); ++i) {
NBNode* node = *i;
EdgeVector incoming = node->getIncomingEdges();
for (EdgeVector::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
if (node->getConnectionTo((*j)->getFromNode()) == 0 && RandHelper::rand() <= bidiProb) {
NBEdge* back = new NBEdge("-" + (*j)->getID(), node, (*j)->getFromNode(),
"", myNetBuilder.getTypeCont().getSpeed(""), myNetBuilder.getTypeCont().getNumLanes(""),
myNetBuilder.getTypeCont().getPriority(""),
myNetBuilder.getTypeCont().getWidth(""), NBEdge::UNSPECIFIED_OFFSET);
myNetBuilder.getEdgeCont().insert(back);
}
}
}
}
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();
}
