std::pair<NBEdge*, NBEdge*>
NBOwnTLDef::getBestPair(EdgeVector& incoming) {
if (incoming.size() == 1) {
// only one there - return the one
std::pair<NBEdge*, NBEdge*> ret(*incoming.begin(), static_cast<NBEdge*>(0));
incoming.clear();
return ret;
}
// determine the best combination
// by priority, first
EdgeVector used;
std::sort(incoming.begin(), incoming.end(), edge_by_incoming_priority_sorter());
used.push_back(*incoming.begin()); // the first will definitely be used
// get the ones with the same priority
int prio = getToPrio(*used.begin());
for (EdgeVector::iterator i = incoming.begin() + 1; i != incoming.end() && prio != getToPrio(*i); ++i) {
used.push_back(*i);
}
// if there only lower priorised, use these, too
if (used.size() < 2) {
used = incoming;
}
std::pair<NBEdge*, NBEdge*> ret = getBestCombination(used);
incoming.erase(find(incoming.begin(), incoming.end(), ret.first));
incoming.erase(find(incoming.begin(), incoming.end(), ret.second));
return ret;
}
// check that for HEFace f the vertices TYPE are connected
bool VoronoiDiagramChecker::faceVerticesConnected( HEFace f, VoronoiVertexStatus Vtype ) {
VertexVector face_verts = g.face_vertices(f);
VertexVector type_verts;
BOOST_FOREACH( HEVertex v, face_verts ) {
if ( g[v].status == Vtype )
type_verts.push_back(v); // build a vector of all Vtype vertices
}
assert( !type_verts.empty() );
if (type_verts.size()==1) // set of 1 is allways connected
return true;
// check that type_verts are connected
HEEdge currentEdge = g[f].edge;
HEVertex endVertex = g.source(currentEdge); // stop when target here
EdgeVector startEdges;
bool done = false;
while (!done) {
HEVertex src = g.source( currentEdge );
HEVertex trg = g.target( currentEdge );
if ( g[src].status != Vtype ) { // seach ?? - Vtype
if ( g[trg].status == Vtype ) { // we have found ?? - Vtype
startEdges.push_back( currentEdge );
}
}
currentEdge = g[currentEdge].next;
if ( trg == endVertex ) {
done = true;
}
}
assert( !startEdges.empty() );
if ( startEdges.size() != 1 ) // when the Vtype vertices are connected, there is exactly one startEdge
return false;
else
return true;
}
void
NBLoadedSUMOTLDef::collectEdgeVectors(EdgeVector& fromEdges, EdgeVector& toEdges, std::vector<int>& fromLanes) const {
assert(fromEdges.size() > 0);
assert(fromEdges.size() == toEdges.size());
const int size = (int)fromEdges.size();
for (NBConnectionVector::const_iterator it = myControlledLinks.begin(); it != myControlledLinks.end(); it++) {
const NBConnection& c = *it;
if (c.getTLIndex() != NBConnection::InvalidTlIndex) {
if (c.getTLIndex() >= size) {
throw ProcessError("Invalid linkIndex " + toString(c.getTLIndex()) + " for traffic light '" + getID() +
"' with " + toString(size) + " links.");
}
fromEdges[c.getTLIndex()] = c.getFrom();
toEdges[c.getTLIndex()] = c.getTo();
fromLanes[c.getTLIndex()] = c.getFromLane();
}
}
}
SUMOReal
NBContHelper::maxSpeed(const EdgeVector& ev) {
assert(ev.size() > 0);
SUMOReal max = (*(ev.begin()))->getSpeed();
for (EdgeVector::const_iterator i = ev.begin() + 1; i != ev.end(); i++) {
max =
max > (*i)->getSpeed()
? max : (*i)->getSpeed();
}
return max;
}
SUMOReal
NBContHelper::getMinSpeed(const EdgeVector& edges) {
if (edges.size() == 0) {
return -1;
}
SUMOReal ret = (*(edges.begin()))->getSpeed();
for (EdgeVector::const_iterator i = edges.begin() + 1; i != edges.end(); i++) {
if ((*i)->getSpeed() < ret) {
ret = (*i)->getSpeed();
}
}
return ret;
}
double
NBContHelper::getMaxSpeed(const EdgeVector& edges) {
if (edges.size() == 0) {
return -1;
}
double ret = (*(edges.begin()))->getSpeed();
for (EdgeVector::const_iterator i = edges.begin() + 1; i != edges.end(); i++) {
if ((*i)->getSpeed() > ret) {
ret = (*i)->getSpeed();
}
}
return ret;
}
std::set<NBEdge*>
NBTrafficLightDefinition::collectReachable(EdgeVector outer, const EdgeVector& within, bool checkControlled) {
std::set<NBEdge*> reachable;
while (outer.size() > 0) {
NBEdge* from = outer.back();
outer.pop_back();
std::vector<NBEdge::Connection>& cons = from->getConnections();
for (std::vector<NBEdge::Connection>::iterator k = cons.begin(); k != cons.end(); k++) {
NBEdge* to = (*k).toEdge;
if (reachable.count(to) == 0 &&
(find(within.begin(), within.end(), to) != within.end()) &&
(!checkControlled || from->mayBeTLSControlled((*k).fromLane, to, (*k).toLane))) {
reachable.insert(to);
outer.push_back(to);
}
}
}
return reachable;
}
std::vector<std::pair<Triangle, int>> FramedFace::makeTriangleEdgePairs(double frameWidth,const VertexVector& vertices,const EdgeVector& edges)
{
int faceSize=(int) edges.size();
std::vector<std::pair<Triangle, int>> pairs;
pairs.reserve(2*faceSize);
for (int i=0;i<faceSize;i++)
{
int index1=(i)%faceSize;
int index2=(i+1)%faceSize;
int edgeIndex=edges.at(i);
Point v1=vertices.at(index1);
Point v2=vertices.at(index2);
pairs.push_back( std::pair<Triangle,int>( Triangle(v1,inners.at(index2),inners.at(index1)) , edgeIndex) );
pairs.push_back( std::pair<Triangle,int>( Triangle(v1,v2,inners.at(index2)) , edgeIndex) );
}
return pairs;
}
void
NBEdgeCont::guessRoundabouts(std::vector<EdgeVector>& marked) {
// step 1: keep only those edges which have no turnarounds
std::set<NBEdge*> candidates;
for (EdgeCont::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
NBEdge* e = (*i).second;
NBNode* const to = e->getToNode();
if (e->getTurnDestination() == 0 && to->getConnectionTo(e->getFromNode()) == 0) {
candidates.insert(e);
}
}
// step 2:
std::set<NBEdge*> visited;
for (std::set<NBEdge*>::const_iterator i = candidates.begin(); i != candidates.end(); ++i) {
EdgeVector loopEdges;
// start with a random edge (this doesn't have to be a roundabout edge)
// loop over connected edges (using always the leftmost one)
// and keep the list in loopEdges
// continue until we loop back onto a loopEdges and extract the loop
NBEdge* e = (*i);
if (visited.count(e) > 0) {
// already seen
continue;
}
loopEdges.push_back(e);
bool doLoop = true;
do {
visited.insert(e);
const EdgeVector& edges = e->getToNode()->getEdges();
if (edges.size() < 2) {
doLoop = false;
break;
}
if (e->getTurnDestination() != 0 || e->getToNode()->getConnectionTo(e->getFromNode()) != 0) {
// do not follow turn-arounds while in a (tentative) loop
doLoop = false;
break;
}
EdgeVector::const_iterator me = find(edges.begin(), edges.end(), e);
NBContHelper::nextCW(edges, me);
NBEdge* left = *me;
SUMOReal angle = fabs(NBHelpers::relAngle(e->getAngleAtNode(e->getToNode()), left->getAngleAtNode(e->getToNode())));
if (angle >= 90) {
// roundabouts do not have sharp turns (or they wouldn't be called 'round')
doLoop = false;
break;
}
EdgeVector::const_iterator loopClosed = find(loopEdges.begin(), loopEdges.end(), left);
const size_t loopSize = loopEdges.end() - loopClosed;
if (loopSize > 0) {
// loop found
if (loopSize < 3) {
doLoop = false; // need at least 3 edges for a roundabout
} else if (loopSize < loopEdges.size()) {
// remove initial edges not belonging to the loop
EdgeVector(loopEdges.begin() + (loopEdges.size() - loopSize), loopEdges.end()).swap(loopEdges);
}
// count attachments to the outside. need at least 3 or a roundabout doesn't make much sense
int attachments = 0;
for (EdgeVector::const_iterator j = loopEdges.begin(); j != loopEdges.end(); ++j) {
if ((*j)->getToNode()->getEdges().size() > 2) {
attachments++;
}
}
if (attachments < 3) {
doLoop = false;
}
break;
}
if (visited.count(left) > 0) {
doLoop = false;
} else {
// keep going
loopEdges.push_back(left);
e = left;
}
} while (doLoop);
// mark collected edges in the case a loop (roundabout) was found
if (doLoop) {
std::set<NBEdge*> loopEdgesSet(loopEdges.begin(), loopEdges.end());
for (std::set<NBEdge*>::const_iterator j = loopEdgesSet.begin(); j != loopEdgesSet.end(); ++j) {
// disable turnarounds on incoming edges
NBNode* node = (*j)->getToNode();
const EdgeVector& incoming = node->getIncomingEdges();
for (EdgeVector::const_iterator k = incoming.begin(); k != incoming.end(); ++k) {
NBEdge* inEdge = *k;
if (loopEdgesSet.count(inEdge) > 0) {
continue;
}
if ((inEdge)->getStep() >= NBEdge::LANES2LANES_USER) {
continue;
}
inEdge->removeFromConnections(inEdge->getTurnDestination(), -1);
}
// let the connections to succeeding roundabout edge have a higher priority
(*j)->setJunctionPriority(node, 1000);
}
marked.push_back(loopEdges);
}
}
}
void
NBEdgeCont::joinSameNodeConnectingEdges(NBDistrictCont& dc,
NBTrafficLightLogicCont& tlc,
EdgeVector edges) {
// !!! Attention!
// No merging of the geometry to come is being done
// The connections are moved from one edge to another within
// the replacement where the edge is a node's incoming edge.
// count the number of lanes, the speed and the id
unsigned int nolanes = 0;
SUMOReal speed = 0;
int priority = 0;
std::string id;
sort(edges.begin(), edges.end(), NBContHelper::same_connection_edge_sorter());
// retrieve the connected nodes
NBEdge* tpledge = *(edges.begin());
NBNode* from = tpledge->getFromNode();
NBNode* to = tpledge->getToNode();
EdgeVector::const_iterator i;
for (i = edges.begin(); i != edges.end(); i++) {
// some assertions
assert((*i)->getFromNode() == from);
assert((*i)->getToNode() == to);
// ad the number of lanes the current edge has
nolanes += (*i)->getNumLanes();
// build the id
if (i != edges.begin()) {
id += "+";
}
id += (*i)->getID();
// compute the speed
speed += (*i)->getSpeed();
// build the priority
priority = MAX2(priority, (*i)->getPriority());
}
speed /= edges.size();
// build the new edge
// @bug new edge does not know about allowed vclass of old edges
// @bug both the width and the offset are not regarded
NBEdge* newEdge = new NBEdge(id, from, to, "", speed, nolanes, priority,
NBEdge::UNSPECIFIED_WIDTH, NBEdge::UNSPECIFIED_OFFSET,
tpledge->getStreetName(), tpledge->myLaneSpreadFunction);
insert(newEdge, true);
// replace old edge by current within the nodes
// and delete the old
from->replaceOutgoing(edges, newEdge);
to->replaceIncoming(edges, newEdge);
// patch connections
// add edge2edge-information
for (i = edges.begin(); i != edges.end(); i++) {
EdgeVector ev = (*i)->getConnectedEdges();
for (EdgeVector::iterator j = ev.begin(); j != ev.end(); j++) {
newEdge->addEdge2EdgeConnection(*j);
}
}
// move lane2lane-connections
unsigned int currLane = 0;
for (i = edges.begin(); i != edges.end(); i++) {
newEdge->moveOutgoingConnectionsFrom(*i, currLane);
currLane += (*i)->getNumLanes();
}
// patch tl-information
currLane = 0;
for (i = edges.begin(); i != edges.end(); i++) {
unsigned int noLanes = (*i)->getNumLanes();
for (unsigned int j = 0; j < noLanes; j++, currLane++) {
// replace in traffic lights
tlc.replaceRemoved(*i, j, newEdge, currLane);
}
}
// delete joined edges
for (i = edges.begin(); i != edges.end(); i++) {
erase(dc, *i);
}
}
void
NBEdgePriorityComputer::setPriorityJunctionPriorities(NBNode& n) {
if (n.myIncomingEdges.size() == 0 || n.myOutgoingEdges.size() == 0) {
return;
}
EdgeVector incoming = n.myIncomingEdges;
EdgeVector outgoing = n.myOutgoingEdges;
// what we do want to have is to extract the pair of roads that are
// the major roads for this junction
// let's get the list of incoming edges with the highest priority
std::sort(incoming.begin(), incoming.end(), NBContHelper::edge_by_priority_sorter());
EdgeVector bestIncoming;
NBEdge* best = incoming[0];
while (incoming.size() > 0 && samePriority(best, incoming[0])) {
bestIncoming.push_back(*incoming.begin());
incoming.erase(incoming.begin());
}
// now, let's get the list of best outgoing
assert(outgoing.size() != 0);
sort(outgoing.begin(), outgoing.end(), NBContHelper::edge_by_priority_sorter());
EdgeVector bestOutgoing;
best = outgoing[0];
while (outgoing.size() > 0 && samePriority(best, outgoing[0])) { //->getPriority()==best->getPriority()) {
bestOutgoing.push_back(*outgoing.begin());
outgoing.erase(outgoing.begin());
}
// now, let's compute for each of the best incoming edges
// the incoming which is most opposite
// the outgoing which is most opposite
EdgeVector::iterator i;
std::map<NBEdge*, NBEdge*> counterIncomingEdges;
std::map<NBEdge*, NBEdge*> counterOutgoingEdges;
incoming = n.myIncomingEdges;
outgoing = n.myOutgoingEdges;
for (i = bestIncoming.begin(); i != bestIncoming.end(); ++i) {
std::sort(incoming.begin(), incoming.end(), NBContHelper::edge_opposite_direction_sorter(*i, &n));
counterIncomingEdges[*i] = *incoming.begin();
std::sort(outgoing.begin(), outgoing.end(), NBContHelper::edge_opposite_direction_sorter(*i, &n));
counterOutgoingEdges[*i] = *outgoing.begin();
}
// ok, let's try
// 1) there is one best incoming road
if (bestIncoming.size() == 1) {
// let's mark this road as the best
NBEdge* best1 = extractAndMarkFirst(n, bestIncoming);
if (counterIncomingEdges.find(best1) != counterIncomingEdges.end()) {
// ok, look, what we want is the opposit of the straight continuation edge
// but, what if such an edge does not exist? By now, we'll determine it
// geometrically
NBEdge* s = counterIncomingEdges.find(best1)->second;
if (GeomHelper::getMinAngleDiff(best1->getAngleAtNode(&n), s->getAngleAtNode(&n)) > 180 - 45) {
s->setJunctionPriority(&n, 1);
}
}
if (bestOutgoing.size() != 0) {
// mark the best outgoing as the continuation
sort(bestOutgoing.begin(), bestOutgoing.end(), NBContHelper::edge_similar_direction_sorter(best1));
best1 = extractAndMarkFirst(n, bestOutgoing);
if (counterOutgoingEdges.find(best1) != counterOutgoingEdges.end()) {
NBEdge* s = counterOutgoingEdges.find(best1)->second;
if (GeomHelper::getMinAngleDiff(best1->getAngleAtNode(&n), s->getAngleAtNode(&n)) > 180 - 45) {
s->setJunctionPriority(&n, 1);
}
}
}
return;
}
// ok, what we want to do in this case is to determine which incoming
// has the best continuation...
// This means, when several incoming roads have the same priority,
// we want a (any) straight connection to be more priorised than a turning
SUMOReal bestAngle = 0;
NBEdge* bestFirst = 0;
NBEdge* bestSecond = 0;
bool hadBest = false;
for (i = bestIncoming.begin(); i != bestIncoming.end(); ++i) {
EdgeVector::iterator j;
NBEdge* t1 = *i;
SUMOReal angle1 = t1->getTotalAngle() + 180;
if (angle1 >= 360) {
angle1 -= 360;
}
for (j = i + 1; j != bestIncoming.end(); ++j) {
NBEdge* t2 = *j;
SUMOReal angle2 = t2->getTotalAngle() + 180;
if (angle2 >= 360) {
angle2 -= 360;
}
SUMOReal angle = GeomHelper::getMinAngleDiff(angle1, angle2);
if (!hadBest || angle > bestAngle) {
bestAngle = angle;
bestFirst = *i;
bestSecond = *j;
hadBest = true;
}
}
}
bestFirst->setJunctionPriority(&n, 1);
sort(bestOutgoing.begin(), bestOutgoing.end(), NBContHelper::edge_similar_direction_sorter(bestFirst));
if (bestOutgoing.size() != 0) {
extractAndMarkFirst(n, bestOutgoing);
}
bestSecond->setJunctionPriority(&n, 1);
sort(bestOutgoing.begin(), bestOutgoing.end(), NBContHelper::edge_similar_direction_sorter(bestSecond));
if (bestOutgoing.size() != 0) {
extractAndMarkFirst(n, bestOutgoing);
}
}
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.");
}
}
void
NIImporter_SUMO::_loadNetwork(OptionsCont& oc) {
// check whether the option is set (properly)
if (!oc.isUsableFileList("sumo-net-file")) {
return;
}
// parse file(s)
std::vector<std::string> files = oc.getStringVector("sumo-net-file");
for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
if (!FileHelpers::isReadable(*file)) {
WRITE_ERROR("Could not open sumo-net-file '" + *file + "'.");
return;
}
setFileName(*file);
PROGRESS_BEGIN_MESSAGE("Parsing sumo-net from '" + *file + "'");
XMLSubSys::runParser(*this, *file, true);
PROGRESS_DONE_MESSAGE();
}
// build edges
for (std::map<std::string, EdgeAttrs*>::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
EdgeAttrs* ed = (*i).second;
// skip internal edges
if (ed->func == EDGEFUNC_INTERNAL || ed->func == EDGEFUNC_CROSSING || ed->func == EDGEFUNC_WALKINGAREA) {
continue;
}
// get and check the nodes
NBNode* from = myNodeCont.retrieve(ed->fromNode);
NBNode* to = myNodeCont.retrieve(ed->toNode);
if (from == 0) {
WRITE_ERROR("Edge's '" + ed->id + "' from-node '" + ed->fromNode + "' is not known.");
continue;
}
if (to == 0) {
WRITE_ERROR("Edge's '" + ed->id + "' to-node '" + ed->toNode + "' is not known.");
continue;
}
// edge shape
PositionVector geom;
if (ed->shape.size() > 0) {
geom = ed->shape;
} else {
// either the edge has default shape consisting only of the two node
// positions or we have a legacy network
geom = reconstructEdgeShape(ed, from->getPosition(), to->getPosition());
}
// build and insert the edge
NBEdge* e = new NBEdge(ed->id, from, to,
ed->type, ed->maxSpeed,
(unsigned int) ed->lanes.size(),
ed->priority, NBEdge::UNSPECIFIED_WIDTH, NBEdge::UNSPECIFIED_OFFSET,
geom, ed->streetName, "", ed->lsf, true); // always use tryIgnoreNodePositions to keep original shape
e->setLoadedLength(ed->length);
if (!myNetBuilder.getEdgeCont().insert(e)) {
WRITE_ERROR("Could not insert edge '" + ed->id + "'.");
delete e;
continue;
}
ed->builtEdge = myNetBuilder.getEdgeCont().retrieve(ed->id);
}
// assign further lane attributes (edges are built)
for (std::map<std::string, EdgeAttrs*>::const_iterator i = myEdges.begin(); i != myEdges.end(); ++i) {
EdgeAttrs* ed = (*i).second;
NBEdge* nbe = ed->builtEdge;
if (nbe == 0) { // inner edge or removed by explicit list, vclass, ...
continue;
}
for (unsigned int fromLaneIndex = 0; fromLaneIndex < (unsigned int) ed->lanes.size(); ++fromLaneIndex) {
LaneAttrs* lane = ed->lanes[fromLaneIndex];
// connections
const std::vector<Connection>& connections = lane->connections;
for (std::vector<Connection>::const_iterator c_it = connections.begin(); c_it != connections.end(); c_it++) {
const Connection& c = *c_it;
if (myEdges.count(c.toEdgeID) == 0) {
WRITE_ERROR("Unknown edge '" + c.toEdgeID + "' given in connection.");
continue;
}
NBEdge* toEdge = myEdges[c.toEdgeID]->builtEdge;
if (toEdge == 0) { // removed by explicit list, vclass, ...
continue;
}
if (nbe->hasConnectionTo(toEdge, c.toLaneIdx)) {
WRITE_WARNING("Target lane '" + toEdge->getLaneID(c.toLaneIdx) + "' has multiple connections from '" + nbe->getID() + "'.");
}
nbe->addLane2LaneConnection(
fromLaneIndex, toEdge, c.toLaneIdx, NBEdge::L2L_VALIDATED,
true, c.mayDefinitelyPass, c.keepClear, c.contPos);
// maybe we have a tls-controlled connection
if (c.tlID != "" && myRailSignals.count(c.tlID) == 0) {
const std::map<std::string, NBTrafficLightDefinition*>& programs = myTLLCont.getPrograms(c.tlID);
if (programs.size() > 0) {
std::map<std::string, NBTrafficLightDefinition*>::const_iterator it;
for (it = programs.begin(); it != programs.end(); it++) {
NBLoadedSUMOTLDef* tlDef = dynamic_cast<NBLoadedSUMOTLDef*>(it->second);
if (tlDef) {
tlDef->addConnection(nbe, toEdge, fromLaneIndex, c.toLaneIdx, c.tlLinkNo);
} else {
throw ProcessError("Corrupt traffic light definition '" + c.tlID + "' (program '" + it->first + "')");
}
}
} else {
WRITE_ERROR("The traffic light '" + c.tlID + "' is not known.");
}
}
}
// allow/disallow XXX preferred
nbe->setPermissions(parseVehicleClasses(lane->allow, lane->disallow), fromLaneIndex);
// width, offset
nbe->setLaneWidth(fromLaneIndex, lane->width);
nbe->setEndOffset(fromLaneIndex, lane->endOffset);
nbe->setSpeed(fromLaneIndex, lane->maxSpeed);
}
nbe->declareConnectionsAsLoaded();
if (!nbe->hasLaneSpecificWidth() && nbe->getLanes()[0].width != NBEdge::UNSPECIFIED_WIDTH) {
nbe->setLaneWidth(-1, nbe->getLaneWidth(0));
}
if (!nbe->hasLaneSpecificEndOffset() && nbe->getEndOffset(0) != NBEdge::UNSPECIFIED_OFFSET) {
nbe->setEndOffset(-1, nbe->getEndOffset(0));
}
}
// insert loaded prohibitions
for (std::vector<Prohibition>::const_iterator it = myProhibitions.begin(); it != myProhibitions.end(); it++) {
NBEdge* prohibitedFrom = myEdges[it->prohibitedFrom]->builtEdge;
NBEdge* prohibitedTo = myEdges[it->prohibitedTo]->builtEdge;
NBEdge* prohibitorFrom = myEdges[it->prohibitorFrom]->builtEdge;
NBEdge* prohibitorTo = myEdges[it->prohibitorTo]->builtEdge;
if (prohibitedFrom == 0) {
WRITE_WARNING("Edge '" + it->prohibitedFrom + "' in prohibition was not built");
} else if (prohibitedTo == 0) {
WRITE_WARNING("Edge '" + it->prohibitedTo + "' in prohibition was not built");
} else if (prohibitorFrom == 0) {
WRITE_WARNING("Edge '" + it->prohibitorFrom + "' in prohibition was not built");
} else if (prohibitorTo == 0) {
WRITE_WARNING("Edge '" + it->prohibitorTo + "' in prohibition was not built");
} else {
NBNode* n = prohibitedFrom->getToNode();
n->addSortedLinkFoes(
NBConnection(prohibitorFrom, prohibitorTo),
NBConnection(prohibitedFrom, prohibitedTo));
}
}
if (!myHaveSeenInternalEdge) {
myNetBuilder.haveLoadedNetworkWithoutInternalEdges();
}
if (oc.isDefault("lefthand")) {
oc.set("lefthand", toString(myAmLefthand));
}
if (oc.isDefault("junctions.corner-detail")) {
oc.set("junctions.corner-detail", toString(myCornerDetail));
}
if (oc.isDefault("junctions.internal-link-detail") && myLinkDetail > 0) {
oc.set("junctions.internal-link-detail", toString(myLinkDetail));
}
if (!deprecatedVehicleClassesSeen.empty()) {
WRITE_WARNING("Deprecated vehicle class(es) '" + toString(deprecatedVehicleClassesSeen) + "' in input network.");
deprecatedVehicleClassesSeen.clear();
}
// add loaded crossings
if (!oc.getBool("no-internal-links")) {
for (std::map<std::string, std::vector<Crossing> >::const_iterator it = myPedestrianCrossings.begin(); it != myPedestrianCrossings.end(); ++it) {
NBNode* node = myNodeCont.retrieve((*it).first);
for (std::vector<Crossing>::const_iterator it_c = (*it).second.begin(); it_c != (*it).second.end(); ++it_c) {
const Crossing& crossing = (*it_c);
EdgeVector edges;
for (std::vector<std::string>::const_iterator it_e = crossing.crossingEdges.begin(); it_e != crossing.crossingEdges.end(); ++it_e) {
NBEdge* edge = myNetBuilder.getEdgeCont().retrieve(*it_e);
// edge might have been removed due to options
if (edge != 0) {
edges.push_back(edge);
}
}
if (edges.size() > 0) {
node->addCrossing(edges, crossing.width, crossing.priority, true);
}
}
}
}
// add roundabouts
for (std::vector<std::vector<std::string> >::const_iterator it = myRoundabouts.begin(); it != myRoundabouts.end(); ++it) {
EdgeSet roundabout;
for (std::vector<std::string>::const_iterator it_r = it->begin(); it_r != it->end(); ++it_r) {
NBEdge* edge = myNetBuilder.getEdgeCont().retrieve(*it_r);
if (edge == 0) {
if (!myNetBuilder.getEdgeCont().wasIgnored(*it_r)) {
WRITE_ERROR("Unknown edge '" + (*it_r) + "' in roundabout");
}
} else {
roundabout.insert(edge);
}
}
myNetBuilder.getEdgeCont().addRoundabout(roundabout);
}
}
NBTrafficLightLogic*
NBOwnTLDef::myCompute(const NBEdgeCont&,
unsigned int brakingTimeSeconds) {
const SUMOTime brakingTime = TIME2STEPS(brakingTimeSeconds);
const SUMOTime leftTurnTime = TIME2STEPS(6); // make configurable ?
// build complete lists first
const EdgeVector& incoming = getIncomingEdges();
EdgeVector fromEdges, toEdges;
std::vector<bool> isLeftMoverV, isTurnaround;
unsigned int noLanesAll = 0;
unsigned int noLinksAll = 0;
for (unsigned int i1 = 0; i1 < incoming.size(); i1++) {
unsigned int noLanes = incoming[i1]->getNumLanes();
noLanesAll += noLanes;
for (unsigned int i2 = 0; i2 < noLanes; i2++) {
NBEdge* fromEdge = incoming[i1];
std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
noLinksAll += (unsigned int) approached.size();
for (unsigned int i3 = 0; i3 < approached.size(); i3++) {
if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
--noLinksAll;
continue;
}
assert(i3 < approached.size());
NBEdge* toEdge = approached[i3].toEdge;
fromEdges.push_back(fromEdge);
//myFromLanes.push_back(i2);
toEdges.push_back(toEdge);
if (toEdge != 0) {
isLeftMoverV.push_back(
isLeftMover(fromEdge, toEdge)
||
fromEdge->isTurningDirectionAt(fromEdge->getToNode(), toEdge));
isTurnaround.push_back(
fromEdge->isTurningDirectionAt(
fromEdge->getToNode(), toEdge));
} else {
isLeftMoverV.push_back(true);
isTurnaround.push_back(true);
}
}
}
}
NBTrafficLightLogic* logic = new NBTrafficLightLogic(getID(), getProgramID(), noLinksAll, myOffset, myType);
EdgeVector toProc = incoming;
const SUMOTime greenTime = TIME2STEPS(OptionsCont::getOptions().getInt("tls.green.time"));
// build all phases
while (toProc.size() > 0) {
std::pair<NBEdge*, NBEdge*> chosen;
if (incoming.size() == 2) {
chosen = std::pair<NBEdge*, NBEdge*>(toProc[0], static_cast<NBEdge*>(0));
toProc.erase(toProc.begin());
} else {
chosen = getBestPair(toProc);
}
unsigned int pos = 0;
std::string state((size_t) noLinksAll, 'o');
// plain straight movers
for (unsigned int i1 = 0; i1 < (unsigned int) incoming.size(); ++i1) {
NBEdge* fromEdge = incoming[i1];
const bool inChosen = fromEdge == chosen.first || fromEdge == chosen.second; //chosen.find(fromEdge)!=chosen.end();
const unsigned int numLanes = fromEdge->getNumLanes();
for (unsigned int i2 = 0; i2 < numLanes; i2++) {
std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
for (unsigned int i3 = 0; i3 < approached.size(); ++i3) {
if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
continue;
}
if (inChosen) {
state[pos] = 'G';
} else {
state[pos] = 'r';
}
++pos;
}
}
}
// correct behaviour for those that are not in chosen, but may drive, though
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] == 'G') {
continue;
}
bool isForbidden = false;
for (unsigned int i2 = 0; i2 < pos && !isForbidden; ++i2) {
if (state[i2] == 'G' && !isTurnaround[i2] &&
(forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true) || forbids(fromEdges[i1], toEdges[i1], fromEdges[i2], toEdges[i2], true))) {
isForbidden = true;
}
}
if (!isForbidden) {
state[i1] = 'G';
}
}
// correct behaviour for those that have to wait (mainly left-mover)
bool haveForbiddenLeftMover = false;
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] != 'G') {
continue;
}
for (unsigned int i2 = 0; i2 < pos; ++i2) {
if ((state[i2] == 'G' || state[i2] == 'g') && forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true)) {
state[i1] = 'g';
if (!isTurnaround[i1]) {
haveForbiddenLeftMover = true;
}
}
}
}
// add step
logic->addStep(greenTime, state);
if (brakingTime > 0) {
// build yellow (straight)
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] != 'G' && state[i1] != 'g') {
continue;
}
if ((state[i1] >= 'a' && state[i1] <= 'z') && haveForbiddenLeftMover) {
continue;
}
state[i1] = 'y';
}
// add step
logic->addStep(brakingTime, state);
}
if (haveForbiddenLeftMover && !myHaveSinglePhase) {
// build left green
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] == 'Y' || state[i1] == 'y') {
state[i1] = 'r';
continue;
}
if (state[i1] == 'g') {
state[i1] = 'G';
}
}
// add step
logic->addStep(leftTurnTime, state);
// build left yellow
if (brakingTime > 0) {
for (unsigned int i1 = 0; i1 < pos; ++i1) {
if (state[i1] != 'G' && state[i1] != 'g') {
continue;
}
state[i1] = 'y';
}
// add step
logic->addStep(brakingTime, state);
}
}
}
const SUMOTime totalDuration = logic->getDuration();
if (totalDuration > 0) {
if (totalDuration > 3 * (greenTime + 2 * brakingTime + leftTurnTime)) {
WRITE_WARNING("The traffic light '" + getID() + "' has a high cycle time of " + time2string(totalDuration) + ".");
}
return logic;
} else {
delete logic;
return 0;
}
}
