// ===========================================================================
// 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
MELoop::buildSegmentsFor(const MSEdge& e, const OptionsCont& oc) {
const SUMOReal length = e.getLength();
int no = numSegmentsFor(length, oc.getFloat("meso-edgelength"));
const SUMOReal slength = length / (SUMOReal)no;
const SUMOReal lengthGeometryFactor = e.getLanes()[0]->getLengthGeometryFactor();
MESegment* newSegment = 0;
MESegment* nextSegment = 0;
bool multiQueue = oc.getBool("meso-multi-queue");
bool junctionControl = oc.getBool("meso-junction-control");
for (int s = no - 1; s >= 0; s--) {
std::string id = e.getID() + ":" + toString(s);
newSegment =
new MESegment(id, e, nextSegment, slength,
e.getLanes()[0]->getSpeedLimit(), s,
string2time(oc.getString("meso-tauff")), string2time(oc.getString("meso-taufj")),
string2time(oc.getString("meso-taujf")), string2time(oc.getString("meso-taujj")),
oc.getFloat("meso-jam-threshold"), multiQueue, junctionControl,
lengthGeometryFactor);
multiQueue = false;
junctionControl = false;
nextSegment = newSegment;
}
while (e.getNumericalID() >= static_cast<int>(myEdges2FirstSegments.size())) {
myEdges2FirstSegments.push_back(0);
}
myEdges2FirstSegments[e.getNumericalID()] = newSegment;
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// NBRampsComputer
// ---------------------------------------------------------------------------
void
NBRampsComputer::computeRamps(NBNetBuilder& nb, OptionsCont& oc) {
SUMOReal minHighwaySpeed = oc.getFloat("ramps.min-highway-speed");
SUMOReal maxRampSpeed = oc.getFloat("ramps.max-ramp-speed");
SUMOReal rampLength = oc.getFloat("ramps.ramp-length");
bool dontSplit = oc.getBool("ramps.no-split");
std::set<NBEdge*> incremented;
// check whether on-off ramps shall be guessed
if (oc.getBool("ramps.guess")) {
NBNodeCont& nc = nb.getNodeCont();
NBEdgeCont& ec = nb.getEdgeCont();
NBDistrictCont& dc = nb.getDistrictCont();
std::set<NBNode*> potOnRamps;
std::set<NBNode*> potOffRamps;
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* cur = (*i).second;
if (mayNeedOnRamp(cur, minHighwaySpeed, maxRampSpeed)) {
potOnRamps.insert(cur);
}
if (mayNeedOffRamp(cur, minHighwaySpeed, maxRampSpeed)) {
potOffRamps.insert(cur);
}
}
for (std::set<NBNode*>::const_iterator i = potOnRamps.begin(); i != potOnRamps.end(); ++i) {
buildOnRamp(*i, nc, ec, dc, rampLength, dontSplit, incremented);
}
for (std::set<NBNode*>::const_iterator i = potOffRamps.begin(); i != potOffRamps.end(); ++i) {
buildOffRamp(*i, nc, ec, dc, rampLength, dontSplit, incremented);
}
}
// check whether on-off ramps shall be guessed
if (oc.isSet("ramps.set")) {
std::vector<std::string> edges = oc.getStringVector("ramps.set");
NBNodeCont& nc = nb.getNodeCont();
NBEdgeCont& ec = nb.getEdgeCont();
NBDistrictCont& dc = nb.getDistrictCont();
for (std::vector<std::string>::iterator i = edges.begin(); i != edges.end(); ++i) {
NBEdge* e = ec.retrieve(*i);
if (e == 0) {
WRITE_WARNING("Can not build on ramp on edge '" + *i + "' - the edge is not known.");
continue;
}
NBNode* from = e->getFromNode();
if (from->getIncomingEdges().size() == 2 && from->getOutgoingEdges().size() == 1) {
buildOnRamp(from, nc, ec, dc, rampLength, dontSplit, incremented);
}
// load edge again to check offramps
e = ec.retrieve(*i);
if (e == 0) {
WRITE_WARNING("Can not build off ramp on edge '" + *i + "' - the edge is not known.");
continue;
}
NBNode* to = e->getToNode();
if (to->getIncomingEdges().size() == 1 && to->getOutgoingEdges().size() == 2) {
buildOffRamp(to, nc, ec, dc, rampLength, dontSplit, incremented);
}
}
}
}
// ===========================================================================
// method definitions
// ===========================================================================
PCTypeMap::PCTypeMap(const OptionsCont& oc) {
myDefaultType.id = oc.getString("type");
myDefaultType.color = RGBColor::parseColor(oc.getString("color"));
myDefaultType.layer = oc.getFloat("layer");
myDefaultType.discard = oc.getBool("discard");
myDefaultType.allowFill = oc.getBool("fill");
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
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() + "'.");
}
}
/**
* 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(oc.getBool("weights.expand"), 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);
}
if (oc.isSet("lane-weight-files")) {
loader.loadWeights(net, "lane-weight-files", oc.getString("weight-attribute"), true);
}
}
// ===========================================================================
// 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();
}
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();
}
}
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet& net, ROLoader& loader, OptionsCont& oc) {
// initialise the loader
loader.openRoutes(net);
// prepare the output
net.openOutput(oc);
// build the router
ROJTRRouter* router = new ROJTRRouter(oc.getBool("ignore-errors"), oc.getBool("accept-all-destinations"),
(int)(((double) net.getEdgeNumber()) * OptionsCont::getOptions().getFloat("max-edges-factor")),
oc.getBool("ignore-vclasses"), oc.getBool("allow-loops"));
RORouteDef::setUsingJTRR();
RORouterProvider provider(router, new PedestrianRouter<ROEdge, ROLane, RONode, ROVehicle>(),
new ROIntermodalRouter(RONet::adaptIntermodalRouter, 0));
loader.processRoutes(string2time(oc.getString("begin")), string2time(oc.getString("end")),
string2time(oc.getString("route-steps")), net, provider);
net.cleanup();
}
// ===========================================================================
// 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();
}
// ===========================================================================
// method definitions
// ===========================================================================
NIXMLEdgesHandler::NIXMLEdgesHandler(NBNodeCont& nc,
NBEdgeCont& ec,
NBTypeCont& tc,
NBDistrictCont& dc,
OptionsCont& options)
: SUMOSAXHandler("xml-edges - file"),
myOptions(options),
myNodeCont(nc), myEdgeCont(ec), myTypeCont(tc), myDistrictCont(dc),
myCurrentEdge(0), myHaveReportedAboutOverwriting(false),
myHaveWarnedAboutDeprecatedLaneId(false),
myKeepEdgeShape(!options.getBool("plain.extend-edge-shape"))
{}
void
MSFrame::setMSGlobals(OptionsCont& oc) {
// pre-initialise the network
// set whether empty edges shall be printed on dump
MSGlobals::gOmitEmptyEdgesOnDump = !oc.getBool("netstate-dump.empty-edges");
#ifdef HAVE_INTERNAL_LANES
// set whether internal lanes shall be used
MSGlobals::gUsingInternalLanes = !oc.getBool("no-internal-links");
#else
MSGlobals::gUsingInternalLanes = false;
#endif
// set the grid lock time
MSGlobals::gTimeToGridlock = string2time(oc.getString("time-to-teleport")) < 0 ? 0 : string2time(oc.getString("time-to-teleport"));
MSGlobals::gCheck4Accidents = !oc.getBool("ignore-accidents");
MSGlobals::gCheckRoutes = !oc.getBool("ignore-route-errors");
#ifdef HAVE_INTERNAL
MSGlobals::gStateLoaded = oc.isSet("load-state");
MSGlobals::gUseMesoSim = oc.getBool("mesosim");
MSGlobals::gMesoLimitedJunctionControl = oc.getBool("meso-junction-control.limited");
if (MSGlobals::gUseMesoSim) {
MSGlobals::gUsingInternalLanes = false;
}
#endif
#ifdef HAVE_SUBSECOND_TIMESTEPS
DELTA_T = string2time(oc.getString("step-length"));
#endif
if (oc.isSet("routeDist.maxsize")) {
MSRoute::setMaxRouteDistSize(oc.getInt("routeDist.maxsize"));
}
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet &net, ROLoader &loader, OptionsCont &oc) {
// initialise the loader
loader.openRoutes(net);
// prepare the output
try {
net.openOutput(oc.getString("output"), false);
} catch (IOError &e) {
throw e;
}
// build the router
ROJTRRouter router(net, oc.getBool("continue-on-unbuild"),
oc.getBool("accept-all-destinations"));
// the routes are sorted - process stepwise
if (!oc.getBool("unsorted")) {
loader.processRoutesStepWise(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, router);
}
// the routes are not sorted: load all and process
else {
loader.processAllRoutes(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, router);
}
// end the processing
net.closeOutput();
}
bool
GeoConvHelper::init(OptionsCont& oc) {
std::string proj = "!"; // the default
double scale = oc.getFloat("proj.scale");
double rot = oc.getFloat("proj.rotate");
Position offset = Position(oc.getFloat("offset.x"), oc.getFloat("offset.y"));
bool inverse = oc.exists("proj.inverse") && oc.getBool("proj.inverse");
bool flatten = oc.exists("flatten") && oc.getBool("flatten");
if (oc.getBool("simple-projection")) {
proj = "-";
}
#ifdef PROJ_API_FILE
if (oc.getBool("proj.inverse") && oc.getString("proj") == "!") {
WRITE_ERROR("Inverse projection works only with explicit proj parameters.");
return false;
}
unsigned numProjections = oc.getBool("simple-projection") + oc.getBool("proj.utm") + oc.getBool("proj.dhdn") + oc.getBool("proj.dhdnutm") + (oc.getString("proj").length() > 1);
if (numProjections > 1) {
WRITE_ERROR("The projection method needs to be uniquely defined.");
return false;
}
if (oc.getBool("proj.utm")) {
proj = "UTM";
} else if (oc.getBool("proj.dhdn")) {
proj = "DHDN";
} else if (oc.getBool("proj.dhdnutm")) {
proj = "DHDN_UTM";
} else if (!oc.isDefault("proj")) {
proj = oc.getString("proj");
}
#endif
myProcessing = GeoConvHelper(proj, offset, Boundary(), Boundary(), scale, rot, inverse, flatten);
myFinal = myProcessing;
return true;
}
void
MSFrame::setMSGlobals(OptionsCont& oc) {
// pre-initialise the network
// set whether empty edges shall be printed on dump
MSGlobals::gOmitEmptyEdgesOnDump = !oc.getBool("netstate-dump.empty-edges");
#ifdef HAVE_INTERNAL_LANES
// set whether internal lanes shall be used
MSGlobals::gUsingInternalLanes = !oc.getBool("no-internal-links");
MSGlobals::gIgnoreJunctionBlocker = string2time(oc.getString("ignore-junction-blocker")) < 0 ?
std::numeric_limits<SUMOTime>::max() : string2time(oc.getString("ignore-junction-blocker"));
#else
MSGlobals::gUsingInternalLanes = false;
MSGlobals::gIgnoreJunctionBlocker = 0;
#endif
// set the grid lock time
MSGlobals::gTimeToGridlock = string2time(oc.getString("time-to-teleport")) < 0 ? 0 : string2time(oc.getString("time-to-teleport"));
MSGlobals::gTimeToGridlockHighways = string2time(oc.getString("time-to-teleport.highways")) < 0 ? 0 : string2time(oc.getString("time-to-teleport.highways"));
MSGlobals::gCheck4Accidents = !oc.getBool("ignore-accidents");
MSGlobals::gCheckRoutes = !oc.getBool("ignore-route-errors");
MSGlobals::gLaneChangeDuration = string2time(oc.getString("lanechange.duration"));
MSGlobals::gLateralResolution = oc.getFloat("lateral-resolution");
MSGlobals::gStateLoaded = oc.isSet("load-state");
MSGlobals::gUseMesoSim = oc.getBool("mesosim");
MSGlobals::gMesoLimitedJunctionControl = oc.getBool("meso-junction-control.limited");
MSGlobals::gMesoOvertaking = oc.getBool("meso-overtaking");
MSGlobals::gMesoTLSPenalty = oc.getFloat("meso-tls-penalty");
if (MSGlobals::gUseMesoSim) {
MSGlobals::gUsingInternalLanes = false;
}
MSGlobals::gWaitingTimeMemory = string2time(oc.getString("waiting-time-memory"));
MSAbstractLaneChangeModel::initGlobalOptions(oc);
MSLane::initCollisionOptions(oc);
DELTA_T = string2time(oc.getString("step-length"));
#ifdef _DEBUG
if (oc.isSet("movereminder-output")) {
MSBaseVehicle::initMoveReminderOutput(oc);
}
#endif
}
bool
RONet::computeRoute(OptionsCont& options, SUMOAbstractRouter<ROEdge, ROVehicle>& router,
const ROVehicle* const veh) {
MsgHandler* mh = (OptionsCont::getOptions().getBool("ignore-errors") ?
MsgHandler::getWarningInstance() : MsgHandler::getErrorInstance());
std::string noRouteMsg = "The vehicle '" + veh->getID() + "' has no valid route.";
RORouteDef* const routeDef = veh->getRouteDefinition();
// check if the route definition is valid
if (routeDef == 0) {
mh->inform(noRouteMsg);
return false;
}
// check whether the route was already saved
if (routeDef->isSaved()) {
return true;
}
//
RORoute* current = routeDef->buildCurrentRoute(router, veh->getDepartureTime(), *veh);
if (current == 0 || current->size() == 0) {
delete current;
mh->inform(noRouteMsg);
return false;
}
// check whether we have to evaluate the route for not containing loops
if (options.getBool("remove-loops")) {
current->recheckForLoops();
// check whether the route is still valid
if (current->size() == 0) {
delete current;
mh->inform(noRouteMsg + " (after removing loops)");
return false;
}
}
// add built route
routeDef->addAlternative(router, veh, current, veh->getDepartureTime());
return true;
}
/* -------------------------------------------------------------------------
* data processing methods
* ----------------------------------------------------------------------- */
void
readDetectors(RODFDetectorCon& detectors, OptionsCont& oc, RODFNet* optNet) {
if (!oc.isSet("detector-files")) {
throw ProcessError("No detector file given (use --detector-files <FILE>).");
}
// read definitions stored in XML-format
std::vector<std::string> files = oc.getStringVector("detector-files");
for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
if (!FileHelpers::exists(*fileIt)) {
throw ProcessError("Could not open detector file '" + *fileIt + "'");
}
PROGRESS_BEGIN_MESSAGE("Loading detector definitions from '" + *fileIt + "'");
RODFDetectorHandler handler(optNet, oc.getBool("ignore-invalid-detectors"), detectors, *fileIt);
if (XMLSubSys::runParser(handler, *fileIt)) {
PROGRESS_DONE_MESSAGE();
} else {
PROGRESS_FAILED_MESSAGE();
throw ProcessError();
}
}
if (detectors.getDetectors().empty()) {
throw ProcessError("No detectors found.");
}
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods
// ---------------------------------------------------------------------------
void
NIImporter_DlrNavteq::loadNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
// check whether the option is set (properly)
if (!oc.isSet("dlr-navteq-prefix")) {
return;
}
time_t csTime;
time(&csTime);
// parse file(s)
LineReader lr;
// load nodes
std::map<std::string, PositionVector> myGeoms;
PROGRESS_BEGIN_MESSAGE("Loading nodes");
std::string file = oc.getString("dlr-navteq-prefix") + "_nodes_unsplitted.txt";
NodesHandler handler1(nb.getNodeCont(), file, myGeoms);
if (!lr.setFile(file)) {
throw ProcessError("The file '" + file + "' could not be opened.");
}
lr.readAll(handler1);
PROGRESS_DONE_MESSAGE();
// load street names if given and wished
std::map<std::string, std::string> streetNames; // nameID : name
if (oc.getBool("output.street-names")) {
file = oc.getString("dlr-navteq-prefix") + "_names.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading Street Names");
NamesHandler handler4(file, streetNames);
lr.readAll(handler4);
PROGRESS_DONE_MESSAGE();
} else {
WRITE_WARNING("Output will not contain street names because the file '" + file + "' was not found");
}
}
// load edges
PROGRESS_BEGIN_MESSAGE("Loading edges");
file = oc.getString("dlr-navteq-prefix") + "_links_unsplitted.txt";
// parse the file
EdgesHandler handler2(nb.getNodeCont(), nb.getEdgeCont(), nb.getTypeCont(), file, myGeoms, streetNames);
if (!lr.setFile(file)) {
throw ProcessError("The file '" + file + "' could not be opened.");
}
lr.readAll(handler2);
nb.getEdgeCont().recheckLaneSpread();
PROGRESS_DONE_MESSAGE();
// load traffic lights if given
file = oc.getString("dlr-navteq-prefix") + "_traffic_signals.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading traffic lights");
TrafficlightsHandler handler3(nb.getNodeCont(), nb.getTLLogicCont(), nb.getEdgeCont(), file);
lr.readAll(handler3);
PROGRESS_DONE_MESSAGE();
}
// load prohibited manoeuvres if given
file = oc.getString("dlr-navteq-prefix") + "_prohibited_manoeuvres.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading prohibited manoeuvres");
ProhibitionHandler handler6(nb.getEdgeCont(), file, csTime);
lr.readAll(handler6);
PROGRESS_DONE_MESSAGE();
}
// load connected lanes if given
file = oc.getString("dlr-navteq-prefix") + "_connected_lanes.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading connected lanes");
ConnectedLanesHandler handler7(nb.getEdgeCont());
lr.readAll(handler7);
PROGRESS_DONE_MESSAGE();
}
// load time restrictions if given
file = oc.getString("dlr-navteq-prefix") + "_links_timerestrictions.txt";
if (lr.setFile(file)) {
PROGRESS_BEGIN_MESSAGE("Loading time restrictions");
if (!oc.isDefault("construction-date")) {
csTime = readDate(oc.getString("construction-date"));
}
TimeRestrictionsHandler handler5(nb.getEdgeCont(), nb.getDistrictCont(), csTime);
lr.readAll(handler5);
handler5.printSummary();
PROGRESS_DONE_MESSAGE();
}
}
bool SUMOVehicleParameter::defaultOptionOverrides
(const OptionsCont& oc, const std::string& optionName)const
{
return oc.isSet(optionName) && oc.getBool("defaults-override");
}
void
NBNodeCont::guessTLs(OptionsCont& oc, NBTrafficLightLogicCont& tlc) {
// build list of definitely not tls-controlled junctions
std::vector<NBNode*> ncontrolled;
if (oc.isSet("tls.unset")) {
std::vector<std::string> notTLControlledNodes = oc.getStringVector("tls.unset");
for (std::vector<std::string>::const_iterator i = notTLControlledNodes.begin(); i != notTLControlledNodes.end(); ++i) {
NBNode* n = NBNodeCont::retrieve(*i);
if (n == 0) {
throw ProcessError(" The node '" + *i + "' to set as not-controlled is not known.");
}
std::set<NBTrafficLightDefinition*> tls = n->getControllingTLS();
for (std::set<NBTrafficLightDefinition*>::const_iterator j = tls.begin(); j != tls.end(); ++j) {
(*j)->removeNode(n);
}
n->removeTrafficLights();
ncontrolled.push_back(n);
}
}
TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(OptionsCont::getOptions().getString("tls.default-type"));
// loop#1 checking whether the node shall be tls controlled,
// because it is assigned to a district
if (oc.exists("tls.taz-nodes") && oc.getBool("tls.taz-nodes")) {
for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) {
NBNode* cur = (*i).second;
if (cur->isNearDistrict() && find(ncontrolled.begin(), ncontrolled.end(), cur) == ncontrolled.end()) {
setAsTLControlled(cur, tlc, type);
}
}
}
// maybe no tls shall be guessed
if (!oc.getBool("tls.guess")) {
return;
}
// guess joined tls first, if wished
if (oc.getBool("tls.join")) {
// get node clusters
std::vector<std::set<NBNode*> > cands;
generateNodeClusters(oc.getFloat("tls.join-dist"), cands);
// check these candidates (clusters) whether they should be controlled by a tls
for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end();) {
std::set<NBNode*>& c = (*i);
// regard only junctions which are not yet controlled and are not
// forbidden to be controlled
for (std::set<NBNode*>::iterator j = c.begin(); j != c.end();) {
if ((*j)->isTLControlled() || find(ncontrolled.begin(), ncontrolled.end(), *j) != ncontrolled.end()) {
c.erase(j++);
} else {
++j;
}
}
// check whether the cluster should be controlled
if (!shouldBeTLSControlled(c)) {
i = cands.erase(i);
} else {
++i;
}
}
// cands now only contain sets of junctions that shall be joined into being tls-controlled
unsigned int index = 0;
for (std::vector<std::set<NBNode*> >::iterator i = cands.begin(); i != cands.end(); ++i) {
std::vector<NBNode*> nodes;
for (std::set<NBNode*>::iterator j = (*i).begin(); j != (*i).end(); j++) {
nodes.push_back(*j);
}
std::string id = "joinedG_" + toString(index++);
NBTrafficLightDefinition* tlDef = new NBOwnTLDef(id, nodes, 0, type);
if (!tlc.insert(tlDef)) {
// actually, nothing should fail here
WRITE_WARNING("Could not build guessed, joined tls");
delete tlDef;
return;
}
}
}
// guess tls
for (NodeCont::iterator i = myNodes.begin(); i != myNodes.end(); i++) {
NBNode* cur = (*i).second;
// do nothing if already is tl-controlled
if (cur->isTLControlled()) {
continue;
}
// do nothing if in the list of explicit non-controlled junctions
if (find(ncontrolled.begin(), ncontrolled.end(), cur) != ncontrolled.end()) {
continue;
}
std::set<NBNode*> c;
c.insert(cur);
if (!shouldBeTLSControlled(c) || cur->getIncomingEdges().size() < 3) {
continue;
}
setAsTLControlled((*i).second, tlc, type);
}
}
void
PCLoaderDlrNavteq::loadPOIFile(const std::string& file,
OptionsCont& oc, PCPolyContainer& toFill,
PCTypeMap& tm) {
// get the defaults
RGBColor c = RGBColor::parseColor(oc.getString("color"));
// parse
int l = 0;
LineReader lr(file);
while (lr.hasMore()) {
std::string line = lr.readLine();
++l;
// skip invalid/empty lines
if (line.length() == 0 || line.find("#") != std::string::npos) {
continue;
}
if (StringUtils::prune(line) == "") {
continue;
}
// parse the poi
std::istringstream stream(line);
// attributes of the poi
std::string name, skip, type, desc;
std::getline(stream, name, '\t');
std::getline(stream, skip, '\t');
std::getline(stream, type, '\t');
std::getline(stream, desc, '\t');
if (stream.fail()) {
throw ProcessError("Invalid dlr-navteq-poi in line " + toString(l) + ":\n" + line);
}
double x, y;
stream >> x;
if (stream.fail()) {
throw ProcessError("Invalid x coordinate for POI '" + name + "'.");
}
stream >> y;
if (stream.fail()) {
throw ProcessError("Invalid y coordinate for POI '" + name + "'.");
}
Position pos(x, y);
// check the poi
if (name == "") {
throw ProcessError("The name of a POI is missing.");
}
if (!GeoConvHelper::getProcessing().x2cartesian(pos, true)) {
throw ProcessError("Unable to project coordinates for POI '" + name + "'.");
}
// patch the values
bool discard = oc.getBool("discard");
int layer = oc.getInt("layer");
RGBColor color;
if (tm.has(type)) {
const PCTypeMap::TypeDef& def = tm.get(type);
name = def.prefix + name;
type = def.id;
color = def.color;
discard = def.discard;
layer = def.layer;
} else {
name = oc.getString("prefix") + name;
type = oc.getString("type");
color = c;
}
if (!discard) {
bool ignorePrunning = false;
if (OptionsCont::getOptions().isInStringVector("prune.keep-list", name)) {
ignorePrunning = true;
}
PointOfInterest* poi = new PointOfInterest(name, type, color, pos, (SUMOReal)layer);
toFill.insert(name, poi, layer, ignorePrunning);
}
}
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet& net, ROLoader& loader, OptionsCont& oc) {
// initialise the loader
loader.openRoutes(net);
// prepare the output
const std::string& filename = oc.getString("output-file");
std::string altFilename = filename + ".alt";
const size_t len = filename.length();
if (len > 4 && filename.substr(len - 4) == ".xml") {
altFilename = filename.substr(0, len - 4) + ".alt.xml";
} else if (len > 4 && filename.substr(len - 4) == ".sbx") {
altFilename = filename.substr(0, len - 4) + ".alt.sbx";
}
net.openOutput(filename, altFilename, oc.getString("vtype-output"));
// build the router
SUMOAbstractRouter<ROEdge, ROVehicle>* router;
const std::string measure = oc.getString("weight-attribute");
const std::string routingAlgorithm = oc.getString("routing-algorithm");
if (measure == "traveltime") {
if (routingAlgorithm == "dijkstra") {
if (net.hasRestrictions()) {
router = new DijkstraRouterTT_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
} else {
router = new DijkstraRouterTT_Direct<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
}
} else if (routingAlgorithm == "astar") {
if (net.hasRestrictions()) {
router = new AStarRouterTT_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
} else {
router = new AStarRouterTT_Direct<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
}
#ifdef HAVE_INTERNAL // catchall for internal stuff
} else if (routingAlgorithm == "bulkstar") {
if (net.hasRestrictions()) {
router = new BulkStarRouterTT<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &ROEdge::getMinimumTravelTime);
} else {
router = new BulkStarRouterTT<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &ROEdge::getMinimumTravelTime);
}
} else if (routingAlgorithm == "CH") {
// defaultVehicle is only in constructor and may be safely deleted
// it is mainly needed for its maximum speed. @todo XXX make this configurable
ROVehicle defaultVehicle(SUMOVehicleParameter(), 0, net.getVehicleTypeSecure(DEFAULT_VTYPE_ID));
const SUMOTime begin = string2time(oc.getString("begin"));
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
if (net.hasRestrictions()) {
router = new CHRouter<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &defaultVehicle, begin, weightPeriod, true);
} else {
router = new CHRouter<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &defaultVehicle, begin, weightPeriod, false);
}
} else if (routingAlgorithm == "CHWrapper") {
const SUMOTime begin = string2time(oc.getString("begin"));
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
router = new CHRouterWrapper<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, begin, weightPeriod);
#endif // have HAVE_INTERNAL
} else {
throw ProcessError("Unknown routing Algorithm '" + routingAlgorithm + "'!");
}
} else {
DijkstraRouterEffort_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >::Operation op;
if (measure == "CO") {
op = &ROEdge::getCOEffort;
} else if (measure == "CO2") {
op = &ROEdge::getCO2Effort;
} else if (measure == "PMx") {
op = &ROEdge::getPMxEffort;
} else if (measure == "HC") {
op = &ROEdge::getHCEffort;
} else if (measure == "NOx") {
op = &ROEdge::getNOxEffort;
} else if (measure == "fuel") {
op = &ROEdge::getFuelEffort;
} else if (measure == "noise") {
op = &ROEdge::getNoiseEffort;
} else {
net.closeOutput();
throw ProcessError("Unknown measure (weight attribute '" + measure + "')!");
}
if (net.hasRestrictions()) {
router = new DijkstraRouterEffort_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), op, &ROEdge::getTravelTime);
} else {
router = new DijkstraRouterEffort_Direct<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), op, &ROEdge::getTravelTime);
}
}
// process route definitions
try {
if (routingAlgorithm == "bulkstar") {
#ifdef HAVE_INTERNAL // catchall for internal stuff
// need to load all routes for spatial aggregation
loader.processAllRoutesWithBulkRouter(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, *router);
#endif
} else {
loader.processRoutes(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, *router);
}
// end the processing
net.closeOutput();
delete router;
ROCostCalculator::cleanup();
} catch (ProcessError&) {
net.closeOutput();
delete router;
ROCostCalculator::cleanup();
throw;
}
}
void
NBEdgeCont::applyOptions(OptionsCont& oc) {
myAmLeftHanded = oc.getBool("lefthand");
// set edges dismiss/accept options
myEdgesMinSpeed = oc.isSet("keep-edges.min-speed") ? oc.getFloat("keep-edges.min-speed") : -1;
myRemoveEdgesAfterJoining = oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload");
if (oc.isSet("keep-edges.explicit")) {
const std::vector<std::string> edges = oc.getStringVector("keep-edges.explicit");
myEdges2Keep.insert(edges.begin(), edges.end());
}
if (oc.isSet("remove-edges.explicit")) {
const std::vector<std::string> edges = oc.getStringVector("remove-edges.explicit");
myEdges2Remove.insert(edges.begin(), edges.end());
}
if (oc.exists("keep-edges.by-vclass") && oc.isSet("keep-edges.by-vclass")) {
const std::vector<std::string> classes = oc.getStringVector("keep-edges.by-vclass");
for (std::vector<std::string>::const_iterator i = classes.begin(); i != classes.end(); ++i) {
myVehicleClasses2Keep |= getVehicleClassID(*i);
}
}
if (oc.exists("remove-edges.by-vclass") && oc.isSet("remove-edges.by-vclass")) {
const std::vector<std::string> classes = oc.getStringVector("remove-edges.by-vclass");
for (std::vector<std::string>::const_iterator i = classes.begin(); i != classes.end(); ++i) {
myVehicleClasses2Remove |= getVehicleClassID(*i);
}
}
if (oc.exists("keep-edges.by-type") && oc.isSet("keep-edges.by-type")) {
const std::vector<std::string> types = oc.getStringVector("keep-edges.by-type");
myTypes2Keep.insert(types.begin(), types.end());
}
if (oc.exists("remove-edges.by-type") && oc.isSet("remove-edges.by-type")) {
const std::vector<std::string> types = oc.getStringVector("remove-edges.by-type");
myTypes2Remove.insert(types.begin(), types.end());
}
if (oc.isSet("keep-edges.in-boundary") || oc.isSet("keep-edges.in-geo-boundary")) {
std::vector<std::string> polyS = oc.getStringVector(oc.isSet("keep-edges.in-boundary") ?
"keep-edges.in-boundary" : "keep-edges.in-geo-boundary");
// !!! throw something if length<4 || length%2!=0?
std::vector<SUMOReal> poly;
for (std::vector<std::string>::iterator i = polyS.begin(); i != polyS.end(); ++i) {
poly.push_back(TplConvert::_2SUMOReal((*i).c_str())); // !!! may throw something anyhow...
}
if (poly.size() < 4) {
throw ProcessError("Invalid boundary: need at least 2 coordinates");
} else if (poly.size() % 2 != 0) {
throw ProcessError("Invalid boundary: malformed coordinate");
} else if (poly.size() == 4) {
// prunning boundary (box)
myPrunningBoundary.push_back(Position(poly[0], poly[1]));
myPrunningBoundary.push_back(Position(poly[2], poly[1]));
myPrunningBoundary.push_back(Position(poly[2], poly[3]));
myPrunningBoundary.push_back(Position(poly[0], poly[3]));
} else {
for (std::vector<SUMOReal>::iterator j = poly.begin(); j != poly.end();) {
SUMOReal x = *j++;
SUMOReal y = *j++;
myPrunningBoundary.push_back(Position(x, y));
}
}
if (oc.isSet("keep-edges.in-geo-boundary")) {
NBNetBuilder::transformCoordinates(myPrunningBoundary, false);
}
}
}
void
PCLoaderArcView::load(const std::string& file, OptionsCont& oc, PCPolyContainer& toFill,
PCTypeMap&) {
#ifdef HAVE_GDAL
GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing();
// get defaults
std::string prefix = oc.getString("prefix");
std::string type = oc.getString("type");
RGBColor color = RGBColor::parseColor(oc.getString("color"));
int layer = oc.getInt("layer");
std::string idField = oc.getString("shapefile.id-column");
bool useRunningID = oc.getBool("shapefile.use-running-id");
// start parsing
std::string shpName = file + ".shp";
OGRRegisterAll();
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(shpName.c_str(), FALSE);
if (poDS == NULL) {
throw ProcessError("Could not open shape description '" + shpName + "'.");
}
// begin file parsing
OGRLayer* poLayer = poDS->GetLayer(0);
poLayer->ResetReading();
// build coordinate transformation
OGRSpatialReference* origTransf = poLayer->GetSpatialRef();
OGRSpatialReference destTransf;
// use wgs84 as destination
destTransf.SetWellKnownGeogCS("WGS84");
OGRCoordinateTransformation* poCT = OGRCreateCoordinateTransformation(origTransf, &destTransf);
if (poCT == NULL) {
if (oc.isSet("shapefile.guess-projection")) {
OGRSpatialReference origTransf2;
origTransf2.SetWellKnownGeogCS("WGS84");
poCT = OGRCreateCoordinateTransformation(&origTransf2, &destTransf);
}
if (poCT == 0) {
WRITE_WARNING("Could not create geocoordinates converter; check whether proj.4 is installed.");
}
}
OGRFeature* poFeature;
poLayer->ResetReading();
unsigned int runningID = 0;
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// read in edge attributes
std::string id = useRunningID ? toString(runningID) : poFeature->GetFieldAsString(idField.c_str());
++runningID;
id = StringUtils::prune(id);
if (id == "") {
throw ProcessError("Missing id under '" + idField + "'");
}
id = prefix + id;
// read in the geometry
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
if (poGeometry == 0) {
OGRFeature::DestroyFeature(poFeature);
continue;
}
// try transform to wgs84
poGeometry->transform(poCT);
OGRwkbGeometryType gtype = poGeometry->getGeometryType();
switch (gtype) {
case wkbPoint: {
OGRPoint* cgeom = (OGRPoint*) poGeometry;
Position pos((SUMOReal) cgeom->getX(), (SUMOReal) cgeom->getY());
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for POI '" + id + "'.");
}
PointOfInterest* poi = new PointOfInterest(id, type, color, pos, (SUMOReal)layer);
if (!toFill.insert(id, poi, layer)) {
WRITE_ERROR("POI '" + id + "' could not be added.");
delete poi;
}
}
break;
case wkbLineString: {
OGRLineString* cgeom = (OGRLineString*) poGeometry;
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(id, type, color, shape, false, (SUMOReal)layer);
if (!toFill.insert(id, poly, layer)) {
WRITE_ERROR("Polygon '" + id + "' could not be added.");
delete poly;
}
}
break;
case wkbPolygon: {
OGRLinearRing* cgeom = ((OGRPolygon*) poGeometry)->getExteriorRing();
PositionVector shape;
for (int j = 0; j < cgeom->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom->getX(j), (SUMOReal) cgeom->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + id + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(id, type, color, shape, true, (SUMOReal)layer);
if (!toFill.insert(id, poly, layer)) {
WRITE_ERROR("Polygon '" + id + "' could not be added.");
delete poly;
}
}
break;
case wkbMultiPoint: {
OGRMultiPoint* cgeom = (OGRMultiPoint*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRPoint* cgeom2 = (OGRPoint*) cgeom->getGeometryRef(i);
Position pos((SUMOReal) cgeom2->getX(), (SUMOReal) cgeom2->getY());
std::string tid = id + "#" + toString(i);
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for POI '" + tid + "'.");
}
PointOfInterest* poi = new PointOfInterest(tid, type, color, pos, (SUMOReal)layer);
if (!toFill.insert(tid, poi, layer)) {
WRITE_ERROR("POI '" + tid + "' could not be added.");
delete poi;
}
}
}
break;
case wkbMultiLineString: {
OGRMultiLineString* cgeom = (OGRMultiLineString*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRLineString* cgeom2 = (OGRLineString*) cgeom->getGeometryRef(i);
PositionVector shape;
std::string tid = id + "#" + toString(i);
for (int j = 0; j < cgeom2->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(tid, type, color, shape, false, (SUMOReal)layer);
if (!toFill.insert(tid, poly, layer)) {
WRITE_ERROR("Polygon '" + tid + "' could not be added.");
delete poly;
}
}
}
break;
case wkbMultiPolygon: {
OGRMultiPolygon* cgeom = (OGRMultiPolygon*) poGeometry;
for (int i = 0; i < cgeom->getNumGeometries(); ++i) {
OGRLinearRing* cgeom2 = ((OGRPolygon*) cgeom->getGeometryRef(i))->getExteriorRing();
PositionVector shape;
std::string tid = id + "#" + toString(i);
for (int j = 0; j < cgeom2->getNumPoints(); j++) {
Position pos((SUMOReal) cgeom2->getX(j), (SUMOReal) cgeom2->getY(j));
if (!geoConvHelper.x2cartesian(pos)) {
WRITE_ERROR("Unable to project coordinates for polygon '" + tid + "'.");
}
shape.push_back_noDoublePos(pos);
}
Polygon* poly = new Polygon(tid, type, color, shape, true, (SUMOReal)layer);
if (!toFill.insert(tid, poly, layer)) {
WRITE_ERROR("Polygon '" + tid + "' could not be added.");
delete poly;
}
}
}
break;
default:
WRITE_WARNING("Unsupported shape type occured (id='" + id + "').");
break;
}
OGRFeature::DestroyFeature(poFeature);
}
PROGRESS_DONE_MESSAGE();
#else
WRITE_ERROR("SUMO was compiled without GDAL support.");
#endif
}
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;
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods
// ---------------------------------------------------------------------------
void
NWWriter_OpenDrive::writeNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
// check whether an opendrive-file shall be generated
if (!oc.isSet("opendrive-output")) {
return;
}
const NBNodeCont& nc = nb.getNodeCont();
const NBEdgeCont& ec = nb.getEdgeCont();
const bool origNames = oc.getBool("output.original-names");
const bool lefthand = oc.getBool("lefthand");
const double straightThresh = DEG2RAD(oc.getFloat("opendrive-output.straight-threshold"));
// some internal mapping containers
int nodeID = 1;
int edgeID = nc.size() * 10; // distinct from node ids
StringBijection<int> edgeMap;
StringBijection<int> nodeMap;
//
OutputDevice& device = OutputDevice::getDevice(oc.getString("opendrive-output"));
device << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
device.openTag("OpenDRIVE");
time_t now = time(0);
std::string dstr(ctime(&now));
const Boundary& b = GeoConvHelper::getFinal().getConvBoundary();
// write header
device.openTag("header");
device.writeAttr("revMajor", "1");
device.writeAttr("revMinor", "4");
device.writeAttr("name", "");
device.writeAttr("version", "1.00");
device.writeAttr("date", dstr.substr(0, dstr.length() - 1));
device.writeAttr("north", b.ymax());
device.writeAttr("south", b.ymin());
device.writeAttr("east", b.xmax());
device.writeAttr("west", b.xmin());
/* @note obsolete in 1.4
device.writeAttr("maxRoad", ec.size());
device.writeAttr("maxJunc", nc.size());
device.writeAttr("maxPrg", 0);
*/
device.closeTag();
// write optional geo reference
const GeoConvHelper& gch = GeoConvHelper::getFinal();
if (gch.usingGeoProjection()) {
if (gch.getOffsetBase() == Position(0,0)) {
device.openTag("geoReference");
device.writePreformattedTag(" <![CDATA[\n "
+ gch.getProjString()
+ "\n]]>\n");
device.closeTag();
} else {
WRITE_WARNING("Could not write OpenDRIVE geoReference. Only unshifted Coordinate systems are supported (offset=" + toString(gch.getOffsetBase()) + ")");
}
}
// write normal edges (road)
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
const NBEdge* e = (*i).second;
const int fromNodeID = e->getIncomingEdges().size() > 0 ? getID(e->getFromNode()->getID(), nodeMap, nodeID) : INVALID_ID;
const int toNodeID = e->getConnections().size() > 0 ? getID(e->getToNode()->getID(), nodeMap, nodeID) : INVALID_ID;
writeNormalEdge(device, e,
getID(e->getID(), edgeMap, edgeID),
fromNodeID, toNodeID,
origNames, straightThresh);
}
device.lf();
// write junction-internal edges (road). In OpenDRIVE these are called 'paths' or 'connecting roads'
OutputDevice_String junctionOSS(false, 3);
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* n = (*i).second;
int connectionID = 0; // unique within a junction
const int nID = getID(n->getID(), nodeMap, nodeID);
if (n->numNormalConnections() > 0) {
junctionOSS << " <junction name=\"" << n->getID() << "\" id=\"" << nID << "\">\n";
}
std::vector<NBEdge*> incoming = (*i).second->getIncomingEdges();
if (lefthand) {
std::reverse(incoming.begin(), incoming.end());
}
for (NBEdge* inEdge : incoming) {
std::string centerMark = "none";
const int inEdgeID = getID(inEdge->getID(), edgeMap, edgeID);
// group parallel edges
const NBEdge* outEdge = 0;
bool isOuterEdge = true; // determine where a solid outer border should be drawn
int lastFromLane = -1;
std::vector<NBEdge::Connection> parallel;
std::vector<NBEdge::Connection> connections = inEdge->getConnections();
if (lefthand) {
std::reverse(connections.begin(), connections.end());
}
for (const NBEdge::Connection& c : connections) {
assert(c.toEdge != 0);
if (outEdge != c.toEdge || c.fromLane == lastFromLane) {
if (outEdge != 0) {
if (isOuterEdge) {
addPedestrianConnection(inEdge, outEdge, parallel);
}
connectionID = writeInternalEdge(device, junctionOSS, inEdge, nID,
getID(parallel.back().getInternalLaneID(), edgeMap, edgeID),
inEdgeID,
getID(outEdge->getID(), edgeMap, edgeID),
connectionID,
parallel, isOuterEdge, straightThresh, centerMark);
parallel.clear();
isOuterEdge = false;
}
outEdge = c.toEdge;
}
lastFromLane = c.fromLane;
parallel.push_back(c);
}
if (isOuterEdge) {
addPedestrianConnection(inEdge, outEdge, parallel);
}
if (!parallel.empty()) {
if (!lefthand && (n->geometryLike() || inEdge->isTurningDirectionAt(outEdge))) {
centerMark = "solid";
}
connectionID = writeInternalEdge(device, junctionOSS, inEdge, nID,
getID(parallel.back().getInternalLaneID(), edgeMap, edgeID),
inEdgeID,
getID(outEdge->getID(), edgeMap, edgeID),
connectionID,
parallel, isOuterEdge, straightThresh, centerMark);
parallel.clear();
}
}
if (n->numNormalConnections() > 0) {
junctionOSS << " </junction>\n";
}
}
device.lf();
// write junctions (junction)
device << junctionOSS.getString();
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* n = (*i).second;
const std::vector<NBEdge*>& incoming = n->getIncomingEdges();
// check if any connections must be written
int numConnections = 0;
for (std::vector<NBEdge*>::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
numConnections += (int)((*j)->getConnections().size());
}
if (numConnections == 0) {
continue;
}
for (std::vector<NBEdge*>::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
const NBEdge* inEdge = *j;
const std::vector<NBEdge::Connection>& elv = inEdge->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
const NBEdge::Connection& c = *k;
const NBEdge* outEdge = c.toEdge;
if (outEdge == 0) {
continue;
}
}
}
}
device.closeTag();
device.close();
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet& net, ROLoader& loader, OptionsCont& oc) {
// initialise the loader
loader.openRoutes(net);
// build the router
auto ttFunction = gWeightsRandomFactor > 1 ? &ROEdge::getTravelTimeStaticRandomized : &ROEdge::getTravelTimeStatic;
SUMOAbstractRouter<ROEdge, ROVehicle>* router;
const std::string measure = oc.getString("weight-attribute");
const std::string routingAlgorithm = oc.getString("routing-algorithm");
const SUMOTime begin = string2time(oc.getString("begin"));
const SUMOTime end = string2time(oc.getString("end"));
if (measure == "traveltime") {
if (routingAlgorithm == "dijkstra") {
if (net.hasPermissions()) {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction);
} else {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction);
}
} else if (routingAlgorithm == "astar") {
if (net.hasPermissions()) {
typedef AStarRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> > AStar;
std::shared_ptr<const AStar::LookupTable> lookup;
if (oc.isSet("astar.all-distances")) {
lookup = std::make_shared<const AStar::FLT>(oc.getString("astar.all-distances"), (int)ROEdge::getAllEdges().size());
} else if (oc.isSet("astar.landmark-distances")) {
CHRouterWrapper<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> > router(
ROEdge::getAllEdges(), true, &ROEdge::getTravelTimeStatic,
begin, end, std::numeric_limits<int>::max(), 1);
ROVehicle defaultVehicle(SUMOVehicleParameter(), nullptr, net.getVehicleTypeSecure(DEFAULT_VTYPE_ID), &net);
lookup = std::make_shared<const AStar::LMLT>(oc.getString("astar.landmark-distances"), ROEdge::getAllEdges(), &router, &defaultVehicle,
oc.isSet("astar.save-landmark-distances") ? oc.getString("astar.save-landmark-distances") : "", oc.getInt("routing-threads"));
}
router = new AStar(ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction, lookup);
} else {
typedef AStarRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> > AStar;
std::shared_ptr<const AStar::LookupTable> lookup;
if (oc.isSet("astar.all-distances")) {
lookup = std::make_shared<const AStar::FLT>(oc.getString("astar.all-distances"), (int)ROEdge::getAllEdges().size());
} else if (oc.isSet("astar.landmark-distances")) {
CHRouterWrapper<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> > router(
ROEdge::getAllEdges(), true, &ROEdge::getTravelTimeStatic,
begin, end, std::numeric_limits<int>::max(), 1);
ROVehicle defaultVehicle(SUMOVehicleParameter(), nullptr, net.getVehicleTypeSecure(DEFAULT_VTYPE_ID), &net);
lookup = std::make_shared<const AStar::LMLT>(oc.getString("astar.landmark-distances"), ROEdge::getAllEdges(), &router, &defaultVehicle,
oc.isSet("astar.save-landmark-distances") ? oc.getString("astar.save-landmark-distances") : "", oc.getInt("routing-threads"));
}
router = new AStar(ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction, lookup);
}
} else if (routingAlgorithm == "CH") {
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
if (net.hasPermissions()) {
router = new CHRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic, SVC_IGNORING, weightPeriod, true);
} else {
router = new CHRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic, SVC_IGNORING, weightPeriod, false);
}
} else if (routingAlgorithm == "CHWrapper") {
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
router = new CHRouterWrapper<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic,
begin, end, weightPeriod, oc.getInt("routing-threads"));
} else {
throw ProcessError("Unknown routing Algorithm '" + routingAlgorithm + "'!");
}
} else {
DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >::Operation op;
if (measure == "CO") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::CO>;
} else if (measure == "CO2") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::CO2>;
} else if (measure == "PMx") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::PM_X>;
} else if (measure == "HC") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::HC>;
} else if (measure == "NOx") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::NO_X>;
} else if (measure == "fuel") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::FUEL>;
} else if (measure == "electricity") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::ELEC>;
} else if (measure == "noise") {
op = &ROEdge::getNoiseEffort;
} else {
throw ProcessError("Unknown measure (weight attribute '" + measure + "')!");
}
if (net.hasPermissions()) {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), op, ttFunction);
} else {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), op, ttFunction);
}
}
int carWalk = 0;
for (const std::string& opt : oc.getStringVector("persontrip.transfer.car-walk")) {
if (opt == "parkingAreas") {
carWalk |= ROIntermodalRouter::Network::PARKING_AREAS;
} else if (opt == "ptStops") {
carWalk |= ROIntermodalRouter::Network::PT_STOPS;
} else if (opt == "allJunctions") {
carWalk |= ROIntermodalRouter::Network::ALL_JUNCTIONS;
}
}
RORouterProvider provider(router, new PedestrianRouter<ROEdge, ROLane, RONode, ROVehicle>(),
new ROIntermodalRouter(RONet::adaptIntermodalRouter, carWalk, routingAlgorithm));
// process route definitions
try {
net.openOutput(oc);
loader.processRoutes(begin, end, string2time(oc.getString("route-steps")), net, provider);
net.writeIntermodal(oc, provider.getIntermodalRouter());
// end the processing
net.cleanup();
} catch (ProcessError&) {
net.cleanup();
throw;
}
}
void
PCLoaderDlrNavteq::loadPolyFile(const std::string& file,
OptionsCont& oc, PCPolyContainer& toFill,
PCTypeMap& tm) {
// get the defaults
RGBColor c = RGBColor::parseColor(oc.getString("color"));
// attributes of the poly
// parse
int l = 0;
LineReader lr(file);
while (lr.hasMore()) {
std::string line = lr.readLine();
++l;
// skip invalid/empty lines
if (line.length() == 0 || line.find("#") != std::string::npos) {
continue;
}
if (StringUtils::prune(line) == "") {
continue;
}
// parse the poi
StringTokenizer st(line, "\t");
std::vector<std::string> values = st.getVector();
if (values.size() < 6 || values.size() % 2 != 0) {
throw ProcessError("Invalid dlr-navteq-polygon - line: '" + line + "'.");
}
std::string id = values[0];
std::string ort = values[1];
std::string type = values[2];
std::string name = values[3];
PositionVector vec;
size_t index = 4;
// now collect the positions
while (values.size() > index) {
std::string xpos = values[index];
std::string ypos = values[index + 1];
index += 2;
SUMOReal x = TplConvert::_2SUMOReal(xpos.c_str());
SUMOReal y = TplConvert::_2SUMOReal(ypos.c_str());
Position pos(x, y);
if (!GeoConvHelper::getProcessing().x2cartesian(pos)) {
WRITE_WARNING("Unable to project coordinates for polygon '" + id + "'.");
}
vec.push_back(pos);
}
name = StringUtils::convertUmlaute(name);
if (name == "noname" || toFill.containsPolygon(name)) {
name = name + "#" + toString(toFill.getEnumIDFor(name));
}
// check the polygon
if (vec.size() == 0) {
WRITE_WARNING("The polygon '" + id + "' is empty.");
continue;
}
if (id == "") {
WRITE_WARNING("The name of a polygon is missing; it will be discarded.");
continue;
}
// patch the values
bool fill = vec.front() == vec.back();
bool discard = oc.getBool("discard");
int layer = oc.getInt("layer");
RGBColor color;
if (tm.has(type)) {
const PCTypeMap::TypeDef& def = tm.get(type);
name = def.prefix + name;
type = def.id;
color = def.color;
fill = fill && def.allowFill;
discard = def.discard;
layer = def.layer;
} else {
name = oc.getString("prefix") + name;
type = oc.getString("type");
color = c;
}
if (!discard) {
Polygon* poly = new Polygon(name, type, color, vec, fill, (SUMOReal)layer);
toFill.insert(name, poly, layer);
}
vec.clear();
}
}
