void
MSLaneSpeedTrigger::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
// check whether the correct tag is read
if (element != SUMO_TAG_STEP) {
return;
}
// extract the values
bool ok = true;
SUMOTime next = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, getID().c_str(), ok);
SUMOReal speed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, getID().c_str(), ok, -1);
// check the values
if (next < 0) {
WRITE_ERROR("Wrong time in vss '" + getID() + "'.");
return;
}
if (speed < 0) {
WRITE_ERROR("Wrong speed in vss '" + getID() + "'.");
return;
}
// set the values for the next step if they are valid
if (myLoadedSpeeds.size() != 0 && myLoadedSpeeds.back().first == next) {
WRITE_WARNING("Time " + time2string(next) + " was set twice for vss '" + getID() + "'; replacing first entry.");
myLoadedSpeeds.back().second = speed;
} else {
myLoadedSpeeds.push_back(std::make_pair(next, speed));
}
}
void
MSRouteHandler::openRouteDistribution(const SUMOSAXAttributes& attrs) {
// check whether the id is really necessary
bool ok = true;
if (myVehicleParameter != 0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
myCurrentRouteDistributionID = "!" + myVehicleParameter->id; // !!! document this
} else {
myCurrentRouteDistributionID = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
}
myCurrentRouteDistribution = new RandomDistributor<const MSRoute*>();
if (attrs.hasAttribute(SUMO_ATTR_ROUTES)) {
bool ok = true;
StringTokenizer st(attrs.getStringReporting(SUMO_ATTR_ROUTES, myCurrentRouteDistributionID.c_str(), ok));
while (st.hasNext()) {
std::string routeID = st.next();
const MSRoute* route = MSRoute::dictionary(routeID);
if (route == 0) {
throw ProcessError("Unknown route '" + routeID + "' in distribution '" + myCurrentRouteDistributionID + "'.");
}
myCurrentRouteDistribution->add(1., route, false);
}
}
}
void
NLDiscreteEventBuilder::buildSaveTLStateCommand(const SUMOSAXAttributes& attrs,
const std::string& basePath) {
bool ok = true;
const std::string dest = attrs.getOptStringReporting(SUMO_ATTR_DEST, 0, ok, "");
const std::string source = attrs.getOptStringReporting(SUMO_ATTR_SOURCE, 0, ok, "");
// check the parameter
if (dest == "" || !ok) {
throw InvalidArgument("Incomplete description of an 'SaveTLSState'-action occured.");
}
if (source == "") {
const std::vector<std::string> ids = myNet.getTLSControl().getAllTLIds();
for (std::vector<std::string>::const_iterator tls = ids.begin(); tls != ids.end(); ++tls) {
const MSTLLogicControl::TLSLogicVariants& logics = myNet.getTLSControl().get(*tls);
new Command_SaveTLSState(logics, OutputDevice::getDevice(dest, basePath));
}
} else {
// get the logic
if (!myNet.getTLSControl().knows(source)) {
throw InvalidArgument("The traffic light logic to save (" + source + ") is not known.");
}
const MSTLLogicControl::TLSLogicVariants& logics = myNet.getTLSControl().get(source);
// build the action
new Command_SaveTLSState(logics, OutputDevice::getDevice(dest, basePath));
}
}
void
NLTriggerBuilder::buildVaporizer(const SUMOSAXAttributes& attrs) {
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) {
return;
}
MSEdge* e = MSEdge::dictionary(id);
if (e == 0) {
WRITE_ERROR("Unknown edge ('" + id + "') referenced in a vaporizer.");
return;
}
SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, 0, ok);
SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, 0, ok);
if (!ok) {
return;
}
if (begin < 0) {
WRITE_ERROR("A vaporization begin time is negative (edge id='" + id + "').");
return;
}
if (begin >= end) {
WRITE_ERROR("A vaporization ends before it starts (edge id='" + id + "').");
return;
}
if (end >= string2time(OptionsCont::getOptions().getString("begin"))) {
Command* cb = new WrappingCommand< MSEdge >(e, &MSEdge::incVaporization);
MSNet::getInstance()->getBeginOfTimestepEvents().addEvent(cb, begin, MSEventControl::ADAPT_AFTER_EXECUTION);
Command* ce = new WrappingCommand< MSEdge >(e, &MSEdge::decVaporization);
MSNet::getInstance()->getBeginOfTimestepEvents().addEvent(ce, end, MSEventControl::ADAPT_AFTER_EXECUTION);
}
}
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
NIImporter_SUMO::addJunction(const SUMOSAXAttributes &attrs) {
// get the id, report an error if not given or empty...
std::string id;
if (!attrs.setIDFromAttributes("junction", id)) {
return;
}
if (id[0]==':') {
return;
}
bool ok = true;
SUMOReal x = attrs.getOptSUMORealReporting(SUMO_ATTR_X, "junction", id.c_str(), ok, -1);
SUMOReal y = attrs.getOptSUMORealReporting(SUMO_ATTR_Y, "junction", id.c_str(), ok, -1);
// !!! this is too simplified! A proper error check should be done
if (x==-1||y==-1) {
MsgHandler::getErrorInstance()->inform("Junction '" + id + "' has an invalid position.");
return;
}
Position2D pos(x, y);
if (!GeoConvHelper::x2cartesian(pos)) {
MsgHandler::getErrorInstance()->inform("Unable to project coordinates for junction " + id + ".");
return;
}
NBNode *node = new NBNode(id, pos);
if (!myNodeCont.insert(node)) {
MsgHandler::getErrorInstance()->inform("Problems on adding junction '" + id + "'.");
delete node;
return;
}
}
void
NIXMLTrafficLightsHandler::removeTlConnection(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string tlID = attrs.getStringReporting(SUMO_ATTR_TLID, 0, ok);
// does the traffic light still exist?
const std::map<std::string, NBTrafficLightDefinition*>& programs = myTLLCont.getPrograms(tlID);
if (programs.size() > 0) {
// parse identifying attributes
NBEdge* from = retrieveEdge(attrs, SUMO_ATTR_FROM, ok);
NBEdge* to = retrieveEdge(attrs, SUMO_ATTR_TO, ok);
if (!ok) {
return;
}
int fromLane = retrieveLaneIndex(attrs, SUMO_ATTR_FROM_LANE, from, ok);
int toLane = retrieveLaneIndex(attrs, SUMO_ATTR_TO_LANE, to, ok);
if (!ok) {
return;
}
int tlIndex = attrs.getIntReporting(SUMO_ATTR_TLLINKINDEX, 0, ok);
NBConnection conn(from, fromLane, to, toLane, tlIndex);
// remove the connection from all definitions
std::map<std::string, NBTrafficLightDefinition*>::const_iterator it;
for (it = programs.begin(); it != programs.end(); it++) {
NBLoadedSUMOTLDef* tlDef = dynamic_cast<NBLoadedSUMOTLDef*>(it->second);
if (tlDef) {
tlDef->removeConnection(conn, false);
} else {
throw ProcessError("Corrupt traffic light definition '"
+ tlID + "' (program '" + it->first + "')");
}
}
}
}
void
RONetHandler::parseDistrict(const SUMOSAXAttributes& attrs) {
myCurrentEdge = 0;
bool ok = true;
myCurrentName = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
ROEdge* sink = myEdgeBuilder.buildEdge(myCurrentName + "-sink", 0, 0, 0);
sink->setType(ROEdge::ET_DISTRICT);
myNet.addEdge(sink);
ROEdge* source = myEdgeBuilder.buildEdge(myCurrentName + "-source", 0, 0, 0);
source->setType(ROEdge::ET_DISTRICT);
myNet.addEdge(source);
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
std::vector<std::string> desc = attrs.getStringVector(SUMO_ATTR_EDGES);
for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
ROEdge* edge = myNet.getEdge(*i);
// check whether the edge exists
if (edge == 0) {
throw ProcessError("The edge '" + *i + "' within district '" + myCurrentName + "' is not known.");
}
source->addFollower(edge);
edge->addFollower(sink);
}
}
}
void
AGActivityGenHandler::parseStreets(const SUMOSAXAttributes& attrs) {
try {
SUMOReal pop = 0;
SUMOReal work = 0;
if (attrs.hasAttribute(AGEN_ATTR_POPULATION)) {
pop = attrs.getFloat(AGEN_ATTR_POPULATION);
}
if (attrs.hasAttribute(AGEN_ATTR_OUT_WORKPOSITION)) {
work = attrs.getFloat(AGEN_ATTR_OUT_WORKPOSITION);
}
std::string eid = attrs.getString(SUMO_ATTR_EDGE);
AGStreet* street = dynamic_cast<AGStreet*>(net->getEdge(eid));
if (street == 0) {
WRITE_ERROR("Edge '" + eid + "' is not known.");
return;
}
street->setPopulation(pop * street->getLength());
street->setWorkplaceNumber(work * street->getLength());
myCity.streets.push_back(street);
} catch (const std::exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_STREET) + ": " +
e.what());
throw ProcessError();
}
}
bool
NIXMLEdgesHandler::setNodes(const SUMOSAXAttributes &attrs) throw() {
// the names and the coordinates of the beginning and the end node
// may be found, try
bool ok = true;
std::string begNodeID = myIsUpdate ? myCurrentEdge->getFromNode()->getID() : "";
std::string endNodeID = myIsUpdate ? myCurrentEdge->getToNode()->getID() : "";
begNodeID = attrs.hasAttribute(SUMO_ATTR_FROMNODE) ? attrs.getStringReporting(SUMO_ATTR_FROMNODE, "edge", 0, ok) : begNodeID;
endNodeID = attrs.hasAttribute(SUMO_ATTR_TONODE) ? attrs.getStringReporting(SUMO_ATTR_TONODE, "edge", 0, ok) : endNodeID;
if (!ok) {
return false;
}
// or their positions !!! deprecated
SUMOReal begNodeXPos = tryGetPosition(attrs, SUMO_ATTR_XFROM, "XFrom");
SUMOReal begNodeYPos = tryGetPosition(attrs, SUMO_ATTR_YFROM, "YFrom");
SUMOReal endNodeXPos = tryGetPosition(attrs, SUMO_ATTR_XTO, "XTo");
SUMOReal endNodeYPos = tryGetPosition(attrs, SUMO_ATTR_YTO, "YTo");
if (begNodeXPos!=SUMOXML_INVALID_POSITION&&begNodeYPos!=SUMOXML_INVALID_POSITION) {
Position2D pos(begNodeXPos, begNodeYPos);
GeoConvHelper::x2cartesian(pos);
begNodeXPos = pos.x();
begNodeYPos = pos.y();
}
if (endNodeXPos!=SUMOXML_INVALID_POSITION&&endNodeYPos!=SUMOXML_INVALID_POSITION) {
Position2D pos(endNodeXPos, endNodeYPos);
GeoConvHelper::x2cartesian(pos);
endNodeXPos = pos.x();
endNodeYPos = pos.y();
}
// check the obtained values for nodes
myFromNode = insertNodeChecking(Position2D(begNodeXPos, begNodeYPos), begNodeID, "from");
myToNode = insertNodeChecking(Position2D(endNodeXPos, endNodeYPos), endNodeID, "to");
return myFromNode!=0&&myToNode!=0;
}
void
NIImporter_SUMO::addLane(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string id = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
if (!myCurrentEdge) {
WRITE_ERROR("Found lane '" + id + "' not within edge element");
return;
}
myCurrentLane = new LaneAttrs;
if (myCurrentEdge->func == toString(EDGEFUNC_INTERNAL)) {
return; // skip internal lanes
}
if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED__DEPRECATED)) {
myCurrentLane->maxSpeed = attrs.getSUMORealReporting(SUMO_ATTR_MAXSPEED__DEPRECATED, id.c_str(), ok);
if (!myHaveWarnedAboutDeprecatedMaxSpeed) {
myHaveWarnedAboutDeprecatedMaxSpeed = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_MAXSPEED__DEPRECATED) + "' is deprecated, please use '" + toString(SUMO_ATTR_SPEED) + "' instead.");
}
} else {
myCurrentLane->maxSpeed = attrs.getSUMORealReporting(SUMO_ATTR_SPEED, id.c_str(), ok);
}
myCurrentLane->allow = attrs.getOptStringReporting(SUMO_ATTR_ALLOW, id.c_str(), ok, "");
myCurrentLane->disallow = attrs.getOptStringReporting(SUMO_ATTR_DISALLOW, id.c_str(), ok, "");
myCurrentLane->width = attrs.getOptSUMORealReporting(SUMO_ATTR_WIDTH, id.c_str(), ok, (SUMOReal) NBEdge::UNSPECIFIED_WIDTH);
myCurrentLane->offset = attrs.getOptSUMORealReporting(SUMO_ATTR_ENDOFFSET, id.c_str(), ok, (SUMOReal) NBEdge::UNSPECIFIED_OFFSET);
myCurrentLane->shape = GeomConvHelper::parseShapeReporting(
attrs.getStringReporting(SUMO_ATTR_SHAPE, id.c_str(), ok),
attrs.getObjectType(), id.c_str(), ok, false);
// lane coordinates are derived (via lane spread) do not include them in convex boundary
NILoader::transformCoordinates(myCurrentLane->shape, false, myLocation);
}
void
NIImporter_SUMO::addRoundabout(const SUMOSAXAttributes& attrs) {
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
myRoundabouts.push_back(attrs.getStringVector(SUMO_ATTR_EDGES));
} else {
WRITE_ERROR("Empty edges in roundabout.");
}
}
void
SUMORouteHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
switch (element) {
case SUMO_TAG_VEHICLE:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
break;
case SUMO_TAG_PERSON:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs, false, false, true);
break;
case SUMO_TAG_CONTAINER:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
break;
case SUMO_TAG_FLOW:
delete myVehicleParameter;
myVehicleParameter = SUMOVehicleParserHelper::parseFlowAttributes(attrs, myBeginDefault, myEndDefault);
break;
case SUMO_TAG_VTYPE:
myCurrentVType = SUMOVehicleParserHelper::beginVTypeParsing(attrs, getFileName());
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_STOP:
addStop(attrs);
break;
case SUMO_TAG_TRIP: {
myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs, true);
if (myVehicleParameter->id == "") {
//@todo warn about deprecation of missing trip ids
myVehicleParameter->id = myIdSupplier.getNext();
}
myVehicleParameter->setParameter |= VEHPARS_FORCE_REROUTE;
myActiveRouteID = "!" + myVehicleParameter->id;
break;
}
case SUMO_TAG_INTERVAL: {
bool ok;
myBeginDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, 0, ok);
myEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, 0, ok);
break;
}
case SUMO_TAG_PARAM:
addParam(attrs);
break;
default:
break;
}
}
void NIXMLEdgesHandler::addSplit(const SUMOSAXAttributes& attrs) {
if (myCurrentEdge == 0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
WRITE_WARNING("Ignoring 'split' because it cannot be assigned to an edge");
}
return;
}
bool ok = true;
Split e;
e.pos = attrs.get<SUMOReal>(SUMO_ATTR_POSITION, 0, ok);
if (ok) {
if (fabs(e.pos) > myCurrentEdge->getGeometry().length()) {
WRITE_ERROR("Edge '" + myCurrentID + "' has a split at invalid position " + toString(e.pos) + ".");
return;
}
std::vector<Split>::iterator i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder(e.pos));
if (i != mySplits.end()) {
WRITE_ERROR("Edge '" + myCurrentID + "' has already a split at position " + toString(e.pos) + ".");
return;
}
const std::string nameid = toString((int)e.pos);
if (e.pos < 0) {
e.pos += myCurrentEdge->getGeometry().length();
}
std::vector<std::string> lanes;
SUMOSAXAttributes::parseStringVector(attrs.getOpt<std::string>(SUMO_ATTR_LANES, 0, ok, ""), lanes);
for (std::vector<std::string>::iterator i = lanes.begin(); i != lanes.end(); ++i) {
try {
int lane = TplConvert::_2int((*i).c_str());
e.lanes.push_back(lane);
} catch (NumberFormatException&) {
WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
} catch (EmptyData&) {
WRITE_ERROR("Error on parsing a split (edge '" + myCurrentID + "').");
}
}
if (e.lanes.empty()) {
for (int l = 0; l < myCurrentEdge->getNumLanes(); ++l) {
e.lanes.push_back(l);
}
}
e.speed = attrs.getOpt(SUMO_ATTR_SPEED, 0, ok, myCurrentEdge->getSpeed());
if (attrs.hasAttribute(SUMO_ATTR_SPEED) && myOptions.getBool("speed-in-kmh")) {
e.speed /= (SUMOReal) 3.6;
}
e.idBefore = attrs.getOpt(SUMO_ATTR_ID_BEFORE, 0, ok, std::string(""));
e.idAfter = attrs.getOpt(SUMO_ATTR_ID_AFTER, 0, ok, std::string(""));
if (!ok) {
return;
}
e.node = new NBNode(myCurrentID + "." + nameid,
myCurrentEdge->getGeometry().positionAtOffset(e.pos));
NIXMLNodesHandler::processNodeType(attrs, e.node, e.node->getID(), e.node->getPosition(), false,
myNodeCont, myTLLogicCont);
mySplits.push_back(e);
}
}
GUIVisualizationSizeSettings
GUISettingsHandler::parseSizeSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationSizeSettings defaults) {
return GUIVisualizationSizeSettings(
TplConvert::_2SUMOReal(attrs.getStringSecure(prefix + "_minSize", toString(defaults.minSize)).c_str()),
TplConvert::_2SUMOReal(attrs.getStringSecure(prefix + "_exaggeration", toString(defaults.exaggeration)).c_str()),
TplConvert::_2bool(attrs.getStringSecure(prefix + "_constantSize", toString(defaults.constantSize)).c_str()));
}
GUIVisualizationTextSettings
GUISettingsHandler::parseTextSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationTextSettings defaults) {
bool ok = true;
return GUIVisualizationTextSettings(
TplConvert::_2bool(attrs.getStringSecure(prefix + "_show", toString(defaults.show)).c_str()),
TplConvert::_2SUMOReal(attrs.getStringSecure(prefix + "_size", toString(defaults.size)).c_str()),
RGBColor::parseColorReporting(attrs.getStringSecure(prefix + "_color", toString(defaults.color)), "edges", 0, true, ok));
}
GUIVisualizationSizeSettings
GUISettingsHandler::parseSizeSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationSizeSettings defaults) {
return GUIVisualizationSizeSettings(
StringUtils::toDouble(attrs.getStringSecure(prefix + "_minSize", toString(defaults.minSize))),
StringUtils::toDouble(attrs.getStringSecure(prefix + "_exaggeration", toString(defaults.exaggeration))),
StringUtils::toBool(attrs.getStringSecure(prefix + "_constantSize", toString(defaults.constantSize))),
StringUtils::toBool(attrs.getStringSecure(prefix + "_constantSizeSelected", toString(defaults.constantSizeSelected))));
}
Position
NIImporter_SUMO::readPosition(const SUMOSAXAttributes& attrs, const std::string& id, bool& ok) {
SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_X, id.c_str(), ok);
SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_Y, id.c_str(), ok);
SUMOReal z = 0;
if (attrs.hasAttribute(SUMO_ATTR_Z)) {
z = attrs.getSUMORealReporting(SUMO_ATTR_Z, id.c_str(), ok);
}
return Position(x, y, z);
}
void
NIXMLTrafficLightsHandler::addTlConnection(const SUMOSAXAttributes& attrs) {
bool ok = true;
// parse identifying attributes
NBEdge* from = retrieveEdge(attrs, SUMO_ATTR_FROM, ok);
NBEdge* to = retrieveEdge(attrs, SUMO_ATTR_TO, ok);
if (!ok) {
return;
}
int fromLane = retrieveLaneIndex(attrs, SUMO_ATTR_FROM_LANE, from, ok);
int toLane = retrieveLaneIndex(attrs, SUMO_ATTR_TO_LANE, to, ok);
if (!ok) {
return;
}
// retrieve connection
const std::vector<NBEdge::Connection>& connections = from->getConnections();
std::vector<NBEdge::Connection>::const_iterator con_it;
con_it = find_if(connections.begin(), connections.end(),
NBEdge::connections_finder(fromLane, to, toLane));
if (con_it == connections.end()) {
WRITE_ERROR("Connection from=" + from->getID() + " to=" + to->getID() +
" fromLane=" + toString(fromLane) + " toLane=" + toString(toLane) + " not found");
return;
}
NBEdge::Connection c = *con_it;
// read other attributes
std::string tlID = attrs.getOptStringReporting(SUMO_ATTR_TLID, 0, ok, "");
if (tlID == "") {
// we are updating an existing tl-controlled connection
tlID = c.tlID;
assert(tlID != "");
}
int tlIndex = attrs.getOptIntReporting(SUMO_ATTR_TLLINKINDEX, 0, ok, -1);
if (tlIndex == -1) {
// we are updating an existing tl-controlled connection
tlIndex = c.tlLinkNo;
}
// register the connection with all definitions
const std::map<std::string, NBTrafficLightDefinition*>& programs = myTLLCont.getPrograms(tlID);
if (programs.size() > 0) {
std::map<std::string, NBTrafficLightDefinition*>::const_iterator it;
for (it = programs.begin(); it != programs.end(); it++) {
NBLoadedSUMOTLDef* tlDef = dynamic_cast<NBLoadedSUMOTLDef*>(it->second);
if (tlDef) {
tlDef->addConnection(from, c.toEdge, c.fromLane, c.toLane, tlIndex);
} else {
throw ProcessError("Corrupt traffic light definition '"
+ tlID + "' (program '" + it->first + "')");
}
}
} else {
WRITE_ERROR("The traffic light '" + tlID + "' is not known.");
}
}
void
NIImporter_SUMO::addLane(const SUMOSAXAttributes &attrs) {
myCurrentLane = new LaneAttrs;
bool ok = true;
myCurrentLane->maxSpeed = attrs.getOptSUMORealReporting(SUMO_ATTR_MAXSPEED, "lane", 0, ok, -1);
myCurrentLane->depart = attrs.getOptBoolReporting(SUMO_ATTR_DEPART, 0, 0, ok, false);
if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
// @deprecated At some time, SUMO_ATTR_SHAPE will be mandatory
myCurrentLane->shape = GeomConvHelper::parseShapeReporting(attrs.getStringReporting(SUMO_ATTR_SHAPE, "lane", 0, ok), "lane", 0, ok, false);
}
}
void
SUMORouteHandler::addParam(const SUMOSAXAttributes& attrs) {
bool ok = true;
const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, 0, ok);
// circumventing empty string test
const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
if (myVehicleParameter != 0) {
myVehicleParameter->addParameter(key, val);
} else if (myCurrentVType != 0) {
myCurrentVType->addParameter(key, val);
}
}
GUIVisualizationTextSettings
GUISettingsHandler::parseTextSettings(
const std::string& prefix, const SUMOSAXAttributes& attrs,
GUIVisualizationTextSettings defaults) {
bool ok = true;
return GUIVisualizationTextSettings(
StringUtils::toBool(attrs.getStringSecure(prefix + "_show", toString(defaults.show))),
StringUtils::toDouble(attrs.getStringSecure(prefix + "_size", toString(defaults.size))),
RGBColor::parseColorReporting(attrs.getStringSecure(prefix + "_color", toString(defaults.color)), "textSettings", nullptr, true, ok),
RGBColor::parseColorReporting(attrs.getStringSecure(prefix + "_bgColor", toString(defaults.bgColor)), "textSettings", nullptr, true, ok),
StringUtils::toBool(attrs.getStringSecure(prefix + "_constantSize", toString(defaults.constSize))));
}
void
NIImporter_SUMO::addJunction(const SUMOSAXAttributes& attrs) {
// get the id, report an error if not given or empty...
myCurrentJunction.node = 0;
myCurrentJunction.intLanes.clear();
myCurrentJunction.response.clear();
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
if (id[0] == ':') { // internal node
return;
}
SumoXMLNodeType type = attrs.getNodeType(ok);
if (ok) {
if (type == NODETYPE_DEAD_END_DEPRECATED || type == NODETYPE_DEAD_END) {
// dead end is a computed status. Reset this to unknown so it will
// be corrected if additional connections are loaded
type = NODETYPE_UNKNOWN;
}
} else {
WRITE_WARNING("Unknown node type for junction '" + id + "'.");
}
Position pos = readPosition(attrs, id, ok);
NBNetBuilder::transformCoordinates(pos, true, myLocation);
NBNode* node = new NBNode(id, pos, type);
if (!myNodeCont.insert(node)) {
WRITE_ERROR("Problems on adding junction '" + id + "'.");
delete node;
return;
}
myCurrentJunction.node = node;
SUMOSAXAttributes::parseStringVector(attrs.get<std::string>(SUMO_ATTR_INTLANES, 0, ok, false), myCurrentJunction.intLanes);
// set optional radius
if (attrs.hasAttribute(SUMO_ATTR_RADIUS)) {
node->setRadius(attrs.get<SUMOReal>(SUMO_ATTR_RADIUS, id.c_str(), ok));
}
// handle custom shape
if (attrs.getOpt<bool>(SUMO_ATTR_CUSTOMSHAPE, 0, ok, false)) {
node->setCustomShape(attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok));
}
if (myCustomShapeMaps.count(id) > 0) {
NBNode::CustomShapeMap customShapes = myCustomShapeMaps[id];
for (NBNode::CustomShapeMap::const_iterator it = customShapes.begin(); it != customShapes.end(); ++it) {
node->setCustomLaneShape(it->first, it->second);
}
}
if (type == NODETYPE_RAIL_SIGNAL || type == NODETYPE_RAIL_CROSSING) {
// both types of nodes come without a tlLogic
myRailSignals.insert(id);
}
}
void
RORouteHandler::parseFromViaTo(std::string element,
const SUMOSAXAttributes& attrs) {
myActiveRoute.clear();
bool useTaz = OptionsCont::getOptions().getBool("with-taz");
if (useTaz && !myVehicleParameter->wasSet(VEHPARS_FROM_TAZ_SET) && !myVehicleParameter->wasSet(VEHPARS_TO_TAZ_SET)) {
WRITE_WARNING("Taz usage was requested but no taz present in " + element + " '" + myVehicleParameter->id + "'!");
useTaz = false;
}
bool ok = true;
if ((useTaz || !attrs.hasAttribute(SUMO_ATTR_FROM)) && myVehicleParameter->wasSet(VEHPARS_FROM_TAZ_SET)) {
const ROEdge* fromTaz = myNet.getEdge(myVehicleParameter->fromTaz + "-source");
if (fromTaz == 0) {
myErrorOutput->inform("Source taz '" + myVehicleParameter->fromTaz + "' not known for " + element + " '" + myVehicleParameter->id + "'!");
} else if (fromTaz->getNumSuccessors() == 0) {
myErrorOutput->inform("Source taz '" + myVehicleParameter->fromTaz + "' has no outgoing edges for " + element + " '" + myVehicleParameter->id + "'!");
} else {
myActiveRoute.push_back(fromTaz);
}
} else {
parseEdges(attrs.getOpt<std::string>(SUMO_ATTR_FROM, myVehicleParameter->id.c_str(), ok, "", true),
myActiveRoute, "for " + element + " '" + myVehicleParameter->id + "'");
}
if (!attrs.hasAttribute(SUMO_ATTR_VIA)) {
myInsertStopEdgesAt = (int)myActiveRoute.size();
}
ConstROEdgeVector viaEdges;
parseEdges(attrs.getOpt<std::string>(SUMO_ATTR_VIA, myVehicleParameter->id.c_str(), ok, "", true),
viaEdges, "for " + element + " '" + myVehicleParameter->id + "'");
for (ConstROEdgeVector::const_iterator i = viaEdges.begin(); i != viaEdges.end(); ++i) {
myActiveRoute.push_back(*i);
myVehicleParameter->via.push_back((*i)->getID());
}
if ((useTaz || !attrs.hasAttribute(SUMO_ATTR_TO)) && myVehicleParameter->wasSet(VEHPARS_TO_TAZ_SET)) {
const ROEdge* toTaz = myNet.getEdge(myVehicleParameter->toTaz + "-sink");
if (toTaz == 0) {
myErrorOutput->inform("Sink taz '" + myVehicleParameter->toTaz + "' not known for " + element + " '" + myVehicleParameter->id + "'!");
} else if (toTaz->getNumPredecessors() == 0) {
myErrorOutput->inform("Sink taz '" + myVehicleParameter->toTaz + "' has no incoming edges for " + element + " '" + myVehicleParameter->id + "'!");
} else {
myActiveRoute.push_back(toTaz);
}
} else {
parseEdges(attrs.getOpt<std::string>(SUMO_ATTR_TO, myVehicleParameter->id.c_str(), ok, "", true),
myActiveRoute, "for " + element + " '" + myVehicleParameter->id + "'");
}
myActiveRouteID = "!" + myVehicleParameter->id;
if (myVehicleParameter->routeid == "") {
myVehicleParameter->routeid = myActiveRouteID;
}
}
void
NIImporter_SUMO::addSuccEdge(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string edge_id = attrs.getStringReporting(SUMO_ATTR_EDGE, 0, ok);
myCurrentEdge = 0;
if (myEdges.count(edge_id) == 0) {
WRITE_ERROR("Unknown edge '" + edge_id + "' given in succedge.");
return;
}
myCurrentEdge = myEdges[edge_id];
std::string lane_id = attrs.getStringReporting(SUMO_ATTR_LANE, 0, ok);
myCurrentLane = getLaneAttrsFromID(myCurrentEdge, lane_id);
}
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
MSVehicleTransfer::loadState(const SUMOSAXAttributes& attrs, const SUMOTime offset, MSVehicleControl& vc) {
MSVehicle* veh = dynamic_cast<MSVehicle*>(vc.getVehicle(attrs.getString(SUMO_ATTR_ID)));
assert(veh != 0);
SUMOTime proceedTime = (SUMOTime)attrs.getLong(SUMO_ATTR_DEPART);
MSLane* parkingLane = attrs.hasAttribute(SUMO_ATTR_PARKING) ? MSLane::dictionary(attrs.getString(SUMO_ATTR_PARKING)): 0;
myVehicles.push_back(VehicleInformation(veh, proceedTime + offset, parkingLane != 0));
if (parkingLane != 0) {
myParkingVehicles[parkingLane].insert(veh);
veh->setTentativeLaneAndPosition(parkingLane, veh->getPositionOnLane());
veh->processNextStop(veh->getSpeed());
}
MSNet::getInstance()->getInsertionControl().alreadyDeparted(veh);
}
void
AGActivityGenHandler::parseClosingHour(const SUMOSAXAttributes& attrs) {
if (myCurrentObject == "workHours") {
try {
myCity.statData.endWorkHours[attrs.getInt(AGEN_ATTR_HOUR)] = attrs.getFloat(AGEN_ATTR_PROP);
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_CLOSING) + ": "
+ e.what());
throw ProcessError();
}
}
}
void
TraCIHandler::openVehicleTag(const SUMOSAXAttributes& attributes) {
int repNo;
int period;
int depart;
OptionsCont& optCont = OptionsCont::getOptions();
SUMOTime simStart = string2time(optCont.getString("begin"));
SUMOTime simEnd = string2time(optCont.getString("end"));
if (simEnd<0) {
simEnd = SUMOTime_MAX;
}
// every found vehicle tag counts for one vehicle
currentVehCount = 1;
// read value for emit period and number (if any)
try {
repNo = attributes.getInt(SUMO_ATTR_REPNUMBER);
period = attributes.getInt(SUMO_ATTR_PERIOD);
} catch (...) {
repNo = 0;
period = 0;
}
// read depart time
try {
depart = attributes.getInt(SUMO_ATTR_DEPART);
} catch (...) {
// no depart time: error, don't count vehicle
currentVehCount = 0;
// std::cerr << "no depart time, vehicle = 0" << std::endl;
return;
}
while ((depart < simStart) && (repNo >= 0)) {
depart += period;
repNo--;
// std::cerr << "removing 1 vehicle from repno (depart before sim start)" << std::endl;
}
// don't count vehicles that depart / are emitted after the sim ends
while (((depart + (repNo * period)) > simEnd) && (repNo >= 0)) {
repNo--;
// std::cerr << "removing 1 vehicle from repno (depart after sim end)" << std::endl;
}
// add number of vehicles, that will be emitted until sim end, to total count
currentVehCount += repNo;
// std::cerr << "result: " << currentVehCount << " vehicles" << std::endl;
}
void
RORouteHandler::openRoute(const SUMOSAXAttributes& attrs) {
myActiveRoute.clear();
myInsertStopEdgesAt = -1;
// check whether the id is really necessary
std::string rid;
if (myCurrentAlternatives != 0) {
myActiveRouteID = myCurrentAlternatives->getID();
rid = "distribution '" + myCurrentAlternatives->getID() + "'";
} else if (myVehicleParameter != 0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
myVehicleParameter->routeid = myActiveRouteID = "!" + myVehicleParameter->id; // !!! document this
if (attrs.hasAttribute(SUMO_ATTR_ID)) {
WRITE_WARNING("Ids of internal routes are ignored (vehicle '" + myVehicleParameter->id + "').");
}
} else {
bool ok = true;
myActiveRouteID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
rid = "'" + myActiveRouteID + "'";
}
if (myVehicleParameter != 0) { // have to do this here for nested route distributions
rid = "for vehicle '" + myVehicleParameter->id + "'";
}
bool ok = true;
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
parseEdges(attrs.get<std::string>(SUMO_ATTR_EDGES, myActiveRouteID.c_str(), ok), myActiveRoute, rid);
}
myActiveRouteRefID = attrs.getOpt<std::string>(SUMO_ATTR_REFID, myActiveRouteID.c_str(), ok, "");
if (myActiveRouteRefID != "" && myNet.getRouteDef(myActiveRouteRefID) == 0) {
myErrorOutput->inform("Invalid reference to route '" + myActiveRouteRefID + "' in route " + rid + ".");
}
if (myCurrentAlternatives != 0 && !attrs.hasAttribute(SUMO_ATTR_PROB)) {
WRITE_WARNING("No probability for a route in '" + rid + "', using default.");
}
myActiveRouteProbability = attrs.getOpt<double>(SUMO_ATTR_PROB, myActiveRouteID.c_str(), ok, DEFAULT_VEH_PROB);
if (ok && myActiveRouteProbability < 0) {
myErrorOutput->inform("Invalid probability for route '" + myActiveRouteID + "'.");
}
myActiveRouteColor = attrs.hasAttribute(SUMO_ATTR_COLOR) ? new RGBColor(attrs.get<RGBColor>(SUMO_ATTR_COLOR, myActiveRouteID.c_str(), ok)) : 0;
ok = true;
myCurrentCosts = attrs.getOpt<double>(SUMO_ATTR_COST, myActiveRouteID.c_str(), ok, -1);
if (ok && myCurrentCosts != -1 && myCurrentCosts < 0) {
myErrorOutput->inform("Invalid cost for route '" + myActiveRouteID + "'.");
}
}