void GUISettingsHandler::myStartElement(SumoXMLTag element, const SUMOSAXAttributes &attrs) throw(ProcessError) { bool ok = true; switch (element) { case SUMO_TAG_DELAY: myDelay = attrs.getOptSUMORealReporting(SUMO_ATTR_VALUE, "delay", 0, ok, myDelay); break; case SUMO_TAG_VIEWPORT: myZoom = attrs.getOptSUMORealReporting(SUMO_ATTR_ZOOM, "viewport", 0, ok, myZoom); myXPos = attrs.getOptSUMORealReporting(SUMO_ATTR_X, "viewport", 0, ok, myXPos); myYPos = attrs.getOptSUMORealReporting(SUMO_ATTR_Y, "viewport", 0, ok, myYPos); break; case SUMO_TAG_SNAPSHOT: { bool ok = true; std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, "snapshot", 0, ok); if (file != "" && !FileHelpers::isAbsolute(file)) { file = FileHelpers::getConfigurationRelative(getFileName(), file); } mySnapshots[attrs.getOptSUMOTimeReporting(SUMO_ATTR_TIME, "snapshot", file.c_str(), ok, 0)] = file; } break; case SUMO_TAG_VIEWSETTINGS_SCHEME: { bool ok = true; mySettings.name = attrs.getOptStringReporting(SUMO_ATTR_NAME, 0, 0, ok, mySettings.name); if (gSchemeStorage.contains(mySettings.name)) { mySettings = gSchemeStorage.get(mySettings.name); } } break; case SUMO_TAG_VIEWSETTINGS_OPENGL: mySettings.antialiase = TplConvert<char>::_2bool(attrs.getStringSecure("antialiase", toString(mySettings.antialiase)).c_str()); mySettings.dither = TplConvert<char>::_2bool(attrs.getStringSecure("dither", toString(mySettings.dither)).c_str()); break; case SUMO_TAG_VIEWSETTINGS_BACKGROUND: { bool ok = true; mySettings.backgroundColor = RGBColor::parseColorReporting(attrs.getStringSecure("backgroundColor", toString(mySettings.backgroundColor)), "background", 0, true, ok); mySettings.showGrid = TplConvert<char>::_2bool(attrs.getStringSecure("showGrid", toString(mySettings.showGrid)).c_str()); mySettings.gridXSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("gridXSize", toString(mySettings.gridXSize)).c_str()); mySettings.gridYSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("gridYSize", toString(mySettings.gridYSize)).c_str()); } break; case SUMO_TAG_VIEWSETTINGS_EDGES: { bool ok = true; int laneEdgeMode = TplConvert<char>::_2int(attrs.getStringSecure("laneEdgeMode", "0").c_str()); mySettings.laneShowBorders = TplConvert<char>::_2bool(attrs.getStringSecure("laneShowBorders", toString(mySettings.laneShowBorders)).c_str()); mySettings.showLinkDecals = TplConvert<char>::_2bool(attrs.getStringSecure("showLinkDecals", toString(mySettings.showLinkDecals)).c_str()); mySettings.showRails = TplConvert<char>::_2bool(attrs.getStringSecure("showRails", toString(mySettings.showRails)).c_str()); mySettings.drawEdgeName = TplConvert<char>::_2bool(attrs.getStringSecure("drawEdgeName", toString(mySettings.drawEdgeName)).c_str()); mySettings.edgeNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("edgeNameSize", toString(mySettings.edgeNameSize)).c_str()); mySettings.edgeNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("edgeNameColor", toString(mySettings.edgeNameColor)), "edges", 0, true, ok); mySettings.drawInternalEdgeName = TplConvert<char>::_2bool(attrs.getStringSecure("drawInternalEdgeName", toString(mySettings.drawInternalEdgeName)).c_str()); mySettings.internalEdgeNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("internalEdgeNameSize", toString(mySettings.internalEdgeNameSize)).c_str()); mySettings.internalEdgeNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("internalEdgeNameColor", toString(mySettings.internalEdgeNameColor)), "edges", 0, true, ok); mySettings.hideConnectors = TplConvert<char>::_2bool(attrs.getStringSecure("hideConnectors", toString(mySettings.hideConnectors)).c_str()); myCurrentColorer = element; #ifdef HAVE_MESOSIM mySettings.edgeColorer.setActive(laneEdgeMode); #endif mySettings.laneColorer.setActive(laneEdgeMode); } break; case SUMO_TAG_COLORSCHEME: myCurrentScheme = 0; if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_EDGES) { myCurrentScheme = mySettings.laneColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, "")); #ifdef HAVE_MESOSIM if (myCurrentScheme == 0) { myCurrentScheme = mySettings.edgeColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, "")); } #endif } if (myCurrentColorer == SUMO_TAG_VIEWSETTINGS_VEHICLES) { myCurrentScheme = mySettings.vehicleColorer.getSchemeByName(attrs.getStringSecure(SUMO_ATTR_NAME, "")); } if (myCurrentScheme && !myCurrentScheme->isFixed()) { bool ok = true; myCurrentScheme->setInterpolated(attrs.getOptBoolReporting(SUMO_ATTR_INTERPOLATED, "colorScheme", 0, ok, false)); myCurrentScheme->clear(); } break; case SUMO_TAG_ENTRY: if (myCurrentScheme) { bool ok = true; std::string colorStr = attrs.getStringReporting(SUMO_ATTR_COLOR, "entry", 0, ok); RGBColor color = RGBColor::parseColorReporting(colorStr, "edgeColoring", 0, true, ok); if (myCurrentScheme->isFixed()) { myCurrentScheme->setColor(attrs.getStringSecure(SUMO_ATTR_NAME, ""), color); } else { myCurrentScheme->addColor(color, attrs.getSUMORealReporting(SUMO_ATTR_THRESHOLD, "entry", 0, ok)); } } break; case SUMO_TAG_VIEWSETTINGS_VEHICLES: mySettings.vehicleColorer.setActive(TplConvert<char>::_2int(attrs.getStringSecure("vehicleMode", "0").c_str())); mySettings.vehicleQuality = TplConvert<char>::_2int(attrs.getStringSecure("vehicleQuality", toString(mySettings.vehicleQuality)).c_str()); mySettings.minVehicleSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("minVehicleSize", toString(mySettings.minVehicleSize)).c_str()); mySettings.vehicleExaggeration = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("vehicleExaggeration", toString(mySettings.vehicleExaggeration)).c_str()); mySettings.showBlinker = TplConvert<char>::_2bool(attrs.getStringSecure("showBlinker", toString(mySettings.showBlinker)).c_str()); mySettings.drawVehicleName = TplConvert<char>::_2bool(attrs.getStringSecure("drawVehicleName", toString(mySettings.drawVehicleName)).c_str()); mySettings.vehicleNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("vehicleNameSize", toString(mySettings.vehicleNameSize)).c_str()); mySettings.vehicleNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("vehicleNameColor", toString(mySettings.vehicleNameColor)), "vehicles", 0, true, ok); myCurrentColorer = element; break; case SUMO_TAG_VIEWSETTINGS_JUNCTIONS: mySettings.junctionMode = TplConvert<char>::_2int(attrs.getStringSecure("junctionMode", toString(mySettings.junctionMode)).c_str()); mySettings.drawLinkTLIndex = TplConvert<char>::_2bool(attrs.getStringSecure("drawLinkTLIndex", toString(mySettings.drawLinkTLIndex)).c_str()); mySettings.drawLinkJunctionIndex = TplConvert<char>::_2bool(attrs.getStringSecure("drawLinkJunctionIndex", toString(mySettings.drawLinkJunctionIndex)).c_str()); mySettings.drawJunctionName = TplConvert<char>::_2bool(attrs.getStringSecure("drawJunctionName", toString(mySettings.drawJunctionName)).c_str()); mySettings.junctionNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("junctionNameSize", toString(mySettings.junctionNameSize)).c_str()); mySettings.junctionNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("junctionNameColor", toString(mySettings.junctionNameColor)), "junctions", 0, true, ok); mySettings.showLane2Lane = TplConvert<char>::_2bool(attrs.getStringSecure("showLane2Lane", toString(mySettings.showLane2Lane)).c_str()); break; case SUMO_TAG_VIEWSETTINGS_ADDITIONALS: mySettings.addMode = TplConvert<char>::_2int(attrs.getStringSecure("addMode", toString(mySettings.addMode)).c_str()); mySettings.minAddSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("minAddSize", toString(mySettings.minAddSize)).c_str()); mySettings.addExaggeration = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("addExaggeration", toString(mySettings.addExaggeration)).c_str()); mySettings.drawAddName = TplConvert<char>::_2bool(attrs.getStringSecure("drawAddName", toString(mySettings.drawAddName)).c_str()); mySettings.addNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("addNameSize", toString(mySettings.addNameSize)).c_str()); break; case SUMO_TAG_VIEWSETTINGS_POIS: mySettings.poiExaggeration = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("poiExaggeration", toString(mySettings.poiExaggeration)).c_str()); mySettings.minPOISize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("minPOISize", toString(mySettings.minPOISize)).c_str()); mySettings.drawPOIName = TplConvert<char>::_2bool(attrs.getStringSecure("drawPOIName", toString(mySettings.drawPOIName)).c_str()); mySettings.poiNameSize = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("poiNameSize", toString(mySettings.poiNameSize)).c_str()); mySettings.poiNameColor = RGBColor::parseColorReporting(attrs.getStringSecure("poiNameColor", toString(mySettings.poiNameColor)), "pois", 0, true, ok); break; case SUMO_TAG_VIEWSETTINGS_LEGEND: mySettings.showSizeLegend = TplConvert<char>::_2bool(attrs.getStringSecure("showSizeLegend", toString(mySettings.showSizeLegend)).c_str()); break; case SUMO_TAG_VIEWSETTINGS_DECAL: { GUISUMOAbstractView::Decal d; d.filename = attrs.getStringSecure("filename", d.filename); if (d.filename != "" && !FileHelpers::isAbsolute(d.filename)) { d.filename = FileHelpers::getConfigurationRelative(getFileName(), d.filename); } d.centerX = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("centerX", toString(d.centerX)).c_str()); d.centerY = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("centerY", toString(d.centerY)).c_str()); d.width = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("width", toString(d.width)).c_str()); d.height = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("height", toString(d.height)).c_str()); d.rot = TplConvert<char>::_2SUMOReal(attrs.getStringSecure("rotation", toString(d.rot)).c_str()); d.initialised = false; myDecals.push_back(d); } break; } }
void PCLoaderXML::myStartElement(int element, const SUMOSAXAttributes& attrs) { if (element != SUMO_TAG_POI && element != SUMO_TAG_POLY) { return; } if (element == SUMO_TAG_POI) { bool ok = true; // get the id, report an error if not given or empty... std::string id = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok); SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_X, id.c_str(), ok); SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_Y, id.c_str(), ok); std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, id.c_str(), ok, ""); if (!ok) { return; } Position pos(x, y); if (!GeoConvHelper::getProcessing().x2cartesian(pos)) { WRITE_WARNING("Unable to project coordinates for POI '" + id + "'."); } // patch the values bool discard = myOptions.getBool("discard"); int layer = myOptions.getInt("layer"); RGBColor color; if (myTypeMap.has(type)) { const PCTypeMap::TypeDef& def = myTypeMap.get(type); id = def.prefix + id; type = def.id; color = RGBColor::parseColor(def.color); discard = def.discard; layer = def.layer; } else { id = myOptions.getString("prefix") + id; type = myOptions.getString("type"); color = RGBColor::parseColor(myOptions.getString("color")); } if (!discard) { bool ignorePrunning = false; if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) { ignorePrunning = true; } PointOfInterest* poi = new PointOfInterest(id, type, pos, color); if (!myCont.insert(id, poi, layer, ignorePrunning)) { WRITE_ERROR("POI '" + id + "' could not been added."); delete poi; } } } if (element == SUMO_TAG_POLY) { bool discard = myOptions.getBool("discard"); int layer = myOptions.getInt("layer"); bool ok = true; std::string id = attrs.getOptStringReporting(SUMO_ATTR_ID, myCurrentID.c_str(), ok, ""); std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok, ""); if (!ok) { return; } RGBColor color; if (myTypeMap.has(type)) { const PCTypeMap::TypeDef& def = myTypeMap.get(type); id = def.prefix + id; type = def.id; color = RGBColor::parseColor(def.color); discard = def.discard; layer = def.layer; } else { id = myOptions.getString("prefix") + id; type = myOptions.getString("type"); color = RGBColor::parseColor(myOptions.getString("color")); } if (!discard) { bool ignorePrunning = false; if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) { ignorePrunning = true; } myCurrentID = id; myCurrentType = type; myCurrentColor = color; myCurrentIgnorePrunning = ignorePrunning; myCurrentLayer = layer; if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) { // @deprecated At some time, no shape definition using characters will be allowed myCharacters(element, attrs.getStringReporting(SUMO_ATTR_SHAPE, myCurrentID.c_str(), ok)); } } } }
void 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 PCLoaderXML::myStartElement(int element, const SUMOSAXAttributes& attrs) { if (element != SUMO_TAG_POI && element != SUMO_TAG_POLY) { return; } if (element == SUMO_TAG_POI) { bool ok = true; // get the id, report an error if not given or empty... std::string id = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok); SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_X, id.c_str(), ok); SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_Y, id.c_str(), ok); std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, id.c_str(), ok, myOptions.getString("type")); if (!ok) { return; } Position pos(x, y); if (!GeoConvHelper::getProcessing().x2cartesian(pos)) { WRITE_WARNING("Unable to project coordinates for POI '" + id + "'."); } // patch the values bool discard = myOptions.getBool("discard"); SUMOReal layer = (SUMOReal)myOptions.getInt("layer"); RGBColor color; if (myTypeMap.has(type)) { const PCTypeMap::TypeDef& def = myTypeMap.get(type); id = def.prefix + id; type = def.id; color = RGBColor::parseColor(def.color); discard = def.discard; layer = (SUMOReal)def.layer; } else { id = myOptions.getString("prefix") + id; color = RGBColor::parseColor(myOptions.getString("color")); } layer = attrs.getOptSUMORealReporting(SUMO_ATTR_LAYER, id.c_str(), ok, layer); if (attrs.hasAttribute(SUMO_ATTR_COLOR)) { color = attrs.getColorReporting(id.c_str(), ok); } SUMOReal angle = attrs.getOptSUMORealReporting(SUMO_ATTR_ANGLE, id.c_str(), ok, Shape::DEFAULT_ANGLE); std::string imgFile = attrs.getOptStringReporting(SUMO_ATTR_IMGFILE, id.c_str(), ok, Shape::DEFAULT_IMG_FILE); if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) { imgFile = FileHelpers::getConfigurationRelative(getFileName(), imgFile); } SUMOReal imgWidth = attrs.getOptSUMORealReporting(SUMO_ATTR_WIDTH, id.c_str(), ok, Shape::DEFAULT_IMG_WIDTH); SUMOReal imgHeight = attrs.getOptSUMORealReporting(SUMO_ATTR_HEIGHT, id.c_str(), ok, Shape::DEFAULT_IMG_HEIGHT); if (!ok) { return; } if (!discard) { bool ignorePrunning = false; if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) { ignorePrunning = true; } PointOfInterest* poi = new PointOfInterest(id, type, color, pos, layer, angle, imgFile, imgWidth, imgHeight); if (!myCont.insert(id, poi, (int)layer, ignorePrunning)) { WRITE_ERROR("POI '" + id + "' could not be added."); delete poi; } } } if (element == SUMO_TAG_POLY) { bool discard = myOptions.getBool("discard"); SUMOReal layer = (SUMOReal)myOptions.getInt("layer"); bool ok = true; std::string id = attrs.getOptStringReporting(SUMO_ATTR_ID, myCurrentID.c_str(), ok, ""); std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok, myOptions.getString("type")); if (!ok) { return; } RGBColor color; if (myTypeMap.has(type)) { const PCTypeMap::TypeDef& def = myTypeMap.get(type); id = def.prefix + id; type = def.id; color = RGBColor::parseColor(def.color); discard = def.discard; layer = (SUMOReal)def.layer; } else { id = myOptions.getString("prefix") + id; color = RGBColor::parseColor(myOptions.getString("color")); } layer = attrs.getOptSUMORealReporting(SUMO_ATTR_LAYER, id.c_str(), ok, layer); if (attrs.hasAttribute(SUMO_ATTR_COLOR)) { color = attrs.getColorReporting(id.c_str(), ok); } SUMOReal angle = attrs.getOptSUMORealReporting(SUMO_ATTR_ANGLE, id.c_str(), ok, Shape::DEFAULT_ANGLE); std::string imgFile = attrs.getOptStringReporting(SUMO_ATTR_IMGFILE, id.c_str(), ok, Shape::DEFAULT_IMG_FILE); if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) { imgFile = FileHelpers::getConfigurationRelative(getFileName(), imgFile); } bool fill = attrs.getOptBoolReporting(SUMO_ATTR_FILL, id.c_str(), ok, false); if (!ok) { return; } if (!discard) { bool ignorePrunning = false; if (OptionsCont::getOptions().isInStringVector("prune.keep-list", id)) { ignorePrunning = true; } myCurrentID = id; myCurrentType = type; myCurrentColor = color; myCurrentIgnorePrunning = ignorePrunning; myCurrentLayer = layer; PositionVector pshape = attrs.getShapeReporting(SUMO_ATTR_SHAPE, myCurrentID.c_str(), ok, false); if (!ok) { return; } PositionVector shape; for (PositionVector::ContType::const_iterator i = pshape.begin(); i != pshape.end(); ++i) { Position pos((*i)); if (!GeoConvHelper::getProcessing().x2cartesian(pos)) { WRITE_WARNING("Unable to project coordinates for polygon '" + myCurrentID + "'."); } shape.push_back(pos); } Polygon* poly = new Polygon(myCurrentID, myCurrentType, myCurrentColor, shape, fill, layer, angle, imgFile); if (!myCont.insert(myCurrentID, poly, (int)myCurrentLayer, myCurrentIgnorePrunning)) { WRITE_ERROR("Polygon '" + myCurrentID + "' could not be added."); delete poly; } } } }
void NIXMLEdgesHandler::addEdge(const SUMOSAXAttributes& attrs) { myIsUpdate = false; bool ok = true; // initialise the edge myCurrentEdge = 0; mySplits.clear(); // get the id, report an error if not given or empty... myCurrentID = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok); if (!ok) { return; } myCurrentEdge = myEdgeCont.retrieve(myCurrentID); // check deprecated (unused) attributes // use default values, first myCurrentSpeed = myTypeCont.getSpeed(""); myCurrentPriority = myTypeCont.getPriority(""); myCurrentLaneNo = myTypeCont.getNumLanes(""); myPermissions = myTypeCont.getPermissions(""); myCurrentWidth = myTypeCont.getWidth(""); myCurrentOffset = NBEdge::UNSPECIFIED_OFFSET; myCurrentType = ""; myShape = PositionVector(); myLanesSpread = LANESPREAD_RIGHT; myLength = NBEdge::UNSPECIFIED_LOADED_LENGTH; myCurrentStreetName = ""; myReinitKeepEdgeShape = false; // check whether a type's values shall be used if (attrs.hasAttribute(SUMO_ATTR_TYPE)) { myCurrentType = attrs.getStringReporting(SUMO_ATTR_TYPE, myCurrentID.c_str(), ok); if (!ok) { return; } if (!myTypeCont.knows(myCurrentType)) { WRITE_ERROR("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined."); return; } myCurrentSpeed = myTypeCont.getSpeed(myCurrentType); myCurrentPriority = myTypeCont.getPriority(myCurrentType); myCurrentLaneNo = myTypeCont.getNumLanes(myCurrentType); myPermissions = myTypeCont.getPermissions(myCurrentType); myCurrentWidth = myTypeCont.getWidth(myCurrentType); } // use values from the edge to overwrite if existing, then if (myCurrentEdge != 0) { myIsUpdate = true; if (!myHaveReportedAboutOverwriting) { WRITE_MESSAGE("Duplicate edge id occured ('" + myCurrentID + "'); assuming overwriting is wished."); myHaveReportedAboutOverwriting = true; } if (attrs.getOptBoolReporting(SUMO_ATTR_REMOVE, myCurrentID.c_str(), ok, false)) { myEdgeCont.erase(myDistrictCont, myCurrentEdge); myCurrentEdge = 0; return; } myCurrentSpeed = myCurrentEdge->getSpeed(); myCurrentPriority = myCurrentEdge->getPriority(); myCurrentLaneNo = myCurrentEdge->getNumLanes(); myCurrentType = myCurrentEdge->getTypeID(); myPermissions = myCurrentEdge->getPermissions(); if (!myCurrentEdge->hasDefaultGeometry()) { myShape = myCurrentEdge->getGeometry(); myReinitKeepEdgeShape = true; } myCurrentWidth = myCurrentEdge->getWidth(); myCurrentOffset = myCurrentEdge->getOffset(); myLanesSpread = myCurrentEdge->getLaneSpreadFunction(); if (myCurrentEdge->hasLoadedLength()) { myLength = myCurrentEdge->getLoadedLength(); } myCurrentStreetName = myCurrentEdge->getStreetName(); } // speed, priority and the number of lanes have now default values; // try to read the real values from the file if (attrs.hasAttribute(SUMO_ATTR_SPEED)) { myCurrentSpeed = attrs.getSUMORealReporting(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok); } if (myOptions.getBool("speed-in-kmh")) { myCurrentSpeed = myCurrentSpeed / (SUMOReal) 3.6; } // try to get the number of lanes if (attrs.hasAttribute(SUMO_ATTR_NUMLANES)) { myCurrentLaneNo = attrs.getIntReporting(SUMO_ATTR_NUMLANES, myCurrentID.c_str(), ok); } // try to get the priority if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) { myCurrentPriority = attrs.getIntReporting(SUMO_ATTR_PRIORITY, myCurrentID.c_str(), ok); } // try to get the width if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) { myCurrentWidth = attrs.getSUMORealReporting(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok); } // try to get the width if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) { myCurrentOffset = attrs.getSUMORealReporting(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok); } // try to get the street name myCurrentStreetName = attrs.getOptStringReporting(SUMO_ATTR_NAME, myCurrentID.c_str(), ok, myCurrentStreetName); // try to get the allowed/disallowed classes if (attrs.hasAttribute(SUMO_ATTR_ALLOW) || attrs.hasAttribute(SUMO_ATTR_DISALLOW)) { std::string allowS = attrs.hasAttribute(SUMO_ATTR_ALLOW) ? attrs.getStringSecure(SUMO_ATTR_ALLOW, "") : ""; std::string disallowS = attrs.hasAttribute(SUMO_ATTR_DISALLOW) ? attrs.getStringSecure(SUMO_ATTR_DISALLOW, "") : ""; // XXX matter of interpretation: should updated permissions replace or extend previously set permissions? myPermissions = parseVehicleClasses(allowS, disallowS); } // try to set the nodes if (!setNodes(attrs)) { // return if this failed return; } // try to get the shape myShape = tryGetShape(attrs); // try to get the spread type myLanesSpread = tryGetLaneSpread(attrs); // try to get the length myLength = attrs.getOptSUMORealReporting(SUMO_ATTR_LENGTH, myCurrentID.c_str(), ok, myLength); // insert the parsed edge into the edges map if (!ok) { return; } // check whether a previously defined edge shall be overwritten if (myCurrentEdge != 0) { myCurrentEdge->reinit(myFromNode, myToNode, myCurrentType, myCurrentSpeed, myCurrentLaneNo, myCurrentPriority, myShape, myCurrentWidth, myCurrentOffset, myCurrentStreetName, myLanesSpread, myReinitKeepEdgeShape); } else { // the edge must be allocated in dependence to whether a shape is given if (myShape.size() == 0) { myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed, myCurrentLaneNo, myCurrentPriority, myCurrentWidth, myCurrentOffset, myCurrentStreetName, myLanesSpread); } else { myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed, myCurrentLaneNo, myCurrentPriority, myCurrentWidth, myCurrentOffset, myShape, myCurrentStreetName, myLanesSpread, myKeepEdgeShape); } } myCurrentEdge->setLoadedLength(myLength); myCurrentEdge->setPermissions(myPermissions); }
void NIXMLEdgesHandler::myStartElement(SumoXMLTag element, const SUMOSAXAttributes &attrs) throw(ProcessError) { if (element==SUMO_TAG_EDGE) { myIsUpdate = false; bool ok = true; // initialise the edge myCurrentEdge = 0; mySplits.clear(); // get the id, report an error if not given or empty... if (!attrs.setIDFromAttributes("edge", myCurrentID)) { return; } myCurrentEdge = myEdgeCont.retrieve(myCurrentID); // check deprecated (unused) attributes if (!myHaveReportedAboutFunctionDeprecation&&attrs.hasAttribute(SUMO_ATTR_FUNCTION)) { MsgHandler::getWarningInstance()->inform("While parsing edge '" + myCurrentID + "': 'function' is deprecated.\n All occurences are ignored."); myHaveReportedAboutFunctionDeprecation = true; } // use default values, first myCurrentSpeed = myTypeCont.getDefaultSpeed(); myCurrentPriority = myTypeCont.getDefaultPriority(); myCurrentLaneNo = myTypeCont.getDefaultNoLanes(); // use values from the edge to overwrite if existing, then if (myCurrentEdge!=0) { myIsUpdate = true; if (!myHaveReportedAboutOverwriting) { MsgHandler::getMessageInstance()->inform("Duplicate edge id occured ('" + myCurrentID + "'); assuming overwriting is wished."); myHaveReportedAboutOverwriting = true; } myCurrentSpeed = myCurrentEdge->getSpeed(); myCurrentPriority = myCurrentEdge->getPriority(); myCurrentLaneNo = myCurrentEdge->getNoLanes(); myCurrentType = myCurrentEdge->getTypeID(); } // check whether a type's values shall be used myCurrentType = ""; if (attrs.hasAttribute(SUMO_ATTR_TYPE)) { myCurrentType = attrs.getStringReporting(SUMO_ATTR_TYPE, "edge", myCurrentID.c_str(), ok); if (!ok) { return; } if (!myTypeCont.knows(myCurrentType)) { MsgHandler::getErrorInstance()->inform("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined."); return; } myCurrentSpeed = myTypeCont.getSpeed(myCurrentType); myCurrentPriority = myTypeCont.getPriority(myCurrentType); myCurrentLaneNo = myTypeCont.getNoLanes(myCurrentType); } // speed, priority and the number of lanes have now default values; // try to read the real values from the file if (attrs.hasAttribute(SUMO_ATTR_SPEED)) { myCurrentSpeed = attrs.getSUMORealReporting(SUMO_ATTR_SPEED, "edge", myCurrentID.c_str(), ok); } if (myOptions.getBool("speed-in-kmh")) { myCurrentSpeed = myCurrentSpeed / (SUMOReal) 3.6; } // try to get the number of lanes if (attrs.hasAttribute(SUMO_ATTR_NOLANES)) { myCurrentLaneNo = attrs.getIntReporting(SUMO_ATTR_NOLANES, "edge", myCurrentID.c_str(), ok); } // try to get the priority if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) { myCurrentPriority = attrs.getIntReporting(SUMO_ATTR_PRIORITY, "edge", myCurrentID.c_str(), ok); } // try to get the shape myShape = tryGetShape(attrs); // and how to spread the lanes if (attrs.getOptStringReporting(SUMO_ATTR_SPREADFUNC, "edge", myCurrentID.c_str(), ok, "")=="center") { myLanesSpread = NBEdge::LANESPREAD_CENTER; } else { myLanesSpread = NBEdge::LANESPREAD_RIGHT; } // try to set the nodes if (!setNodes(attrs)) { // return if this failed return; } // get the length or compute it if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) { myLength = attrs.getSUMORealReporting(SUMO_ATTR_LENGTH, "edge", myCurrentID.c_str(), ok); } else { myLength = 0; } /// insert the parsed edge into the edges map if (!ok) { return; } // check whether a previously defined edge shall be overwritten if (myCurrentEdge!=0) { myCurrentEdge->reinit(myFromNode, myToNode, myCurrentType, myCurrentSpeed, myCurrentLaneNo, myCurrentPriority, myShape, myLanesSpread); } else { // the edge must be allocated in dependence to whether a shape is given if (myShape.size()==0) { myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed, myCurrentLaneNo, myCurrentPriority, myLanesSpread); } else { myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed, myCurrentLaneNo, myCurrentPriority, myShape, myLanesSpread, OptionsCont::getOptions().getBool("xml.keep-shape")); } myCurrentEdge->setLoadedLength(myLength); } } if (element==SUMO_TAG_LANE) { if (myCurrentEdge==0) { if (!OptionsCont::getOptions().isInStringVector("remove-edges", myCurrentID)) { MsgHandler::getErrorInstance()->inform("Additional lane information could not been set - the edge with id '" + myCurrentID + "' is not known."); } return; } bool ok = true; int lane = attrs.getIntReporting(SUMO_ATTR_ID, "lane", 0, ok); std::vector<std::string> disallowed, allowed, preferred; SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_DISALLOW, "lane", 0, ok, ""), disallowed); SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_ALLOW, "lane", 0, ok, ""), allowed); SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_PREFER, "lane", 0, ok, ""), preferred); if (!ok) { return; } if (lane<0) { MsgHandler::getErrorInstance()->inform("Missing lane-id in lane definition (edge '" + myCurrentID + "')."); return; } // check whether this lane exists if (lane>=(int) myCurrentEdge->getNoLanes()) { MsgHandler::getErrorInstance()->inform("Lane-id is larger than number of lanes (edge '" + myCurrentID + "')."); return; } // set information about allowed / disallowed vehicle classes for (std::vector<std::string>::iterator i=disallowed.begin(); i!=disallowed.end(); ++i) { myCurrentEdge->disallowVehicleClass(lane, getVehicleClassID(*i)); } for (std::vector<std::string>::iterator i=allowed.begin(); i!=allowed.end(); ++i) { myCurrentEdge->allowVehicleClass(lane, getVehicleClassID(*i)); } for (std::vector<std::string>::iterator i=preferred.begin(); i!=preferred.end(); ++i) { myCurrentEdge->preferVehicleClass(lane, getVehicleClassID(*i)); } // set information about later beginning lanes if (attrs.hasAttribute(SUMO_ATTR_FORCE_LENGTH)) { bool ok = true; int forcedLength = attrs.getIntReporting(SUMO_ATTR_FORCE_LENGTH, "lane", myCurrentID.c_str(), ok); // !!! edge id if (ok) { int nameid = forcedLength; forcedLength = (int)(myCurrentEdge->getGeometry().length() - forcedLength); std::vector<Split>::iterator i; i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder((SUMOReal) forcedLength)); if (i==mySplits.end()) { Split e; e.pos = (SUMOReal) forcedLength; e.nameid = nameid; for (unsigned int j=0; j<myCurrentEdge->getNoLanes(); j++) { e.lanes.push_back(j); } mySplits.push_back(e); } i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder((SUMOReal) forcedLength)); std::vector<int>::iterator k = find((*i).lanes.begin(), (*i).lanes.end(), lane); if (k!=(*i).lanes.end()) { (*i).lanes.erase(k); } } } } if (element==SUMO_TAG_SPLIT) { bool ok = true; Split e; e.pos = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "split", 0, ok); std::vector<Split>::iterator i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder(e.pos)); if (i!=mySplits.end()) { MsgHandler::getErrorInstance()->inform("Edge '" + myCurrentID + "' has already a split at position " + toString(e.pos) + "."); return; } if (e.pos<0) { e.pos = myCurrentEdge->getGeometry().length() - e.pos; } e.nameid = (int)e.pos; if (ok) { if (myCurrentEdge==0) { if (!OptionsCont::getOptions().isInStringVector("remove-edges", myCurrentID)) { MsgHandler::getErrorInstance()->inform("Additional lane information could not been set - the edge with id '" + myCurrentID + "' is not known."); } return; } if (e.pos<0) { e.pos = myCurrentEdge->getGeometry().length() + e.pos; } std::vector<std::string> lanes; SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_LANES, "split", 0, ok, ""), lanes); for (std::vector<std::string>::iterator i=lanes.begin(); i!=lanes.end(); ++i) { try { int lane = TplConvert<char>::_2int((*i).c_str()); e.lanes.push_back(lane); } catch (NumberFormatException &) { MsgHandler::getErrorInstance()->inform("Error on parsing a split (edge '" + myCurrentID + "')."); } catch (EmptyData &) { MsgHandler::getErrorInstance()->inform("Error on parsing a split (edge '" + myCurrentID + "')."); } } if (e.lanes.size()==0) { MsgHandler::getErrorInstance()->inform("Missing lane information in split of edge '" + myCurrentID + "'."); } else { mySplits.push_back(e); } } } }
void 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); } } }