void
GNELane::setAttribute(SumoXMLAttr key, const std::string& value) {
NBEdge* edge = myParentEdge.getNBEdge();
switch (key) {
case SUMO_ATTR_ID:
throw InvalidArgument("modifying lane attribute '" + toString(key) + "' not allowed");
case SUMO_ATTR_SPEED:
edge->setSpeed(myIndex, parse<SUMOReal>(value));
break;
case SUMO_ATTR_ALLOW:
edge->setPermissions(parseVehicleClasses(value), myIndex);
break;
case SUMO_ATTR_DISALLOW:
edge->setPermissions(~parseVehicleClasses(value), myIndex); // negation yields allowed
break;
case SUMO_ATTR_WIDTH:
edge->setLaneWidth(myIndex, parse<SUMOReal>(value));
break;
case SUMO_ATTR_ENDOFFSET:
edge->setEndOffset(myIndex, parse<SUMOReal>(value));
break;
default:
throw InvalidArgument("lane attribute '" + toString(key) + "' not allowed");
}
}
void
NIImporter_SUMO::_loadNetwork(const 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::exists(*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);
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 == toString(EDGEFUNC_INTERNAL)) {
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;
mySuspectKeepShape = false; // no problem with reconstruction if edge shape is given explicit
} 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;
}
nbe->addLane2LaneConnection(
fromLaneIndex, toEdge, c.toLaneIdx, NBEdge::L2L_VALIDATED,
false, c.mayDefinitelyPass);
// maybe we have a tls-controlled connection
if (c.tlID != "") {
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
SUMOVehicleClasses allowed;
SUMOVehicleClasses disallowed;
parseVehicleClasses(lane->allow, lane->disallow, allowed, disallowed);
nbe->setVehicleClasses(allowed, disallowed, fromLaneIndex);
// width, offset
nbe->setWidth(fromLaneIndex, lane->width);
nbe->setOffset(fromLaneIndex, lane->offset);
nbe->setSpeed(fromLaneIndex, lane->maxSpeed);
}
nbe->declareConnectionsAsLoaded();
}
// insert loaded prohibitions
for (std::vector<Prohibition>::const_iterator it = myProhibitions.begin(); it != myProhibitions.end(); it++) {
NBEdge* prohibitedFrom = myEdges[it->prohibitedFrom]->builtEdge;
if (prohibitedFrom == 0) {
WRITE_ERROR("Edge '" + it->prohibitedFrom + "' in prohibition was not built");
} else {
NBNode* n = prohibitedFrom->getToNode();
n->addSortedLinkFoes(
NBConnection(myEdges[it->prohibitorFrom]->builtEdge, myEdges[it->prohibitorTo]->builtEdge),
NBConnection(prohibitedFrom, myEdges[it->prohibitedTo]->builtEdge));
}
}
// final warning
if (mySuspectKeepShape) {
WRITE_WARNING("The input network may have been built using option 'xml.keep-shape'.\n... Accuracy of junction positions cannot be guaranteed.");
}
}
void
NIVissimEdge::buildNBEdge(NBDistrictCont& dc, NBNodeCont& nc, NBEdgeCont& ec,
SUMOReal sameNodesOffset) {
// build the edge
std::pair<NIVissimConnectionCluster*, NBNode*> fromInf, toInf;
NBNode* fromNode, *toNode;
fromNode = toNode = 0;
sort(myConnectionClusters.begin(), myConnectionClusters.end(), connection_cluster_position_sorter(myID));
sort(myDistrictConnections.begin(), myDistrictConnections.end());
ConnectionClusters tmpClusters = myConnectionClusters;
if (tmpClusters.size() != 0) {
sort(tmpClusters.begin(), tmpClusters.end(), connection_cluster_position_sorter(myID));
// get or build the from-node
// A node may have to be build when the edge starts or ends at
// a parking place or something like this
fromInf = getFromNode(nc, tmpClusters);
fromNode = fromInf.second;
// get or build the to-node
//if(tmpClusters.size()>0) {
toInf = getToNode(nc, tmpClusters);
toNode = toInf.second;
if (fromInf.first != 0 && toNode != 0 && fromInf.first->around(toNode->getPosition())) {
WRITE_WARNING("Will not build edge '" + toString(myID) + "'.");
myAmWithinJunction = true;
return;
}
//}
// if both nodes are the same, resolve the problem otherwise
if (fromNode == toNode) {
std::pair<NBNode*, NBNode*> tmp = resolveSameNode(nc, sameNodesOffset, fromNode, toNode);
if (fromNode != tmp.first) {
fromInf.first = 0;
}
if (toNode != tmp.second) {
toInf.first = 0;
}
fromNode = tmp.first;
toNode = tmp.second;
}
}
//
if (fromNode == 0) {
fromInf.first = 0;
Position pos = myGeom[0];
fromNode = new NBNode(toString<int>(myID) + "-SourceNode", pos, NODETYPE_NOJUNCTION);
if (!nc.insert(fromNode)) {
throw ProcessError("Could not insert node '" + fromNode->getID() + "' to nodes container.");
}
}
if (toNode == 0) {
toInf.first = 0;
Position pos = myGeom[-1];
toNode = new NBNode(toString<int>(myID) + "-DestinationNode", pos, NODETYPE_NOJUNCTION);
if (!nc.insert(toNode)) {
throw ProcessError("Could not insert node '" + toNode->getID() + "' to nodes container.");
}
}
// build the edge
SUMOReal avgSpeed = 0;
int i;
for (i = 0; i < (int) myNoLanes; i++) {
if (myLaneSpeeds.size() <= (size_t) i || myLaneSpeeds[i] == -1) {
myLanesWithMissingSpeeds.push_back(toString(myID) + "_" + toString(i));
avgSpeed += OptionsCont::getOptions().getFloat("vissim.default-speed");
} else {
avgSpeed += myLaneSpeeds[i];
}
}
avgSpeed /= (SUMOReal) myLaneSpeeds.size();
avgSpeed *= OptionsCont::getOptions().getFloat("vissim.speed-norm");
if (fromNode == toNode) {
WRITE_WARNING("Could not build edge '" + toString(myID) + "'; would connect same node.");
return;
}
NBEdge* buildEdge = new NBEdge(toString<int>(myID), fromNode, toNode, myType,
avgSpeed / (SUMOReal) 3.6, myNoLanes, -1,
NBEdge::UNSPECIFIED_WIDTH, NBEdge::UNSPECIFIED_OFFSET,
myGeom, myName, LANESPREAD_CENTER, true);
for (i = 0; i < (int) myNoLanes; i++) {
if ((int) myLaneSpeeds.size() <= i || myLaneSpeeds[i] == -1) {
buildEdge->setSpeed(i, OptionsCont::getOptions().getFloat("vissim.default-speed") / (SUMOReal) 3.6);
} else {
buildEdge->setSpeed(i, myLaneSpeeds[i] / (SUMOReal) 3.6);
}
}
ec.insert(buildEdge);
// check whether the edge contains any other clusters
if (tmpClusters.size() > 0) {
bool cont = true;
for (ConnectionClusters::iterator j = tmpClusters.begin(); cont && j != tmpClusters.end(); ++j) {
// split the edge at the previously build node
std::string nextID = buildEdge->getID() + "[1]";
cont = ec.splitAt(dc, buildEdge, (*j)->getNBNode());
// !!! what to do if the edge could not be split?
buildEdge = ec.retrieve(nextID);
}
}
}
bool
NBEdgeCont::splitAt(NBDistrictCont& dc,
NBEdge* edge, SUMOReal pos, NBNode* node,
const std::string& firstEdgeName,
const std::string& secondEdgeName,
unsigned int noLanesFirstEdge, unsigned int noLanesSecondEdge) {
// build the new edges' geometries
std::pair<PositionVector, PositionVector> geoms =
edge->getGeometry().splitAt(pos);
if (geoms.first[-1] != node->getPosition()) {
geoms.first.pop_back();
geoms.first.push_back(node->getPosition());
}
if (geoms.second[0] != node->getPosition()) {
geoms.second.pop_front();
geoms.second.push_front(node->getPosition());
}
// build and insert the edges
NBEdge* one = new NBEdge(firstEdgeName,
edge->myFrom, node, edge->myType, edge->mySpeed, noLanesFirstEdge,
edge->getPriority(), edge->myLaneWidth, 0, geoms.first,
edge->getStreetName(), edge->myLaneSpreadFunction, true);
for (unsigned int i = 0; i < noLanesFirstEdge && i < edge->getNumLanes(); i++) {
one->setSpeed(i, edge->getLaneSpeed(i));
}
NBEdge* two = new NBEdge(secondEdgeName,
node, edge->myTo, edge->myType, edge->mySpeed, noLanesSecondEdge,
edge->getPriority(), edge->myLaneWidth, edge->myOffset, geoms.second,
edge->getStreetName(), edge->myLaneSpreadFunction, true);
for (unsigned int i = 0; i < noLanesSecondEdge && i < edge->getNumLanes(); i++) {
two->setSpeed(i, edge->getLaneSpeed(i));
}
two->copyConnectionsFrom(edge);
// replace information about this edge within the nodes
edge->myFrom->replaceOutgoing(edge, one, 0);
edge->myTo->replaceIncoming(edge, two, 0);
// the edge is now occuring twice in both nodes...
// clean up
edge->myFrom->removeDoubleEdges();
edge->myTo->removeDoubleEdges();
// add connections from the first to the second edge
// check special case:
// one in, one out, the outgoing has one lane more
if (noLanesFirstEdge == noLanesSecondEdge - 1) {
for (unsigned int i = 0; i < one->getNumLanes(); i++) {
if (!one->addLane2LaneConnection(i, two, i + 1, NBEdge::L2L_COMPUTED)) { // !!! Bresenham, here!!!
throw ProcessError("Could not set connection!");
}
}
one->addLane2LaneConnection(0, two, 0, NBEdge::L2L_COMPUTED);
} else {
for (unsigned int i = 0; i < one->getNumLanes() && i < two->getNumLanes(); i++) {
if (!one->addLane2LaneConnection(i, two, i, NBEdge::L2L_COMPUTED)) {// !!! Bresenham, here!!!
throw ProcessError("Could not set connection!");
}
}
}
if (myRemoveEdgesAfterJoining) {
if (find(myEdges2Keep.begin(), myEdges2Keep.end(), edge->getID()) != myEdges2Keep.end()) {
myEdges2Keep.insert(one->getID());
myEdges2Keep.insert(two->getID());
}
if (find(myEdges2Remove.begin(), myEdges2Remove.end(), edge->getID()) != myEdges2Remove.end()) {
myEdges2Remove.insert(one->getID());
myEdges2Remove.insert(two->getID());
}
}
// erase the splitted edge
erase(dc, edge);
insert(one, true);
insert(two, true);
myEdgesSplit++;
return true;
}
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);
}
}
