unsigned int
NBNodeCont::removeUnwishedNodes(NBDistrictCont& dc, NBEdgeCont& ec,
NBJoinedEdgesMap& je, NBTrafficLightLogicCont& tlc,
bool removeGeometryNodes) {
unsigned int no = 0;
std::vector<NBNode*> toRemove;
for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) {
NBNode* current = (*i).second;
bool remove = false;
std::vector<std::pair<NBEdge*, NBEdge*> > toJoin;
// check for completely empty nodes
if (current->getOutgoingEdges().size() == 0 && current->getIncomingEdges().size() == 0) {
// remove if empty
remove = true;
}
// check for nodes which are only geometry nodes
if (removeGeometryNodes) {
if ((current->getOutgoingEdges().size() == 1 && current->getIncomingEdges().size() == 1)
||
(current->getOutgoingEdges().size() == 2 && current->getIncomingEdges().size() == 2)) {
// ok, one in, one out or two in, two out
// -> ask the node whether to join
remove = current->checkIsRemovable();
if (remove) {
toJoin = current->getEdgesToJoin();
}
}
}
// remove the node and join the geometries when wished
if (!remove) {
continue;
}
for (std::vector<std::pair<NBEdge*, NBEdge*> >::iterator j = toJoin.begin(); j != toJoin.end(); j++) {
NBEdge* begin = (*j).first;
NBEdge* continuation = (*j).second;
begin->append(continuation);
continuation->getToNode()->replaceIncoming(continuation, begin, 0);
tlc.replaceRemoved(continuation, -1, begin, -1);
je.appended(begin->getID(), continuation->getID());
ec.erase(dc, continuation);
}
toRemove.push_back(current);
no++;
}
// erase all
for (std::vector<NBNode*>::iterator j = toRemove.begin(); j != toRemove.end(); ++j) {
erase(*j);
}
return no;
}
void
NBNodeCont::joinNodeClusters(NodeClusters clusters,
NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tlc) {
for (NodeClusters::iterator i = clusters.begin(); i != clusters.end(); ++i) {
std::set<NBNode*> cluster = *i;
assert(cluster.size() > 1);
Position pos;
bool setTL;
std::string id;
TrafficLightType type;
analyzeCluster(cluster, id, pos, setTL, type);
if (!insert(id, pos)) {
// should not fail
WRITE_WARNING("Could not join junctions " + id);
continue;
}
NBNode* newNode = retrieve(id);
if (setTL) {
NBTrafficLightDefinition* tlDef = new NBOwnTLDef(id, newNode, 0, type);
if (!tlc.insert(tlDef)) {
// actually, nothing should fail here
delete tlDef;
throw ProcessError("Could not allocate tls '" + id + "'.");
}
}
// collect edges
std::set<NBEdge*> allEdges;
for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); ++j) {
const EdgeVector& edges = (*j)->getEdges();
allEdges.insert(edges.begin(), edges.end());
}
// remap and remove edges which are completely within the new intersection
for (std::set<NBEdge*>::iterator j = allEdges.begin(); j != allEdges.end();) {
NBEdge* e = (*j);
NBNode* from = e->getFromNode();
NBNode* to = e->getToNode();
if (cluster.count(from) > 0 && cluster.count(to) > 0) {
for (std::set<NBEdge*>::iterator l = allEdges.begin(); l != allEdges.end(); ++l) {
if (e != *l) {
(*l)->replaceInConnections(e, e->getConnections());
}
}
ec.erase(dc, e);
allEdges.erase(j++); // erase does not invalidate the other iterators
} else {
++j;
}
}
// remap edges which are incoming / outgoing
for (std::set<NBEdge*>::iterator j = allEdges.begin(); j != allEdges.end(); ++j) {
NBEdge* e = (*j);
std::vector<NBEdge::Connection> conns = e->getConnections();
const bool outgoing = cluster.count(e->getFromNode()) > 0;
NBNode* from = outgoing ? newNode : e->getFromNode();
NBNode* to = outgoing ? e->getToNode() : newNode;
e->reinitNodes(from, to);
// re-add connections which previously existed and may still valid.
// connections to removed edges will be ignored
for (std::vector<NBEdge::Connection>::iterator k = conns.begin(); k != conns.end(); ++k) {
e->addLane2LaneConnection((*k).fromLane, (*k).toEdge, (*k).toLane, NBEdge::L2L_USER, false, (*k).mayDefinitelyPass);
}
}
// remove original nodes
registerJoinedCluster(cluster);
for (std::set<NBNode*>::const_iterator j = cluster.begin(); j != cluster.end(); ++j) {
erase(*j);
}
}
}
void
NBNodeCont::removeIsolatedRoads(NBDistrictCont& dc, NBEdgeCont& ec, NBTrafficLightLogicCont& tc) {
UNUSED_PARAMETER(tc);
// Warn of isolated edges, i.e. a single edge with no connection to another edge
int edgeCounter = 0;
const std::vector<std::string>& edgeNames = ec.getAllNames();
for (std::vector<std::string>::const_iterator it = edgeNames.begin(); it != edgeNames.end(); ++it) {
// Test whether this node starts at a dead end, i.e. it has only one adjacent node
// to which an edge exists and from which an edge may come.
NBEdge* e = ec.retrieve(*it);
if (e == 0) {
continue;
}
NBNode* from = e->getFromNode();
const EdgeVector& outgoingEdges = from->getOutgoingEdges();
if (outgoingEdges.size() != 1) {
// At this node, several edges or no edge start; so, this node is no dead end.
continue;
}
const EdgeVector& incomingEdges = from->getIncomingEdges();
if (incomingEdges.size() > 1) {
// At this node, several edges end; so, this node is no dead end.
continue;
} else if (incomingEdges.size() == 1) {
NBNode* fromNodeOfIncomingEdge = incomingEdges[0]->getFromNode();
NBNode* toNodeOfOutgoingEdge = outgoingEdges[0]->getToNode();
if (fromNodeOfIncomingEdge != toNodeOfOutgoingEdge) {
// At this node, an edge ends which is not the inverse direction of
// the starting node.
continue;
}
}
// Now we know that the edge e starts a dead end.
// Next we test if the dead end is isolated, i.e. does not lead to a junction
bool hasJunction = false;
EdgeVector road;
NBEdge* eOld = 0;
NBNode* to;
std::set<NBNode*> adjacentNodes;
do {
road.push_back(e);
eOld = e;
from = e->getFromNode();
to = e->getToNode();
const EdgeVector& outgoingEdgesOfToNode = to->getOutgoingEdges();
const EdgeVector& incomingEdgesOfToNode = to->getIncomingEdges();
adjacentNodes.clear();
for (EdgeVector::const_iterator itOfOutgoings = outgoingEdgesOfToNode.begin(); itOfOutgoings != outgoingEdgesOfToNode.end(); ++itOfOutgoings) {
if ((*itOfOutgoings)->getToNode() != from // The back path
&& (*itOfOutgoings)->getToNode() != to // A loop / dummy edge
) {
e = *itOfOutgoings; // Probably the next edge
}
adjacentNodes.insert((*itOfOutgoings)->getToNode());
}
for (EdgeVector::const_iterator itOfIncomings = incomingEdgesOfToNode.begin(); itOfIncomings != incomingEdgesOfToNode.end(); ++itOfIncomings) {
adjacentNodes.insert((*itOfIncomings)->getFromNode());
}
adjacentNodes.erase(to); // Omit loops
if (adjacentNodes.size() > 2) {
hasJunction = true;
}
} while (!hasJunction && eOld != e);
if (!hasJunction) {
edgeCounter += int(road.size());
std::string warningString = "Removed a road without junctions: ";
for (EdgeVector::iterator roadIt = road.begin(); roadIt != road.end(); ++roadIt) {
if (roadIt == road.begin()) {
warningString += (*roadIt)->getID();
} else {
warningString += ", " + (*roadIt)->getID();
}
NBNode* fromNode = (*roadIt)->getFromNode();
NBNode* toNode = (*roadIt)->getToNode();
ec.erase(dc, *roadIt);
if (fromNode->getIncomingEdges().size() == 0 && fromNode->getOutgoingEdges().size() == 0) {
// Node is empty; can be removed
erase(fromNode);
}
if (toNode->getIncomingEdges().size() == 0 && toNode->getOutgoingEdges().size() == 0) {
// Node is empty; can be removed
erase(toNode);
}
}
WRITE_WARNING(warningString);
}
}
if (edgeCounter > 0 && !OptionsCont::getOptions().getBool("remove-edges.isolated")) {
WRITE_WARNING("Detected isolated roads. Use the option --remove-edges.isolated to get a list of all affected edges.");
}
}