// ---- the root/edge - element
void
NLHandler::beginEdgeParsing(const SUMOSAXAttributes& attrs) {
bool ok = true;
myCurrentIsBroken = false;
// get the id, report an error if not given or empty...
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
myCurrentIsBroken = true;
return;
}
// omit internal edges if not wished
if (!MSGlobals::gUsingInternalLanes && id[0] == ':') {
myHaveSeenInternalEdge = true;
myCurrentIsInternalToSkip = true;
return;
}
myCurrentIsInternalToSkip = false;
// parse the function
const SumoXMLEdgeFunc func = attrs.getEdgeFunc(ok);
if (!ok) {
WRITE_ERROR("Edge '" + id + "' has an invalid type.");
myCurrentIsBroken = true;
return;
}
// interpret the function
MSEdge::EdgeBasicFunction funcEnum = MSEdge::EDGEFUNCTION_UNKNOWN;
switch (func) {
case EDGEFUNC_NORMAL:
funcEnum = MSEdge::EDGEFUNCTION_NORMAL;
break;
case EDGEFUNC_CONNECTOR:
case EDGEFUNC_SINK:
case EDGEFUNC_SOURCE:
funcEnum = MSEdge::EDGEFUNCTION_CONNECTOR;
break;
case EDGEFUNC_INTERNAL:
funcEnum = MSEdge::EDGEFUNCTION_INTERNAL;
break;
}
// get the street name
std::string streetName = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
if (!ok) {
myCurrentIsBroken = true;
return;
}
//
try {
myEdgeControlBuilder.beginEdgeParsing(id, funcEnum, streetName);
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
myCurrentIsBroken = true;
}
}
void
NIImporter_SUMO::addEdge(const SUMOSAXAttributes& attrs) {
// get the id, report an error if not given or empty...
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
myCurrentEdge = new EdgeAttrs();
myCurrentEdge->builtEdge = 0;
myCurrentEdge->id = id;
// get the function
myCurrentEdge->func = attrs.getEdgeFunc(ok);
if (myCurrentEdge->func == EDGEFUNC_CROSSING) {
// add the crossing but don't do anything else
Crossing c;
c.edgeID = id;
SUMOSAXAttributes::parseStringVector(attrs.get<std::string>(SUMO_ATTR_CROSSING_EDGES, 0, ok), c.crossingEdges);
myPedestrianCrossings[SUMOXMLDefinitions::getJunctionIDFromInternalEdge(id)].push_back(c);
return;
} else if (myCurrentEdge->func == EDGEFUNC_INTERNAL || myCurrentEdge->func == EDGEFUNC_WALKINGAREA) {
return; // skip internal edges
}
// get the type
myCurrentEdge->type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
// get the origin and the destination node
myCurrentEdge->fromNode = attrs.getOpt<std::string>(SUMO_ATTR_FROM, id.c_str(), ok, "");
myCurrentEdge->toNode = attrs.getOpt<std::string>(SUMO_ATTR_TO, id.c_str(), ok, "");
myCurrentEdge->priority = attrs.getOpt<int>(SUMO_ATTR_PRIORITY, id.c_str(), ok, -1);
myCurrentEdge->type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
myCurrentEdge->shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok, PositionVector());
NBNetBuilder::transformCoordinates(myCurrentEdge->shape, true, myLocation);
myCurrentEdge->length = attrs.getOpt<SUMOReal>(SUMO_ATTR_LENGTH, id.c_str(), ok, NBEdge::UNSPECIFIED_LOADED_LENGTH);
myCurrentEdge->maxSpeed = 0;
myCurrentEdge->streetName = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), ok, "");
if (myCurrentEdge->streetName != "" && OptionsCont::getOptions().isDefault("output.street-names")) {
OptionsCont::getOptions().set("output.street-names", "true");
}
std::string lsfS = toString(LANESPREAD_RIGHT);
lsfS = attrs.getOpt<std::string>(SUMO_ATTR_SPREADTYPE, id.c_str(), ok, lsfS);
if (SUMOXMLDefinitions::LaneSpreadFunctions.hasString(lsfS)) {
myCurrentEdge->lsf = SUMOXMLDefinitions::LaneSpreadFunctions.get(lsfS);
} else {
WRITE_ERROR("Unknown spreadType '" + lsfS + "' for edge '" + id + "'.");
}
}
void
NIImporter_SUMO::addEdge(const SUMOSAXAttributes& attrs) {
// get the id, report an error if not given or empty...
bool ok = true;
std::string id = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
myCurrentEdge = new EdgeAttrs();
myCurrentEdge->builtEdge = 0;
myCurrentEdge->id = id;
// get the function
myCurrentEdge->func = attrs.getEdgeFunc(ok);
if (myCurrentEdge->func == EDGEFUNC_INTERNAL) {
return; // skip internal edges
}
// get the type
myCurrentEdge->type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, id.c_str(), ok, "");
// get the origin and the destination node
myCurrentEdge->fromNode = attrs.getOptStringReporting(SUMO_ATTR_FROM, id.c_str(), ok, "");
myCurrentEdge->toNode = attrs.getOptStringReporting(SUMO_ATTR_TO, id.c_str(), ok, "");
myCurrentEdge->priority = attrs.getOptIntReporting(SUMO_ATTR_PRIORITY, id.c_str(), ok, -1);
myCurrentEdge->type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, id.c_str(), ok, "");
myCurrentEdge->shape = attrs.getShapeReporting(SUMO_ATTR_SHAPE, id.c_str(), ok, true);
NILoader::transformCoordinates(myCurrentEdge->shape, true, myLocation);
myCurrentEdge->length = attrs.getOptSUMORealReporting(SUMO_ATTR_LENGTH, id.c_str(), ok, NBEdge::UNSPECIFIED_LOADED_LENGTH);
myCurrentEdge->maxSpeed = 0;
myCurrentEdge->streetName = attrs.getOptStringReporting(SUMO_ATTR_NAME, id.c_str(), ok, "");
std::string lsfS = toString(LANESPREAD_RIGHT);
lsfS = attrs.getOptStringReporting(SUMO_ATTR_SPREADTYPE, id.c_str(), ok, lsfS);
if (SUMOXMLDefinitions::LaneSpreadFunctions.hasString(lsfS)) {
myCurrentEdge->lsf = SUMOXMLDefinitions::LaneSpreadFunctions.get(lsfS);
} else {
WRITE_ERROR("Unknown spreadType '" + lsfS + "' for edge '" + id + "'.");
}
}
void
RONetHandler::parseEdge(const SUMOSAXAttributes& attrs) {
// get the id, report an error if not given or empty...
bool ok = true;
myCurrentName = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
throw ProcessError();
}
const SumoXMLEdgeFunc func = attrs.getEdgeFunc(ok);
if (!ok) {
WRITE_ERROR("Edge '" + myCurrentName + "' has an unknown type.");
return;
}
// get the edge
std::string from;
std::string to;
RONode* fromNode;
RONode* toNode;
int priority;
myCurrentEdge = 0;
if (func == EDGEFUNC_INTERNAL || func == EDGEFUNC_CROSSING || func == EDGEFUNC_WALKINGAREA) {
assert(myCurrentName[0] == ':');
std::string junctionID = myCurrentName.substr(1, myCurrentName.rfind('_') - 1);
myJunctionGraph[myCurrentName] = std::make_pair(junctionID, junctionID);
from = junctionID;
to = junctionID;
priority = 0;
} else {
from = attrs.get<std::string>(SUMO_ATTR_FROM, myCurrentName.c_str(), ok);
to = attrs.get<std::string>(SUMO_ATTR_TO, myCurrentName.c_str(), ok);
priority = attrs.get<int>(SUMO_ATTR_PRIORITY, myCurrentName.c_str(), ok);
if (!ok) {
return;
}
}
myJunctionGraph[myCurrentName] = std::make_pair(from, to);
fromNode = myNet.getNode(from);
if (fromNode == 0) {
fromNode = new RONode(from);
myNet.addNode(fromNode);
}
toNode = myNet.getNode(to);
if (toNode == 0) {
toNode = new RONode(to);
myNet.addNode(toNode);
}
// build the edge
myCurrentEdge = myEdgeBuilder.buildEdge(myCurrentName, fromNode, toNode, priority);
// set the type
myCurrentEdge->setRestrictions(myNet.getRestrictions(attrs.getOpt<std::string>(SUMO_ATTR_TYPE, myCurrentName.c_str(), ok, "")));
myProcess = true;
switch (func) {
case EDGEFUNC_CONNECTOR:
case EDGEFUNC_NORMAL:
myCurrentEdge->setFunc(ROEdge::ET_NORMAL);
break;
case EDGEFUNC_SOURCE:
myCurrentEdge->setFunc(ROEdge::ET_SOURCE);
break;
case EDGEFUNC_SINK:
myCurrentEdge->setFunc(ROEdge::ET_SINK);
break;
case EDGEFUNC_WALKINGAREA:
myCurrentEdge->setFunc(ROEdge::ET_WALKINGAREA);
break;
case EDGEFUNC_CROSSING:
myCurrentEdge->setFunc(ROEdge::ET_CROSSING);
break;
case EDGEFUNC_INTERNAL:
myCurrentEdge->setFunc(ROEdge::ET_INTERNAL);
myProcess = false;
break;
default:
throw ProcessError("Unhandled EdgeFunc " + toString(func));
}
if (!myNet.addEdge(myCurrentEdge)) {
myCurrentEdge = 0;
}
}
void
RONetHandler::parseEdge(const SUMOSAXAttributes& attrs) {
// get the id, report an error if not given or empty...
bool ok = true;
myCurrentName = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
throw ProcessError();
}
const SumoXMLEdgeFunc type = attrs.getEdgeFunc(ok);
if (!ok) {
WRITE_ERROR("Edge '" + myCurrentName + "' has an unknown type.");
return;
}
// get the edge
RONode* fromNode;
RONode* toNode;
int priority;
myCurrentEdge = 0;
if (type == EDGEFUNC_INTERNAL) {
// this is an internal edge - for now we only us it the ensure a match
// between numerical edge ids in router and simulation
// !!! recheck this; internal edges may be of importance during the dua
fromNode = 0;
toNode = 0;
priority = 0;
} else {
const std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, myCurrentName.c_str(), ok);
const std::string to = attrs.get<std::string>(SUMO_ATTR_TO, myCurrentName.c_str(), ok);
priority = attrs.get<int>(SUMO_ATTR_PRIORITY, myCurrentName.c_str(), ok);
if (!ok) {
return;
}
fromNode = myNet.getNode(from);
if (fromNode == 0) {
fromNode = new RONode(from);
myNet.addNode(fromNode);
}
toNode = myNet.getNode(to);
if (toNode == 0) {
toNode = new RONode(to);
myNet.addNode(toNode);
}
}
// build the edge
myCurrentEdge = myEdgeBuilder.buildEdge(myCurrentName, fromNode, toNode, priority);
// set the type
myProcess = true;
switch (type) {
case EDGEFUNC_CONNECTOR:
case EDGEFUNC_NORMAL:
myCurrentEdge->setType(ROEdge::ET_NORMAL);
break;
case EDGEFUNC_SOURCE:
myCurrentEdge->setType(ROEdge::ET_SOURCE);
break;
case EDGEFUNC_SINK:
myCurrentEdge->setType(ROEdge::ET_SINK);
break;
case EDGEFUNC_INTERNAL:
myCurrentEdge->setType(ROEdge::ET_INTERNAL);
myProcess = false;
break;
default:
throw ProcessError("Unhandled EdgeFunk " + toString(type));
}
if (!myNet.addEdge(myCurrentEdge)) {
myCurrentEdge = 0;
}
}