GNEConnectorFrame::LaneStatus
GNEConnectorFrame::getLaneStatus(const std::vector<NBEdge::Connection>& connections, GNELane* targetLane) {
NBEdge* srcEdge = myCurrentLane->getParentEdge().getNBEdge();
const int fromIndex = myCurrentLane->getIndex();
NBEdge* destEdge = targetLane->getParentEdge().getNBEdge();
const int toIndex = targetLane->getIndex();
std::vector<NBEdge::Connection>::const_iterator con_it = find_if(
connections.begin(), connections.end(),
NBEdge::connections_finder(fromIndex, destEdge, toIndex));
const bool isConnected = con_it != connections.end();
if (isConnected) {
if (con_it->mayDefinitelyPass) {
return CONNECTED_PASS;
} else {
return CONNECTED;
}
} else if (srcEdge->hasConnectionTo(destEdge, toIndex)) {
return CONFLICTED;
} else {
return UNCONNECTED;
}
}
void
NIXMLConnectionsHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
if (element == SUMO_TAG_DELETE) {
bool ok = true;
std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, 0, ok);
std::string to = attrs.get<std::string>(SUMO_ATTR_TO, 0, ok);
if (!ok) {
return;
}
// these connections were removed when the edge was deleted
if (myEdgeCont.wasRemoved(from) || myEdgeCont.wasRemoved(to)) {
return;
}
NBEdge* fromEdge = myEdgeCont.retrieve(from);
NBEdge* toEdge = myEdgeCont.retrieve(to);
if (fromEdge == 0) {
myErrorMsgHandler->inform("The connection-source edge '" + from + "' to reset is not known.");
return;
}
if (toEdge == 0) {
myErrorMsgHandler->inform("The connection-destination edge '" + to + "' to reset is not known.");
return;
}
if (!fromEdge->isConnectedTo(toEdge) && fromEdge->getStep() >= NBEdge::EDGE2EDGES) {
WRITE_WARNING("Target edge '" + toEdge->getID() + "' is not connected with '" + fromEdge->getID() + "'; the connection cannot be reset.");
return;
}
int fromLane = -1; // Assume all lanes are to be reset.
int toLane = -1;
if (attrs.hasAttribute(SUMO_ATTR_LANE)
|| attrs.hasAttribute(SUMO_ATTR_FROM_LANE)
|| attrs.hasAttribute(SUMO_ATTR_TO_LANE)) {
if (!parseLaneInfo(attrs, fromEdge, toEdge, &fromLane, &toLane)) {
return;
}
// we could be trying to reset a connection loaded from a sumo net and which has become obsolete.
// In this case it's ok to encounter invalid lance indices
if (!fromEdge->hasConnectionTo(toEdge, toLane) && fromEdge->getStep() >= NBEdge::LANES2EDGES) {
WRITE_WARNING("Edge '" + fromEdge->getID() + "' has no connection to lane " + toString(toLane) + " of edge '" + toEdge->getID() + "'; the connection cannot be reset.");
}
}
fromEdge->removeFromConnections(toEdge, fromLane, toLane, true);
}
if (element == SUMO_TAG_CONNECTION) {
bool ok = true;
std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, "connection", ok);
std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "connection", ok, "");
if (!ok || myEdgeCont.wasIgnored(from) || myEdgeCont.wasIgnored(to)) {
return;
}
// extract edges
NBEdge* fromEdge = myEdgeCont.retrieve(from);
NBEdge* toEdge = to.length() != 0 ? myEdgeCont.retrieve(to) : 0;
// check whether they are valid
if (fromEdge == 0) {
myErrorMsgHandler->inform("The connection-source edge '" + from + "' is not known.");
return;
}
if (toEdge == 0 && to.length() != 0) {
myErrorMsgHandler->inform("The connection-destination edge '" + to + "' is not known.");
return;
}
fromEdge->getToNode()->invalidateTLS(myTLLogicCont, true, false);
// parse optional lane information
if (attrs.hasAttribute(SUMO_ATTR_LANE) || attrs.hasAttribute(SUMO_ATTR_FROM_LANE) || attrs.hasAttribute(SUMO_ATTR_TO_LANE)) {
parseLaneBound(attrs, fromEdge, toEdge);
} else {
fromEdge->addEdge2EdgeConnection(toEdge);
}
}
if (element == SUMO_TAG_PROHIBITION) {
bool ok = true;
std::string prohibitor = attrs.getOpt<std::string>(SUMO_ATTR_PROHIBITOR, 0, ok, "");
std::string prohibited = attrs.getOpt<std::string>(SUMO_ATTR_PROHIBITED, 0, ok, "");
if (!ok) {
return;
}
NBConnection prohibitorC = parseConnection("prohibitor", prohibitor);
NBConnection prohibitedC = parseConnection("prohibited", prohibited);
if (prohibitorC == NBConnection::InvalidConnection || prohibitedC == NBConnection::InvalidConnection) {
// something failed
return;
}
NBNode* n = prohibitorC.getFrom()->getToNode();
n->addSortedLinkFoes(prohibitorC, prohibitedC);
}
if (element == SUMO_TAG_CROSSING) {
addCrossing(attrs);
}
if (element == SUMO_TAG_WALKINGAREA) {
addWalkingArea(attrs);
}
}
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);
}
}
