GUIVisualizationSizeSettings
GUISettingsHandler::parseSizeSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationSizeSettings defaults) {
return GUIVisualizationSizeSettings(
TplConvert::_2SUMOReal(attrs.getStringSecure(prefix + "_minSize", toString(defaults.minSize)).c_str()),
TplConvert::_2SUMOReal(attrs.getStringSecure(prefix + "_exaggeration", toString(defaults.exaggeration)).c_str()),
TplConvert::_2bool(attrs.getStringSecure(prefix + "_constantSize", toString(defaults.constantSize)).c_str()));
}
GUIVisualizationTextSettings
GUISettingsHandler::parseTextSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationTextSettings defaults) {
bool ok = true;
return GUIVisualizationTextSettings(
TplConvert::_2bool(attrs.getStringSecure(prefix + "_show", toString(defaults.show)).c_str()),
TplConvert::_2SUMOReal(attrs.getStringSecure(prefix + "_size", toString(defaults.size)).c_str()),
RGBColor::parseColorReporting(attrs.getStringSecure(prefix + "_color", toString(defaults.color)), "edges", 0, true, ok));
}
GUIVisualizationSizeSettings
GUISettingsHandler::parseSizeSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationSizeSettings defaults) {
return GUIVisualizationSizeSettings(
StringUtils::toDouble(attrs.getStringSecure(prefix + "_minSize", toString(defaults.minSize))),
StringUtils::toDouble(attrs.getStringSecure(prefix + "_exaggeration", toString(defaults.exaggeration))),
StringUtils::toBool(attrs.getStringSecure(prefix + "_constantSize", toString(defaults.constantSize))),
StringUtils::toBool(attrs.getStringSecure(prefix + "_constantSizeSelected", toString(defaults.constantSizeSelected))));
}
GUIVisualizationTextSettings
GUISettingsHandler::parseTextSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationTextSettings defaults) {
bool ok = true;
return GUIVisualizationTextSettings(
StringUtils::toBool(attrs.getStringSecure(prefix + "_show", toString(defaults.show))),
StringUtils::toDouble(attrs.getStringSecure(prefix + "_size", toString(defaults.size))),
RGBColor::parseColorReporting(attrs.getStringSecure(prefix + "_color", toString(defaults.color)), "textSettings", nullptr, true, ok),
RGBColor::parseColorReporting(attrs.getStringSecure(prefix + "_bgColor", toString(defaults.bgColor)), "textSettings", nullptr, true, ok),
StringUtils::toBool(attrs.getStringSecure(prefix + "_constantSize", toString(defaults.constSize))));
}
void
NIImporter_OpenStreetMap::NodesHandler::myStartElement(int element, const SUMOSAXAttributes& attrs) {
++myHierarchyLevel;
if (element == SUMO_TAG_NODE) {
bool ok = true;
if (myHierarchyLevel != 2) {
WRITE_ERROR("Node element on wrong XML hierarchy level (id='" + toString(attrs.getIntReporting(SUMO_ATTR_ID, 0, ok)) + "', level='" + toString(myHierarchyLevel) + "').");
return;
}
int id = attrs.getIntReporting(SUMO_ATTR_ID, 0, ok);
std::string action = attrs.hasAttribute("action") ? attrs.getStringSecure("action", "") : "";
if (action == "delete") {
return;
}
if (!ok) {
return;
}
myLastNodeID = -1;
if (myToFill.find(id) == myToFill.end()) {
myLastNodeID = id;
// assume we are loading multiple files...
// ... so we won't report duplicate nodes
bool ok = true;
double tlat, tlon;
std::istringstream lon(attrs.getStringReporting(SUMO_ATTR_LON, toString(id).c_str(), ok));
if (!ok) {
return;
}
lon >> tlon;
if (lon.fail()) {
WRITE_ERROR("Node's '" + toString(id) + "' lon information is not numeric.");
return;
}
std::istringstream lat(attrs.getStringReporting(SUMO_ATTR_LAT, toString(id).c_str(), ok));
if (!ok) {
return;
}
lat >> tlat;
if (lat.fail()) {
WRITE_ERROR("Node's '" + toString(id) + "' lat information is not numeric.");
return;
}
NIOSMNode* toAdd = new NIOSMNode();
toAdd->id = id;
toAdd->tlsControlled = false;
toAdd->lat = tlat;
toAdd->lon = tlon;
myIsInValidNodeTag = true;
std::set<NIOSMNode*, CompareNodes>::iterator similarNode = myUniqueNodes.find(toAdd);
if (similarNode == myUniqueNodes.end()) {
myUniqueNodes.insert(toAdd);
} else {
delete toAdd;
toAdd = *similarNode;
WRITE_MESSAGE("Found duplicate nodes. Substituting " + toString(id) + " with " + toString(toAdd->id));
}
myToFill[id] = toAdd;
}
// ---- the root/junction - element
void
NLHandler::openJunction(const SUMOSAXAttributes& attrs) {
myCurrentIsBroken = false;
bool ok = true;
// 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;
}
PositionVector shape;
if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
// inner junctions have no shape
shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok, PositionVector());
}
SUMOReal x = attrs.get<SUMOReal>(SUMO_ATTR_X, id.c_str(), ok);
SUMOReal y = attrs.get<SUMOReal>(SUMO_ATTR_Y, id.c_str(), ok);
bool typeOK = true;
SumoXMLNodeType type = attrs.getNodeType(typeOK);
if (!typeOK) {
WRITE_ERROR("An unknown or invalid junction type occured in junction '" + id + "'.");
ok = false;
}
std::string key = attrs.getOpt<std::string>(SUMO_ATTR_KEY, id.c_str(), ok, "");
// incoming lanes
std::vector<MSLane*> incomingLanes;
parseLanes(id, attrs.getStringSecure(SUMO_ATTR_INCLANES, ""), incomingLanes, ok);
// internal lanes
std::vector<MSLane*> internalLanes;
#ifdef HAVE_INTERNAL_LANES
if (MSGlobals::gUsingInternalLanes) {
parseLanes(id, attrs.getStringSecure(SUMO_ATTR_INTLANES, ""), internalLanes, ok);
}
#endif
if (!ok) {
myCurrentIsBroken = true;
} else {
try {
myJunctionControlBuilder.openJunction(id, key, type, x, y, shape, incomingLanes, internalLanes);
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what() + std::string("\n Can not build according junction."));
myCurrentIsBroken = true;
}
}
}
void
NLHandler::addVTypeProbeDetector(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, id.c_str(), ok);
std::string type = attrs.getStringSecure(SUMO_ATTR_TYPE, "");
std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
if (!ok) {
return;
}
try {
myDetectorBuilder.buildVTypeProbe(id, type, frequency, FileHelpers::checkForRelativity(file, getFileName()));
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
} catch (IOError& e) {
WRITE_ERROR(e.what());
}
}
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.get<std::string>(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.get<std::string>(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.getOpt<bool>(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->getLaneWidth();
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.get<SUMOReal>(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.get<int>(SUMO_ATTR_NUMLANES, myCurrentID.c_str(), ok);
}
// try to get the priority
if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
myCurrentPriority = attrs.get<int>(SUMO_ATTR_PRIORITY, myCurrentID.c_str(), ok);
}
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
myCurrentWidth = attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok);
}
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
myCurrentOffset = attrs.get<SUMOReal>(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok);
}
// try to get the street name
myCurrentStreetName = attrs.getOpt<std::string>(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.getOpt<SUMOReal>(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
GUISettingsHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
bool ok = true;
switch (element) {
case SUMO_TAG_BREAKPOINTS_FILE: {
std::string file = attrs.get<std::string>(SUMO_ATTR_VALUE, 0, ok);
myBreakpoints = loadBreakpoints(file);
}
break;
case SUMO_TAG_VIEWSETTINGS:
myViewType = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, 0, ok, "default");
std::transform(myViewType.begin(), myViewType.end(), myViewType.begin(), tolower);
break;
case SUMO_TAG_DELAY:
myDelay = attrs.getOpt<SUMOReal>(SUMO_ATTR_VALUE, 0, ok, myDelay);
break;
case SUMO_TAG_VIEWPORT: {
const SUMOReal x = attrs.getOpt<SUMOReal>(SUMO_ATTR_X, 0, ok, myLookFrom.x());
const SUMOReal y = attrs.getOpt<SUMOReal>(SUMO_ATTR_Y, 0, ok, myLookFrom.y());
const SUMOReal z = attrs.getOpt<SUMOReal>(SUMO_ATTR_ZOOM, 0, ok, myLookFrom.z());
myLookFrom.set(x, y, z);
const SUMOReal cx = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_X, 0, ok, myLookAt.x());
const SUMOReal cy = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_Y, 0, ok, myLookAt.y());
const SUMOReal cz = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_Z, 0, ok, myLookAt.z());
myLookAt.set(cx, cy, cz);
break;
}
case SUMO_TAG_SNAPSHOT: {
bool ok = true;
std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, 0, ok);
if (file != "" && !FileHelpers::isAbsolute(file)) {
file = FileHelpers::getConfigurationRelative(getFileName(), file);
}
mySnapshots[attrs.getOptSUMOTimeReporting(SUMO_ATTR_TIME, file.c_str(), ok, 0)] = file;
}
break;
case SUMO_TAG_VIEWSETTINGS_SCHEME: {
bool ok = true;
mySettings.name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, 0, ok, mySettings.name);
if (gSchemeStorage.contains(mySettings.name)) {
mySettings = gSchemeStorage.get(mySettings.name);
}
}
break;
case SUMO_TAG_VIEWSETTINGS_OPENGL:
mySettings.antialiase = TplConvert::_2bool(attrs.getStringSecure("antialiase", toString(mySettings.antialiase)).c_str());
mySettings.dither = TplConvert::_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::_2bool(attrs.getStringSecure("showGrid", toString(mySettings.showGrid)).c_str());
mySettings.gridXSize = TplConvert::_2SUMOReal(attrs.getStringSecure("gridXSize", toString(mySettings.gridXSize)).c_str());
mySettings.gridYSize = TplConvert::_2SUMOReal(attrs.getStringSecure("gridYSize", toString(mySettings.gridYSize)).c_str());
}
break;
case SUMO_TAG_VIEWSETTINGS_EDGES: {
int laneEdgeMode = TplConvert::_2int(attrs.getStringSecure("laneEdgeMode", "0").c_str());
int laneEdgeScaleMode = TplConvert::_2int(attrs.getStringSecure("scaleMode", "0").c_str());
mySettings.laneShowBorders = TplConvert::_2bool(attrs.getStringSecure("laneShowBorders", toString(mySettings.laneShowBorders)).c_str());
mySettings.showLinkDecals = TplConvert::_2bool(attrs.getStringSecure("showLinkDecals", toString(mySettings.showLinkDecals)).c_str());
mySettings.showRails = TplConvert::_2bool(attrs.getStringSecure("showRails", toString(mySettings.showRails)).c_str());
mySettings.edgeName = parseTextSettings("edgeName", attrs, mySettings.edgeName);
mySettings.internalEdgeName = parseTextSettings("internalEdgeName", attrs, mySettings.internalEdgeName);
mySettings.cwaEdgeName = parseTextSettings("cwaEdgeName", attrs, mySettings.cwaEdgeName);
mySettings.streetName = parseTextSettings("streetName", attrs, mySettings.streetName);
mySettings.hideConnectors = TplConvert::_2bool(attrs.getStringSecure("hideConnectors", toString(mySettings.hideConnectors)).c_str());
mySettings.laneWidthExaggeration = TplConvert::_2SUMOReal(attrs.getStringSecure("widthExaggeration", toString(mySettings.laneWidthExaggeration)).c_str());
myCurrentColorer = element;
#ifdef HAVE_INTERNAL
mySettings.edgeColorer.setActive(laneEdgeMode);
mySettings.edgeScaler.setActive(laneEdgeScaleMode);
#endif
mySettings.laneColorer.setActive(laneEdgeMode);
mySettings.laneScaler.setActive(laneEdgeScaleMode);
}
break;
case SUMO_TAG_COLORSCHEME:
myCurrentScheme = 0;
myCurrentScaleScheme = 0;
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_EDGES) {
myCurrentScheme = mySettings.laneColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
#ifdef HAVE_INTERNAL
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 (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_PERSONS) {
myCurrentScheme = mySettings.personColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_JUNCTIONS) {
myCurrentScheme = mySettings.junctionColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentScheme && !myCurrentScheme->isFixed()) {
bool ok = true;
myCurrentScheme->setInterpolated(attrs.getOpt<bool>(SUMO_ATTR_INTERPOLATED, 0, ok, false));
myCurrentScheme->clear();
}
break;
case SUMO_TAG_SCALINGSCHEME:
myCurrentScheme = 0;
myCurrentScaleScheme = 0;
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_EDGES) {
myCurrentScaleScheme = mySettings.laneScaler.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
#ifdef HAVE_INTERNAL
if (myCurrentScaleScheme == 0) {
myCurrentScaleScheme = mySettings.edgeScaler.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
#endif
}
if (myCurrentScaleScheme && !myCurrentScaleScheme->isFixed()) {
bool ok = true;
myCurrentScaleScheme->setInterpolated(attrs.getOpt<bool>(SUMO_ATTR_INTERPOLATED, 0, ok, false));
myCurrentScaleScheme->clear();
}
break;
case SUMO_TAG_ENTRY:
if (myCurrentScheme != 0) {
bool ok = true;
RGBColor color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, 0, ok);
if (myCurrentScheme->isFixed()) {
myCurrentScheme->setColor(attrs.getStringSecure(SUMO_ATTR_NAME, ""), color);
} else {
myCurrentScheme->addColor(color, attrs.getOpt<SUMOReal>(SUMO_ATTR_THRESHOLD, 0, ok, 0));
}
} else if (myCurrentScaleScheme != 0) {
bool ok = true;
SUMOReal scale = attrs.get<SUMOReal>(SUMO_ATTR_COLOR, 0, ok);
if (myCurrentScaleScheme->isFixed()) {
myCurrentScaleScheme->setColor(attrs.getStringSecure(SUMO_ATTR_NAME, ""), scale);
} else {
myCurrentScaleScheme->addColor(scale, attrs.getOpt<SUMOReal>(SUMO_ATTR_THRESHOLD, 0, ok, 0));
}
}
break;
case SUMO_TAG_VIEWSETTINGS_VEHICLES:
mySettings.vehicleColorer.setActive(TplConvert::_2int(attrs.getStringSecure("vehicleMode", "0").c_str()));
mySettings.vehicleQuality = TplConvert::_2int(attrs.getStringSecure("vehicleQuality", toString(mySettings.vehicleQuality)).c_str());
mySettings.showBlinker = TplConvert::_2bool(attrs.getStringSecure("showBlinker", toString(mySettings.showBlinker)).c_str());
mySettings.vehicleSize = parseSizeSettings("vehicle", attrs, mySettings.vehicleSize);
mySettings.vehicleName = parseTextSettings("vehicleName", attrs, mySettings.vehicleName);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_PERSONS:
mySettings.personColorer.setActive(TplConvert::_2int(attrs.getStringSecure("personMode", "0").c_str()));
mySettings.personQuality = TplConvert::_2int(attrs.getStringSecure("personQuality", toString(mySettings.personQuality)).c_str());
mySettings.personSize = parseSizeSettings("person", attrs, mySettings.personSize);
mySettings.personName = parseTextSettings("personName", attrs, mySettings.personName);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_CONTAINERS:
mySettings.containerColorer.setActive(TplConvert::_2int(attrs.getStringSecure("containerMode", "0").c_str()));
mySettings.containerQuality = TplConvert::_2int(attrs.getStringSecure("containerQuality", toString(mySettings.containerQuality)).c_str());
mySettings.containerSize = parseSizeSettings("container", attrs, mySettings.containerSize);
mySettings.containerName = parseTextSettings("containerName", attrs, mySettings.containerName);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_JUNCTIONS:
mySettings.junctionColorer.setActive(TplConvert::_2int(attrs.getStringSecure("junctionMode", "0").c_str()));
mySettings.drawLinkTLIndex = parseTextSettings("drawLinkTLIndex", attrs, mySettings.drawLinkTLIndex);
mySettings.drawLinkJunctionIndex = parseTextSettings("drawLinkJunctionIndex", attrs, mySettings.drawLinkJunctionIndex);
mySettings.junctionName = parseTextSettings("junctionName", attrs, mySettings.junctionName);
mySettings.internalJunctionName = parseTextSettings("internalJunctionName", attrs, mySettings.internalJunctionName);
mySettings.showLane2Lane = TplConvert::_2bool(attrs.getStringSecure("showLane2Lane", toString(mySettings.showLane2Lane)).c_str());
mySettings.drawJunctionShape = TplConvert::_2bool(attrs.getStringSecure("drawShape", toString(mySettings.drawJunctionShape)).c_str());
mySettings.drawCrossingsAndWalkingareas = TplConvert::_2bool(attrs.getStringSecure(
"drawCrossingsAndWalkingareas", toString(mySettings.drawCrossingsAndWalkingareas)).c_str());
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_ADDITIONALS:
mySettings.addMode = TplConvert::_2int(attrs.getStringSecure("addMode", toString(mySettings.addMode)).c_str());
mySettings.addSize = parseSizeSettings("add", attrs, mySettings.addSize);
mySettings.addName = parseTextSettings("addName", attrs, mySettings.addName);
break;
case SUMO_TAG_VIEWSETTINGS_POIS:
mySettings.poiSize = parseSizeSettings("poi", attrs, mySettings.poiSize);
mySettings.poiName = parseTextSettings("poiName", attrs, mySettings.poiName);
break;
case SUMO_TAG_VIEWSETTINGS_POLYS:
mySettings.polySize = parseSizeSettings("poly", attrs, mySettings.polySize);
mySettings.polyName = parseTextSettings("polyName", attrs, mySettings.polyName);
break;
case SUMO_TAG_VIEWSETTINGS_LEGEND:
mySettings.showSizeLegend = TplConvert::_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 = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_X, 0, ok, d.centerX);
d.centerY = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_Y, 0, ok, d.centerY);
d.centerZ = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_Z, 0, ok, d.centerZ);
d.width = attrs.getOpt<SUMOReal>(SUMO_ATTR_WIDTH, 0, ok, d.width);
d.height = attrs.getOpt<SUMOReal>(SUMO_ATTR_HEIGHT, 0, ok, d.height);
d.altitude = TplConvert::_2SUMOReal(attrs.getStringSecure("altitude", toString(d.height)).c_str());
d.rot = TplConvert::_2SUMOReal(attrs.getStringSecure("rotation", toString(d.rot)).c_str());
d.tilt = TplConvert::_2SUMOReal(attrs.getStringSecure("tilt", toString(d.tilt)).c_str());
d.roll = TplConvert::_2SUMOReal(attrs.getStringSecure("roll", toString(d.roll)).c_str());
d.layer = attrs.getOpt<SUMOReal>(SUMO_ATTR_LAYER, 0, ok, d.layer);
d.initialised = false;
myDecals.push_back(d);
}
break;
case SUMO_TAG_VIEWSETTINGS_LIGHT: {
GUISUMOAbstractView::Decal d;
d.filename = "light" + attrs.getOpt<std::string>(SUMO_ATTR_INDEX, 0, ok, "0");
d.centerX = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_X, 0, ok, d.centerX);
d.centerY = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_Y, 0, ok, d.centerY);
d.centerZ = attrs.getOpt<SUMOReal>(SUMO_ATTR_CENTER_Z, 0, ok, d.centerZ);
d.width = attrs.getOpt<SUMOReal>(SUMO_ATTR_WIDTH, 0, ok, d.width);
d.height = attrs.getOpt<SUMOReal>(SUMO_ATTR_HEIGHT, 0, ok, d.height);
d.altitude = TplConvert::_2SUMOReal(attrs.getStringSecure("altitude", toString(d.height)).c_str());
d.rot = TplConvert::_2SUMOReal(attrs.getStringSecure("rotation", toString(d.rot)).c_str());
d.tilt = TplConvert::_2SUMOReal(attrs.getStringSecure("tilt", toString(d.tilt)).c_str());
d.roll = TplConvert::_2SUMOReal(attrs.getStringSecure("roll", toString(d.roll)).c_str());
d.layer = attrs.getOpt<SUMOReal>(SUMO_ATTR_LAYER, 0, ok, d.layer);
d.initialised = false;
myDecals.push_back(d);
}
break;
case SUMO_TAG_VIEWSETTINGS_EVENT: {
const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
const std::string cmd = attrs.get<std::string>(SUMO_ATTR_COMMAND, 0, ok);
const SUMOReal prob = attrs.get<SUMOReal>(SUMO_ATTR_PROB, id.c_str(), ok);
myEventDistributions[id].add(prob, cmd);
}
break;
case SUMO_TAG_VIEWSETTINGS_EVENT_JAM_TIME:
myJamSoundTime = attrs.get<SUMOReal>(SUMO_ATTR_VALUE, 0, ok);
break;
default:
break;
}
}
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
GUISettingsHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
bool ok = true;
switch (element) {
case SUMO_TAG_BREAKPOINTS_FILE: {
std::string file = attrs.get<std::string>(SUMO_ATTR_VALUE, nullptr, ok);
myBreakpoints = loadBreakpoints(file);
}
break;
case SUMO_TAG_BREAKPOINT:
myBreakpoints.push_back(attrs.getSUMOTimeReporting(SUMO_ATTR_VALUE, nullptr, ok));
break;
case SUMO_TAG_VIEWSETTINGS:
myViewType = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, nullptr, ok, "default");
std::transform(myViewType.begin(), myViewType.end(), myViewType.begin(), tolower);
break;
case SUMO_TAG_DELAY:
myDelay = attrs.getOpt<double>(SUMO_ATTR_VALUE, nullptr, ok, myDelay);
break;
case SUMO_TAG_VIEWPORT: {
const double x = attrs.getOpt<double>(SUMO_ATTR_X, nullptr, ok, myLookFrom.x());
const double y = attrs.getOpt<double>(SUMO_ATTR_Y, nullptr, ok, myLookFrom.y());
const double z = attrs.getOpt<double>(SUMO_ATTR_ZOOM, nullptr, ok, myLookFrom.z());
myLookFrom.set(x, y, z);
const double cx = attrs.getOpt<double>(SUMO_ATTR_CENTER_X, nullptr, ok, myLookAt.x());
const double cy = attrs.getOpt<double>(SUMO_ATTR_CENTER_Y, nullptr, ok, myLookAt.y());
const double cz = attrs.getOpt<double>(SUMO_ATTR_CENTER_Z, nullptr, ok, myLookAt.z());
myLookAt.set(cx, cy, cz);
myRotation = attrs.getOpt<double>(SUMO_ATTR_ANGLE, nullptr, ok, myRotation);
break;
}
case SUMO_TAG_SNAPSHOT: {
bool ok = true;
std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, nullptr, ok);
if (file != "" && !FileHelpers::isAbsolute(file)) {
file = FileHelpers::getConfigurationRelative(getFileName(), file);
}
mySnapshots[attrs.getOptSUMOTimeReporting(SUMO_ATTR_TIME, file.c_str(), ok, 0)].push_back(file);
}
break;
case SUMO_TAG_VIEWSETTINGS_SCHEME: {
bool ok = true;
mySettings.name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, nullptr, ok, mySettings.name);
if (gSchemeStorage.contains(mySettings.name)) {
mySettings = gSchemeStorage.get(mySettings.name);
}
}
break;
case SUMO_TAG_VIEWSETTINGS_OPENGL:
mySettings.dither = StringUtils::toBool(attrs.getStringSecure("dither", toString(mySettings.dither)));
mySettings.fps = StringUtils::toBool(attrs.getStringSecure("fps", toString(mySettings.fps)));
mySettings.drawBoundaries = StringUtils::toBool(attrs.getStringSecure("drawBoundaries", toString(mySettings.drawBoundaries)));
mySettings.forceDrawForSelecting = StringUtils::toBool(attrs.getStringSecure("forceDrawForSelecting", toString(mySettings.forceDrawForSelecting)));
break;
case SUMO_TAG_VIEWSETTINGS_BACKGROUND: {
bool ok = true;
mySettings.backgroundColor = RGBColor::parseColorReporting(attrs.getStringSecure("backgroundColor", toString(mySettings.backgroundColor)), "background", nullptr, true, ok);
mySettings.showGrid = StringUtils::toBool(attrs.getStringSecure("showGrid", toString(mySettings.showGrid)));
mySettings.gridXSize = StringUtils::toDouble(attrs.getStringSecure("gridXSize", toString(mySettings.gridXSize)));
mySettings.gridYSize = StringUtils::toDouble(attrs.getStringSecure("gridYSize", toString(mySettings.gridYSize)));
}
break;
case SUMO_TAG_VIEWSETTINGS_EDGES: {
int laneEdgeMode = StringUtils::toInt(attrs.getStringSecure("laneEdgeMode", "0"));
int laneEdgeScaleMode = StringUtils::toInt(attrs.getStringSecure("scaleMode", "0"));
mySettings.laneShowBorders = StringUtils::toBool(attrs.getStringSecure("laneShowBorders", toString(mySettings.laneShowBorders)));
mySettings.showBikeMarkings = StringUtils::toBool(attrs.getStringSecure("showBikeMarkings", toString(mySettings.showBikeMarkings)));
mySettings.showLinkDecals = StringUtils::toBool(attrs.getStringSecure("showLinkDecals", toString(mySettings.showLinkDecals)));
mySettings.showLinkRules = StringUtils::toBool(attrs.getStringSecure("showLinkRules", toString(mySettings.showLinkRules)));
mySettings.showRails = StringUtils::toBool(attrs.getStringSecure("showRails", toString(mySettings.showRails)));
mySettings.edgeName = parseTextSettings("edgeName", attrs, mySettings.edgeName);
mySettings.internalEdgeName = parseTextSettings("internalEdgeName", attrs, mySettings.internalEdgeName);
mySettings.cwaEdgeName = parseTextSettings("cwaEdgeName", attrs, mySettings.cwaEdgeName);
mySettings.streetName = parseTextSettings("streetName", attrs, mySettings.streetName);
mySettings.edgeValue = parseTextSettings("edgeValue", attrs, mySettings.edgeValue);
mySettings.hideConnectors = StringUtils::toBool(attrs.getStringSecure("hideConnectors", toString(mySettings.hideConnectors)));
mySettings.laneWidthExaggeration = StringUtils::toDouble(attrs.getStringSecure("widthExaggeration", toString(mySettings.laneWidthExaggeration)));
mySettings.laneMinSize = StringUtils::toDouble(attrs.getStringSecure("minSize", toString(mySettings.laneWidthExaggeration)));
mySettings.showLaneDirection = StringUtils::toBool(attrs.getStringSecure("showDirection", toString(mySettings.showLaneDirection)));
mySettings.showSublanes = StringUtils::toBool(attrs.getStringSecure("showSublanes", toString(mySettings.showSublanes)));
mySettings.spreadSuperposed = StringUtils::toBool(attrs.getStringSecure("spreadSuperposed", toString(mySettings.spreadSuperposed)));
mySettings.edgeParam = attrs.getStringSecure("edgeParam", mySettings.edgeParam);
mySettings.laneParam = attrs.getStringSecure("laneParam", mySettings.laneParam);
mySettings.edgeData = attrs.getStringSecure("edgeData", mySettings.edgeData);
myCurrentColorer = element;
mySettings.edgeColorer.setActive(laneEdgeMode);
mySettings.edgeScaler.setActive(laneEdgeScaleMode);
mySettings.laneColorer.setActive(laneEdgeMode);
mySettings.laneScaler.setActive(laneEdgeScaleMode);
}
break;
case SUMO_TAG_COLORSCHEME:
myCurrentScheme = nullptr;
myCurrentScaleScheme = nullptr;
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_EDGES) {
myCurrentScheme = mySettings.laneColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
if (myCurrentScheme == nullptr) {
myCurrentScheme = mySettings.edgeColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
}
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_VEHICLES) {
myCurrentScheme = mySettings.vehicleColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_PERSONS) {
myCurrentScheme = mySettings.personColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_JUNCTIONS) {
myCurrentScheme = mySettings.junctionColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_POIS) {
myCurrentScheme = mySettings.poiColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_POLYS) {
myCurrentScheme = mySettings.polyColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
if (myCurrentScheme && !myCurrentScheme->isFixed()) {
bool ok = true;
myCurrentScheme->setInterpolated(attrs.getOpt<bool>(SUMO_ATTR_INTERPOLATED, nullptr, ok, false));
myCurrentScheme->clear();
}
break;
case SUMO_TAG_SCALINGSCHEME:
myCurrentScheme = nullptr;
myCurrentScaleScheme = nullptr;
if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_EDGES) {
myCurrentScaleScheme = mySettings.laneScaler.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
if (myCurrentScaleScheme == nullptr) {
myCurrentScaleScheme = mySettings.edgeScaler.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, ""));
}
}
if (myCurrentScaleScheme && !myCurrentScaleScheme->isFixed()) {
bool ok = true;
myCurrentScaleScheme->setInterpolated(attrs.getOpt<bool>(SUMO_ATTR_INTERPOLATED, nullptr, ok, false));
myCurrentScaleScheme->clear();
}
break;
case SUMO_TAG_ENTRY:
if (myCurrentScheme != nullptr) {
bool ok = true;
RGBColor color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, nullptr, ok);
if (myCurrentScheme->isFixed()) {
myCurrentScheme->setColor(attrs.getStringSecure(SUMO_ATTR_NAME, ""), color);
} else {
myCurrentScheme->addColor(color, attrs.getOpt<double>(SUMO_ATTR_THRESHOLD, nullptr, ok, 0));
}
} else if (myCurrentScaleScheme != nullptr) {
bool ok = true;
double scale = attrs.get<double>(SUMO_ATTR_COLOR, nullptr, ok);
if (myCurrentScaleScheme->isFixed()) {
myCurrentScaleScheme->setColor(attrs.getStringSecure(SUMO_ATTR_NAME, ""), scale);
} else {
myCurrentScaleScheme->addColor(scale, attrs.getOpt<double>(SUMO_ATTR_THRESHOLD, nullptr, ok, 0));
}
}
break;
case SUMO_TAG_VIEWSETTINGS_VEHICLES:
mySettings.vehicleColorer.setActive(StringUtils::toInt(attrs.getStringSecure("vehicleMode", "0")));
mySettings.vehicleQuality = StringUtils::toInt(attrs.getStringSecure("vehicleQuality", toString(mySettings.vehicleQuality)));
mySettings.showBlinker = StringUtils::toBool(attrs.getStringSecure("showBlinker", toString(mySettings.showBlinker)));
mySettings.drawMinGap = StringUtils::toBool(attrs.getStringSecure("drawMinGap", toString(mySettings.drawMinGap)));
mySettings.vehicleSize = parseSizeSettings("vehicle", attrs, mySettings.vehicleSize);
mySettings.vehicleName = parseTextSettings("vehicleName", attrs, mySettings.vehicleName);
mySettings.vehicleValue = parseTextSettings("vehicleValue", attrs, mySettings.vehicleValue);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_PERSONS:
mySettings.personColorer.setActive(StringUtils::toInt(attrs.getStringSecure("personMode", "0")));
mySettings.personQuality = StringUtils::toInt(attrs.getStringSecure("personQuality", toString(mySettings.personQuality)));
mySettings.personSize = parseSizeSettings("person", attrs, mySettings.personSize);
mySettings.personName = parseTextSettings("personName", attrs, mySettings.personName);
mySettings.personValue = parseTextSettings("personValue", attrs, mySettings.personValue);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_CONTAINERS:
mySettings.containerColorer.setActive(StringUtils::toInt(attrs.getStringSecure("containerMode", "0")));
mySettings.containerQuality = StringUtils::toInt(attrs.getStringSecure("containerQuality", toString(mySettings.containerQuality)));
mySettings.containerSize = parseSizeSettings("container", attrs, mySettings.containerSize);
mySettings.containerName = parseTextSettings("containerName", attrs, mySettings.containerName);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_JUNCTIONS:
mySettings.junctionColorer.setActive(StringUtils::toInt(attrs.getStringSecure("junctionMode", "0")));
mySettings.drawLinkTLIndex = parseTextSettings("drawLinkTLIndex", attrs, mySettings.drawLinkTLIndex);
mySettings.drawLinkJunctionIndex = parseTextSettings("drawLinkJunctionIndex", attrs, mySettings.drawLinkJunctionIndex);
mySettings.junctionName = parseTextSettings("junctionName", attrs, mySettings.junctionName);
mySettings.internalJunctionName = parseTextSettings("internalJunctionName", attrs, mySettings.internalJunctionName);
mySettings.tlsPhaseIndex = parseTextSettings("tlsPhaseIndex", attrs, mySettings.tlsPhaseIndex);
mySettings.showLane2Lane = StringUtils::toBool(attrs.getStringSecure("showLane2Lane", toString(mySettings.showLane2Lane)));
mySettings.drawJunctionShape = StringUtils::toBool(attrs.getStringSecure("drawShape", toString(mySettings.drawJunctionShape)));
mySettings.drawCrossingsAndWalkingareas = StringUtils::toBool(attrs.getStringSecure(
"drawCrossingsAndWalkingareas", toString(mySettings.drawCrossingsAndWalkingareas)));
mySettings.junctionSize = parseSizeSettings("junction", attrs, mySettings.junctionSize);
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_ADDITIONALS:
mySettings.addMode = StringUtils::toInt(attrs.getStringSecure("addMode", toString(mySettings.addMode)));
mySettings.addSize = parseSizeSettings("add", attrs, mySettings.addSize);
mySettings.addName = parseTextSettings("addName", attrs, mySettings.addName);
mySettings.addFullName = parseTextSettings("addFullName", attrs, mySettings.addFullName);
break;
case SUMO_TAG_VIEWSETTINGS_POIS:
mySettings.poiSize = parseSizeSettings("poi", attrs, mySettings.poiSize);
mySettings.poiName = parseTextSettings("poiName", attrs, mySettings.poiName);
mySettings.poiType = parseTextSettings("poiType", attrs, mySettings.poiType);
mySettings.poiColorer.setActive(StringUtils::toInt(attrs.getStringSecure("personMode", "0")));
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_POLYS:
mySettings.polySize = parseSizeSettings("poly", attrs, mySettings.polySize);
mySettings.polyName = parseTextSettings("polyName", attrs, mySettings.polyName);
mySettings.polyType = parseTextSettings("polyType", attrs, mySettings.polyType);
mySettings.polyColorer.setActive(StringUtils::toInt(attrs.getStringSecure("personMode", "0")));
myCurrentColorer = element;
break;
case SUMO_TAG_VIEWSETTINGS_LEGEND:
mySettings.showSizeLegend = StringUtils::toBool(attrs.getStringSecure("showSizeLegend", toString(mySettings.showSizeLegend)));
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 = attrs.getOpt<double>(SUMO_ATTR_CENTER_X, nullptr, ok, d.centerX);
d.centerY = attrs.getOpt<double>(SUMO_ATTR_CENTER_Y, nullptr, ok, d.centerY);
d.centerZ = attrs.getOpt<double>(SUMO_ATTR_CENTER_Z, nullptr, ok, d.centerZ);
d.width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, nullptr, ok, d.width);
d.height = attrs.getOpt<double>(SUMO_ATTR_HEIGHT, nullptr, ok, d.height);
d.altitude = StringUtils::toDouble(attrs.getStringSecure("altitude", toString(d.height)));
d.rot = StringUtils::toDouble(attrs.getStringSecure("rotation", toString(d.rot)));
d.tilt = StringUtils::toDouble(attrs.getStringSecure("tilt", toString(d.tilt)));
d.roll = StringUtils::toDouble(attrs.getStringSecure("roll", toString(d.roll)));
d.layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, nullptr, ok, d.layer);
d.screenRelative = StringUtils::toBool(attrs.getStringSecure("screenRelative", toString(d.screenRelative)));
d.initialised = false;
myDecals.push_back(d);
}
break;
case SUMO_TAG_VIEWSETTINGS_LIGHT: {
GUISUMOAbstractView::Decal d;
d.filename = "light" + attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "0");
d.centerX = attrs.getOpt<double>(SUMO_ATTR_CENTER_X, nullptr, ok, d.centerX);
d.centerY = attrs.getOpt<double>(SUMO_ATTR_CENTER_Y, nullptr, ok, d.centerY);
d.centerZ = attrs.getOpt<double>(SUMO_ATTR_CENTER_Z, nullptr, ok, d.centerZ);
d.width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, nullptr, ok, d.width);
d.height = attrs.getOpt<double>(SUMO_ATTR_HEIGHT, nullptr, ok, d.height);
d.altitude = StringUtils::toDouble(attrs.getStringSecure("altitude", toString(d.height)));
d.rot = StringUtils::toDouble(attrs.getStringSecure("rotation", toString(d.rot)));
d.tilt = StringUtils::toDouble(attrs.getStringSecure("tilt", toString(d.tilt)));
d.roll = StringUtils::toDouble(attrs.getStringSecure("roll", toString(d.roll)));
d.layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, nullptr, ok, d.layer);
d.initialised = false;
myDecals.push_back(d);
}
break;
case SUMO_TAG_VIEWSETTINGS_EVENT: {
const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
const std::string cmd = attrs.get<std::string>(SUMO_ATTR_COMMAND, nullptr, ok);
const double prob = attrs.get<double>(SUMO_ATTR_PROB, id.c_str(), ok);
myEventDistributions[id].add(cmd, prob);
}
break;
case SUMO_TAG_VIEWSETTINGS_EVENT_JAM_TIME:
myJamSoundTime = attrs.get<double>(SUMO_ATTR_VALUE, nullptr, ok);
break;
default:
break;
}
}
// ------------ loading begin
void
MSTriggeredRerouter::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
if (element == SUMO_TAG_INTERVAL) {
bool ok = true;
myCurrentIntervalBegin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, 0, ok, -1);
myCurrentIntervalEnd = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, 0, ok, -1);
}
if (element == SUMO_TAG_DEST_PROB_REROUTE) {
// by giving probabilities of new destinations
// get the destination edge
std::string dest = attrs.getStringSecure(SUMO_ATTR_ID, "");
if (dest == "") {
throw ProcessError("MSTriggeredRerouter " + getID() + ": No destination edge id given.");
}
MSEdge* to = MSEdge::dictionary(dest);
if (to == 0) {
if (dest == "keepDestination") {
to = &mySpecialDest_keepDestination;
} else if (dest == "terminateRoute") {
to = &mySpecialDest_terminateRoute;
} else {
throw ProcessError("MSTriggeredRerouter " + getID() + ": Destination edge '" + dest + "' is not known.");
}
}
// get the probability to reroute
bool ok = true;
SUMOReal prob = attrs.getOpt<SUMOReal>(SUMO_ATTR_PROB, getID().c_str(), ok, 1.);
if (!ok) {
throw ProcessError();
}
if (prob < 0) {
throw ProcessError("MSTriggeredRerouter " + getID() + ": Attribute 'probability' for destination '" + dest + "' is negative (must not).");
}
// add
myCurrentEdgeProb.add(prob, to);
}
if (element == SUMO_TAG_CLOSING_REROUTE) {
// by closing
std::string closed_id = attrs.getStringSecure(SUMO_ATTR_ID, "");
if (closed_id == "") {
throw ProcessError("MSTriggeredRerouter " + getID() + ": closed edge id given.");
}
MSEdge* closed = MSEdge::dictionary(closed_id);
if (closed == 0) {
throw ProcessError("MSTriggeredRerouter " + getID() + ": Edge '" + closed_id + "' to close is not known.");
}
myCurrentClosed.push_back(closed);
}
if (element == SUMO_TAG_ROUTE_PROB_REROUTE) {
// by explicit rerouting using routes
// check if route exists
std::string routeStr = attrs.getStringSecure(SUMO_ATTR_ID, "");
if (routeStr == "") {
throw ProcessError("MSTriggeredRerouter " + getID() + ": No route id given.");
}
const MSRoute* route = MSRoute::dictionary(routeStr);
if (route == 0) {
throw ProcessError("MSTriggeredRerouter " + getID() + ": Route '" + routeStr + "' does not exist.");
}
// get the probability to reroute
bool ok = true;
SUMOReal prob = attrs.getOpt<SUMOReal>(SUMO_ATTR_PROB, getID().c_str(), ok, 1.);
if (!ok) {
throw ProcessError();
}
if (prob < 0) {
throw ProcessError("MSTriggeredRerouter " + getID() + ": Attribute 'probability' for route '" + routeStr + "' is negative (must not).");
}
// add
myCurrentRouteProb.add(prob, route);
}
}
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
}