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
MSRouteHandler::openVehicleTypeDistribution(const SUMOSAXAttributes& attrs) {
bool ok = true;
myCurrentVTypeDistributionID = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
if (ok) {
myCurrentVTypeDistribution = new RandomDistributor<MSVehicleType*>();
if (attrs.hasAttribute(SUMO_ATTR_VTYPES) || attrs.hasAttribute(SUMO_ATTR_VTYPES__DEPRECATED)) {
std::string vTypes;
if (!myHaveWarnedAboutDeprecatedVTypes && attrs.hasAttribute(SUMO_ATTR_VTYPES__DEPRECATED)) {
myHaveWarnedAboutDeprecatedVTypes = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_VTYPES__DEPRECATED) + "' is deprecated, please use '" + toString(SUMO_ATTR_VTYPES) + "' instead.");
vTypes = attrs.getStringReporting(SUMO_ATTR_VTYPES__DEPRECATED, myCurrentVTypeDistributionID.c_str(), ok);
} else {
vTypes = attrs.getStringReporting(SUMO_ATTR_VTYPES, myCurrentVTypeDistributionID.c_str(), ok);
}
StringTokenizer st(vTypes);
while (st.hasNext()) {
std::string vtypeID = st.next();
MSVehicleType* type = MSNet::getInstance()->getVehicleControl().getVType(vtypeID);
if (type == 0) {
throw ProcessError("Unknown vtype '" + vtypeID + "' in distribution '" + myCurrentVTypeDistributionID + "'.");
}
myCurrentVTypeDistribution->add(type->getDefaultProbability(), type);
}
}
}
}
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();
}
}
void
TrajectoriesHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
bool ok = true;
switch (element) {
case SUMO_TAG_TRAJECTORIES:
myStepSize = attrs.getFloat("timeStepSize") / 1000.;
break;
case SUMO_TAG_TIMESTEP:
myCurrentTime = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, 0, ok);
break;
case SUMO_TAG_VEHICLE:
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
SUMOReal v = attrs.getFloat(SUMO_ATTR_SPEED);
SUMOReal a = INVALID_VALUE;
SUMOReal s = INVALID_VALUE;
writeEmissions(std::cout, attrs.getString(SUMO_ATTR_ID), myDefaultClass, STEPS2TIME(myCurrentTime), v, a, s);
} else {
const std::string acId = attrs.getString(SUMO_ATTR_ACTORCONFIG);
const std::string id = attrs.getString(SUMO_ATTR_ID);
if (myEmissionClassByType.count(acId) == 0) {
WRITE_WARNING("Unknown actor configuration '" + acId + "' for vehicle '" + id + "'!");
} else {
myEmissionClassByVehicle[id] = myEmissionClassByType.count(acId) > 0 ? myEmissionClassByType[acId] : myDefaultClass;
}
}
break;
case SUMO_TAG_ACTORCONFIG: {
const std::string id = attrs.getString(SUMO_ATTR_ID);
const std::string vClass = attrs.getString(SUMO_ATTR_VEHICLECLASS);
const std::string fuel = attrs.getString(SUMO_ATTR_FUEL);
const std::string eClass = attrs.getString(SUMO_ATTR_EMISSIONCLASS);
const SUMOReal weight = attrs.getOpt<SUMOReal>(SUMO_ATTR_WEIGHT, id.c_str(), ok, 0.) * 10.;
myEmissionClassByType[id] = PollutantsInterface::getClass(myDefaultClass, vClass, fuel, eClass, weight);
break;
}
case SUMO_TAG_MOTIONSTATE: {
const std::string id = attrs.getString(SUMO_ATTR_VEHICLE);
if (myEmissionClassByVehicle.count(id) == 0) {
WRITE_WARNING("Motion state for unknown vehicle '" + id + "'!");
myEmissionClassByVehicle[id] = myDefaultClass;
}
const SUMOEmissionClass c = myEmissionClassByVehicle[id];
SUMOReal v = attrs.getFloat(SUMO_ATTR_SPEED) / 100.;
SUMOReal a = attrs.hasAttribute(SUMO_ATTR_ACCELERATION) ? attrs.get<SUMOReal>(SUMO_ATTR_ACCELERATION, id.c_str(), ok) / 1000. : INVALID_VALUE;
SUMOReal s = attrs.hasAttribute(SUMO_ATTR_SLOPE) ? RAD2DEG(asin(attrs.get<SUMOReal>(SUMO_ATTR_SLOPE, id.c_str(), ok) / 10000.)) : INVALID_VALUE;
const SUMOTime time = attrs.getOpt<int>(SUMO_ATTR_TIME, id.c_str(), ok, INVALID_VALUE);
if (myXMLOut != 0) {
writeXMLEmissions(id, c, time, v, a, s);
}
if (myStdOut != 0) {
writeEmissions(*myStdOut, id, c, STEPS2TIME(time), v, a, s);
}
break;
}
default:
break;
}
}
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
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 + "'.");
}
}
void
NLHandler::addDistrict(const SUMOSAXAttributes& attrs) {
bool ok = true;
myCurrentIsBroken = false;
// get the id, report an error if not given or empty...
myCurrentDistrictID = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
myCurrentIsBroken = true;
return;
}
try {
MSEdge* sink = myEdgeControlBuilder.buildEdge(myCurrentDistrictID + "-sink", MSEdge::EDGEFUNCTION_DISTRICT);
if (!MSEdge::dictionary(myCurrentDistrictID + "-sink", sink)) {
delete sink;
throw InvalidArgument("Another edge with the id '" + myCurrentDistrictID + "-sink' exists.");
}
sink->initialize(new std::vector<MSLane*>());
MSEdge* source = myEdgeControlBuilder.buildEdge(myCurrentDistrictID + "-source", MSEdge::EDGEFUNCTION_DISTRICT);
if (!MSEdge::dictionary(myCurrentDistrictID + "-source", source)) {
delete source;
throw InvalidArgument("Another edge with the id '" + myCurrentDistrictID + "-source' exists.");
}
source->initialize(new std::vector<MSLane*>());
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) {
MSEdge* edge = MSEdge::dictionary(*i);
// check whether the edge exists
if (edge == 0) {
throw InvalidArgument("The edge '" + *i + "' within district '" + myCurrentDistrictID + "' is not known.");
}
source->addFollower(edge);
edge->addFollower(sink);
}
}
if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
PositionVector shape = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, myCurrentDistrictID.c_str(), ok);
if (shape.size() != 0) {
if (!myNet.getShapeContainer().addPolygon(myCurrentDistrictID, "taz", RGBColor::parseColor("1.0,.33,.33"), 0, 0, "", shape, false)) {
WRITE_WARNING("Skipping visualization of taz '" + myCurrentDistrictID + "', polygon already exists.");
}
}
}
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
myCurrentIsBroken = true;
}
}
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
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
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
SUMOVehicleParserHelper::parseLCParams(SUMOVTypeParameter& into, LaneChangeModel model, const SUMOSAXAttributes& attrs) {
if (allowedLCModelAttrs.size() == 0) {
// init static map
std::set<SumoXMLAttr> lc2013Params;
lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_PARAM);
lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_PARAM);
lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_PARAM);
lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_PARAM);
allowedLCModelAttrs[LCM_LC2013] = lc2013Params;
std::set<SumoXMLAttr> sl2015Params = lc2013Params;
sl2015Params.insert(SUMO_ATTR_LCA_PUSHY);
sl2015Params.insert(SUMO_ATTR_LCA_SUBLANE_PARAM);
sl2015Params.insert(SUMO_ATTR_LCA_ASSERTIVE);
allowedLCModelAttrs[LCM_SL2015] = sl2015Params;
std::set<SumoXMLAttr> noParams;
allowedLCModelAttrs[LCM_DK2008] = noParams;
// default model may be either LC2013 or SL2013
// we allow both sets (sl2015 is a superset of lc2013Params)
allowedLCModelAttrs[LCM_DEFAULT] = sl2015Params;
}
bool ok = true;
std::set<SumoXMLAttr> allowed = allowedLCModelAttrs[model];
for (std::set<SumoXMLAttr>::const_iterator it = allowed.begin(); it != allowed.end(); it++) {
if (attrs.hasAttribute(*it)) {
into.lcParameter[*it] = attrs.get<SUMOReal>(*it, into.id.c_str(), ok);
}
}
if (!ok) {
throw ProcessError();
}
}
void
NIXMLTypesHandler::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
if (element!=SUMO_TAG_TYPE) {
return;
}
// get the id, report a warning if not given or empty...
std::string id;
if (!attrs.setIDFromAttributes("type", id), false) {
WRITE_WARNING("No type id given... Skipping.");
return;
}
// check deprecated (unused) attributes
if (!myHaveReportedAboutFunctionDeprecation&&attrs.hasAttribute(SUMO_ATTR_FUNCTION)) {
MsgHandler::getWarningInstance()->inform("While parsing type '" + id + "': 'function' is deprecated.\n All occurences are ignored.");
myHaveReportedAboutFunctionDeprecation = true;
}
bool ok = true;
int priority = attrs.getOptIntReporting(SUMO_ATTR_PRIORITY, "type", id.c_str(), ok, myTypeCont.getDefaultPriority());
int noLanes = attrs.getOptIntReporting(SUMO_ATTR_NOLANES, "type", id.c_str(), ok, myTypeCont.getDefaultNoLanes());
SUMOReal speed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, "type", id.c_str(), ok, (SUMOReal) myTypeCont.getDefaultSpeed());
bool discard = attrs.getOptBoolReporting(SUMO_ATTR_DISCARD, 0, 0, ok, false);
if (!ok) {
return;
}
// build the type
if (!myTypeCont.insert(id, noLanes, speed, priority)) {
MsgHandler::getErrorInstance()->inform("Duplicate type occured. ID='" + id + "'");
} else {
if (discard) {
myTypeCont.markAsToDiscard(id);
}
}
}
void
ROJTRTurnDefLoader::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
bool ok = true;
switch (element) {
case SUMO_TAG_INTERVAL:
myIntervalBegin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, 0, ok);
myIntervalEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, 0, ok);
break;
case SUMO_TAG_FROMEDGE:
beginFromEdge(attrs);
break;
case SUMO_TAG_TOEDGE:
addToEdge(attrs);
break;
case SUMO_TAG_SINK:
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
std::string edges = attrs.get<std::string>(SUMO_ATTR_EDGES, 0, ok);
StringTokenizer st(edges, StringTokenizer::WHITECHARS);
while (st.hasNext()) {
std::string id = st.next();
ROEdge* edge = myNet.getEdge(id);
if (edge == 0) {
throw ProcessError("The edge '" + id + "' declared as a sink is not known.");
}
edge->setType(ROEdge::ET_SINK);
}
}
break;
case SUMO_TAG_SOURCE:
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
std::string edges = attrs.get<std::string>(SUMO_ATTR_EDGES, 0, ok);
StringTokenizer st(edges, StringTokenizer::WHITECHARS);
while (st.hasNext()) {
std::string id = st.next();
ROEdge* edge = myNet.getEdge(id);
if (edge == 0) {
throw ProcessError("The edge '" + id + "' declared as a source is not known.");
}
edge->setType(ROEdge::ET_SOURCE);
}
}
break;
default:
break;
}
}
void
NIXMLEdgesHandler::addLane(const SUMOSAXAttributes& attrs) {
if (myCurrentEdge == 0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges.explicit", myCurrentID)) {
WRITE_ERROR("Additional lane information could not be set - the edge with id '" + myCurrentID + "' is not known.");
}
return;
}
bool ok = true;
int lane;
if (attrs.hasAttribute(SUMO_ATTR_ID)) {
lane = attrs.get<int>(SUMO_ATTR_ID, myCurrentID.c_str(), ok);
if (!myHaveWarnedAboutDeprecatedLaneId) {
myHaveWarnedAboutDeprecatedLaneId = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_ID) + "' is deprecated, please use '" + toString(SUMO_ATTR_INDEX) + "' instead.");
}
} else {
lane = attrs.get<int>(SUMO_ATTR_INDEX, myCurrentID.c_str(), ok);
}
std::string allowed, disallowed, preferred;
allowed = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, 0, ok, "");
disallowed = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, 0, ok, "");
preferred = attrs.getOpt<std::string>(SUMO_ATTR_PREFER, 0, ok, "");
if (!ok) {
return;
}
// check whether this lane exists
if (lane >= (int) myCurrentEdge->getNumLanes()) {
WRITE_ERROR("Lane index is larger than number of lanes (edge '" + myCurrentID + "').");
return;
}
// set information about allowed / disallowed vehicle classes
myCurrentEdge->setPermissions(parseVehicleClasses(allowed, disallowed), lane);
myCurrentEdge->setPreferredVehicleClass(parseVehicleClasses(preferred), lane);
// try to get the width
if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
myCurrentEdge->setLaneWidth(lane, attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, myCurrentID.c_str(), ok));
}
// try to get the end-offset (lane shortened due to pedestrian crossing etc..)
if (attrs.hasAttribute(SUMO_ATTR_ENDOFFSET)) {
myCurrentEdge->setOffset(lane, attrs.get<SUMOReal>(SUMO_ATTR_ENDOFFSET, myCurrentID.c_str(), ok));
}
// try to get lane specific speed (should not occur for german networks)
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
myCurrentEdge->setSpeed(lane, attrs.get<SUMOReal>(SUMO_ATTR_SPEED, myCurrentID.c_str(), ok));
}
}
void
NIImporter_OpenStreetMap::NodesHandler::myStartElement(int element, const SUMOSAXAttributes& attrs) {
++myHierarchyLevel;
if (element == SUMO_TAG_NODE) {
bool ok = true;
if (myHierarchyLevel != 2) {
WRITE_ERROR("Node element on wrong XML hierarchy level (id='" + toString(attrs.getIntReporting(SUMO_ATTR_ID, 0, ok)) + "', level='" + toString(myHierarchyLevel) + "').");
return;
}
int id = attrs.getIntReporting(SUMO_ATTR_ID, 0, ok);
std::string action = attrs.hasAttribute("action") ? attrs.getStringSecure("action", "") : "";
if (action == "delete") {
return;
}
if (!ok) {
return;
}
myLastNodeID = -1;
if (myToFill.find(id) == myToFill.end()) {
myLastNodeID = id;
// assume we are loading multiple files...
// ... so we won't report duplicate nodes
bool ok = true;
double tlat, tlon;
std::istringstream lon(attrs.getStringReporting(SUMO_ATTR_LON, toString(id).c_str(), ok));
if (!ok) {
return;
}
lon >> tlon;
if (lon.fail()) {
WRITE_ERROR("Node's '" + toString(id) + "' lon information is not numeric.");
return;
}
std::istringstream lat(attrs.getStringReporting(SUMO_ATTR_LAT, toString(id).c_str(), ok));
if (!ok) {
return;
}
lat >> tlat;
if (lat.fail()) {
WRITE_ERROR("Node's '" + toString(id) + "' lat information is not numeric.");
return;
}
NIOSMNode* toAdd = new NIOSMNode();
toAdd->id = id;
toAdd->tlsControlled = false;
toAdd->lat = tlat;
toAdd->lon = tlon;
myIsInValidNodeTag = true;
std::set<NIOSMNode*, CompareNodes>::iterator similarNode = myUniqueNodes.find(toAdd);
if (similarNode == myUniqueNodes.end()) {
myUniqueNodes.insert(toAdd);
} else {
delete toAdd;
toAdd = *similarNode;
WRITE_MESSAGE("Found duplicate nodes. Substituting " + toString(id) + " with " + toString(toAdd->id));
}
myToFill[id] = toAdd;
}
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.");
}
}
PositionVector
NIXMLEdgesHandler::tryGetShape(const SUMOSAXAttributes& attrs) {
if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
return myShape;
}
// try to build shape
bool ok = true;
if (!attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
myReinitKeepEdgeShape = false;
return PositionVector();
}
PositionVector shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, 0, ok, PositionVector());
if (!NILoader::transformCoordinates(shape)) {
WRITE_ERROR("Unable to project coordinates for edge '" + myCurrentID + "'.");
}
myReinitKeepEdgeShape = myKeepEdgeShape;
return shape;
}
bool
NIXMLConnectionsHandler::parseLaneInfo(const SUMOSAXAttributes& attributes, NBEdge* fromEdge, NBEdge* toEdge,
int* fromLane, int* toLane) {
if (attributes.hasAttribute(SUMO_ATTR_LANE)) {
return parseDeprecatedLaneDefinition(attributes, fromEdge, toEdge, fromLane, toLane);
} else {
return parseLaneDefinition(attributes, fromLane, toLane);
}
}
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);
}
}
void
MSRouteHandler::openRoute(const SUMOSAXAttributes& attrs) {
// check whether the id is really necessary
std::string rid;
if (myCurrentRouteDistribution != 0) {
myActiveRouteID = myCurrentRouteDistributionID + "#" + toString(myCurrentRouteDistribution->getProbs().size()); // !!! document this
rid = "distribution '" + myCurrentRouteDistributionID + "'";
} else if (myVehicleParameter != 0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
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.getStringReporting(SUMO_ATTR_ID, 0, ok, false);
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)) {
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, myActiveRouteID.c_str(), ok), myActiveRoute, rid);
}
myActiveRouteRefID = attrs.getOptStringReporting(SUMO_ATTR_REFID, myActiveRouteID.c_str(), ok, "");
if (attrs.hasAttribute(SUMO_ATTR_REFID__DEPRECATED)) {
myActiveRouteRefID = attrs.getOptStringReporting(SUMO_ATTR_REFID__DEPRECATED, myActiveRouteID.c_str(), ok, "");
if (!myHaveWarnedAboutDeprecatedRefID) {
myHaveWarnedAboutDeprecatedRefID = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_REFID__DEPRECATED) + "' is deprecated, please use '" + toString(SUMO_ATTR_REFID) + "' instead.");
}
}
if (myActiveRouteRefID != "" && MSRoute::dictionary(myActiveRouteRefID) == 0) {
WRITE_ERROR("Invalid reference to route '" + myActiveRouteRefID + "' in route " + rid + ".");
}
myActiveRouteProbability = attrs.getOptSUMORealReporting(SUMO_ATTR_PROB, myActiveRouteID.c_str(), ok, DEFAULT_VEH_PROB);
myActiveRouteColor = attrs.hasAttribute(SUMO_ATTR_COLOR) ? RGBColor::parseColorReporting(attrs.getString(SUMO_ATTR_COLOR), attrs.getObjectType(), myActiveRouteID.c_str(), true, ok) : RGBColor::getDefaultColor();
}
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.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
}
myCurrentRouteDistribution = new RandomDistributor<const MSRoute*>(MSRoute::getMaxRouteDistSize(), &MSRoute::releaseRoute);
std::vector<SUMOReal> probs;
if (attrs.hasAttribute(SUMO_ATTR_PROBS)) {
bool ok = true;
StringTokenizer st(attrs.get<std::string>(SUMO_ATTR_PROBS, myCurrentRouteDistributionID.c_str(), ok));
while (st.hasNext()) {
probs.push_back(TplConvert::_2SUMORealSec(st.next().c_str(), 1.0));
}
}
if (attrs.hasAttribute(SUMO_ATTR_ROUTES)) {
bool ok = true;
StringTokenizer st(attrs.get<std::string>(SUMO_ATTR_ROUTES, myCurrentRouteDistributionID.c_str(), ok));
size_t probIndex = 0;
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 + "'.");
}
const SUMOReal prob = (probs.size() > probIndex ? probs[probIndex] : 1.0);
myCurrentRouteDistribution->add(prob, route, false);
probIndex++;
}
if (probs.size() > 0 && probIndex != probs.size()) {
WRITE_WARNING("Got " + toString(probs.size()) + " probabilities for " + toString(probIndex) +
" routes in routeDistribution '" + myCurrentRouteDistributionID + "'");
}
}
}
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
NLHandler::addPOI(const SUMOSAXAttributes& attrs) {
bool ok = true;
const SUMOReal INVALID_POSITION(-1000000);
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
SUMOReal x = attrs.getOpt<SUMOReal>(SUMO_ATTR_X, id.c_str(), ok, INVALID_POSITION);
SUMOReal y = attrs.getOpt<SUMOReal>(SUMO_ATTR_Y, id.c_str(), ok, INVALID_POSITION);
SUMOReal lon = attrs.getOpt<SUMOReal>(SUMO_ATTR_LON, id.c_str(), ok, INVALID_POSITION);
SUMOReal lat = attrs.getOpt<SUMOReal>(SUMO_ATTR_LAT, id.c_str(), ok, INVALID_POSITION);
SUMOReal lanePos = attrs.getOpt<SUMOReal>(SUMO_ATTR_POSITION, id.c_str(), ok, INVALID_POSITION);
SUMOReal layer = attrs.getOpt<SUMOReal>(SUMO_ATTR_LAYER, id.c_str(), ok, (SUMOReal)GLO_POI);
std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), ok, "");
std::string laneID = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), ok, "");
RGBColor color = attrs.hasAttribute(SUMO_ATTR_COLOR) ? attrs.get<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), ok) : RGBColor::RED;
SUMOReal angle = attrs.getOpt<SUMOReal>(SUMO_ATTR_ANGLE, id.c_str(), ok, Shape::DEFAULT_ANGLE);
std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, id.c_str(), ok, Shape::DEFAULT_IMG_FILE);
if (imgFile != "" && !FileHelpers::isAbsolute(imgFile)) {
imgFile = FileHelpers::getConfigurationRelative(getFileName(), imgFile);
}
SUMOReal width = attrs.getOpt<SUMOReal>(SUMO_ATTR_WIDTH, id.c_str(), ok, Shape::DEFAULT_IMG_WIDTH);
SUMOReal height = attrs.getOpt<SUMOReal>(SUMO_ATTR_HEIGHT, id.c_str(), ok, Shape::DEFAULT_IMG_HEIGHT);
if (!ok) {
return;
}
Position pos(x, y);
if (x == INVALID_POSITION || y == INVALID_POSITION) {
// try computing x,y from lane,pos
if (laneID != "") {
MSLane* lane = MSLane::dictionary(laneID);
if (lane == 0) {
WRITE_ERROR("Lane '" + laneID + "' to place a poi '" + id + "'on is not known.");
return;
}
if (lanePos < 0) {
lanePos = lane->getLength() + lanePos;
}
pos = lane->geometryPositionAtOffset(lanePos);
} else {
// try computing x,y from lon,lat
if (lat == INVALID_POSITION || lon == INVALID_POSITION) {
WRITE_ERROR("Either (x,y), (lon,lat) or (lane,pos) must be specified for poi '" + id + "'.");
return;
} else if (!GeoConvHelper::getFinal().usingGeoProjection()) {
WRITE_ERROR("(lon, lat) is specified for poi '" + id + "' but no geo-conversion is specified for the network.");
return;
}
pos.set(lon, lat);
GeoConvHelper::getFinal().x2cartesian_const(pos);
}
}
if (!myNet.getShapeContainer().addPOI(id, type, color, layer, angle, imgFile, pos, width, height)) {
WRITE_ERROR("PoI '" + id + "' already exists.");
}
}
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
MSRouteHandler::openRoute(const SUMOSAXAttributes &attrs) {
// check whether the id is really necessary
if (myVehicleParameter!=0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
myActiveRouteID = "!" + myVehicleParameter->id; // !!! document this
} else {
bool ok = true;
myActiveRouteID = attrs.getStringReporting(SUMO_ATTR_ID, "route", 0, ok, false);
if (!ok) {
return;
}
}
bool ok = true;
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, "route", myActiveRouteID.c_str(), ok), myActiveRoute, myActiveRouteID);
}
myActiveRouteProbability = attrs.getOptSUMORealReporting(SUMO_ATTR_PROB, "route", myActiveRouteID.c_str(), ok, DEFAULT_VEH_PROB);
myActiveRouteColor = attrs.hasAttribute(SUMO_ATTR_COLOR) ? RGBColor::parseColorReporting(attrs.getString(SUMO_ATTR_COLOR), "route", myActiveRouteID.c_str(), true, ok) : RGBColor::getDefaultColor();
}
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
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);
}
}
void
RORouteHandler::openRouteDistribution(const SUMOSAXAttributes& attrs) {
// check whether the id is really necessary
bool ok = true;
std::string id;
if (myVehicleParameter != 0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
myVehicleParameter->routeid = id = "!" + myVehicleParameter->id; // !!! document this
if (attrs.hasAttribute(SUMO_ATTR_ID)) {
WRITE_WARNING("Ids of internal route distributions are ignored (vehicle '" + myVehicleParameter->id + "').");
}
} else {
id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
}
// try to get the index of the last element
int index = attrs.getOpt<int>(SUMO_ATTR_LAST, id.c_str(), ok, 0);
if (ok && index < 0) {
myErrorOutput->inform("Negative index of a route alternative (id='" + id + "').");
return;
}
// build the alternative cont
myCurrentAlternatives = new RORouteDef(id, index, myTryRepair, false);
if (attrs.hasAttribute(SUMO_ATTR_ROUTES)) {
ok = true;
StringTokenizer st(attrs.get<std::string>(SUMO_ATTR_ROUTES, id.c_str(), ok));
while (st.hasNext()) {
const std::string routeID = st.next();
const RORouteDef* route = myNet.getRouteDef(routeID);
if (route == 0) {
myErrorOutput->inform("Unknown route '" + routeID + "' in distribution '" + id + "'.");
} else {
myCurrentAlternatives->addAlternativeDef(route);
}
}
}
}
bool
NIXMLEdgesHandler::setNodes(const SUMOSAXAttributes& attrs) {
// 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() : "";
std::string oldBegID = begNodeID;
std::string oldEndID = endNodeID;
if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
begNodeID = attrs.get<std::string>(SUMO_ATTR_FROM, 0, ok);
} else if (!myIsUpdate) {
WRITE_ERROR("The from-node is not given for edge '" + myCurrentID + "'.");
ok = false;
}
if (attrs.hasAttribute(SUMO_ATTR_TO)) {
endNodeID = attrs.get<std::string>(SUMO_ATTR_TO, 0, ok);
} else if (!myIsUpdate) {
WRITE_ERROR("The to-node is not given for edge '" + myCurrentID + "'.");
ok = false;
}
if (!ok) {
return false;
}
myFromNode = myNodeCont.retrieve(begNodeID);
myToNode = myNodeCont.retrieve(endNodeID);
if (myFromNode == 0) {
WRITE_ERROR("Edge's '" + myCurrentID + "' from-node '" + begNodeID + "' is not known.");
}
if (myToNode == 0) {
WRITE_ERROR("Edge's '" + myCurrentID + "' to-node '" + endNodeID + "' is not known.");
}
if (myFromNode != 0 && myToNode != 0) {
if (myIsUpdate && (myFromNode->getID() != oldBegID || myToNode->getID() != oldEndID)) {
myShape = PositionVector();
}
}
return myFromNode != 0 && myToNode != 0;
}
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);
}
AGStreet str(net->getEdge(attrs.getString(SUMO_ATTR_EDGE)), pop, work);
myCity.streets.push_back(str);
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_STREET) + ": " +
e.what());
throw ProcessError();
}
}
