bool
NWWriter_SUMO::writeInternalNodes(OutputDevice& into, const NBNode& n) {
bool ret = false;
const std::vector<NBEdge*>& incoming = n.getIncomingEdges();
for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
if ((*k).toEdge == 0 || !(*k).haveVia) {
continue;
}
Position pos = (*k).shape[-1];
into.openTag(SUMO_TAG_JUNCTION).writeAttr(SUMO_ATTR_ID, (*k).viaID + "_0");
into.writeAttr(SUMO_ATTR_TYPE, NODETYPE_INTERNAL);
NWFrame::writePositionLong(pos, into);
std::string incLanes = (*k).id + "_0";
if ((*k).foeIncomingLanes.length() != 0) {
incLanes += " " + (*k).foeIncomingLanes;
}
into.writeAttr(SUMO_ATTR_INCLANES, incLanes);
into.writeAttr(SUMO_ATTR_INTLANES, (*k).foeInternalLanes);
into.closeTag();
ret = true;
}
}
return ret;
}
void
ROPerson::saveAsXML(OutputDevice& os, OutputDevice* const typeos, bool asAlternatives, OptionsCont& options) const {
// write the person's vehicles
for (std::vector<PlanItem*>::const_iterator it = myPlan.begin(); it != myPlan.end(); ++it) {
(*it)->saveVehicles(os, typeos, asAlternatives, options);
}
if (typeos != 0 && myType != 0 && !myType->saved) {
myType->write(*typeos);
myType->saved = true;
}
if (myType != 0 && !myType->saved) {
myType->write(os);
myType->saved = asAlternatives;
}
// write the person
myParameter.write(os, options, SUMO_TAG_PERSON);
for (std::vector<PlanItem*>::const_iterator it = myPlan.begin(); it != myPlan.end(); ++it) {
(*it)->saveAsXML(os);
}
for (std::map<std::string, std::string>::const_iterator j = myParameter.getMap().begin(); j != myParameter.getMap().end(); ++j) {
os.openTag(SUMO_TAG_PARAM);
os.writeAttr(SUMO_ATTR_KEY, (*j).first);
os.writeAttr(SUMO_ATTR_VALUE, (*j).second);
os.closeTag();
}
os.closeTag();
}
void
ODMatrix::writeFlows(const SUMOTime begin, const SUMOTime end,
OutputDevice& dev, bool noVtype,
const std::string& prefix,
bool asProbability) {
if (myContainer.size() == 0) {
return;
}
int flowName = 0;
sortByBeginTime();
// recheck begin time
for (std::vector<ODCell*>::const_iterator i = myContainer.begin(); i != myContainer.end(); ++i) {
const ODCell* const c = *i;
if (c->end > begin && c->begin < end) {
dev.openTag(SUMO_TAG_FLOW).writeAttr(SUMO_ATTR_ID, prefix + toString(flowName++));
dev.writeAttr(SUMO_ATTR_BEGIN, time2string(c->begin));
dev.writeAttr(SUMO_ATTR_END, time2string(c->end));
if (!asProbability) {
dev.writeAttr(SUMO_ATTR_NUMBER, int(c->vehicleNumber));
} else {
const double probability = float(c->vehicleNumber) / STEPS2TIME(c->end - c->begin);
if (probability > 1) {
WRITE_WARNING("Flow density of " + toString(probability) + " vehicles per second, cannot be represented with a simple probability. Falling back to even spacing.");
dev.writeAttr(SUMO_ATTR_NUMBER, int(c->vehicleNumber));
} else {
dev.setPrecision(6);
dev.writeAttr(SUMO_ATTR_PROB, probability);
dev.setPrecision();
}
}
writeDefaultAttrs(dev, noVtype, *i);
dev.closeTag();
}
}
}
void
NWWriter_SUMO::writeRoundabout(OutputDevice& into, const std::vector<std::string>& edgeIDs,
const NBEdgeCont& ec) {
std::vector<std::string> validEdgeIDs;
std::vector<std::string> invalidEdgeIDs;
std::vector<std::string> nodeIDs;
for (std::vector<std::string>::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
const NBEdge* edge = ec.retrieve(*i);
if (edge != 0) {
nodeIDs.push_back(edge->getToNode()->getID());
validEdgeIDs.push_back(edge->getID());
} else {
invalidEdgeIDs.push_back(*i);
}
}
std::sort(nodeIDs.begin(), nodeIDs.end());
if (validEdgeIDs.size() > 0) {
into.openTag(SUMO_TAG_ROUNDABOUT);
into.writeAttr(SUMO_ATTR_NODES, joinToString(nodeIDs, " "));
into.writeAttr(SUMO_ATTR_EDGES, joinToString(validEdgeIDs, " "));
into.closeTag();
if (invalidEdgeIDs.size() > 0) {
WRITE_WARNING("Writing incomplete roundabout. Edges: '"
+ joinToString(invalidEdgeIDs, " ") + "' no longer exist'");
}
}
}
void
NWFrame::writePositionLong(const Position& pos, OutputDevice& dev) {
dev.writeAttr(SUMO_ATTR_X, pos.x());
dev.writeAttr(SUMO_ATTR_Y, pos.y());
if (pos.z() != 0) {
dev.writeAttr(SUMO_ATTR_Z, pos.z());
}
}
void
MSBaseVehicle::saveState(OutputDevice& out) {
out.openTag(SUMO_TAG_VEHICLE).writeAttr(SUMO_ATTR_ID, myParameter->id);
out.writeAttr(SUMO_ATTR_DEPART, time2string(myParameter->depart));
out.writeAttr(SUMO_ATTR_ROUTE, myRoute->getID());
out.writeAttr(SUMO_ATTR_TYPE, myType->getID());
// here starts the vehicle internal part (see loading)
// @note: remember to close the vehicle tag when calling this in a subclass!
}
void
GNEDetectorEntry::writeAdditional(OutputDevice& device, const std::string &) {
// Write parameters
device.openTag(getTag());
device.writeAttr(SUMO_ATTR_LANE, myLane->getID());
device.writeAttr(SUMO_ATTR_POSITION, myPosition.x());
// Close tag
device.closeTag();
}
void
MSFullExport::writeLane(OutputDevice& of, const MSLane& lane) {
of.openTag("lane").writeAttr("id", lane.getID()).writeAttr("CO", lane.getCOEmissions()).writeAttr("CO2", lane.getCO2Emissions());
of.writeAttr("NOx", lane.getNOxEmissions()).writeAttr("PMx", lane.getPMxEmissions()).writeAttr("HC", lane.getHCEmissions());
of.writeAttr("noise", lane.getHarmonoise_NoiseEmissions()).writeAttr("fuel", lane.getFuelConsumption()).writeAttr("maxspeed", lane.getSpeedLimit());
of.writeAttr("meanspeed", lane.getMeanSpeed() * 3.6).writeAttr("occupancy", lane.getNettoOccupancy()).writeAttr("vehicle_count", lane.getVehicleNumber());
of.closeTag();
}
void
MSPerson::MSPersonStage_Walking::routeOutput(OutputDevice& os) const {
os.openTag("walk").writeAttr(SUMO_ATTR_EDGES, myRoute);
if (myWalkingTime > 0) {
os.writeAttr(SUMO_ATTR_DURATION, time2string(myWalkingTime));
} else if (mySpeed > 0) {
os.writeAttr(SUMO_ATTR_SPEED, mySpeed);
}
os.closeTag();
}
void
NWWriter_SUMO::writeConnection(OutputDevice& into, const NBEdge& from, const NBEdge::Connection& c,
bool includeInternal, ConnectionStyle style) {
assert(c.toEdge != 0);
into.openTag(SUMO_TAG_CONNECTION);
into.writeAttr(SUMO_ATTR_FROM, from.getID());
into.writeAttr(SUMO_ATTR_TO, c.toEdge->getID());
into.writeAttr(SUMO_ATTR_FROM_LANE, c.fromLane);
into.writeAttr(SUMO_ATTR_TO_LANE, c.toLane);
if (c.mayDefinitelyPass) {
into.writeAttr(SUMO_ATTR_PASS, c.mayDefinitelyPass);
}
if (style != PLAIN) {
if (includeInternal) {
into.writeAttr(SUMO_ATTR_VIA, c.id + "_0");
}
// set information about the controlling tl if any
if (c.tlID != "") {
into.writeAttr(SUMO_ATTR_TLID, c.tlID);
into.writeAttr(SUMO_ATTR_TLLINKINDEX, c.tlLinkNo);
}
if (style == SUMONET) {
// write the direction information
LinkDirection dir = from.getToNode()->getDirection(&from, c.toEdge);
assert(dir != LINKDIR_NODIR);
into.writeAttr(SUMO_ATTR_DIR, toString(dir));
// write the state information
const LinkState linkState = from.getToNode()->getLinkState(
&from, c.toEdge, c.toLane, c.mayDefinitelyPass, c.tlID);
into.writeAttr(SUMO_ATTR_STATE, linkState);
}
}
into.closeTag();
}
void
MSDevice_Tripinfo::saveState(OutputDevice& out) const {
out.openTag(SUMO_TAG_DEVICE);
out.writeAttr(SUMO_ATTR_ID, getID());
std::vector<std::string> internals;
internals.push_back(myDepartLane);
internals.push_back(toString(myDepartPosLat));
internals.push_back(toString(myDepartSpeed));
out.writeAttr(SUMO_ATTR_STATE, toString(internals));
out.closeTag();
}
void
MSPerson::MSPersonStage_Waiting::routeOutput(OutputDevice& os) const {
os.openTag("stop").writeAttr(SUMO_ATTR_LANE, getDestination().getID());
if (myWaitingDuration >= 0) {
os.writeAttr(SUMO_ATTR_DURATION, time2string(myWaitingDuration));
}
if (myWaitingUntil >= 0) {
os.writeAttr(SUMO_ATTR_UNTIL, time2string(myWaitingUntil));
}
os.closeTag();
}
void
MSVehicleTransfer::saveState(OutputDevice& out) const {
for (VehicleInfVector::const_iterator it = myVehicles.begin(); it != myVehicles.end(); ++it) {
out.openTag(SUMO_TAG_VEHICLETRANSFER);
out.writeAttr(SUMO_ATTR_ID, it->myVeh->getID());
out.writeAttr(SUMO_ATTR_DEPART, it->myProceedTime);
if (it->myParking) {
out.writeAttr(SUMO_ATTR_PARKING, it->myVeh->getLane()->getID());
}
out.closeTag();
}
}
void
NWWriter_SUMO::writeJunction(OutputDevice& into, const NBNode& n) {
// write the attributes
into.openTag(SUMO_TAG_JUNCTION).writeAttr(SUMO_ATTR_ID, n.getID());
into.writeAttr(SUMO_ATTR_TYPE, n.getType());
NWFrame::writePositionLong(n.getPosition(), into);
// write the incoming lanes
std::string incLanes;
const std::vector<NBEdge*>& incoming = n.getIncomingEdges();
for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); ++i) {
unsigned int noLanes = (*i)->getNumLanes();
for (unsigned int j = 0; j < noLanes; j++) {
incLanes += (*i)->getLaneID(j);
if (i != incoming.end() - 1 || j < noLanes - 1) {
incLanes += ' ';
}
}
}
into.writeAttr(SUMO_ATTR_INCLANES, incLanes);
// write the internal lanes
std::string intLanes;
if (!OptionsCont::getOptions().getBool("no-internal-links")) {
unsigned int l = 0;
for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
if ((*k).toEdge == 0) {
continue;
}
if (l != 0) {
intLanes += ' ';
}
if (!(*k).haveVia) {
intLanes += (*k).id + "_0";
} else {
intLanes += (*k).viaID + "_0";
}
l++;
}
}
}
into.writeAttr(SUMO_ATTR_INTLANES, intLanes);
// close writing
into.writeAttr(SUMO_ATTR_SHAPE, n.getShape());
if (n.getType() == NODETYPE_DEAD_END) {
into.closeTag();
} else {
// write right-of-way logics
n.writeLogic(into);
into.closeTag();
}
}
void
MSInsertionControl::saveState(OutputDevice& out) {
// save flow states
for (const Flow& flow : myFlows) {
out.openTag(SUMO_TAG_FLOWSTATE);
out.writeAttr(SUMO_ATTR_ID, flow.pars->id);
out.writeAttr(SUMO_ATTR_INDEX, flow.index);
if (flow.pars->wasSet(VEHPARS_FORCE_REROUTE)) {
out.writeAttr(SUMO_ATTR_REROUTE, true);
}
out.closeTag();
}
}
void
GUIDialog_EditViewport::writeXML(OutputDevice& dev) {
dev.openTag(SUMO_TAG_VIEWPORT);
dev.writeAttr(SUMO_ATTR_ZOOM, myZoom->getValue());
dev.writeAttr(SUMO_ATTR_X, myXOff->getValue());
dev.writeAttr(SUMO_ATTR_Y, myYOff->getValue());
#ifdef HAVE_OSG
dev.writeAttr(SUMO_ATTR_CENTER_X, myLookAtX->getValue());
dev.writeAttr(SUMO_ATTR_CENTER_Y, myLookAtY->getValue());
dev.writeAttr(SUMO_ATTR_CENTER_Z, myLookAtZ->getValue());
#endif
dev.closeTag();
}
void
NWWriter_SUMO::writeTrafficLights(OutputDevice& into, const NBTrafficLightLogicCont& tllCont) {
std::vector<NBTrafficLightLogic*> logics = tllCont.getComputed();
for (std::vector<NBTrafficLightLogic*>::iterator it = logics.begin(); it != logics.end(); it++) {
into.openTag(SUMO_TAG_TLLOGIC);
into.writeAttr(SUMO_ATTR_ID, (*it)->getID());
into.writeAttr(SUMO_ATTR_TYPE, (*it)->getType());
into.writeAttr(SUMO_ATTR_PROGRAMID, (*it)->getProgramID());
into.writeAttr(SUMO_ATTR_OFFSET, writeSUMOTime((*it)->getOffset()));
// write params
const std::map<std::string, std::string>& params = (*it)->getMap();
for (std::map<std::string, std::string>::const_iterator i = params.begin(); i != params.end(); ++i) {
into.openTag(SUMO_TAG_PARAM);
into.writeAttr(SUMO_ATTR_KEY, (*i).first);
into.writeAttr(SUMO_ATTR_VALUE, (*i).second);
into.closeTag();
}
// write the phases
const std::vector<NBTrafficLightLogic::PhaseDefinition>& phases = (*it)->getPhases();
for (std::vector<NBTrafficLightLogic::PhaseDefinition>::const_iterator j = phases.begin(); j != phases.end(); ++j) {
into.openTag(SUMO_TAG_PHASE);
into.writeAttr(SUMO_ATTR_DURATION, writeSUMOTime(j->duration));
into.writeAttr(SUMO_ATTR_STATE, j->state);
into.closeTag();
}
into.closeTag();
}
if (logics.size() > 0) {
into.lf();
}
}
void
ODMatrix::writeDefaultAttrs(OutputDevice& dev, const bool noVtype,
const ODCell* const cell) {
const OptionsCont& oc = OptionsCont::getOptions();
if (!noVtype && cell->vehicleType != "") {
dev.writeAttr(SUMO_ATTR_TYPE, cell->vehicleType);
}
dev.writeAttr(SUMO_ATTR_FROM_TAZ, cell->origin).writeAttr(SUMO_ATTR_TO_TAZ, cell->destination);
if (oc.isSet("departlane") && oc.getString("departlane") != "default") {
dev.writeAttr(SUMO_ATTR_DEPARTLANE, oc.getString("departlane"));
}
if (oc.isSet("departpos")) {
dev.writeAttr(SUMO_ATTR_DEPARTPOS, oc.getString("departpos"));
}
if (oc.isSet("departspeed") && oc.getString("departspeed") != "default") {
dev.writeAttr(SUMO_ATTR_DEPARTSPEED, oc.getString("departspeed"));
}
if (oc.isSet("arrivallane")) {
dev.writeAttr(SUMO_ATTR_ARRIVALLANE, oc.getString("arrivallane"));
}
if (oc.isSet("arrivalpos")) {
dev.writeAttr(SUMO_ATTR_ARRIVALPOS, oc.getString("arrivalpos"));
}
if (oc.isSet("arrivalspeed")) {
dev.writeAttr(SUMO_ATTR_ARRIVALSPEED, oc.getString("arrivalspeed"));
}
}
// ===========================================================================
// method definitions
// ===========================================================================
void
MSEmissionExport::write(OutputDevice& of, SUMOTime timestep, int precision) {
of.openTag("timestep").writeAttr("time", time2string(timestep));
of.setPrecision(precision);
MSVehicleControl& vc = MSNet::getInstance()->getVehicleControl();
for (MSVehicleControl::constVehIt it = vc.loadedVehBegin(); it != vc.loadedVehEnd(); ++it) {
const SUMOVehicle* veh = it->second;
const MSVehicle* microVeh = dynamic_cast<const MSVehicle*>(veh);
if (veh->isOnRoad()) {
std::string fclass = veh->getVehicleType().getID();
fclass = fclass.substr(0, fclass.find_first_of("@"));
PollutantsInterface::Emissions emiss = PollutantsInterface::computeAll(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getAcceleration(), veh->getSlope());
of.openTag("vehicle").writeAttr("id", veh->getID()).writeAttr("eclass", PollutantsInterface::getName(veh->getVehicleType().getEmissionClass()));
of.writeAttr("CO2", emiss.CO2).writeAttr("CO", emiss.CO).writeAttr("HC", emiss.HC).writeAttr("NOx", emiss.NOx);
of.writeAttr("PMx", emiss.PMx).writeAttr("fuel", emiss.fuel).writeAttr("electricity", emiss.electricity);
of.writeAttr("noise", HelpersHarmonoise::computeNoise(veh->getVehicleType().getEmissionClass(), veh->getSpeed(), veh->getAcceleration()));
of.writeAttr("route", veh->getRoute().getID()).writeAttr("type", fclass);
if (microVeh != 0) {
of.writeAttr("waiting", microVeh->getWaitingSeconds());
of.writeAttr("lane", microVeh->getLane()->getID());
}
of.writeAttr("pos", veh->getPositionOnLane()).writeAttr("speed", veh->getSpeed());
of.writeAttr("angle", GeomHelper::naviDegree(veh->getAngle())).writeAttr("x", veh->getPosition().x()).writeAttr("y", veh->getPosition().y());
of.closeTag();
}
}
of.setPrecision(OUTPUT_ACCURACY);
of.closeTag();
}
void
MSRoute::dict_saveState(OutputDevice& out) {
for (RouteDict::iterator it = myDict.begin(); it != myDict.end(); ++it) {
out.openTag(SUMO_TAG_ROUTE).writeAttr(SUMO_ATTR_ID, (*it).second->getID());
out.writeAttr(SUMO_ATTR_STATE, (*it).second->myAmPermanent);
out.writeAttr(SUMO_ATTR_EDGES, (*it).second->myEdges).closeTag();
}
for (RouteDistDict::iterator it = myDistDict.begin(); it != myDistDict.end(); ++it) {
out.openTag(SUMO_TAG_ROUTE_DISTRIBUTION).writeAttr(SUMO_ATTR_ID, (*it).first);
out.writeAttr(SUMO_ATTR_STATE, (*it).second.second);
out.writeAttr(SUMO_ATTR_ROUTES, (*it).second.first->getVals());
out.writeAttr(SUMO_ATTR_PROBS, (*it).second.first->getProbs());
out.closeTag();
}
}
void
ROPerson::Ride::saveAsXML(OutputDevice& os) const {
os.openTag(SUMO_TAG_RIDE);
if (from != 0) {
os.writeAttr(SUMO_ATTR_FROM, from->getID());
}
if (to != 0) {
os.writeAttr(SUMO_ATTR_TO, to->getID());
}
if (destStop != "") {
os.writeAttr(SUMO_ATTR_BUS_STOP, destStop);
}
os.writeAttr(SUMO_ATTR_LINES, lines);
os.closeTag();
}
void
NWWriter_SUMO::writeDistrict(OutputDevice& into, const NBDistrict& d) {
std::vector<SUMOReal> sourceW = d.getSourceWeights();
VectorHelper<SUMOReal>::normaliseSum(sourceW, 1.0);
std::vector<SUMOReal> sinkW = d.getSinkWeights();
VectorHelper<SUMOReal>::normaliseSum(sinkW, 1.0);
// write the head and the id of the district
into.openTag(SUMO_TAG_TAZ).writeAttr(SUMO_ATTR_ID, d.getID());
if (d.getShape().size() > 0) {
into.writeAttr(SUMO_ATTR_SHAPE, d.getShape());
}
size_t i;
// write all sources
const std::vector<NBEdge*>& sources = d.getSourceEdges();
for (i = 0; i < sources.size(); i++) {
// write the head and the id of the source
into.openTag(SUMO_TAG_TAZSOURCE).writeAttr(SUMO_ATTR_ID, sources[i]->getID()).writeAttr(SUMO_ATTR_WEIGHT, sourceW[i]);
into.closeTag();
}
// write all sinks
const std::vector<NBEdge*>& sinks = d.getSinkEdges();
for (i = 0; i < sinks.size(); i++) {
// write the head and the id of the sink
into.openTag(SUMO_TAG_TAZSINK).writeAttr(SUMO_ATTR_ID, sinks[i]->getID()).writeAttr(SUMO_ATTR_WEIGHT, sinkW[i]);
into.closeTag();
}
// write the tail
into.closeTag();
}
int
NBRequest::writeLaneResponse(OutputDevice& od, NBEdge* from,
int fromLane, int pos) const {
std::vector<NBEdge::Connection> connected = from->getConnectionsFromLane(fromLane);
for (std::vector<NBEdge::Connection>::iterator j = connected.begin(); j != connected.end(); j++) {
od.openTag(SUMO_TAG_REQUEST);
od.writeAttr(SUMO_ATTR_INDEX, pos++);
od.writeAttr(SUMO_ATTR_RESPONSE, getResponseString(from, (*j).toEdge, fromLane, (*j).mayDefinitelyPass));
od.writeAttr(SUMO_ATTR_FOES, getFoesString(from, (*j).toEdge));
if (!OptionsCont::getOptions().getBool("no-internal-links")) {
od.writeAttr(SUMO_ATTR_CONT, j->haveVia);
}
od.closeTag();
}
return pos;
}
void
MSMeanData_Harmonoise::MSLaneMeanDataValues::write(OutputDevice& dev, const SUMOTime period,
const SUMOReal /*numLanes*/, const SUMOReal defaultTravelTime, const int /*numVehicles*/) const {
dev.writeAttr("noise", (meanNTemp != 0 ? (SUMOReal)(10. * log10(meanNTemp * TS / STEPS2TIME(period))) : (SUMOReal) 0.));
if (sampleSeconds > myParent->myMinSamples) {
SUMOReal traveltime = myParent->myMaxTravelTime;
if (travelledDistance > 0.f) {
traveltime = MIN2(traveltime, myLaneLength * sampleSeconds / travelledDistance);
}
dev.writeAttr("traveltime", traveltime);
} else if (defaultTravelTime >= 0.) {
// @todo default value for noise
dev.writeAttr("traveltime", defaultTravelTime);
}
dev.closeTag();
}
void
GeoConvHelper::writeLocation(OutputDevice& into) {
into.openTag(SUMO_TAG_LOCATION);
into.writeAttr(SUMO_ATTR_NET_OFFSET, myFinal.getOffsetBase());
into.writeAttr(SUMO_ATTR_CONV_BOUNDARY, myFinal.getConvBoundary());
if (myFinal.usingGeoProjection()) {
into.setPrecision(gPrecisionGeo);
}
into.writeAttr(SUMO_ATTR_ORIG_BOUNDARY, myFinal.getOrigBoundary());
if (myFinal.usingGeoProjection()) {
into.setPrecision();
}
into.writeAttr(SUMO_ATTR_ORIG_PROJ, myFinal.getProjString());
into.closeTag();
into.lf();
}
void
NWWriter_SUMO::writeLocation(OutputDevice& into) {
const GeoConvHelper& geoConvHelper = GeoConvHelper::getFinal();
into.openTag(SUMO_TAG_LOCATION);
into.writeAttr(SUMO_ATTR_NET_OFFSET, geoConvHelper.getOffsetBase());
into.writeAttr(SUMO_ATTR_CONV_BOUNDARY, geoConvHelper.getConvBoundary());
if (geoConvHelper.usingGeoProjection()) {
into.setPrecision(GEO_OUTPUT_ACCURACY);
}
into.writeAttr(SUMO_ATTR_ORIG_BOUNDARY, geoConvHelper.getOrigBoundary());
if (geoConvHelper.usingGeoProjection()) {
into.setPrecision();
}
into.writeAttr(SUMO_ATTR_ORIG_PROJ, geoConvHelper.getProjString());
into.closeTag();
into.lf();
}
void
NWWriter_SUMO::writePreferences(OutputDevice& into, SVCPermissions preferred) {
if (preferred == SVCFreeForAll || preferred == 0) {
return;
} else {
into.writeAttr(SUMO_ATTR_PREFER, getAllowedVehicleClassNames(preferred));
}
}
bool
NWWriter_SUMO::writeInternalNodes(OutputDevice& into, const NBNode& n) {
bool ret = false;
const std::vector<NBEdge*>& incoming = n.getIncomingEdges();
// build the list of internal lane ids
std::vector<std::string> internalLaneIDs;
for (EdgeVector::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
if ((*k).toEdge != 0) {
internalLaneIDs.push_back((*k).getInternalLaneID());
}
}
}
const std::vector<NBNode::Crossing>& crossings = n.getCrossings();
for (std::vector<NBNode::Crossing>::const_iterator it_c = crossings.begin(); it_c != crossings.end(); ++it_c) {
internalLaneIDs.push_back((*it_c).id + "_0");
}
// write the internal nodes
for (std::vector<NBEdge*>::const_iterator i = incoming.begin(); i != incoming.end(); i++) {
const std::vector<NBEdge::Connection>& elv = (*i)->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
if ((*k).toEdge == 0 || !(*k).haveVia) {
continue;
}
Position pos = (*k).shape[-1];
into.openTag(SUMO_TAG_JUNCTION).writeAttr(SUMO_ATTR_ID, (*k).viaID + "_0");
into.writeAttr(SUMO_ATTR_TYPE, NODETYPE_INTERNAL);
NWFrame::writePositionLong(pos, into);
std::string incLanes = (*k).getInternalLaneID();
if ((*k).foeIncomingLanes.length() != 0) {
incLanes += " " + (*k).foeIncomingLanes;
}
into.writeAttr(SUMO_ATTR_INCLANES, incLanes);
const std::vector<unsigned int>& foes = (*k).foeInternalLinks;
std::vector<std::string> foeIDs;
for (std::vector<unsigned int>::const_iterator it = foes.begin(); it != foes.end(); ++it) {
foeIDs.push_back(internalLaneIDs[*it]);
}
into.writeAttr(SUMO_ATTR_INTLANES, joinToString(foeIDs, " "));
into.closeTag();
ret = true;
}
}
return ret;
}
void
writePreferences(OutputDevice& into, SVCPermissions preferred) {
if (preferred == SVCAll || preferred == 0) {
return;
} else {
into.writeAttr(SUMO_ATTR_PREFER, getVehicleClassNames(preferred));
}
}
void
NWWriter_SUMO::writePermissions(OutputDevice& into, SVCPermissions permissions) {
if (permissions == SVCFreeForAll) {
return;
} else if (permissions == 0) {
// special case: since all-empty encodes FreeForAll we must list all disallowed
into.writeAttr(SUMO_ATTR_DISALLOW, getAllowedVehicleClassNames(SVCFreeForAll));
return;
} else {
std::pair<std::string, bool> encoding = getPermissionEncoding(permissions);
if (encoding.second) {
into.writeAttr(SUMO_ATTR_ALLOW, encoding.first);
} else {
into.writeAttr(SUMO_ATTR_DISALLOW, encoding.first);
}
}
}
