// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static methods // --------------------------------------------------------------------------- void NIImporter_MATSim::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) { // check whether the option is set (properly) if (!oc.isSet("matsim-files")) { return; } /* Parse file(s) * Each file is parsed twice: first for nodes, second for edges. */ std::vector<std::string> files = oc.getStringVector("matsim-files"); // load nodes, first NodesHandler nodesHandler(nb.getNodeCont()); for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) { // nodes if (!FileHelpers::isReadable(*file)) { WRITE_ERROR("Could not open matsim-file '" + *file + "'."); return; } nodesHandler.setFileName(*file); PROGRESS_BEGIN_MESSAGE("Parsing nodes from matsim-file '" + *file + "'"); if (!XMLSubSys::runParser(nodesHandler, *file)) { return; } PROGRESS_DONE_MESSAGE(); } // load edges, then EdgesHandler edgesHandler(nb.getNodeCont(), nb.getEdgeCont(), oc.getBool("matsim.keep-length"), oc.getBool("matsim.lanes-from-capacity"), NBCapacity2Lanes(oc.getFloat("lanes-from-capacity.norm"))); for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) { // edges edgesHandler.setFileName(*file); PROGRESS_BEGIN_MESSAGE("Parsing edges from matsim-file '" + *file + "'"); XMLSubSys::runParser(edgesHandler, *file); PROGRESS_DONE_MESSAGE(); } }
void NBHeightMapper::loadIfSet(OptionsCont& oc) { if (oc.isSet("heightmap.geotiff")) { // parse file(s) std::vector<std::string> files = oc.getStringVector("heightmap.geotiff"); for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) { PROGRESS_BEGIN_MESSAGE("Parsing from GeoTIFF '" + *file + "'"); int numFeatures = Singleton.loadTiff(*file); MsgHandler::getMessageInstance()->endProcessMsg( " done (parsed " + toString(numFeatures) + " features, Boundary: " + toString(Singleton.getBoundary()) + ")."); } } if (oc.isSet("heightmap.shapefiles")) { // parse file(s) std::vector<std::string> files = oc.getStringVector("heightmap.shapefiles"); for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) { PROGRESS_BEGIN_MESSAGE("Parsing from shape-file '" + *file + "'"); int numFeatures = Singleton.loadShapeFile(*file); MsgHandler::getMessageInstance()->endProcessMsg( " done (parsed " + toString(numFeatures) + " features, Boundary: " + toString(Singleton.getBoundary()) + ")."); } } }
void loadJTRDefinitions(RONet& net, OptionsCont& oc) { // load the turning definitions (and possible sink definition) if (oc.isSet("turn-ratio-files")) { ROJTRTurnDefLoader loader(net); std::vector<std::string> ratio_files = oc.getStringVector("turn-ratio-files"); for (std::vector<std::string>::const_iterator i = ratio_files.begin(); i != ratio_files.end(); ++i) { if (!XMLSubSys::runParser(loader, *i)) { throw ProcessError(); } } } if (MsgHandler::getErrorInstance()->wasInformed() && oc.getBool("ignore-errors")) { MsgHandler::getErrorInstance()->clear(); } // parse sink edges specified at the input/within the configuration if (oc.isSet("sink-edges")) { std::vector<std::string> edges = oc.getStringVector("sink-edges"); for (std::vector<std::string>::const_iterator i = edges.begin(); i != edges.end(); ++i) { ROJTREdge* edge = static_cast<ROJTREdge*>(net.getEdge(*i)); if (edge == 0) { throw ProcessError("The edge '" + *i + "' declared as a sink is not known."); } edge->setSink(); } } }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static methods (interface in this case) // --------------------------------------------------------------------------- void NIImporter_RobocupRescue::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) { // check whether the option is set (properly) if (!oc.isSet("robocup-dir")) { return; } // build the handler NIImporter_RobocupRescue handler(nb.getNodeCont(), nb.getEdgeCont()); // parse file(s) std::vector<std::string> files = oc.getStringVector("robocup-dir"); for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) { // nodes std::string nodesName = (*file) + "/node.bin"; if (!FileHelpers::exists(nodesName)) { WRITE_ERROR("Could not open robocup-node-file '" + nodesName + "'."); return; } PROGRESS_BEGIN_MESSAGE("Parsing robocup-nodes from '" + nodesName + "'"); handler.loadNodes(nodesName); PROGRESS_DONE_MESSAGE(); // edges std::string edgesName = (*file) + "/road.bin"; if (!FileHelpers::exists(edgesName)) { WRITE_ERROR("Could not open robocup-road-file '" + edgesName + "'."); return; } PROGRESS_BEGIN_MESSAGE("Parsing robocup-roads from '" + edgesName + "'"); handler.loadEdges(edgesName); PROGRESS_DONE_MESSAGE(); } }
/* ------------------------------------------------------------------------- * file loading methods * ----------------------------------------------------------------------- */ void NILoader::loadXML(OptionsCont& oc) { // load nodes loadXMLType(new NIXMLNodesHandler(myNetBuilder.getNodeCont(), myNetBuilder.getTLLogicCont(), oc), oc.getStringVector("node-files"), "nodes"); // load the edges loadXMLType(new NIXMLEdgesHandler(myNetBuilder.getNodeCont(), myNetBuilder.getEdgeCont(), myNetBuilder.getTypeCont(), myNetBuilder.getDistrictCont(), myNetBuilder.getTLLogicCont(), oc), oc.getStringVector("edge-files"), "edges"); if (!deprecatedVehicleClassesSeen.empty()) { WRITE_WARNING("Deprecated vehicle class(es) '" + toString(deprecatedVehicleClassesSeen) + "' in input edge files."); } // load the connections loadXMLType(new NIXMLConnectionsHandler(myNetBuilder.getEdgeCont(), myNetBuilder.getTLLogicCont()), oc.getStringVector("connection-files"), "connections"); // load traffic lights (needs to come last, references loaded edges and connections) loadXMLType(new NIXMLTrafficLightsHandler( myNetBuilder.getTLLogicCont(), myNetBuilder.getEdgeCont()), oc.getStringVector("tllogic-files"), "traffic lights"); }
void NWWriter_DlrNavteq::writeTrafficSignals(const OptionsCont& oc, NBNodeCont& nc) { OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_traffic_signals.txt"); writeHeader(device, oc); const GeoConvHelper& gch = GeoConvHelper::getFinal(); const bool haveGeo = gch.usingGeoProjection(); const double geoScale = pow(10.0f, haveGeo ? 5 : 2); // see NIImporter_DlrNavteq::GEO_SCALE device.setPrecision(oc.getInt("dlr-navteq.precision")); // write format specifier device << "#Traffic signal related to LINK_ID and NODE_ID with location relative to driving direction.\n#column format like pointcollection.\n#DESCRIPTION->LOCATION: 1-rechts von LINK; 2-links von LINK; 3-oberhalb LINK -1-keineAngabe\n#RELATREC_ID\tPOICOL_TYPE\tDESCRIPTION\tLONGITUDE\tLATITUDE\tLINK_ID\n"; // write record for every edge incoming to a tls controlled node for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) { NBNode* n = (*i).second; if (n->isTLControlled()) { Position pos = n->getPosition(); gch.cartesian2geo(pos); pos.mul(geoScale); const EdgeVector& incoming = n->getIncomingEdges(); for (EdgeVector::const_iterator it = incoming.begin(); it != incoming.end(); ++it) { NBEdge* e = *it; device << e->getID() << "\t" << "12\t" // POICOL_TYPE << "LSA;NODEIDS#" << n->getID() << "#;LOCATION#-1#;\t" << pos.x() << "\t" << pos.y() << "\t" << e->getID() << "\n"; } } } device.close(); }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static methods (interface in this case) // --------------------------------------------------------------------------- void NIImporter_ArcView::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) { if (!oc.isSet("shapefile-prefix")) { return; } // check whether the correct set of entries is given // and compute both file names std::string dbf_file = oc.getString("shapefile-prefix") + ".dbf"; std::string shp_file = oc.getString("shapefile-prefix") + ".shp"; std::string shx_file = oc.getString("shapefile-prefix") + ".shx"; // check whether the files do exist if (!FileHelpers::isReadable(dbf_file)) { WRITE_ERROR("File not accessible: " + dbf_file); } if (!FileHelpers::isReadable(shp_file)) { WRITE_ERROR("File not accessible: " + shp_file); } if (!FileHelpers::isReadable(shx_file)) { WRITE_ERROR("File not accessible: " + shx_file); } if (MsgHandler::getErrorInstance()->wasInformed()) { return; } // load the arcview files NIImporter_ArcView loader(oc, nb.getNodeCont(), nb.getEdgeCont(), nb.getTypeCont(), dbf_file, shp_file, oc.getBool("speed-in-kmh")); loader.load(); }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static methods // --------------------------------------------------------------------------- void NIImporter_ITSUMO::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) { // check whether the option is set (properly) if (!oc.isSet("itsumo-files")) { return; } /* Parse file(s) * Each file is parsed twice: first for nodes, second for edges. */ std::vector<std::string> files = oc.getStringVector("itsumo-files"); // load nodes, first Handler Handler(nb); for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) { // nodes if (!FileHelpers::exists(*file)) { WRITE_ERROR("Could not open itsumo-file '" + *file + "'."); return; } Handler.setFileName(*file); PROGRESS_BEGIN_MESSAGE("Parsing nodes from itsumo-file '" + *file + "'"); if (!XMLSubSys::runParser(Handler, *file)) { return; } PROGRESS_DONE_MESSAGE(); } }
void MSBaseVehicle::initMoveReminderOutput(const OptionsCont& oc) { if (oc.isSet("movereminder-output.vehicles")) { const std::vector<std::string> vehicles = oc.getStringVector("movereminder-output.vehicles"); myShallTraceMoveReminders.insert(vehicles.begin(), vehicles.end()); } }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static initialisation methods // --------------------------------------------------------------------------- void MSDevice_Example::insertOptions(OptionsCont& oc) { oc.addOptionSubTopic("Example Device"); insertDefaultAssignmentOptions("example", "Example Device", oc); oc.doRegister("device.example.parameter", new Option_Float(0.0)); oc.addDescription("device.example.parameter", "Example Device", "An exemplary parameter which can be used by all instances of the example device"); }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static initialisation methods // --------------------------------------------------------------------------- void MSDevice_FCD::insertOptions(OptionsCont& oc) { oc.addOptionSubTopic("FCD Device"); insertDefaultAssignmentOptions("fcd", "FCD Device", oc); oc.doRegister("device.fcd.period", new Option_String("0")); oc.addDescription("device.fcd.period", "FCD Device", "Recording period for FCD-data"); }
// =========================================================================== // method definitions // =========================================================================== PCTypeMap::PCTypeMap(const OptionsCont& oc) { myDefaultType.id = oc.getString("type"); myDefaultType.color = RGBColor::parseColor(oc.getString("color")); myDefaultType.layer = oc.getInt("layer"); myDefaultType.discard = oc.getBool("discard"); myDefaultType.allowFill = true; myDefaultType.prefix = oc.getString("prefix"); }
void NWWriter_DlrNavteq::writeLinksUnsplitted(const OptionsCont& oc, NBEdgeCont& ec) { std::map<const std::string, std::string> nameIDs; OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_links_unsplitted.txt"); writeHeader(device, oc); // write format specifier device << "# LINK_ID\tNODE_ID_FROM\tNODE_ID_TO\tBETWEEN_NODE_ID\tLENGTH\tVEHICLE_TYPE\tFORM_OF_WAY\tBRUNNEL_TYPE\tFUNCTIONAL_ROAD_CLASS\tSPEED_CATEGORY\tNUMBER_OF_LANES\tSPEED_LIMIT\tSPEED_RESTRICTION\tNAME_ID1_REGIONAL\tNAME_ID2_LOCAL\tHOUSENUMBERS_RIGHT\tHOUSENUMBERS_LEFT\tZIP_CODE\tAREA_ID\tSUBAREA_ID\tTHROUGH_TRAFFIC\tSPECIAL_RESTRICTIONS\tEXTENDED_NUMBER_OF_LANES\tISRAMP\tCONNECTION\n"; // write edges for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) { NBEdge* e = (*i).second; const int kph = speedInKph(e->getSpeed()); const std::string& betweenNodeID = (e->getGeometry().size() > 2) ? e->getID() : UNDEFINED; std::string nameID = UNDEFINED; if (oc.getBool("output.street-names")) { const std::string& name = i->second->getStreetName(); if (name != "" && nameIDs.count(name) == 0) { nameID = toString(nameIDs.size()); nameIDs[name] = nameID; } } device << e->getID() << "\t" << e->getFromNode()->getID() << "\t" << e->getToNode()->getID() << "\t" << betweenNodeID << "\t" << getGraphLength(e) << "\t" << getAllowedTypes(e->getPermissions()) << "\t" << "3\t" // Speed Category 1-8 XXX refine this << UNDEFINED << "\t" // no special brunnel type (we don't know yet) << getRoadClass(e) << "\t" << getSpeedCategory(kph) << "\t" << getNavteqLaneCode(e->getNumLanes()) << "\t" << getSpeedCategoryUpperBound(kph) << "\t" << kph << "\t" << nameID << "\t" // NAME_ID1_REGIONAL XXX << UNDEFINED << "\t" // NAME_ID2_LOCAL XXX << UNDEFINED << "\t" // housenumbers_right << UNDEFINED << "\t" // housenumbers_left << UNDEFINED << "\t" // ZIP_CODE << UNDEFINED << "\t" // AREA_ID << UNDEFINED << "\t" // SUBAREA_ID << "1\t" // through_traffic (allowed) << UNDEFINED << "\t" // special_restrictions << UNDEFINED << "\t" // extended_number_of_lanes << UNDEFINED << "\t" // isRamp << "0\t" // connection (between nodes always in order) << "\n"; } if (oc.getBool("output.street-names")) { OutputDevice& namesDevice = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_names.txt"); writeHeader(namesDevice, oc); // write format specifier namesDevice << "# NAME_ID\tName\n" << nameIDs.size() << "\n"; for (std::map<const std::string, std::string>::const_iterator i = nameIDs.begin(); i != nameIDs.end(); ++i) { namesDevice << i->second << "\t" << i->first << "\n"; } } }
void NBNetBuilder::applyOptions(OptionsCont& oc) { // apply options to type control myTypeCont.setDefaults(oc.getInt("default.lanenumber"), oc.getFloat("default.lanewidth"), oc.getFloat("default.speed"), oc.getInt("default.priority")); // apply options to edge control myEdgeCont.applyOptions(oc); // apply options to traffic light logics control myTLLCont.applyOptions(oc); }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static methods (interface in this case) // --------------------------------------------------------------------------- void NIImporter_Vissim::loadNetwork(const OptionsCont &oc, NBNetBuilder &nb) { if (!oc.isSet("vissim")) { return; } // load the visum network NIImporter_Vissim loader(nb, oc.getString("vissim")); loader.load(oc); }
// =========================================================================== // method definitions // =========================================================================== void PCLoaderDlrNavteq::loadIfSet(OptionsCont& oc, PCPolyContainer& toFill, PCTypeMap& tm) { if (oc.isSet("dlr-navteq-poly-files")) { loadPolyFiles(oc, toFill, tm); } if (oc.isSet("dlr-navteq-poi-files")) { loadPOIFiles(oc, toFill, tm); } }
void NILoader::load(OptionsCont& oc) { // load types first NIXMLTypesHandler* handler = new NIXMLTypesHandler(myNetBuilder.getTypeCont()); loadXMLType(handler, oc.getStringVector("type-files"), "types"); // try to load height data so it is ready for use by other importers #ifdef HAVE_INTERNAL HeightMapper::loadIfSet(oc); #endif // try to load using different methods NIImporter_SUMO::loadNetwork(oc, myNetBuilder); NIImporter_RobocupRescue::loadNetwork(oc, myNetBuilder); NIImporter_OpenStreetMap::loadNetwork(oc, myNetBuilder); NIImporter_VISUM::loadNetwork(oc, myNetBuilder); NIImporter_ArcView::loadNetwork(oc, myNetBuilder); NIImporter_Vissim::loadNetwork(oc, myNetBuilder); NIImporter_DlrNavteq::loadNetwork(oc, myNetBuilder); NIImporter_OpenDrive::loadNetwork(oc, myNetBuilder); NIImporter_MATSim::loadNetwork(oc, myNetBuilder); NIImporter_ITSUMO::loadNetwork(oc, myNetBuilder); if (oc.getBool("tls.discard-loaded") || oc.getBool("tls.discard-simple")) { myNetBuilder.getNodeCont().discardTrafficLights(myNetBuilder.getTLLogicCont(), oc.getBool("tls.discard-simple"), oc.getBool("tls.guess-signals")); size_t removed = myNetBuilder.getTLLogicCont().getNumExtracted(); if (removed > 0) { WRITE_MESSAGE(" Removed " + toString(removed) + " traffic lights before loading plain-XML"); } } loadXML(oc); // check the loaded structures if (myNetBuilder.getNodeCont().size() == 0) { throw ProcessError("No nodes loaded."); } if (myNetBuilder.getEdgeCont().size() == 0) { throw ProcessError("No edges loaded."); } // report loaded structures WRITE_MESSAGE(" Import done:"); if (myNetBuilder.getDistrictCont().size() > 0) { WRITE_MESSAGE(" " + toString(myNetBuilder.getDistrictCont().size()) + " districts loaded."); } WRITE_MESSAGE(" " + toString(myNetBuilder.getNodeCont().size()) + " nodes loaded."); if (myNetBuilder.getTypeCont().size() > 0) { WRITE_MESSAGE(" " + toString(myNetBuilder.getTypeCont().size()) + " types loaded."); } WRITE_MESSAGE(" " + toString(myNetBuilder.getEdgeCont().size()) + " edges loaded."); if (myNetBuilder.getEdgeCont().getNoEdgeSplits() > 0) { WRITE_MESSAGE("The split of edges was performed " + toString(myNetBuilder.getEdgeCont().getNoEdgeSplits()) + " times."); } if (GeoConvHelper::getProcessing().usingGeoProjection()) { WRITE_MESSAGE("Proj projection parameters used: '" + GeoConvHelper::getProcessing().getProjString() + "'."); } }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static methods (interface in this case) // --------------------------------------------------------------------------- void NIImporter_VISUM::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) { // check whether the option is set (properly) if (!oc.isSet("visum-file")) { return; } // build the handler NIImporter_VISUM loader(nb, oc.getString("visum-file"), NBCapacity2Lanes(oc.getFloat("lanes-from-capacity.norm")), oc.getBool("visum.use-type-priority")); loader.load(); }
void NWWriter_XML::writeNodes(const OptionsCont& oc, NBNodeCont& nc) { const GeoConvHelper& gch = GeoConvHelper::getFinal(); bool useGeo = oc.exists("proj.plain-geo") && oc.getBool("proj.plain-geo"); if (useGeo && !gch.usingGeoProjection()) { WRITE_WARNING("Ignoring option \"proj.plain-geo\" because no geo-conversion has been defined"); useGeo = false; } const bool geoAccuracy = useGeo || gch.usingInverseGeoProjection(); OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".nod.xml"); device.writeXMLHeader("nodes", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/nodes_file.xsd\""); // write network offsets and projection to allow reconstruction of original coordinates if (!useGeo) { NWWriter_SUMO::writeLocation(device); } // write nodes for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) { NBNode* n = (*i).second; device.openTag(SUMO_TAG_NODE); device.writeAttr(SUMO_ATTR_ID, n->getID()); // write position Position pos = n->getPosition(); if (useGeo) { gch.cartesian2geo(pos); } if (geoAccuracy) { device.setPrecision(GEO_OUTPUT_ACCURACY); } NWFrame::writePositionLong(pos, device); if (geoAccuracy) { device.setPrecision(); } device.writeAttr(SUMO_ATTR_TYPE, toString(n->getType())); if (n->isTLControlled()) { const std::set<NBTrafficLightDefinition*>& tlss = n->getControllingTLS(); // set may contain multiple programs for the same id. // make sure ids are unique and sorted std::set<std::string> tlsIDs; for (std::set<NBTrafficLightDefinition*>::const_iterator it_tl = tlss.begin(); it_tl != tlss.end(); it_tl++) { tlsIDs.insert((*it_tl)->getID()); } std::vector<std::string> sortedIDs(tlsIDs.begin(), tlsIDs.end()); sort(sortedIDs.begin(), sortedIDs.end()); device.writeAttr(SUMO_ATTR_TLID, sortedIDs); } device.closeTag(); } device.close(); }
SUMOTime RONet::saveAndRemoveRoutesUntil(OptionsCont& options, SUMOAbstractRouter<ROEdge, ROVehicle>& router, SUMOTime time) { checkFlows(time); SUMOTime lastTime = -1; // write all vehicles (and additional structures) while (myVehicles.size() != 0 || myPersons.size() != 0) { // get the next vehicle and person const ROVehicle* const veh = myVehicles.getTopVehicle(); const SUMOTime vehicleTime = veh == 0 ? SUMOTime_MAX : veh->getDepartureTime(); PersonMap::iterator person = myPersons.begin(); const SUMOTime personTime = person == myPersons.end() ? SUMOTime_MAX : person->first; // check whether it shall not yet be computed if (vehicleTime > time && personTime > time) { lastTime = MIN2(vehicleTime, personTime); break; } if (vehicleTime < personTime) { // check whether to print the output if (lastTime != vehicleTime && lastTime != -1) { // report writing progress if (options.getInt("stats-period") >= 0 && ((int) vehicleTime % options.getInt("stats-period")) == 0) { WRITE_MESSAGE("Read: " + toString(myReadRouteNo) + ", Discarded: " + toString(myDiscardedRouteNo) + ", Written: " + toString(myWrittenRouteNo)); } } lastTime = vehicleTime; // ok, compute the route (try it) if (computeRoute(options, router, veh)) { // write the route veh->saveAllAsXML(*myRoutesOutput, myRouteAlternativesOutput, myTypesOutput, options.getBool("exit-times")); myWrittenRouteNo++; } else { myDiscardedRouteNo++; } // delete routes and the vehicle if (veh->getRouteDefinition()->getID()[0] == '!') { if (!myRoutes.erase(veh->getRouteDefinition()->getID())) { delete veh->getRouteDefinition(); } } myVehicles.erase(veh->getID()); } else { myRoutesOutput->writePreformattedTag(person->second); if (myRouteAlternativesOutput != 0) { myRouteAlternativesOutput->writePreformattedTag(person->second); } myPersons.erase(person); } } return lastTime; }
void NBTrafficLightLogicCont::applyOptions(OptionsCont &oc) throw() { // check whether any offsets shall be manipulated by setting // them to half of the duration if (oc.isSet("tl-logics.half-offset")) { myHalfOffsetTLS = oc.getStringVector("tl-logics.half-offset"); } // check whether any offsets shall be manipulated by setting // them to a quarter of the duration if (oc.isSet("tl-logics.quarter-offset")) { myQuarterOffsetTLS = oc.getStringVector("tl-logics.quarter-offset"); } }
void NWFrame::writeNetwork(const OptionsCont& oc, NBNetBuilder& nb) { NWWriter_SUMO::writeNetwork(oc, nb); NWWriter_MATSim::writeNetwork(oc, nb); NWWriter_OpenDrive::writeNetwork(oc, nb); NWWriter_DlrNavteq::writeNetwork(oc, nb); NWWriter_XML::writeNetwork(oc, nb); // save the mapping information when wished if (oc.isSet("map-output")) { OutputDevice& mdevice = OutputDevice::getDevice(oc.getString("map-output")); mdevice << nb.getJoinedEdgesMap(); mdevice.close(); } }
bool ROFrame::checkOptions(OptionsCont& oc) { // check whether the output is valid and can be build if (!oc.isSet("output-file")) { WRITE_ERROR("No output specified."); return false; } // if (oc.getInt("max-alternatives") < 2) { WRITE_ERROR("At least two alternatives should be enabled"); return false; } return true; }
// =========================================================================== // method definitions // =========================================================================== void PCLoaderArcView::loadIfSet(OptionsCont& oc, PCPolyContainer& toFill, PCTypeMap& tm) { if (!oc.isSet("shapefile-prefixes")) { return; } // parse file(s) std::vector<std::string> files = oc.getStringVector("shapefile-prefixes"); for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) { PROGRESS_BEGIN_MESSAGE("Parsing from shape-file '" + *file + "'"); load(*file, oc, toFill, tm); PROGRESS_DONE_MESSAGE(); } }
/** * loads the net * The net is in this meaning made up by the net itself and the dynamic * weights which may be supplied in a separate file */ void initNet(RONet& net, ROLoader& loader, OptionsCont& oc) { // load the net RODUAEdgeBuilder builder; ROEdge::setGlobalOptions(oc.getBool("weights.interpolate")); loader.loadNet(net, builder); // load the weights when wished/available if (oc.isSet("weight-files")) { loader.loadWeights(net, "weight-files", oc.getString("weight-attribute"), false, oc.getBool("weights.expand")); } if (oc.isSet("lane-weight-files")) { loader.loadWeights(net, "lane-weight-files", oc.getString("weight-attribute"), true, oc.getBool("weights.expand")); } }
bool ROFrame::checkOptions(OptionsCont &oc) { // check whether the output is valid and can be build if (!oc.isSet("output")) { MsgHandler::getErrorInstance()->inform("No output specified."); return false; } // if (oc.getInt("max-alternatives")<2) { MsgHandler::getErrorInstance()->inform("At least two alternatives should be enabled"); return false; } // check departure/arrival options return true; }
// =========================================================================== // method definitions // =========================================================================== // --------------------------------------------------------------------------- // static methods // --------------------------------------------------------------------------- void NWWriter_XML::writeNetwork(const OptionsCont& oc, NBNetBuilder& nb) { // check whether plain-output files shall be generated if (oc.isSet("plain-output-prefix")) { writeNodes(oc, nb.getNodeCont()); writeEdgesAndConnections(oc, nb.getNodeCont(), nb.getEdgeCont()); writeTrafficLights(oc, nb.getTLLogicCont(), nb.getEdgeCont()); } if (oc.isSet("junctions.join-output")) { writeJoinedJunctions(oc, nb.getNodeCont()); } if (oc.isSet("street-sign-output")) { writeStreetSigns(oc, nb.getEdgeCont()); } }
void NBTrafficLightLogicCont::applyOptions(OptionsCont& oc) { // check whether any offsets shall be manipulated by setting // them to half of the duration if (oc.isSet("tls.half-offset")) { std::vector<std::string> ids = oc.getStringVector("tls.half-offset"); myHalfOffsetTLS.insert(ids.begin(), ids.end()); } // check whether any offsets shall be manipulated by setting // them to a quarter of the duration if (oc.isSet("tls.quarter-offset")) { std::vector<std::string> ids = oc.getStringVector("tls.quarter-offset"); myHalfOffsetTLS.insert(ids.begin(), ids.end()); } }
void NWWriter_DlrNavteq::writeConnectedLanes(const OptionsCont& oc, NBNodeCont& nc) { OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_connected_lanes.txt"); writeHeader(device, oc); // write format specifier device << "#Lane connections related to LINK-IDs and NODE-ID.\n"; device << "#column format like pointcollection.\n"; device << "#NODE-ID\tVEHICLE-TYPE\tFROM_LANE\tTO_LANE\tTHROUGH_TRAFFIC\tLINK_IDs[2..*]\n"; // write record for every connection for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) { NBNode* n = (*i).second; const EdgeVector& incoming = n->getIncomingEdges(); for (EdgeVector::const_iterator j = incoming.begin(); j != incoming.end(); ++j) { NBEdge* from = *j; const SVCPermissions fromPerm = from->getPermissions(); const std::vector<NBEdge::Connection>& connections = from->getConnections(); for (std::vector<NBEdge::Connection>::const_iterator it_c = connections.begin(); it_c != connections.end(); it_c++) { const NBEdge::Connection& c = *it_c; device << n->getID() << "\t" << getAllowedTypes(fromPerm & c.toEdge->getPermissions()) << "\t" << c.fromLane + 1 << "\t" // one-based << c.toLane + 1 << "\t" // one-based << 1 << "\t" // no information regarding permissibility of through traffic << from->getID() << "\t" << c.toEdge->getID() << "\t" << "\n"; } } } device.close(); }
void NWWriter_DlrNavteq::writeHeader(OutputDevice& device, const OptionsCont& oc) { time_t rawtime; time(&rawtime); char buffer [80]; strftime(buffer, 80, "on %c", localtime(&rawtime)); device << "# Generated " << buffer << " by " << oc.getFullName() << "\n"; device << "# Format matches GdfExtractor version: V6.0\n"; std::stringstream tmp; oc.writeConfiguration(tmp, true, false, false); tmp.seekg(std::ios_base::beg); std::string line; while (!tmp.eof()) { std::getline(tmp, line); device << "# " << line << "\n"; } device << "#\n"; }