SUMOVehicleShape
SUMOVehicleParserHelper::parseGuiShape(const SUMOSAXAttributes& attrs, const std::string& id) {
bool ok = true;
std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_GUISHAPE, id.c_str(), ok, "");
if (SumoVehicleShapeStrings.hasString(vclassS)) {
const SUMOVehicleShape result = SumoVehicleShapeStrings.get(vclassS);
const std::string& realName = SumoVehicleShapeStrings.getString(result);
if (realName != vclassS) {
WRITE_WARNING("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
}
return result;
} else {
WRITE_ERROR("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is not known.");
return SVS_UNKNOWN;
}
}
void
NIImporter_SUMO::addLane(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string id = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
if (!myCurrentEdge) {
WRITE_ERROR("Found lane '" + id + "' not within edge element");
return;
}
myCurrentLane = new LaneAttrs;
if (myCurrentEdge->func == toString(EDGEFUNC_INTERNAL)) {
return; // skip internal lanes
}
if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED__DEPRECATED)) {
myCurrentLane->maxSpeed = attrs.getSUMORealReporting(SUMO_ATTR_MAXSPEED__DEPRECATED, id.c_str(), ok);
if (!myHaveWarnedAboutDeprecatedMaxSpeed) {
myHaveWarnedAboutDeprecatedMaxSpeed = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_MAXSPEED__DEPRECATED) + "' is deprecated, please use '" + toString(SUMO_ATTR_SPEED) + "' instead.");
}
} else {
myCurrentLane->maxSpeed = attrs.getSUMORealReporting(SUMO_ATTR_SPEED, id.c_str(), ok);
}
myCurrentLane->allow = attrs.getOptStringReporting(SUMO_ATTR_ALLOW, id.c_str(), ok, "");
myCurrentLane->disallow = attrs.getOptStringReporting(SUMO_ATTR_DISALLOW, id.c_str(), ok, "");
myCurrentLane->width = attrs.getOptSUMORealReporting(SUMO_ATTR_WIDTH, id.c_str(), ok, (SUMOReal) NBEdge::UNSPECIFIED_WIDTH);
myCurrentLane->offset = attrs.getOptSUMORealReporting(SUMO_ATTR_ENDOFFSET, id.c_str(), ok, (SUMOReal) NBEdge::UNSPECIFIED_OFFSET);
myCurrentLane->shape = GeomConvHelper::parseShapeReporting(
attrs.getStringReporting(SUMO_ATTR_SHAPE, id.c_str(), ok),
attrs.getObjectType(), id.c_str(), ok, false);
// lane coordinates are derived (via lane spread) do not include them in convex boundary
NILoader::transformCoordinates(myCurrentLane->shape, false, myLocation);
}
SUMOEmissionClass
SUMOVehicleParserHelper::parseEmissionClass(const SUMOSAXAttributes& attrs, const std::string& id) {
try {
bool ok = true;
std::string eClassS = attrs.getOpt<std::string>(SUMO_ATTR_EMISSIONCLASS, id.c_str(), ok, "");
return PollutantsInterface::getClassByName(eClassS);
} catch (...) {
WRITE_ERROR("The emission class for " + attrs.getObjectType() + " '" + id + "' is not known.");
return 0;
}
}
SUMOVehicleClass
SUMOVehicleParserHelper::parseVehicleClass(const SUMOSAXAttributes& attrs,
const std::string& id) {
SUMOVehicleClass vclass = SVC_IGNORING;
try {
bool ok = true;
std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok, "");
if (vclassS == "") {
return vclass;
}
const SUMOVehicleClass result = getVehicleClassID(vclassS);
const std::string& realName = SumoVehicleClassStrings.getString(result);
if (realName != vclassS) {
WRITE_WARNING("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
}
return result;
} catch (...) {
WRITE_ERROR("The class for " + attrs.getObjectType() + " '" + id + "' is not known.");
}
return vclass;
}
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.getOptStringReporting(SUMO_ATTR_FUNCTION, id.c_str(), ok, "normal");
if (myCurrentEdge->func == toString(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 = GeomConvHelper::parseShapeReporting(
attrs.getOptStringReporting(SUMO_ATTR_SHAPE, id.c_str(), ok, ""),
attrs.getObjectType(), 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);
if (attrs.hasAttribute(SUMO_ATTR_SPREADFUNC__DEPRECATED)) {
lsfS = attrs.getStringReporting(SUMO_ATTR_SPREADFUNC__DEPRECATED, id.c_str(), ok);
if (!myHaveWarnedAboutDeprecatedSpreadType) {
WRITE_WARNING("'" + toString(SUMO_ATTR_SPREADFUNC__DEPRECATED) + "' is deprecated; please use '" + toString(SUMO_ATTR_SPREADTYPE) + "'.");
myHaveWarnedAboutDeprecatedSpreadType = true;
}
} else {
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
NIImporter_SUMO::addJunction(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;
}
if (id[0] == ':') { // internal node
return;
}
SumoXMLNodeType type = NODETYPE_UNKNOWN;
std::string typeS = attrs.getStringReporting(SUMO_ATTR_TYPE, id.c_str(), ok);
if (SUMOXMLDefinitions::NodeTypes.hasString(typeS)) {
type = SUMOXMLDefinitions::NodeTypes.get(typeS);
if (type == NODETYPE_DEAD_END_DEPRECATED) { // patch legacy type
type = NODETYPE_DEAD_END;
}
} else {
WRITE_WARNING("Unknown node type '" + typeS + "' for junction '" + id + "'.");
}
Position pos = readPosition(attrs, id, ok);
NILoader::transformCoordinates(pos, true, myLocation);
// the network may have been built with the option "plain.keep-edge-shape" this
// makes accurate reconstruction of legacy networks impossible. We ought to warn about this
std::string shapeS = attrs.getStringReporting(SUMO_ATTR_SHAPE, id.c_str(), ok, false);
if (shapeS != "") {
PositionVector shape = GeomConvHelper::parseShapeReporting(
shapeS, attrs.getObjectType(), id.c_str(), ok, false);
shape.push_back_noDoublePos(shape[0]); // need closed shape
if (!shape.around(pos) && shape.distance(pos) > 1) { // MAGIC_THRESHOLD
// WRITE_WARNING("Junction '" + id + "': distance between pos and shape is " + toString(shape.distance(pos)));
mySuspectKeepShape = true;
}
}
NBNode* node = new NBNode(id, pos, type);
if (!myNodeCont.insert(node)) {
WRITE_ERROR("Problems on adding junction '" + id + "'.");
delete node;
return;
}
}
std::pair<std::string, SUMOReal>
ODDistrictHandler::parseConnection(const SUMOSAXAttributes& attrs) {
// check the current district first
if (myCurrentDistrict == 0) {
return std::pair<std::string, SUMOReal>("", -1);
}
// 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 std::pair<std::string, SUMOReal>("", -1);
}
// get the weight
SUMOReal weight = attrs.get<SUMOReal>(SUMO_ATTR_WEIGHT, id.c_str(), ok);
if (ok) {
if (weight < 0) {
WRITE_ERROR("'probability' must be positive (in definition of " + attrs.getObjectType() + " '" + id + "').");
} else {
return std::pair<std::string, SUMOReal>(id, weight);
}
}
return std::pair<std::string, SUMOReal>("", -1);
}
void
MSRouteHandler::openRoute(const SUMOSAXAttributes& attrs) {
// check whether the id is really necessary
std::string rid;
if (myCurrentRouteDistribution != 0) {
myActiveRouteID = myCurrentRouteDistributionID + "#" + toString(myCurrentRouteDistribution->getProbs().size()); // !!! document this
rid = "distribution '" + myCurrentRouteDistributionID + "'";
} else if (myVehicleParameter != 0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
myActiveRouteID = "!" + myVehicleParameter->id; // !!! document this
if (attrs.hasAttribute(SUMO_ATTR_ID)) {
WRITE_WARNING("Ids of internal routes are ignored (vehicle '" + myVehicleParameter->id + "').");
}
} else {
bool ok = true;
myActiveRouteID = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok, false);
if (!ok) {
return;
}
rid = "'" + myActiveRouteID + "'";
}
if (myVehicleParameter != 0) { // have to do this here for nested route distributions
rid = "for vehicle '" + myVehicleParameter->id + "'";
}
bool ok = true;
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, myActiveRouteID.c_str(), ok), myActiveRoute, rid);
}
myActiveRouteRefID = attrs.getOptStringReporting(SUMO_ATTR_REFID, myActiveRouteID.c_str(), ok, "");
if (attrs.hasAttribute(SUMO_ATTR_REFID__DEPRECATED)) {
myActiveRouteRefID = attrs.getOptStringReporting(SUMO_ATTR_REFID__DEPRECATED, myActiveRouteID.c_str(), ok, "");
if (!myHaveWarnedAboutDeprecatedRefID) {
myHaveWarnedAboutDeprecatedRefID = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_REFID__DEPRECATED) + "' is deprecated, please use '" + toString(SUMO_ATTR_REFID) + "' instead.");
}
}
if (myActiveRouteRefID != "" && MSRoute::dictionary(myActiveRouteRefID) == 0) {
WRITE_ERROR("Invalid reference to route '" + myActiveRouteRefID + "' in route " + rid + ".");
}
myActiveRouteProbability = attrs.getOptSUMORealReporting(SUMO_ATTR_PROB, myActiveRouteID.c_str(), ok, DEFAULT_VEH_PROB);
myActiveRouteColor = attrs.hasAttribute(SUMO_ATTR_COLOR) ? RGBColor::parseColorReporting(attrs.getString(SUMO_ATTR_COLOR), attrs.getObjectType(), myActiveRouteID.c_str(), true, ok) : RGBColor::getDefaultColor();
}