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); } } }