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);
}
Position
NIImporter_SUMO::readPosition(const SUMOSAXAttributes& attrs, const std::string& id, bool& ok) {
SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_X, id.c_str(), ok);
SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_Y, id.c_str(), ok);
SUMOReal z = 0;
if (attrs.hasAttribute(SUMO_ATTR_Z)) {
z = attrs.getSUMORealReporting(SUMO_ATTR_Z, id.c_str(), ok);
}
return Position(x, y, z);
}
void
NIXMLEdgesHandler::addLane(const SUMOSAXAttributes& attrs) {
if (myCurrentEdge == 0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
WRITE_ERROR("Additional lane information could not be set - the edge with id '" + myCurrentID + "' is not known.");
}
return;
}
bool ok = true;
int lane;
if (attrs.hasAttribute(SUMO_ATTR_ID)) {
lane = attrs.getIntReporting(SUMO_ATTR_ID, myCurrentID.c_str(), ok);
if (!myHaveWarnedAboutDeprecatedLaneId) {
myHaveWarnedAboutDeprecatedLaneId = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_ID) + "' is deprecated, please use '" + toString(SUMO_ATTR_INDEX) + "' instead.");
}
} else {
lane = attrs.getIntReporting(SUMO_ATTR_INDEX, myCurrentID.c_str(), ok);
}
std::string allowed, disallowed, preferred;
allowed = attrs.getOptStringReporting(SUMO_ATTR_ALLOW, 0, ok, "");
disallowed = attrs.getOptStringReporting(SUMO_ATTR_DISALLOW, 0, ok, "");
preferred = attrs.getOptStringReporting(SUMO_ATTR_PREFER, 0, ok, "");
if (!ok) {
return;
}
// check whether this lane exists
if (lane >= (int) myCurrentEdge->getNumLanes()) {
WRITE_ERROR("Lane index is larger than number of lanes (edge '" + myCurrentID + "').");
return;
}
// set information about allowed / disallowed vehicle classes
myCurrentEdge->setPermissions(parseVehicleClasses(allowed, disallowed), lane);
myCurrentEdge->setPreferredVehicleClass(parseVehicleClasses(preferred), lane);
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
myCurrentEdge->setWidth(lane, attrs.getSUMORealReporting(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok));
}
// try to get the end-offset (lane shortened due to pedestrian crossing etc..)
if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
myCurrentEdge->setOffset(lane, attrs.getSUMORealReporting(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok));
}
// try to get lane specific speed (should not occur for german networks)
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
myCurrentEdge->setSpeed(lane, attrs.getSUMORealReporting(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok));
}
}
void NIXMLEdgesHandler::addSplit(const SUMOSAXAttributes& attrs) {
if (myCurrentEdge == 0) {
WRITE_WARNING("Ignoring 'split' because it cannot be assigned to an edge");
return;
}
bool ok = true;
Split e;
e.pos = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, 0, ok);
if (ok) {
if (fabs(e.pos) > myCurrentEdge->getGeometry().length()) {
WRITE_ERROR("Edge '" + myCurrentID + "' has a split at invalid position " + toString(e.pos) + ".");
return;
}
std::vector<Split>::iterator i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder(e.pos));
if (i != mySplits.end()) {
WRITE_ERROR("Edge '" + myCurrentID + "' has already a split at position " + toString(e.pos) + ".");
return;
}
e.nameid = (int)e.pos;
if (myCurrentEdge == 0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
WRITE_ERROR("Additional lane information could not be set - the edge with id '" + myCurrentID + "' is not known.");
}
return;
}
if (e.pos < 0) {
e.pos += myCurrentEdge->getGeometry().length();
}
std::vector<std::string> lanes;
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_LANES, 0, ok, ""), lanes);
for (std::vector<std::string>::iterator i = lanes.begin(); i != lanes.end(); ++i) {
try {
int lane = TplConvert::_2int((*i).c_str());
e.lanes.push_back(lane);
} catch (NumberFormatException&) {
WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
} catch (EmptyData&) {
WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
}
}
if (e.lanes.empty()) {
for (size_t l = 0; l < myCurrentEdge->getNumLanes(); ++l) {
e.lanes.push_back((int) l);
}
}
mySplits.push_back(e);
}
}
void
NIImporter_SUMO::addPhase(const SUMOSAXAttributes& attrs, NBLoadedSUMOTLDef* currentTL) {
if (!currentTL) {
WRITE_ERROR("found phase without tl-logic");
return;
}
const std::string& id = currentTL->getID();
bool ok = true;
std::string state = attrs.getStringReporting(SUMO_ATTR_STATE, id.c_str(), ok);
SUMOTime duration = TIME2STEPS(attrs.getSUMORealReporting(SUMO_ATTR_DURATION, id.c_str(), ok));
if (duration < 0) {
WRITE_ERROR("Phase duration for tl-logic '" + id + "/" + currentTL->getProgramID() + "' must be positive.");
return;
}
// if the traffic light is an actuated traffic light, try to get
// the minimum and maximum durations
//SUMOTime minDuration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MINDURATION, id.c_str(), ok, -1);
//SUMOTime maxDuration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MAXDURATION, id.c_str(), ok, -1);
if (ok) {
currentTL->addPhase(duration, state);
}
}
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 == EDGEFUNC_INTERNAL) {
return; // skip internal lanes
}
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 = attrs.getShapeReporting(SUMO_ATTR_SHAPE, 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);
}
void
PCLoaderXML::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
if (element != SUMO_TAG_POI && element != SUMO_TAG_POLY) {
return;
}
if (element == SUMO_TAG_POI) {
bool ok = true;
// get the id, report an error if not given or empty...
std::string id = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_X, id.c_str(), ok);
SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_Y, id.c_str(), ok);
std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, id.c_str(), ok, "");
if (!ok) {
return;
}
Position pos(x, y);
if (!GeoConvHelper::getProcessing().x2cartesian(pos)) {
WRITE_WARNING("Unable to project coordinates for POI '" + id + "'.");
}
// patch the values
bool discard = myOptions.getBool("discard");
int layer = myOptions.getInt("layer");
RGBColor color;
if (myTypeMap.has(type)) {
const PCTypeMap::TypeDef& def = myTypeMap.get(type);
id = def.prefix + id;
type = def.id;
color = RGBColor::parseColor(def.color);
discard = def.discard;
layer = def.layer;
} else {
id = myOptions.getString("prefix") + id;
type = myOptions.getString("type");
color = RGBColor::parseColor(myOptions.getString("color"));
}
if (!discard) {
bool ignorePrunning = false;
if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) {
ignorePrunning = true;
}
PointOfInterest* poi = new PointOfInterest(id, type, pos, color);
if (!myCont.insert(id, poi, layer, ignorePrunning)) {
WRITE_ERROR("POI '" + id + "' could not been added.");
delete poi;
}
}
}
if (element == SUMO_TAG_POLY) {
bool discard = myOptions.getBool("discard");
int layer = myOptions.getInt("layer");
bool ok = true;
std::string id = attrs.getOptStringReporting(SUMO_ATTR_ID, myCurrentID.c_str(), ok, "");
std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok, "");
if (!ok) {
return;
}
RGBColor color;
if (myTypeMap.has(type)) {
const PCTypeMap::TypeDef& def = myTypeMap.get(type);
id = def.prefix + id;
type = def.id;
color = RGBColor::parseColor(def.color);
discard = def.discard;
layer = def.layer;
} else {
id = myOptions.getString("prefix") + id;
type = myOptions.getString("type");
color = RGBColor::parseColor(myOptions.getString("color"));
}
if (!discard) {
bool ignorePrunning = false;
if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) {
ignorePrunning = true;
}
myCurrentID = id;
myCurrentType = type;
myCurrentColor = color;
myCurrentIgnorePrunning = ignorePrunning;
myCurrentLayer = layer;
if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
// @deprecated At some time, no shape definition using characters will be allowed
myCharacters(element, attrs.getStringReporting(SUMO_ATTR_SHAPE, myCurrentID.c_str(), ok));
}
}
}
}
void
GUISettingsHandler::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
bool ok = true;
switch (element) {
case SUMO_TAG_DELAY:
myDelay = attrs.getOptSUMORealReporting(SUMO_ATTR_VALUE, "delay", 0, ok, myDelay);
break;
case SUMO_TAG_VIEWPORT:
myZoom = attrs.getOptSUMORealReporting(SUMO_ATTR_ZOOM, "viewport", 0, ok, myZoom);
myXPos = attrs.getOptSUMORealReporting(SUMO_ATTR_X, "viewport", 0, ok, myXPos);
myYPos = attrs.getOptSUMORealReporting(SUMO_ATTR_Y, "viewport", 0, ok, myYPos);
break;
case SUMO_TAG_SNAPSHOT: {
bool ok = true;
std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, "snapshot", 0, ok);
if (file != "" && !FileHelpers::isAbsolute(file)) {
file = FileHelpers::getConfigurationRelative(getFileName(), file);
}
mySnapshots[attrs.getOptSUMOTimeReporting(SUMO_ATTR_TIME, "snapshot", file.c_str(), ok, 0)] = file;
}
break;
case SUMO_TAG_VIEWSETTINGS_SCHEME: {
bool ok = true;
mySettings.name = attrs.getOptStringReporting(SUMO_ATTR_NAME, 0, 0, ok, mySettings.name);
if (gSchemeStorage.contains(mySettings.name)) {
mySettings = gSchemeStorage.get(mySettings.name);
}
}
break;
case SUMO_TAG_VIEWSETTINGS_OPENGL:
mySettings.antialiase = TplConvert<char>::_2bool(attrs.getStringSecure("antialiase", toString(mySettings.antialiase)).c_str());
mySettings.dither = TplConvert<char>::_2bool(attrs.getStringSecure("dither", toString(mySettings.dither)).c_str());
break;
case SUMO_TAG_VIEWSETTINGS_BACKGROUND: {
bool ok = true;
mySettings.backgroundColor = RGBColor::parseColorReporting(attrs.getStringSecure("backgroundColor", toString(mySettings.backgroundColor)), "background", 0, true, ok);
mySettings.showGrid = TplConvert<char>::_2bool(attrs.getStringSecure("showGrid", toString(mySettings.showGrid)).c_str());
mySettings.gridXSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("gridXSize", toString(mySettings.gridXSize)).c_str());
mySettings.gridYSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("gridYSize", toString(mySettings.gridYSize)).c_str());
}
break;
case SUMO_TAG_VIEWSETTINGS_EDGES: {
bool ok = true;
int laneEdgeMode = TplConvert<char>::_2int(attrs.getStringSecure("laneEdgeMode", "0").c_str());
mySettings.laneShowBorders = TplConvert<char>::_2bool(attrs.getStringSecure("laneShowBorders", toString(mySettings.laneShowBorders)).c_str());
mySettings.showLinkDecals = TplConvert<char>::_2bool(attrs.getStringSecure("showLinkDecals", toString(mySettings.showLinkDecals)).c_str());
mySettings.showRails = TplConvert<char>::_2bool(attrs.getStringSecure("showRails", toString(mySettings.showRails)).c_str());
mySettings.drawEdgeName = TplConvert<char>::_2bool(attrs.getStringSecure("drawEdgeName", toString(mySettings.drawEdgeName)).c_str());
mySettings.edgeNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("edgeNameSize", toString(mySettings.edgeNameSize)).c_str());
mySettings.edgeNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("edgeNameColor", toString(mySettings.edgeNameColor)), "edges", 0, true, ok);
mySettings.drawInternalEdgeName = TplConvert<char>::_2bool(attrs.getStringSecure("drawInternalEdgeName", toString(mySettings.drawInternalEdgeName)).c_str());
mySettings.internalEdgeNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("internalEdgeNameSize", toString(mySettings.internalEdgeNameSize)).c_str());
mySettings.internalEdgeNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("internalEdgeNameColor", toString(mySettings.internalEdgeNameColor)), "edges", 0, true, ok);
mySettings.hideConnectors = TplConvert<char>::_2bool(attrs.getStringSecure("hideConnectors", toString(mySettings.hideConnectors)).c_str());
myCurrentColorer = element;
#ifdef HAVE_MESOSIM
mySettings.edgeColorer.setActive(laneEdgeMode);
#endif
mySettings.laneColorer.setActive(laneEdgeMode);
}
break;
case SUMO_TAG_COLORSCHEME:
myCurrentScheme = 0;
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_EDGES) {
myCurrentScheme = mySettings.laneColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
#ifdef HAVE_MESOSIM
if (myCurrentScheme == 0) {
myCurrentScheme = mySettings.edgeColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
#endif
}
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_VEHICLES) {
myCurrentScheme = mySettings.vehicleColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentScheme && !myCurrentScheme->isFixed()) {
bool ok = true;
myCurrentScheme->setInterpolated(attrs.getOptBoolReporting(SUMO_ATTR_INTERPOLATED, "colorScheme", 0, ok, false));
myCurrentScheme->clear();
}
break;
case SUMO_TAG_ENTRY:
if (myCurrentScheme) {
bool ok = true;
std::string colorStr = attrs.getStringReporting(SUMO_ATTR_COLOR, "entry", 0, ok);
RGBColor color = RGBColor::parseColorReporting(colorStr, "edgeColoring", 0, true, ok);
if (myCurrentScheme->isFixed()) {
myCurrentScheme->setColor(attrs.getStringSecure(SUMO_ATTR_NAME, ""), color);
} else {
myCurrentScheme->addColor(color,
attrs.getSUMORealReporting(SUMO_ATTR_THRESHOLD, "entry", 0, ok));
}
}
break;
case SUMO_TAG_VIEWSETTINGS_VEHICLES:
mySettings.vehicleColorer.setActive(TplConvert<char>::_2int(attrs.getStringSecure("vehicleMode", "0").c_str()));
mySettings.vehicleQuality = TplConvert<char>::_2int(attrs.getStringSecure("vehicleQuality", toString(mySettings.vehicleQuality)).c_str());
mySettings.minVehicleSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("minVehicleSize", toString(mySettings.minVehicleSize)).c_str());
mySettings.vehicleExaggeration = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("vehicleExaggeration", toString(mySettings.vehicleExaggeration)).c_str());
mySettings.showBlinker = TplConvert<char>::_2bool(attrs.getStringSecure("showBlinker", toString(mySettings.showBlinker)).c_str());
mySettings.drawVehicleName = TplConvert<char>::_2bool(attrs.getStringSecure("drawVehicleName", toString(mySettings.drawVehicleName)).c_str());
mySettings.vehicleNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("vehicleNameSize", toString(mySettings.vehicleNameSize)).c_str());
mySettings.vehicleNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("vehicleNameColor", toString(mySettings.vehicleNameColor)), "vehicles", 0, true, ok);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_JUNCTIONS:
mySettings.junctionMode = TplConvert<char>::_2int(attrs.getStringSecure("junctionMode", toString(mySettings.junctionMode)).c_str());
mySettings.drawLinkTLIndex = TplConvert<char>::_2bool(attrs.getStringSecure("drawLinkTLIndex", toString(mySettings.drawLinkTLIndex)).c_str());
mySettings.drawLinkJunctionIndex = TplConvert<char>::_2bool(attrs.getStringSecure("drawLinkJunctionIndex", toString(mySettings.drawLinkJunctionIndex)).c_str());
mySettings.drawJunctionName = TplConvert<char>::_2bool(attrs.getStringSecure("drawJunctionName", toString(mySettings.drawJunctionName)).c_str());
mySettings.junctionNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("junctionNameSize", toString(mySettings.junctionNameSize)).c_str());
mySettings.junctionNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("junctionNameColor", toString(mySettings.junctionNameColor)), "junctions", 0, true, ok);
mySettings.showLane2Lane = TplConvert<char>::_2bool(attrs.getStringSecure("showLane2Lane", toString(mySettings.showLane2Lane)).c_str());
break;
case SUMO_TAG_VIEWSETTINGS_ADDITIONALS:
mySettings.addMode = TplConvert<char>::_2int(attrs.getStringSecure("addMode", toString(mySettings.addMode)).c_str());
mySettings.minAddSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("minAddSize", toString(mySettings.minAddSize)).c_str());
mySettings.addExaggeration = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("addExaggeration", toString(mySettings.addExaggeration)).c_str());
mySettings.drawAddName = TplConvert<char>::_2bool(attrs.getStringSecure("drawAddName", toString(mySettings.drawAddName)).c_str());
mySettings.addNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("addNameSize", toString(mySettings.addNameSize)).c_str());
break;
case SUMO_TAG_VIEWSETTINGS_POIS:
mySettings.poiExaggeration = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("poiExaggeration", toString(mySettings.poiExaggeration)).c_str());
mySettings.minPOISize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("minPOISize", toString(mySettings.minPOISize)).c_str());
mySettings.drawPOIName = TplConvert<char>::_2bool(attrs.getStringSecure("drawPOIName", toString(mySettings.drawPOIName)).c_str());
mySettings.poiNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("poiNameSize", toString(mySettings.poiNameSize)).c_str());
mySettings.poiNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("poiNameColor", toString(mySettings.poiNameColor)), "pois", 0, true, ok);
break;
case SUMO_TAG_VIEWSETTINGS_LEGEND:
mySettings.showSizeLegend = TplConvert<char>::_2bool(attrs.getStringSecure("showSizeLegend", toString(mySettings.showSizeLegend)).c_str());
break;
case SUMO_TAG_VIEWSETTINGS_DECAL: {
GUISUMOAbstractView::Decal d;
d.filename = attrs.getStringSecure("filename", d.filename);
if (d.filename != "" && !FileHelpers::isAbsolute(d.filename)) {
d.filename = FileHelpers::getConfigurationRelative(getFileName(), d.filename);
}
d.centerX = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("centerX", toString(d.centerX)).c_str());
d.centerY = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("centerY", toString(d.centerY)).c_str());
d.width = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("width", toString(d.width)).c_str());
d.height = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("height", toString(d.height)).c_str());
d.rot = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("rotation", toString(d.rot)).c_str());
d.initialised = false;
myDecals.push_back(d);
}
break;
}
}
void
PCLoaderXML::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
if (element != SUMO_TAG_POI && element != SUMO_TAG_POLY) {
return;
}
if (element == SUMO_TAG_POI) {
bool ok = true;
// get the id, report an error if not given or empty...
std::string id = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_X, id.c_str(), ok);
SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_Y, id.c_str(), ok);
std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, id.c_str(), ok, myOptions.getString("type"));
if (!ok) {
return;
}
Position pos(x, y);
if (!GeoConvHelper::getProcessing().x2cartesian(pos)) {
WRITE_WARNING("Unable to project coordinates for POI '" + id + "'.");
}
// patch the values
bool discard = myOptions.getBool("discard");
SUMOReal layer = (SUMOReal)myOptions.getInt("layer");
RGBColor color;
if (myTypeMap.has(type)) {
const PCTypeMap::TypeDef& def = myTypeMap.get(type);
id = def.prefix + id;
type = def.id;
color = RGBColor::parseColor(def.color);
discard = def.discard;
layer = (SUMOReal)def.layer;
} else {
id = myOptions.getString("prefix") + id;
color = RGBColor::parseColor(myOptions.getString("color"));
}
layer = attrs.getOptSUMORealReporting(SUMO_ATTR_LAYER, id.c_str(), ok, layer);
if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
color = attrs.getColorReporting(id.c_str(), ok);
}
SUMOReal angle = attrs.getOptSUMORealReporting(SUMO_ATTR_ANGLE, id.c_str(), ok, Shape::DEFAULT_ANGLE);
std::string imgFile = attrs.getOptStringReporting(SUMO_ATTR_IMGFILE, id.c_str(), ok, Shape::DEFAULT_IMG_FILE);
if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) {
imgFile = FileHelpers::getConfigurationRelative(getFileName(), imgFile);
}
SUMOReal imgWidth = attrs.getOptSUMORealReporting(SUMO_ATTR_WIDTH, id.c_str(), ok, Shape::DEFAULT_IMG_WIDTH);
SUMOReal imgHeight = attrs.getOptSUMORealReporting(SUMO_ATTR_HEIGHT, id.c_str(), ok, Shape::DEFAULT_IMG_HEIGHT);
if (!ok) {
return;
}
if (!discard) {
bool ignorePrunning = false;
if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) {
ignorePrunning = true;
}
PointOfInterest* poi = new PointOfInterest(id, type, color, pos, layer, angle, imgFile, imgWidth, imgHeight);
if (!myCont.insert(id, poi, (int)layer, ignorePrunning)) {
WRITE_ERROR("POI '" + id + "' could not be added.");
delete poi;
}
}
}
if (element == SUMO_TAG_POLY) {
bool discard = myOptions.getBool("discard");
SUMOReal layer = (SUMOReal)myOptions.getInt("layer");
bool ok = true;
std::string id = attrs.getOptStringReporting(SUMO_ATTR_ID, myCurrentID.c_str(), ok, "");
std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok, myOptions.getString("type"));
if (!ok) {
return;
}
RGBColor color;
if (myTypeMap.has(type)) {
const PCTypeMap::TypeDef& def = myTypeMap.get(type);
id = def.prefix + id;
type = def.id;
color = RGBColor::parseColor(def.color);
discard = def.discard;
layer = (SUMOReal)def.layer;
} else {
id = myOptions.getString("prefix") + id;
color = RGBColor::parseColor(myOptions.getString("color"));
}
layer = attrs.getOptSUMORealReporting(SUMO_ATTR_LAYER, id.c_str(), ok, layer);
if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
color = attrs.getColorReporting(id.c_str(), ok);
}
SUMOReal angle = attrs.getOptSUMORealReporting(SUMO_ATTR_ANGLE, id.c_str(), ok, Shape::DEFAULT_ANGLE);
std::string imgFile = attrs.getOptStringReporting(SUMO_ATTR_IMGFILE, id.c_str(), ok, Shape::DEFAULT_IMG_FILE);
if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) {
imgFile = FileHelpers::getConfigurationRelative(getFileName(), imgFile);
}
bool fill = attrs.getOptBoolReporting(SUMO_ATTR_FILL, id.c_str(), ok, false);
if (!ok) {
return;
}
if (!discard) {
bool ignorePrunning = false;
if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) {
ignorePrunning = true;
}
myCurrentID = id;
myCurrentType = type;
myCurrentColor = color;
myCurrentIgnorePrunning = ignorePrunning;
myCurrentLayer = layer;
PositionVector pshape = attrs.getShapeReporting(SUMO_ATTR_SHAPE, myCurrentID.c_str(), ok, false);
if (!ok) {
return;
}
PositionVector shape;
for (PositionVector::ContType::const_iterator i = pshape.begin(); i != pshape.end(); ++i) {
Position pos((*i));
if (!GeoConvHelper::getProcessing().x2cartesian(pos)) {
WRITE_WARNING("Unable to project coordinates for polygon '" + myCurrentID + "'.");
}
shape.push_back(pos);
}
Polygon* poly = new Polygon(myCurrentID, myCurrentType, myCurrentColor, shape, fill, layer, angle, imgFile);
if (!myCont.insert(myCurrentID, poly, (int)myCurrentLayer, myCurrentIgnorePrunning)) {
WRITE_ERROR("Polygon '" + myCurrentID + "' could not be added.");
delete poly;
}
}
}
}
void
NIXMLEdgesHandler::addEdge(const SUMOSAXAttributes& attrs) {
myIsUpdate = false;
bool ok = true;
// initialise the edge
myCurrentEdge = 0;
mySplits.clear();
// get the id, report an error if not given or empty...
myCurrentID = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
myCurrentEdge = myEdgeCont.retrieve(myCurrentID);
// check deprecated (unused) attributes
// use default values, first
myCurrentSpeed = myTypeCont.getSpeed("");
myCurrentPriority = myTypeCont.getPriority("");
myCurrentLaneNo = myTypeCont.getNumLanes("");
myPermissions = myTypeCont.getPermissions("");
myCurrentWidth = myTypeCont.getWidth("");
myCurrentOffset = NBEdge::UNSPECIFIED_OFFSET;
myCurrentType = "";
myShape = PositionVector();
myLanesSpread = LANESPREAD_RIGHT;
myLength = NBEdge::UNSPECIFIED_LOADED_LENGTH;
myCurrentStreetName = "";
myReinitKeepEdgeShape = false;
// check whether a type's values shall be used
if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
myCurrentType = attrs.getStringReporting(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok);
if (!ok) {
return;
}
if (!myTypeCont.knows(myCurrentType)) {
WRITE_ERROR("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined.");
return;
}
myCurrentSpeed = myTypeCont.getSpeed(myCurrentType);
myCurrentPriority = myTypeCont.getPriority(myCurrentType);
myCurrentLaneNo = myTypeCont.getNumLanes(myCurrentType);
myPermissions = myTypeCont.getPermissions(myCurrentType);
myCurrentWidth = myTypeCont.getWidth(myCurrentType);
}
// use values from the edge to overwrite if existing, then
if (myCurrentEdge != 0) {
myIsUpdate = true;
if (!myHaveReportedAboutOverwriting) {
WRITE_MESSAGE("Duplicate edge id occured ('" + myCurrentID + "'); assuming overwriting is wished.");
myHaveReportedAboutOverwriting = true;
}
if (attrs.getOptBoolReporting(SUMO_ATTR_REMOVE, myCurrentID.c_str(), ok, false)) {
myEdgeCont.erase(myDistrictCont, myCurrentEdge);
myCurrentEdge = 0;
return;
}
myCurrentSpeed = myCurrentEdge->getSpeed();
myCurrentPriority = myCurrentEdge->getPriority();
myCurrentLaneNo = myCurrentEdge->getNumLanes();
myCurrentType = myCurrentEdge->getTypeID();
myPermissions = myCurrentEdge->getPermissions();
if (!myCurrentEdge->hasDefaultGeometry()) {
myShape = myCurrentEdge->getGeometry();
myReinitKeepEdgeShape = true;
}
myCurrentWidth = myCurrentEdge->getWidth();
myCurrentOffset = myCurrentEdge->getOffset();
myLanesSpread = myCurrentEdge->getLaneSpreadFunction();
if (myCurrentEdge->hasLoadedLength()) {
myLength = myCurrentEdge->getLoadedLength();
}
myCurrentStreetName = myCurrentEdge->getStreetName();
}
// speed, priority and the number of lanes have now default values;
// try to read the real values from the file
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
myCurrentSpeed = attrs.getSUMORealReporting(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok);
}
if (myOptions.getBool("speed-in-kmh")) {
myCurrentSpeed = myCurrentSpeed / (SUMOReal) 3.6;
}
// try to get the number of lanes
if (attrs.hasAttribute(SUMO_ATTR_NUMLANES)) {
myCurrentLaneNo = attrs.getIntReporting(SUMO_ATTR_NUMLANES, myCurrentID.c_str(), ok);
}
// try to get the priority
if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
myCurrentPriority = attrs.getIntReporting(SUMO_ATTR_PRIORITY, myCurrentID.c_str(), ok);
}
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
myCurrentWidth = attrs.getSUMORealReporting(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok);
}
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
myCurrentOffset = attrs.getSUMORealReporting(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok);
}
// try to get the street name
myCurrentStreetName = attrs.getOptStringReporting(SUMO_ATTR_NAME, myCurrentID.c_str(), ok, myCurrentStreetName);
// try to get the allowed/disallowed classes
if (attrs.hasAttribute(SUMO_ATTR_ALLOW) || attrs.hasAttribute(SUMO_ATTR_DISALLOW)) {
std::string allowS = attrs.hasAttribute(SUMO_ATTR_ALLOW) ? attrs.getStringSecure(SUMO_ATTR_ALLOW, "") : "";
std::string disallowS = attrs.hasAttribute(SUMO_ATTR_DISALLOW) ? attrs.getStringSecure(SUMO_ATTR_DISALLOW, "") : "";
// XXX matter of interpretation: should updated permissions replace or extend previously set permissions?
myPermissions = parseVehicleClasses(allowS, disallowS);
}
// try to set the nodes
if (!setNodes(attrs)) {
// return if this failed
return;
}
// try to get the shape
myShape = tryGetShape(attrs);
// try to get the spread type
myLanesSpread = tryGetLaneSpread(attrs);
// try to get the length
myLength = attrs.getOptSUMORealReporting(SUMO_ATTR_LENGTH, myCurrentID.c_str(), ok, myLength);
// insert the parsed edge into the edges map
if (!ok) {
return;
}
// check whether a previously defined edge shall be overwritten
if (myCurrentEdge != 0) {
myCurrentEdge->reinit(myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myShape,
myCurrentWidth, myCurrentOffset,
myCurrentStreetName, myLanesSpread,
myReinitKeepEdgeShape);
} else {
// the edge must be allocated in dependence to whether a shape is given
if (myShape.size() == 0) {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myCurrentWidth, myCurrentOffset,
myCurrentStreetName, myLanesSpread);
} else {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myCurrentWidth, myCurrentOffset,
myShape, myCurrentStreetName, myLanesSpread,
myKeepEdgeShape);
}
}
myCurrentEdge->setLoadedLength(myLength);
myCurrentEdge->setPermissions(myPermissions);
}
void
NIImporter_OpenDrive::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
bool ok = true;
switch (element) {
case SUMO_TAG_OPENDRIVE_HEADER: {
int majorVersion = attrs.getIntReporting(SUMO_ATTR_OPENDRIVE_REVMAJOR, "opendrive header", 0, ok);
int minorVersion = attrs.getIntReporting(SUMO_ATTR_OPENDRIVE_REVMINOR, "opendrive header", 0, ok);
if (majorVersion!=1||minorVersion!=2) {
MsgHandler::getWarningInstance()->inform("Given openDrive file '" + getFileName() + "' uses version " + toString(majorVersion) + "." + toString(minorVersion) + ";\n Version 1.2 is supported.");
}
}
break;
case SUMO_TAG_OPENDRIVE_ROAD: {
std::string id =
attrs.hasAttribute(SUMO_ATTR_OPENDRIVE_ID)
? attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_ID, "road", 0, ok)
: attrs.getStringReporting(SUMO_ATTR_ID, "road", 0, ok);
std::cout << "found edge '" << id << "'" << std::endl;
std::string junction = attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_JUNCTION, "road", id.c_str(), ok);
SUMOReal length = attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_LENGTH, "road", id.c_str(), ok);
myCurrentEdge = OpenDriveEdge(id, junction, length);
}
break;
case SUMO_TAG_OPENDRIVE_PREDECESSOR: {
if (myElementStack.size()>=2&&myElementStack[myElementStack.size()-2]==SUMO_TAG_OPENDRIVE_ROAD) {
std::string elementType = attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_ELEMENTTYPE, "predecessor", myCurrentEdge.id.c_str(), ok);
std::string elementID = attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_ELEMENTID, "predecessor", myCurrentEdge.id.c_str(), ok);
std::string contactPoint = attrs.hasAttribute(SUMO_ATTR_OPENDRIVE_CONTACTPOINT)
? attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_CONTACTPOINT, "predecessor", myCurrentEdge.id.c_str(), ok)
: "end";
addLink(OPENDRIVE_LT_PREDECESSOR, elementType, elementID, contactPoint);
}
if (myElementStack.size()>=2&&myElementStack[myElementStack.size()-2]==SUMO_TAG_OPENDRIVE_LANE||myElementStack[myElementStack.size()-2]==SUMO_TAG_LANE) { // !!!
int no = attrs.getIntReporting(SUMO_ATTR_ID, "predecessor", myCurrentEdge.id.c_str(), ok);
OpenDriveLane &l = myCurrentEdge.laneSections[myCurrentEdge.laneSections.size()-1].lanesByDir[myCurrentLaneDirection].back();
l.predecessor = no;
}
}
break;
case SUMO_TAG_OPENDRIVE_SUCCESSOR: {
if (myElementStack.size()>=2&&myElementStack[myElementStack.size()-2]==SUMO_TAG_OPENDRIVE_ROAD) {
std::string elementType = attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_ELEMENTTYPE, "successor", myCurrentEdge.id.c_str(), ok);
std::string elementID = attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_ELEMENTID, "successor", myCurrentEdge.id.c_str(), ok);
std::string contactPoint = attrs.hasAttribute(SUMO_ATTR_OPENDRIVE_CONTACTPOINT)
? attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_CONTACTPOINT, "successor", myCurrentEdge.id.c_str(), ok)
: "start";
addLink(OPENDRIVE_LT_SUCCESSOR, elementType, elementID, contactPoint);
}
if (myElementStack.size()>=2&&myElementStack[myElementStack.size()-2]==SUMO_TAG_OPENDRIVE_LANE||myElementStack[myElementStack.size()-2]==SUMO_TAG_LANE) { // !!!
int no = attrs.getIntReporting(SUMO_ATTR_ID, "predecessor", myCurrentEdge.id.c_str(), ok);
OpenDriveLane &l = myCurrentEdge.laneSections[myCurrentEdge.laneSections.size()-1].lanesByDir[myCurrentLaneDirection].back();
l.successor = no;
}
}
break;
case SUMO_TAG_OPENDRIVE_GEOMETRY: {
SUMOReal length = attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_LENGTH, "geometry", myCurrentEdge.id.c_str(), ok);
SUMOReal s = attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_S, "geometry", myCurrentEdge.id.c_str(), ok);
SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_X, "geometry", myCurrentEdge.id.c_str(), ok);
SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_Y, "geometry", myCurrentEdge.id.c_str(), ok);
SUMOReal hdg = attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_HDG, "geometry", myCurrentEdge.id.c_str(), ok);
myCurrentEdge.geometries.push_back(OpenDriveGeometry(length, s, x, y, hdg));
}
break;
case SUMO_TAG_OPENDRIVE_LINE: {
std::vector<SUMOReal> vals;
addGeometryShape(OPENDRIVE_GT_LINE, vals);
}
break;
case SUMO_TAG_OPENDRIVE_SPIRAL: {
std::vector<SUMOReal> vals;
vals.push_back(attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_CURVSTART, "spiral", myCurrentEdge.id.c_str(), ok));
vals.push_back(attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_CURVEND, "spiral", myCurrentEdge.id.c_str(), ok));
addGeometryShape(OPENDRIVE_GT_SPIRAL, vals);
}
break;
case SUMO_TAG_OPENDRIVE_ARC: {
std::vector<SUMOReal> vals;
vals.push_back(attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_CURVATURE, "arc", myCurrentEdge.id.c_str(), ok));
addGeometryShape(OPENDRIVE_GT_ARC, vals);
}
break;
case SUMO_TAG_OPENDRIVE_POLY3: {
std::vector<SUMOReal> vals;
vals.push_back(attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_A, "poly3", myCurrentEdge.id.c_str(), ok));
vals.push_back(attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_B, "poly3", myCurrentEdge.id.c_str(), ok));
vals.push_back(attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_C, "poly3", myCurrentEdge.id.c_str(), ok));
vals.push_back(attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_D, "poly3", myCurrentEdge.id.c_str(), ok));
addGeometryShape(OPENDRIVE_GT_POLY3, vals);
}
break;
case SUMO_TAG_OPENDRIVE_LANESECTION: {
SUMOReal s = attrs.getSUMORealReporting(SUMO_ATTR_OPENDRIVE_S, "geometry", myCurrentEdge.id.c_str(), ok);
myCurrentEdge.laneSections.push_back(OpenDriveLaneSection(s));
}
break;
case SUMO_TAG_OPENDRIVE_LEFT:
case SUMO_TAG_OPENDRIVE_CENTER:
case SUMO_TAG_OPENDRIVE_RIGHT:
myCurrentLaneDirection = element;
break;
case SUMO_TAG_LANE: // !!!
case SUMO_TAG_OPENDRIVE_LANE: {
std::string type = attrs.getStringReporting(SUMO_ATTR_OPENDRIVE_TYPE, "lane", myCurrentEdge.id.c_str(), ok);
int id = attrs.hasAttribute(SUMO_ATTR_OPENDRIVE_ID)
? attrs.getIntReporting(SUMO_ATTR_OPENDRIVE_ID, "lane", myCurrentEdge.id.c_str(), ok)
: attrs.getIntReporting(SUMO_ATTR_ID, "lane", myCurrentEdge.id.c_str(), ok);
int level = attrs.hasAttribute(SUMO_ATTR_OPENDRIVE_LEVEL)
? attrs.getIntReporting(SUMO_ATTR_OPENDRIVE_LEVEL, "lane", myCurrentEdge.id.c_str(), ok)
: 0;
OpenDriveLaneSection &ls = myCurrentEdge.laneSections[myCurrentEdge.laneSections.size()-1];
ls.lanesByDir[myCurrentLaneDirection].push_back(OpenDriveLane(id, level, type));
}
default:
break;
}
myElementStack.push_back(element);
}
void
NIXMLEdgesHandler::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
if (element==SUMO_TAG_EDGE) {
myIsUpdate = false;
bool ok = true;
// initialise the edge
myCurrentEdge = 0;
mySplits.clear();
// get the id, report an error if not given or empty...
if (!attrs.setIDFromAttributes("edge", myCurrentID)) {
return;
}
myCurrentEdge = myEdgeCont.retrieve(myCurrentID);
// check deprecated (unused) attributes
if (!myHaveReportedAboutFunctionDeprecation&&attrs.hasAttribute(SUMO_ATTR_FUNCTION)) {
MsgHandler::getWarningInstance()->inform("While parsing edge '" + myCurrentID + "': 'function' is deprecated.\n All occurences are ignored.");
myHaveReportedAboutFunctionDeprecation = true;
}
// use default values, first
myCurrentSpeed = myTypeCont.getDefaultSpeed();
myCurrentPriority = myTypeCont.getDefaultPriority();
myCurrentLaneNo = myTypeCont.getDefaultNoLanes();
// use values from the edge to overwrite if existing, then
if (myCurrentEdge!=0) {
myIsUpdate = true;
if (!myHaveReportedAboutOverwriting) {
MsgHandler::getMessageInstance()->inform("Duplicate edge id occured ('" + myCurrentID + "'); assuming overwriting is wished.");
myHaveReportedAboutOverwriting = true;
}
myCurrentSpeed = myCurrentEdge->getSpeed();
myCurrentPriority = myCurrentEdge->getPriority();
myCurrentLaneNo = myCurrentEdge->getNoLanes();
myCurrentType = myCurrentEdge->getTypeID();
}
// check whether a type's values shall be used
myCurrentType = "";
if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
myCurrentType = attrs.getStringReporting(SUMO_ATTR_TYPE, "edge", myCurrentID.c_str(), ok);
if (!ok) {
return;
}
if (!myTypeCont.knows(myCurrentType)) {
MsgHandler::getErrorInstance()->inform("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined.");
return;
}
myCurrentSpeed = myTypeCont.getSpeed(myCurrentType);
myCurrentPriority = myTypeCont.getPriority(myCurrentType);
myCurrentLaneNo = myTypeCont.getNoLanes(myCurrentType);
}
// speed, priority and the number of lanes have now default values;
// try to read the real values from the file
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
myCurrentSpeed = attrs.getSUMORealReporting(SUMO_ATTR_SPEED, "edge", myCurrentID.c_str(), ok);
}
if (myOptions.getBool("speed-in-kmh")) {
myCurrentSpeed = myCurrentSpeed / (SUMOReal) 3.6;
}
// try to get the number of lanes
if (attrs.hasAttribute(SUMO_ATTR_NOLANES)) {
myCurrentLaneNo = attrs.getIntReporting(SUMO_ATTR_NOLANES, "edge", myCurrentID.c_str(), ok);
}
// try to get the priority
if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
myCurrentPriority = attrs.getIntReporting(SUMO_ATTR_PRIORITY, "edge", myCurrentID.c_str(), ok);
}
// try to get the shape
myShape = tryGetShape(attrs);
// and how to spread the lanes
if (attrs.getOptStringReporting(SUMO_ATTR_SPREADFUNC, "edge", myCurrentID.c_str(), ok, "")=="center") {
myLanesSpread = NBEdge::LANESPREAD_CENTER;
} else {
myLanesSpread = NBEdge::LANESPREAD_RIGHT;
}
// try to set the nodes
if (!setNodes(attrs)) {
// return if this failed
return;
}
// get the length or compute it
if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
myLength = attrs.getSUMORealReporting(SUMO_ATTR_LENGTH, "edge", myCurrentID.c_str(), ok);
} else {
myLength = 0;
}
/// insert the parsed edge into the edges map
if (!ok) {
return;
}
// check whether a previously defined edge shall be overwritten
if (myCurrentEdge!=0) {
myCurrentEdge->reinit(myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myShape,
myLanesSpread);
} else {
// the edge must be allocated in dependence to whether a shape is given
if (myShape.size()==0) {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myLanesSpread);
} else {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myShape,
myLanesSpread, OptionsCont::getOptions().getBool("xml.keep-shape"));
}
myCurrentEdge->setLoadedLength(myLength);
}
}
if (element==SUMO_TAG_LANE) {
if (myCurrentEdge==0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges", myCurrentID)) {
MsgHandler::getErrorInstance()->inform("Additional lane information could not been set - the edge with id '" + myCurrentID + "' is not known.");
}
return;
}
bool ok = true;
int lane = attrs.getIntReporting(SUMO_ATTR_ID, "lane", 0, ok);
std::vector<std::string> disallowed, allowed, preferred;
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_DISALLOW, "lane", 0, ok, ""), disallowed);
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_ALLOW, "lane", 0, ok, ""), allowed);
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_PREFER, "lane", 0, ok, ""), preferred);
if (!ok) {
return;
}
if (lane<0) {
MsgHandler::getErrorInstance()->inform("Missing lane-id in lane definition (edge '" + myCurrentID + "').");
return;
}
// check whether this lane exists
if (lane>=(int) myCurrentEdge->getNoLanes()) {
MsgHandler::getErrorInstance()->inform("Lane-id is larger than number of lanes (edge '" + myCurrentID + "').");
return;
}
// set information about allowed / disallowed vehicle classes
for (std::vector<std::string>::iterator i=disallowed.begin(); i!=disallowed.end(); ++i) {
myCurrentEdge->disallowVehicleClass(lane, getVehicleClassID(*i));
}
for (std::vector<std::string>::iterator i=allowed.begin(); i!=allowed.end(); ++i) {
myCurrentEdge->allowVehicleClass(lane, getVehicleClassID(*i));
}
for (std::vector<std::string>::iterator i=preferred.begin(); i!=preferred.end(); ++i) {
myCurrentEdge->preferVehicleClass(lane, getVehicleClassID(*i));
}
// set information about later beginning lanes
if (attrs.hasAttribute(SUMO_ATTR_FORCE_LENGTH)) {
bool ok = true;
int forcedLength = attrs.getIntReporting(SUMO_ATTR_FORCE_LENGTH, "lane", myCurrentID.c_str(), ok); // !!! edge id
if (ok) {
int nameid = forcedLength;
forcedLength = (int)(myCurrentEdge->getGeometry().length() - forcedLength);
std::vector<Split>::iterator i;
i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder((SUMOReal) forcedLength));
if (i==mySplits.end()) {
Split e;
e.pos = (SUMOReal) forcedLength;
e.nameid = nameid;
for (unsigned int j=0; j<myCurrentEdge->getNoLanes(); j++) {
e.lanes.push_back(j);
}
mySplits.push_back(e);
}
i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder((SUMOReal) forcedLength));
std::vector<int>::iterator k = find((*i).lanes.begin(), (*i).lanes.end(), lane);
if (k!=(*i).lanes.end()) {
(*i).lanes.erase(k);
}
}
}
}
if (element==SUMO_TAG_SPLIT) {
bool ok = true;
Split e;
e.pos = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "split", 0, ok);
std::vector<Split>::iterator i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder(e.pos));
if (i!=mySplits.end()) {
MsgHandler::getErrorInstance()->inform("Edge '" + myCurrentID + "' has already a split at position " + toString(e.pos) + ".");
return;
}
if (e.pos<0) {
e.pos = myCurrentEdge->getGeometry().length() - e.pos;
}
e.nameid = (int)e.pos;
if (ok) {
if (myCurrentEdge==0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges", myCurrentID)) {
MsgHandler::getErrorInstance()->inform("Additional lane information could not been set - the edge with id '" + myCurrentID + "' is not known.");
}
return;
}
if (e.pos<0) {
e.pos = myCurrentEdge->getGeometry().length() + e.pos;
}
std::vector<std::string> lanes;
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_LANES, "split", 0, ok, ""), lanes);
for (std::vector<std::string>::iterator i=lanes.begin(); i!=lanes.end(); ++i) {
try {
int lane = TplConvert<char>::_2int((*i).c_str());
e.lanes.push_back(lane);
} catch (NumberFormatException &) {
MsgHandler::getErrorInstance()->inform("Error on parsing a split (edge '" + myCurrentID + "').");
} catch (EmptyData &) {
MsgHandler::getErrorInstance()->inform("Error on parsing a split (edge '" + myCurrentID + "').");
}
}
if (e.lanes.size()==0) {
MsgHandler::getErrorInstance()->inform("Missing lane information in split of edge '" + myCurrentID + "'.");
} else {
mySplits.push_back(e);
}
}
}
}
void
MSCalibrator::MSCalibrator_FileTriggeredChild::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
if (element==SUMO_TAG_ROUTEDISTELEM) {
bool ok = true;
SUMOReal freq = attrs.getSUMORealReporting(SUMO_ATTR_PROB, "calibrator/routedistelem", myParent.getID().c_str(), ok);
std::string routeStr = attrs.getStringReporting(SUMO_ATTR_ID, "calibrator/routedistelem", myParent.getID().c_str(), ok);
if (ok) {
const MSRoute* route = MSRoute::dictionary(routeStr);
if (route == 0) {
throw ProcessError("MSTriggeredSource " + myParent.getID() + ": Route '" + routeStr + "' does not exist.");
}
if (freq<0) {
throw ProcessError("MSTriggeredSource " + myParent.getID() + ": Attribute \"probability\" is negative (must not).");
}
// Attributes ok, add to routeDist
myRouteDist.add(freq, route);
}
return;
}
// vehicle-type distributions
if (element==SUMO_TAG_VTYPEDISTELEM) {
// get the id, report an error if not given or empty...
std::string id;
if (!attrs.setIDFromAttributes("vtypedistelem", id)) {
return;
}
bool ok = true;
SUMOReal prob = attrs.getSUMORealReporting(SUMO_ATTR_PROB, "vtypedistelem", id.c_str(), ok);
if (ok) {
if (prob<=0) {
MsgHandler::getErrorInstance()->inform("False probability while parsing calibrator '" + myParent.getID() + "' (" + toString(prob) + ").");
return;
}
MSVehicleType *vtype = MSNet::getInstance()->getVehicleControl().getVType(id);
if (vtype==0) {
MsgHandler::getErrorInstance()->inform("Unknown vtype-object '" + id + "'.");
return;
}
myVTypeDist.add(prob, vtype);
}
}
if (element==SUMO_TAG_FLOW) {
bool ok = true;
SUMOReal no = attrs.getSUMORealReporting(SUMO_ATTR_NO, "flow", myParent.getID().c_str(), ok);
if (no<0) {
MsgHandler::getErrorInstance()->inform("Negative flow in calibrator '" + myParent.getID() + "'.");
return;
}
SUMOTime end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, "flow", myParent.getID().c_str(), ok, -1);
if (!ok) {
return;
}
myFlow = (SUMOReal) no;
if (end==-1||end>=MSNet::getInstance()->getCurrentTimeStep()) {
if (myFlow>0) {
buildAndScheduleFlowVehicle();
MSNet::getInstance()->getEmissionEvents().addEvent(
new WrappingCommand<MSCalibrator::MSCalibrator_FileTriggeredChild>(this, &MSCalibrator::MSCalibrator_FileTriggeredChild::execute),
(SUMOTime)(1. / (myFlow / 3600.))+MSNet::getInstance()->getCurrentTimeStep(),
MSEventControl::ADAPT_AFTER_EXECUTION);
myHaveInitialisedFlow = true;
}
}
}
// check whethe the correct tag is read
if (element==SUMO_TAG_EMIT) {
bool ok = true;
SUMOTime depart = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, "emit", 0, ok);
SUMOReal departSpeed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, "emit", myParent.getID().c_str(), ok, -1);
if (!ok) {
return;
}
if (depart<myBeginTime) {
// do not process the vehicle if the emission time is before the simulation begin
return;
}
SUMOVehicleParameter* pars = new SUMOVehicleParameter();
pars->repetitionNumber = -1;
pars->repetitionOffset = -1;
pars->depart = depart;
pars->departSpeed = departSpeed;
// check and assign id
pars->id = attrs.getStringSecure(SUMO_ATTR_ID, "");
if (myVehicleControl.getVehicle(pars->id)!=0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": Vehicle " + pars->id + " already exists.\n Generating a default id.");
pars->id = "";
}
if (pars->id=="") {
pars->id = myParent.getID() + "_" + toString(pars->depart) + "_" + toString(myRunningID++);
if (myVehicleControl.getVehicle(pars->id)!=0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": Vehicle " + pars->id + " already exists.\n Continuing with next element.");
return;
}
}
// check and assign vehicle type
pars->vtypeid = attrs.getStringReporting(SUMO_ATTR_TYPE, "calibrator/routedistelem", myParent.getID().c_str(), ok, "");
MSVehicleType* aVehType = MSNet::getInstance()->getVehicleControl().getVType(pars->vtypeid);
if (aVehType == 0) {
if (myVTypeDist.getOverallProb()!=0) {
aVehType = myVTypeDist.get();
}
if (aVehType==0) {
aVehType = MSNet::getInstance()->getVehicleControl().getVType();
if (aVehType==0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": no valid vehicle type exists.\n Continuing with next element.");
return;
}
}
}
// check and assign vehicle type
pars->routeid = attrs.getStringReporting(SUMO_ATTR_ROUTE, "calibrator/routedistelem", myParent.getID().c_str(), ok, "");
const MSRoute *aEmitRoute = MSRoute::dictionary(pars->routeid);
if (aEmitRoute==0) {
if (myRouteDist.getOverallProb()!=0) {
aEmitRoute = myRouteDist.get();
}
if (aEmitRoute==0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": no valid route exsists.");
WRITE_WARNING("Continuing with next element.");
return;
}
}
// build vehicle
MSVehicle *veh = MSNet::getInstance()->getVehicleControl().buildVehicle(pars, aEmitRoute, aVehType);
myParent.schedule(this, veh, pars->departSpeed);
myHaveNext = true;
myOffset = SUMOTime(pars->depart);
}
// check whethe the correct tag is read
if (element==SUMO_TAG_RESET) {
myVTypeDist.clear();
myRouteDist.clear();
}
#if 0
#ifdef TM_CALIB
if (element==SUMO_TAG_CALIB) {
WRITE_WARNING("FOUND calib Tag!!!");
/*
MSNet::getInstance()->getEmissionEvents().addEvent(
new WrappingCommand<MSCalibrator::MSCalibrator_FileTriggeredChild>(this, &MSCalibrator::MSCalibrator_FileTriggeredChild::execute2),
//MSNet::getInstance()->getCurrentTimeStep() + 5,
10,
MSEventControl::ADAPT_AFTER_EXECUTION);
*/
}
#endif //TM_CALIB
#endif //0
}
void
MSRouteHandler::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
switch (element) {
case SUMO_TAG_VEHICLE:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
break;
case SUMO_TAG_PERSON:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
myActivePlan = new MSPerson::MSPersonPlan();
break;
case SUMO_TAG_RIDE: {
const std::string pid = myVehicleParameter->id;
bool ok = true;
MSEdge *from = 0;
if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
const std::string fromID = attrs.getStringReporting(SUMO_ATTR_FROM, "ride", pid.c_str(), ok);
from = MSEdge::dictionary(fromID);
if (from==0) {
throw ProcessError("The from edge '" + fromID + "' within a ride of person '" + pid + "' is not known.");
}
if (myActivePlan->empty() || &myActivePlan->back()->getDestination() != from) {
myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(*from, -1, myVehicleParameter->depart));
}
}
const std::string toID = attrs.getStringReporting(SUMO_ATTR_TO, "ride", pid.c_str(), ok);
MSEdge *to = MSEdge::dictionary(toID);
if (to==0) {
throw ProcessError("The to edge '" + toID + "' within a ride of person '" + pid + "' is not known.");
}
const std::string desc = attrs.getStringReporting(SUMO_ATTR_LINES, "ride", pid.c_str(), ok);
StringTokenizer st(desc);
myActivePlan->push_back(new MSPerson::MSPersonStage_Driving(*to, st.getVector()));
break;
}
case SUMO_TAG_WALK: {
myActiveRoute.clear();
bool ok = true;
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, "walk", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
if (myActiveRoute.empty()) {
throw ProcessError("No edges to walk for person '" + myVehicleParameter->id + "'.");
}
if (myActivePlan->empty() || &myActivePlan->back()->getDestination() != myActiveRoute.front()) {
myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(*myActiveRoute.front(), -1, myVehicleParameter->depart));
}
const SUMOTime duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, "walk", 0, ok, -1);
const SUMOReal speed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, "walk", 0, ok, -1);
myActivePlan->push_back(new MSPerson::MSPersonStage_Walking(myActiveRoute, duration, speed));
myActiveRoute.clear();
break;
}
case SUMO_TAG_FLOW:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseFlowAttributes(attrs);
if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
myActiveRouteID = "!" + myVehicleParameter->id;
bool ok = true;
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_FROM, "flow", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_TO, "flow", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
closeRoute();
}
break;
case SUMO_TAG_VTYPE:
myCurrentVType = SUMOVehicleParserHelper::beginVTypeParsing(attrs);
break;
case SUMO_TAG_VTYPE_DISTRIBUTION:
openVehicleTypeDistribution(attrs);
break;
case SUMO_TAG_ROUTE:
openRoute(attrs);
break;
case SUMO_TAG_ROUTE_DISTRIBUTION:
openRouteDistribution(attrs);
break;
case SUMO_TAG_TRIPDEF: {
bool ok = true;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
myActiveRouteID = "!" + myVehicleParameter->id;
if (attrs.hasAttribute(SUMO_ATTR_FROM) || !myVehicleParameter->wasSet(VEHPARS_TAZ_SET)) {
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_FROM, "tripdef", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_TO, "tripdef", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
} else {
const MSEdge* fromTaz = MSEdge::dictionary(myVehicleParameter->fromTaz+"-source");
if (fromTaz == 0) {
WRITE_ERROR("Source district '" + myVehicleParameter->fromTaz + "' not known for '" + myVehicleParameter->id + "'!");
} else if (fromTaz->getNoFollowing() == 0) {
WRITE_ERROR("Source district '" + myVehicleParameter->fromTaz + "' has no outgoing edges for '" + myVehicleParameter->id + "'!");
} else {
myActiveRoute.push_back(fromTaz->getFollower(0));
}
}
closeRoute();
closeVehicle();
}
break;
default:
break;
}
// parse embedded vtype information
if (myCurrentVType!=0&&element!=SUMO_TAG_VTYPE) {
SUMOVehicleParserHelper::parseVTypeEmbedded(*myCurrentVType, element, attrs);
return;
}
if (element==SUMO_TAG_STOP) {
bool ok = true;
SUMOVehicleParameter::Stop stop;
// try to parse the assigne bus stop
stop.busstop = attrs.getOptStringReporting(SUMO_ATTR_BUS_STOP, "stop", 0, ok, "");
if (stop.busstop!="") {
// ok, we have obviously a bus stop
MSBusStop *bs = MSNet::getInstance()->getBusStop(stop.busstop);
if (bs!=0) {
const MSLane &l = bs->getLane();
stop.lane = l.getID();
stop.pos = bs->getEndLanePosition();
} else {
MsgHandler::getErrorInstance()->inform("The bus stop '" + stop.busstop + "' is not known.");
return;
}
} else {
// no, the lane and the position should be given
// get the lane
stop.lane = attrs.getOptStringReporting(SUMO_ATTR_LANE, "stop", 0, ok, "");
if (stop.lane!="") {
if (MSLane::dictionary(stop.lane)==0) {
MsgHandler::getErrorInstance()->inform("The lane '" + stop.lane + "' for a stop is not known.");
return;
}
} else {
MsgHandler::getErrorInstance()->inform("A stop must be placed on a bus stop or a lane.");
return;
}
// get the position
bool ok = true;
stop.pos = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "stop", 0, ok);
if (!ok) {
return;
}
}
// get the standing duration
if (!attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
MsgHandler::getErrorInstance()->inform("The duration of a stop is not defined.");
return;
} else {
bool ok = true;
stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, "stop", 0, ok, -1);
stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, "stop", 0, ok, -1);
if (!ok) {
return;
}
if (stop.duration<0&&stop.until<0) {
MsgHandler::getErrorInstance()->inform("Neither the duration nor the end time is given for a stop.");
return;
}
}
if (myActiveRouteID != "") {
myActiveRouteStops.push_back(stop);
} else {
myVehicleParameter->stops.push_back(stop);
}
}
}