void
NLHandler::addEdgeLaneMeanData(const SUMOSAXAttributes& attrs, int objecttype) {
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
const SUMOReal maxTravelTime = attrs.getOpt<SUMOReal>(SUMO_ATTR_MAX_TRAVELTIME, id.c_str(), ok, 100000);
const SUMOReal minSamples = attrs.getOpt<SUMOReal>(SUMO_ATTR_MIN_SAMPLES, id.c_str(), ok, 0);
const SUMOReal haltingSpeedThreshold = attrs.getOpt<SUMOReal>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), ok, POSITION_EPS);
const std::string excludeEmpty = attrs.getOpt<std::string>(SUMO_ATTR_EXCLUDE_EMPTY, id.c_str(), ok, "false");
const bool withInternal = attrs.getOpt<bool>(SUMO_ATTR_WITH_INTERNAL, id.c_str(), ok, false);
const bool trackVehicles = attrs.getOpt<bool>(SUMO_ATTR_TRACK_VEHICLES, id.c_str(), ok, false);
const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "performance");
std::string vtypes = attrs.getOpt<std::string>(SUMO_ATTR_VTYPES, id.c_str(), ok, "");
const SUMOTime frequency = attrs.getOptSUMOTimeReporting(SUMO_ATTR_FREQUENCY, id.c_str(), ok, -1);
const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), ok, string2time(OptionsCont::getOptions().getString("begin")));
const SUMOTime end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), ok, string2time(OptionsCont::getOptions().getString("end")));
if (!ok) {
return;
}
try {
myDetectorBuilder.createEdgeLaneMeanData(id, frequency, begin, end,
type, objecttype == SUMO_TAG_MEANDATA_LANE,
// equivalent to TplConvert::_2bool used in SUMOSAXAttributes::getBool
excludeEmpty[0] != 't' && excludeEmpty[0] != 'T' && excludeEmpty[0] != '1' && excludeEmpty[0] != 'x',
excludeEmpty == "defaults", withInternal, trackVehicles,
maxTravelTime, minSamples, haltingSpeedThreshold, vtypes,
FileHelpers::checkForRelativity(file, getFileName()));
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
} catch (IOError& e) {
WRITE_ERROR(e.what());
}
}
void
NLHandler::openWAUT(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;
}
SUMOTime t = attrs.getOptSUMOTimeReporting(SUMO_ATTR_REF_TIME, id.c_str(), ok, 0);
std::string pro = attrs.get<std::string>(SUMO_ATTR_START_PROG, id.c_str(), ok);
if (!ok) {
myCurrentIsBroken = true;
}
if (!myCurrentIsBroken) {
myCurrentWAUTID = id;
try {
myJunctionControlBuilder.getTLLogicControlToUse().addWAUT(t, id, pro);
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
myCurrentIsBroken = true;
}
}
}
void
NLTriggerBuilder::parseAndBuildCalibrator(MSNet& net, const SUMOSAXAttributes& attrs,
const std::string& base) {
bool ok = true;
// get the id, throw if not given or empty...
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
throw ProcessError();
}
// get the file name to read further definitions from
MSLane* lane = getLane(attrs, "calibrator", id);
const SUMOReal pos = getPosition(attrs, lane, "calibrator", id);
const SUMOTime freq = attrs.getOptSUMOTimeReporting(SUMO_ATTR_FREQUENCY, id.c_str(), ok, DELTA_T); // !!! no error handling
std::string file = getFileName(attrs, base, true);
std::string outfile = attrs.getOpt<std::string>(SUMO_ATTR_OUTPUT, 0, ok, "");
if (MSGlobals::gUseMesoSim) {
#ifdef HAVE_INTERNAL
METriggeredCalibrator* trigger = buildMECalibrator(net, id, &lane->getEdge(), pos, file, outfile, freq);
if (file == "") {
trigger->registerParent(SUMO_TAG_CALIBRATOR, myHandler);
}
#endif
} else {
MSCalibrator* trigger = buildCalibrator(net, id, &lane->getEdge(), pos, file, outfile, freq);
if (file == "") {
trigger->registerParent(SUMO_TAG_CALIBRATOR, myHandler);
}
}
}
void
NLHandler::addPhase(const SUMOSAXAttributes& attrs) {
// try to get the phase definition
bool ok = true;
std::string state = attrs.get<std::string>(SUMO_ATTR_STATE, 0, ok);
if (!ok) {
return;
}
// try to get the phase duration
SUMOTime duration = attrs.getSUMOTimeReporting(SUMO_ATTR_DURATION, myJunctionControlBuilder.getActiveKey().c_str(), ok);
if (duration == 0) {
WRITE_ERROR("Duration of tls-logic '" + myJunctionControlBuilder.getActiveKey() + "/" + myJunctionControlBuilder.getActiveSubKey() + "' is zero.");
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, myJunctionControlBuilder.getActiveKey().c_str(), ok, duration);
SUMOTime maxDuration = attrs.getOptSUMOTimeReporting(
SUMO_ATTR_MAXDURATION, myJunctionControlBuilder.getActiveKey().c_str(), ok, duration);
myJunctionControlBuilder.addPhase(duration, state, minDuration, maxDuration);
}
void
NLHandler::addE2Detector(const SUMOSAXAttributes& attrs) {
// check whether this is a detector connected to a tls an optionally to a link
bool ok = true;
const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
const std::string lsaid = attrs.getOpt<std::string>(SUMO_ATTR_TLID, id.c_str(), ok, "<invalid>");
const std::string toLane = attrs.getOpt<std::string>(SUMO_ATTR_TO, id.c_str(), ok, "<invalid>");
const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), ok, TIME2STEPS(1));
const SUMOReal haltingSpeedThreshold = attrs.getOpt<SUMOReal>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), ok, 5.0f / 3.6f);
const SUMOReal jamDistThreshold = attrs.getOpt<SUMOReal>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), ok, 10.0f);
const SUMOReal position = attrs.get<SUMOReal>(SUMO_ATTR_POSITION, id.c_str(), ok);
const SUMOReal length = attrs.get<SUMOReal>(SUMO_ATTR_LENGTH, id.c_str(), ok);
const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), ok, false);
const bool cont = attrs.getOpt<bool>(SUMO_ATTR_CONT, id.c_str(), ok, false);
const std::string lane = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), ok);
const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
if (!ok) {
return;
}
try {
if (lsaid != "<invalid>") {
if (toLane == "<invalid>") {
myDetectorBuilder.buildE2Detector(id, lane, position, length, cont,
myJunctionControlBuilder.getTLLogic(lsaid),
FileHelpers::checkForRelativity(file, getFileName()),
haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
friendlyPos);
} else {
myDetectorBuilder.buildE2Detector(id, lane, position, length, cont,
myJunctionControlBuilder.getTLLogic(lsaid), toLane,
FileHelpers::checkForRelativity(file, getFileName()),
haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
friendlyPos);
}
} else {
bool ok = true;
SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, id.c_str(), ok);
if (!ok) {
return;
}
myDetectorBuilder.buildE2Detector(id, lane, position, length, cont, frequency,
FileHelpers::checkForRelativity(file, getFileName()),
haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold,
friendlyPos);
}
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
} catch (IOError& e) {
WRITE_ERROR(e.what());
}
}
void
NLHandler::addRouteProbeDetector(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);
SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), ok, -1);
std::string edge = attrs.get<std::string>(SUMO_ATTR_EDGE, id.c_str(), ok);
std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
if (!ok) {
return;
}
try {
myDetectorBuilder.buildRouteProbe(id, edge, frequency, begin,
FileHelpers::checkForRelativity(file, getFileName()));
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
} catch (IOError& e) {
WRITE_ERROR(e.what());
}
}
void
NLHandler::initTrafficLightLogic(const SUMOSAXAttributes& attrs) {
myAmInTLLogicMode = true;
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
TrafficLightType type;
std::string typeS = attrs.get<std::string>(SUMO_ATTR_TYPE, 0, ok);
if (SUMOXMLDefinitions::TrafficLightTypes.hasString(typeS)) {
type = SUMOXMLDefinitions::TrafficLightTypes.get(typeS);
} else {
WRITE_ERROR("Traffic light '" + id + "' has unknown type '" + typeS + "'");
return;
}
//
SUMOTime offset = attrs.getOptSUMOTimeReporting(SUMO_ATTR_OFFSET, id.c_str(), ok, 0);
if (!ok) {
return;
}
std::string programID = attrs.getOpt<std::string>(SUMO_ATTR_PROGRAMID, id.c_str(), ok, "<unknown>");
myJunctionControlBuilder.initTrafficLightLogic(id, programID, type, offset);
}
void
NLHandler::beginE3Detector(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
const SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, id.c_str(), ok);
const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), ok, TIME2STEPS(1));
const SUMOReal haltingSpeedThreshold = attrs.getOpt<SUMOReal>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), ok, 5.0f / 3.6f);
const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), ok);
if (!ok) {
return;
}
try {
myDetectorBuilder.beginE3Detector(id,
FileHelpers::checkForRelativity(file, getFileName()),
frequency, haltingSpeedThreshold, haltingTimeThreshold);
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
} catch (IOError& e) {
WRITE_ERROR(e.what());
}
}
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
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::addStop(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string errorSuffix;
if (myActiveRouteID != "") {
errorSuffix = " in route '" + myActiveRouteID + "'.";
} else if (myActivePlan) {
errorSuffix = " in person '" + myVehicleParameter->id + "'.";
} else {
errorSuffix = " in vehicle '" + myVehicleParameter->id + "'.";
}
SUMOVehicleParameter::Stop stop;
// try to parse the assigned bus stop
if (attrs.hasAttribute(SUMO_ATTR_BUS_STOP__DEPRECATED)) {
stop.busstop = attrs.getStringReporting(SUMO_ATTR_BUS_STOP__DEPRECATED, 0, ok);
if (!myHaveWarnedAboutDeprecatedBusStop) {
myHaveWarnedAboutDeprecatedBusStop = true;
WRITE_WARNING("'bus_stop' is deprecated, please use 'busStop' instead.");
}
} else {
stop.busstop = attrs.getOptStringReporting(SUMO_ATTR_BUS_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.endPos = bs->getEndLanePosition();
stop.startPos = bs->getBeginLanePosition();
} else {
WRITE_ERROR("The bus stop '" + stop.busstop + "' is not known" + errorSuffix);
return;
}
} else {
// no, the lane and the position should be given
// get the lane
stop.lane = attrs.getOptStringReporting(SUMO_ATTR_LANE, 0, ok, "");
if (ok && stop.lane != "") {
if (MSLane::dictionary(stop.lane) == 0) {
WRITE_ERROR("The lane '" + stop.lane + "' for a stop is not known" + errorSuffix);
return;
}
} else {
WRITE_ERROR("A stop must be placed on a bus stop or a lane" + errorSuffix);
return;
}
if (myActivePlan &&
!myActivePlan->empty() &&
&myActivePlan->back()->getDestination() != &MSLane::dictionary(stop.lane)->getEdge()) {
throw ProcessError("Disconnected plan for person '" + myVehicleParameter->id + "' (" + MSLane::dictionary(stop.lane)->getEdge().getID() + "!=" + myActivePlan->back()->getDestination().getID() + ").");
}
stop.endPos = attrs.getOptSUMORealReporting(SUMO_ATTR_ENDPOS, 0, ok, MSLane::dictionary(stop.lane)->getLength());
if (attrs.hasAttribute(SUMO_ATTR_POSITION)) {
WRITE_WARNING("Deprecated attribute 'pos' in description of stop" + errorSuffix);
stop.endPos = attrs.getOptSUMORealReporting(SUMO_ATTR_POSITION, 0, ok, stop.endPos);
}
stop.startPos = attrs.getOptSUMORealReporting(SUMO_ATTR_STARTPOS, 0, ok, stop.endPos - 2 * POSITION_EPS);
if (attrs.hasAttribute(SUMO_ATTR_FRIENDLY_POS__DEPRECATED) && !myHaveWarnedAboutDeprecatedFriendlyPos) {
myHaveWarnedAboutDeprecatedFriendlyPos = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_FRIENDLY_POS__DEPRECATED) + "' is deprecated, use '" + toString(SUMO_ATTR_FRIENDLY_POS) + "' instead.");
}
bool friendlyPos = attrs.hasAttribute(SUMO_ATTR_FRIENDLY_POS__DEPRECATED)
? attrs.getOptBoolReporting(SUMO_ATTR_FRIENDLY_POS__DEPRECATED, 0, ok, false)
: attrs.getOptBoolReporting(SUMO_ATTR_FRIENDLY_POS, 0, ok, false);
if (!ok || !checkStopPos(stop.startPos, stop.endPos, MSLane::dictionary(stop.lane)->getLength(), POSITION_EPS, friendlyPos)) {
WRITE_ERROR("Invalid start or end position for stop" + errorSuffix);
return;
}
}
// get the standing duration
if (!attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
stop.triggered = attrs.getOptBoolReporting(SUMO_ATTR_TRIGGERED, 0, ok, true);
stop.duration = -1;
stop.until = -1;
} else {
stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, 0, ok, -1);
stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, 0, ok, -1);
if (!ok || (stop.duration < 0 && stop.until < 0)) {
WRITE_ERROR("Invalid duration or end time is given for a stop" + errorSuffix);
return;
}
stop.triggered = attrs.getOptBoolReporting(SUMO_ATTR_TRIGGERED, 0, ok, false);
}
stop.parking = attrs.getOptBoolReporting(SUMO_ATTR_PARKING, 0, ok, stop.triggered);
if (!ok) {
WRITE_ERROR("Invalid bool for 'triggered' or 'parking' for stop" + errorSuffix);
return;
}
const std::string idx = attrs.getOptStringReporting(SUMO_ATTR_INDEX, 0, ok, "end");
if (idx == "end") {
stop.index = STOP_INDEX_END;
} else if (idx == "fit") {
stop.index = STOP_INDEX_FIT;
} else {
stop.index = attrs.getIntReporting(SUMO_ATTR_INDEX, 0, ok);
if (!ok || stop.index < 0) {
WRITE_ERROR("Invalid 'index' for stop" + errorSuffix);
return;
}
}
if (myActiveRouteID != "") {
myActiveRouteStops.push_back(stop);
} else if (myActivePlan) {
myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(MSLane::dictionary(stop.lane)->getEdge(), stop.duration, stop.until));
} else {
myVehicleParameter->stops.push_back(stop);
}
}
void MSRouteHandler::myStartElement
(int element, const SUMOSAXAttributes& attrs)
{
if(oc.getLoadVerbosity()>1)
std::cout << "----> MSRouteHandler::myStartElement" << std::endl;
switch (element) {
case SUMO_TAG_VEHICLE:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
if(oc.getLoadVerbosity()>1)
std::cout << "[110] MSRouteHandler::myStartElement\n myVehiclePar"
"ameter->vtypeid=" << myVehicleParameter->vtypeid
<< "\n myVehicleParameter->id=" << myVehicleParameter
->id << std::endl;
/*TASK
* This could be the first place where we can process the
* electric or nonelectric characteristics of the vehicles
*/
if((myVehicleParameter->id.substr(0, 4)=="elec") ||//DEPRECATED(MANTAIN)
(myVehicleParameter->id.substr(0, 6)=="SHelec")||//DEPRECATED(MANTAIN)
(myVehicleParameter->id.substr(0, 6)=="SHElec")||
(myVehicleParameter->id.substr(0, 9)=="SHItaElec")||
(myVehicleParameter->id.substr(0, 9)=="SHGerElec")||
(myVehicleParameter->id.substr(0, 3)=="fev"))
{
//TASK (uprego) This should be safe, but I'm not completely sure
myVehicleParameter->vtypeid = DEFAULT_ELECVTYPE_ID;
// Electric cars turn green
myVehicleParameter->color = HIB_CAR_COLOR_GREEN;
}
else if((myVehicleParameter->id.substr(0, 4)=="norm")||//DEPRECATED(MANTAIN)
(myVehicleParameter->id.substr(0, 6)=="SHnorm")||//DEPRECATED(MANTAIN)
(myVehicleParameter->id.substr(0, 6)=="SHItaNorm")||
(myVehicleParameter->id.substr(0, 6)=="SHGerNorm")||
(myVehicleParameter->id.substr(0, 6)=="SHNorm"))
{
// Normal cars remain yellow
myVehicleParameter->color = HIB_CAR_COLOR_YELLOW_TRY;
}
else
{
/*
BUSCARLO EN LOS VEHICLES TO TRACK LIST !!!
IF ESTA
// CREARLE EL VTYPEID
ELSE
// Default yellow
myVehicleParameter->color = HIB_CAR_COLOR_YELLOW_TRY;
*/
myVehicleParameter->color=HIB_CAR_COLOR_YELLOW_TRY; // TASK TODO FIXME ALERT DANGER DELETEME
}
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, 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) {
throw ProcessError("Disconnected plan for person '" + myVehicleParameter->id + "' (" + fromID + "!=" + myActivePlan->back()->getDestination().getID() + ").");
}
if (myActivePlan->empty()) {
myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(*from, -1, myVehicleParameter->depart));
}
}
const std::string toID = attrs.getStringReporting(SUMO_ATTR_TO, 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, 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, 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()) {
throw ProcessError("Disconnected plan for person '" + myVehicleParameter->id + "' (" + myActiveRoute.front()->getID() + "!=" + myActivePlan->back()->getDestination().getID() + ").");
}
if (myActivePlan->empty()) {
myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(*myActiveRoute.front(), -1, myVehicleParameter->depart));
}
const SUMOTime duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, 0, ok, -1);
const SUMOReal speed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, 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, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_TO, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
closeRoute();
}
break;
case SUMO_TAG_VTYPE__DEPRECATED:
if (!myHaveWarnedAboutDeprecatedVType) {
myHaveWarnedAboutDeprecatedVType = true;
WRITE_WARNING("'" + toString(SUMO_TAG_VTYPE__DEPRECATED) + "' is deprecated; please use '" + toString(SUMO_TAG_VTYPE) + "'.");
}
case SUMO_TAG_VTYPE:
myCurrentVType = SUMOVehicleParserHelper::beginVTypeParsing(attrs);
break;
case SUMO_TAG_VTYPE_DISTRIBUTION__DEPRECATED:
if (!myHaveWarnedAboutDeprecatedVTypeDistribution) {
myHaveWarnedAboutDeprecatedVTypeDistribution = true;
WRITE_WARNING("'" + toString(SUMO_TAG_VTYPE_DISTRIBUTION__DEPRECATED) + "' is deprecated; please use '" + toString(SUMO_TAG_VTYPE_DISTRIBUTION) + "'.");
}
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_STOP:
addStop(attrs);
break;
case SUMO_TAG_TRIP__DEPRECATED:
case SUMO_TAG_TRIP: {
bool ok = true;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
myVehicleParameter->setParameter |= VEHPARS_FORCE_REROUTE;
myActiveRouteID = "!" + myVehicleParameter->id;
if (attrs.hasAttribute(SUMO_ATTR_FROM) || !myVehicleParameter->wasSet(VEHPARS_TAZ_SET)) {
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_FROM, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_TO, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
} 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 && element != SUMO_TAG_VTYPE__DEPRECATED) {
SUMOVehicleParserHelper::parseVTypeEmbedded(*myCurrentVType, element, attrs);
return;
}
}
// ------------ 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
RORouteHandler::addStop(const SUMOSAXAttributes& attrs) {
if (myActivePlan) {
myActivePlan->openTag(SUMO_TAG_STOP);
(*myActivePlan) << attrs;
myActivePlan->closeTag();
return;
}
bool ok = true;
std::string errorSuffix;
if (myActiveRouteID != "") {
errorSuffix = " in route '" + myActiveRouteID + "'.";
} else {
errorSuffix = " in vehicle '" + myVehicleParameter->id + "'.";
}
SUMOVehicleParameter::Stop stop;
SUMOVehicleParserHelper::parseStop(stop, attrs);
// try to parse the assigned bus stop
stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, 0, ok, "");
if (stop.busstop == "") {
// no, the lane and the position should be given
stop.lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, 0, ok, "");
if (!ok || stop.lane == "") {
myErrorOutput->inform("A stop must be placed on a bus stop or a lane" + errorSuffix);
return;
}
ROEdge* edge = myNet.getEdge(stop.lane.substr(0, stop.lane.rfind('_')));
if (edge == 0) {
myErrorOutput->inform("The lane '" + stop.lane + "' for a stop is not known" + errorSuffix);
return;
}
stop.endPos = attrs.getOpt<SUMOReal>(SUMO_ATTR_ENDPOS, 0, ok, edge->getLength());
stop.startPos = attrs.getOpt<SUMOReal>(SUMO_ATTR_STARTPOS, 0, ok, stop.endPos - 2 * POSITION_EPS);
const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, 0, ok, false);
if (!ok || !checkStopPos(stop.startPos, stop.endPos, edge->getLength(), POSITION_EPS, friendlyPos)) {
myErrorOutput->inform("Invalid start or end position for stop" + errorSuffix);
return;
}
}
// get the standing duration
if (!attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, 0, ok, true);
stop.duration = -1;
stop.until = -1;
} else {
stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, 0, ok, -1);
stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, 0, ok, -1);
if (!ok || (stop.duration < 0 && stop.until < 0)) {
myErrorOutput->inform("Invalid duration or end time is given for a stop" + errorSuffix);
return;
}
stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, 0, ok, false);
}
stop.parking = attrs.getOpt<bool>(SUMO_ATTR_PARKING, 0, ok, stop.triggered);
if (!ok) {
myErrorOutput->inform("Invalid bool for 'triggered' or 'parking' for stop" + errorSuffix);
return;
}
// expected persons
std::string expectedStr = attrs.getOpt<std::string>(SUMO_ATTR_EXPECTED, 0, ok, "");
std::set<std::string> personIDs;
SUMOSAXAttributes::parseStringSet(expectedStr, personIDs);
stop.awaitedPersons = personIDs;
const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, 0, ok, "end");
if (idx == "end") {
stop.index = STOP_INDEX_END;
} else if (idx == "fit") {
stop.index = STOP_INDEX_FIT;
} else {
stop.index = attrs.get<int>(SUMO_ATTR_INDEX, 0, ok);
if (!ok || stop.index < 0) {
myErrorOutput->inform("Invalid 'index' for stop" + errorSuffix);
return;
}
}
if (myVehicleParameter != 0) {
myVehicleParameter->stops.push_back(stop);
} else {
myActiveRouteStops.push_back(stop);
}
}
void
MSRouteHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
SUMORouteHandler::myStartElement(element, attrs);
switch (element) {
case SUMO_TAG_PERSON:
myActivePlan = new MSPerson::MSPersonPlan();
break;
case SUMO_TAG_RIDE: {
const std::string pid = myVehicleParameter->id;
bool ok = true;
MSEdge* from = 0;
const std::string desc = attrs.get<std::string>(SUMO_ATTR_LINES, pid.c_str(), ok);
StringTokenizer st(desc);
std::string bsID = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, 0, ok, "");
MSBusStop* bs = 0;
if (bsID != "") {
bs = MSNet::getInstance()->getBusStop(bsID);
if (bs == 0) {
throw ProcessError("Unknown bus stop '" + bsID + "' for person '" + myVehicleParameter->id + "'.");
}
}
if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
const std::string fromID = attrs.get<std::string>(SUMO_ATTR_FROM, 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) {
throw ProcessError("Disconnected plan for person '" + myVehicleParameter->id + "' (" + fromID + "!=" + myActivePlan->back()->getDestination().getID() + ").");
}
if (myActivePlan->empty()) {
myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(
*from, -1, myVehicleParameter->depart, myVehicleParameter->departPos, "start"));
}
} else if (myActivePlan->empty()) {
throw ProcessError("The start edge within for person '" + pid + "' is not known.");
}
const std::string toID = attrs.get<std::string>(SUMO_ATTR_TO, 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.");
}
myActivePlan->push_back(new MSPerson::MSPersonStage_Driving(*to, bs, st.getVector()));
break;
}
case SUMO_TAG_WALK: {
myActiveRoute.clear();
bool ok = true;
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
MSEdge::parseEdgesList(attrs.get<std::string>(SUMO_ATTR_EDGES, myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
} else {
if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
const std::string fromID = attrs.get<std::string>(SUMO_ATTR_FROM, myVehicleParameter->id.c_str(), ok);
MSEdge* from = MSEdge::dictionary(fromID);
if (from == 0) {
throw ProcessError("The from edge '" + fromID + "' within a walk of person '" + myVehicleParameter->id + "' is not known.");
}
const std::string toID = attrs.get<std::string>(SUMO_ATTR_TO, myVehicleParameter->id.c_str(), ok);
MSEdge* to = MSEdge::dictionary(toID);
if (to == 0) {
throw ProcessError("The to edge '" + toID + "' within a walk of person '" + myVehicleParameter->id + "' is not known.");
}
MSNet::getInstance()->getRouterTT().compute(from, to, 0, 0, myActiveRoute); // @todo: only footways, current time?
}
}
if (myActiveRoute.empty()) {
throw ProcessError("No edges to walk for person '" + myVehicleParameter->id + "'.");
}
if (!myActivePlan->empty() && &myActivePlan->back()->getDestination() != myActiveRoute.front()) {
throw ProcessError("Disconnected plan for person '" + myVehicleParameter->id + "' (" + myActiveRoute.front()->getID() + "!=" + myActivePlan->back()->getDestination().getID() + ").");
}
SUMOReal departPos = attrs.getOpt<SUMOReal>(SUMO_ATTR_DEPARTPOS, myVehicleParameter->id.c_str(), ok, 0);
SUMOReal arrivalPos = attrs.getOpt<SUMOReal>(SUMO_ATTR_ARRIVALPOS, myVehicleParameter->id.c_str(), ok, -1);
const SUMOTime duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, 0, ok, -1);
SUMOReal speed = DEFAULT_PERSON_SPEED;
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
speed = attrs.getOpt<SUMOReal>(SUMO_ATTR_SPEED, 0, ok, speed);
if (speed < 0) {
throw ProcessError("Negative walking speed for '" + myVehicleParameter->id + "'.");
}
}
std::string bsID = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, 0, ok, "");
MSBusStop* bs = 0;
if (bsID != "") {
bs = MSNet::getInstance()->getBusStop(bsID);
if (bs == 0) {
throw ProcessError("Unknown bus stop '" + bsID + "' for person '" + myVehicleParameter->id + "'.");
}
}
if (myActivePlan->empty()) {
myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(
*myActiveRoute.front(), -1, myVehicleParameter->depart, departPos, "start"));
}
myActivePlan->push_back(new MSPerson::MSPersonStage_Walking(myActiveRoute, bs, duration, speed, departPos, arrivalPos));
myActiveRoute.clear();
break;
}
case SUMO_TAG_FLOW:
if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
myActiveRouteID = "!" + myVehicleParameter->id;
bool ok = true;
MSEdge::parseEdgesList(attrs.get<std::string>(SUMO_ATTR_FROM, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
MSEdge::parseEdgesList(attrs.get<std::string>(SUMO_ATTR_TO, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
closeRoute(true);
}
break;
case SUMO_TAG_TRIP: {
bool ok = true;
if (attrs.hasAttribute(SUMO_ATTR_FROM) || !myVehicleParameter->wasSet(VEHPARS_TAZ_SET)) {
MSEdge::parseEdgesList(attrs.get<std::string>(SUMO_ATTR_FROM, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
MSEdge::parseEdgesList(attrs.get<std::string>(SUMO_ATTR_TO, myVehicleParameter->id.c_str(), ok),
myActiveRoute, "for vehicle '" + myVehicleParameter->id + "'");
} 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(true);
closeVehicle();
}
break;
default:
break;
}
// parse embedded vtype information
if (myCurrentVType != 0 && element != SUMO_TAG_VTYPE && element != SUMO_TAG_PARAM) {
SUMOVehicleParserHelper::parseVTypeEmbedded(*myCurrentVType, element, attrs);
return;
}
}
void
MSCalibrator::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
if (element == SUMO_TAG_FLOW) {
AspiredState state;
SUMOTime lastEnd = -1;
if (myIntervals.size() > 0) {
lastEnd = myIntervals.back().end;
if (lastEnd == -1) {
lastEnd = myIntervals.back().begin;
}
}
try {
bool ok = true;
state.q = attrs.getOpt<double>(SUMO_ATTR_VEHSPERHOUR, nullptr, ok, -1.);
state.v = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, -1.);
state.begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, myID.c_str(), ok);
if (state.begin < lastEnd) {
WRITE_ERROR("Overlapping or unsorted intervals in calibrator '" + myID + "'.");
}
state.end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, myID.c_str(), ok, -1);
state.vehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs, true, true);
LeftoverVehicleParameters.push_back(state.vehicleParameter);
// vehicles should be inserted with max speed unless stated otherwise
if (state.vehicleParameter->departSpeedProcedure == DEPART_SPEED_DEFAULT) {
state.vehicleParameter->departSpeedProcedure = DEPART_SPEED_MAX;
}
// vehicles should be inserted on any lane unless stated otherwise
if (state.vehicleParameter->departLaneProcedure == DEPART_LANE_DEFAULT) {
if (myLane == nullptr) {
state.vehicleParameter->departLaneProcedure = DEPART_LANE_ALLOWED_FREE;
} else {
state.vehicleParameter->departLaneProcedure = DEPART_LANE_GIVEN;
state.vehicleParameter->departLane = myLane->getIndex();
}
} else if (myLane != nullptr && (
state.vehicleParameter->departLaneProcedure != DEPART_LANE_GIVEN
|| state.vehicleParameter->departLane != myLane->getIndex())) {
WRITE_WARNING("Insertion lane may differ from calibrator lane for calibrator '" + getID() + "'.");
}
if (state.vehicleParameter->vtypeid != DEFAULT_VTYPE_ID &&
MSNet::getInstance()->getVehicleControl().getVType(state.vehicleParameter->vtypeid) == nullptr) {
WRITE_ERROR("Unknown vehicle type '" + state.vehicleParameter->vtypeid + "' in calibrator '" + myID + "'.");
}
} catch (EmptyData&) {
WRITE_ERROR("Mandatory attribute missing in definition of calibrator '" + myID + "'.");
} catch (NumberFormatException&) {
WRITE_ERROR("Non-numeric value for numeric attribute in definition of calibrator '" + myID + "'.");
}
if (state.q < 0 && state.v < 0) {
WRITE_ERROR("Either 'vehsPerHour' or 'speed' has to be given in flow definition of calibrator '" + myID + "'.");
}
if (myIntervals.size() > 0 && myIntervals.back().end == -1) {
myIntervals.back().end = state.begin;
}
myIntervals.push_back(state);
myCurrentStateInterval = myIntervals.begin();
} else {
MSRouteHandler::myStartElement(element, attrs);
}
}
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;
}
}
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;
}
}
bool
SUMORouteHandler::parseStop(SUMOVehicleParameter::Stop& stop, const SUMOSAXAttributes& attrs, std::string errorSuffix, MsgHandler* const errorOutput) {
stop.setParameter = 0;
if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
stop.setParameter |= STOP_END_SET;
}
if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
stop.setParameter |= STOP_START_SET;
}
if (attrs.hasAttribute(SUMO_ATTR_TRIGGERED)) {
stop.setParameter |= STOP_TRIGGER_SET;
}
if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
stop.setParameter |= STOP_PARKING_SET;
}
if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
stop.setParameter |= STOP_EXPECTED_SET;
}
bool ok = true;
stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, 0, ok, "");
if (stop.busstop != "") {
errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
} else {
errorSuffix = " on lane '" + stop.busstop + "'" + errorSuffix;
}
// get the standing duration
if (!attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, 0, ok, true);
stop.duration = -1;
stop.until = -1;
} else {
stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, 0, ok, -1);
stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, 0, ok, -1);
if (!ok || (stop.duration < 0 && stop.until < 0)) {
errorOutput->inform("Invalid duration or end time is given for a stop" + errorSuffix);
return false;
}
stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, 0, ok, false);
}
stop.parking = attrs.getOpt<bool>(SUMO_ATTR_PARKING, 0, ok, stop.triggered);
if (!ok) {
errorOutput->inform("Invalid bool for 'triggered' or 'parking' for stop" + errorSuffix);
return false;
}
// expected persons
std::string expectedStr = attrs.getOpt<std::string>(SUMO_ATTR_EXPECTED, 0, ok, "");
std::set<std::string> personIDs;
SUMOSAXAttributes::parseStringSet(expectedStr, personIDs);
stop.awaitedPersons = personIDs;
const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, 0, ok, "end");
if (idx == "end") {
stop.index = STOP_INDEX_END;
} else if (idx == "fit") {
stop.index = STOP_INDEX_FIT;
} else {
stop.index = attrs.get<int>(SUMO_ATTR_INDEX, 0, ok);
if (!ok || stop.index < 0) {
errorOutput->inform("Invalid 'index' for stop" + errorSuffix);
return false;
}
}
return true;
}
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);
}
}
}
