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
// ===========================================================================
// ---------------------------------------------------------------------------
// 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
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"));
}
}
// ===========================================================================
// 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";
}
}
}
/**
* 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);
}
}
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 SUMOReal geoScale = pow(10.0f, haveGeo ? 5 : 2); // see NIImporter_DlrNavteq::GEO_SCALE
device.setPrecision(0);
// 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";
}
}
}
}
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();
}
/**
* 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_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);
}
void
ODMatrix::loadMatrix(OptionsCont& oc) {
std::vector<std::string> files = oc.getStringVector("od-matrix-files");
for (std::vector<std::string>::iterator i = files.begin(); i != files.end(); ++i) {
LineReader lr(*i);
if (!lr.good()) {
throw ProcessError("Could not open '" + (*i) + "'.");
}
std::string type = lr.readLine();
// get the type only
if (type.find(';') != std::string::npos) {
type = type.substr(0, type.find(';'));
}
// parse type-dependant
if (type.length() > 1 && type[1] == 'V') {
// process ptv's 'V'-matrices
if (type.find('N') != std::string::npos) {
throw ProcessError("'" + *i + "' does not contain the needed information about the time described.");
}
readV(lr, oc.getFloat("scale"), oc.getString("vtype"), type.find('M') != std::string::npos);
} else if (type.length() > 1 && type[1] == 'O') {
// process ptv's 'O'-matrices
if (type.find('N') != std::string::npos) {
throw ProcessError("'" + *i + "' does not contain the needed information about the time described.");
}
readO(lr, oc.getFloat("scale"), oc.getString("vtype"), type.find('M') != std::string::npos);
} else {
throw ProcessError("'" + *i + "' uses an unknown matrix type '" + type + "'.");
}
}
std::vector<std::string> amitranFiles = oc.getStringVector("od-amitran-files");
for (std::vector<std::string>::iterator i = amitranFiles.begin(); i != amitranFiles.end(); ++i) {
if (!FileHelpers::isReadable(*i)) {
throw ProcessError("Could not access matrix file '" + *i + "' to load.");
}
PROGRESS_BEGIN_MESSAGE("Loading matrix in Amitran format from '" + *i + "'");
ODAmitranHandler handler(*this, *i);
if (!XMLSubSys::runParser(handler, *i)) {
PROGRESS_FAILED_MESSAGE();
} else {
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,
const std::vector<SUMOReal> &turnDefs) {
// load the net
ROJTREdgeBuilder builder;
loader.loadNet(net, builder);
// set the turn defaults
const std::map<std::string, ROEdge*> &edges = net.getEdgeMap();
for (std::map<std::string, ROEdge*>::const_iterator i=edges.begin(); i!=edges.end(); ++i) {
static_cast<ROJTREdge*>((*i).second)->setTurnDefaults(turnDefs);
}
// load the weights when wished/available
if (oc.isSet("weights")) {
loader.loadWeights(net, "weights", oc.getString("measure"), false);
}
if (oc.isSet("lane-weights")) {
loader.loadWeights(net, "lane-weights", oc.getString("measure"), true);
}
}
void
readDetectorFlows(RODFDetectorFlows& flows, OptionsCont& oc, RODFDetectorCon& dc) {
if (!oc.isSet("measure-files")) {
// ok, not given, return an empty container
return;
}
// check whether the file exists
std::vector<std::string> files = oc.getStringVector("measure-files");
for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
if (!FileHelpers::exists(*fileIt)) {
throw ProcessError("The measure-file '" + *fileIt + "' can not be opened.");
}
// parse
PROGRESS_BEGIN_MESSAGE("Loading flows from '" + *fileIt + "'");
RODFDetFlowLoader dfl(dc, flows, string2time(oc.getString("begin")), string2time(oc.getString("end")),
string2time(oc.getString("time-offset")), string2time(oc.getString("time-factor")));
dfl.read(*fileIt);
PROGRESS_DONE_MESSAGE();
}
}
void
NWWriter_DlrNavteq::writeProhibitedManoeuvres(const OptionsCont& oc, const NBNodeCont& nc, const NBEdgeCont& ec) {
OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_prohibited_manoeuvres.txt");
writeHeader(device, oc);
// need to invent id for relation
std::set<std::string> reservedRelIDs;
if (oc.isSet("reserved-ids")) {
NBHelpers::loadPrefixedIDsFomFile(oc.getString("reserved-ids"), "rel:", reservedRelIDs);
}
std::vector<std::string> avoid = ec.getAllNames(); // already used for tls RELATREC_ID
avoid.insert(avoid.end(), reservedRelIDs.begin(), reservedRelIDs.end());
IDSupplier idSupplier("", avoid); // @note: use a global relRecIDsupplier if this is used more often
// write format specifier
device << "#No driving allowed from ID1 to ID2 or the complete chain from ID1 to IDn\n";
device << "#RELATREC_ID\tPERMANENT_ID_INFO\tVALIDITY_PERIOD\tTHROUGH_TRAFFIC\tVEHICLE_TYPE\tNAVTEQ_LINK_ID1\t[NAVTEQ_LINK_ID2 ...]\n";
// write record for every pair of incoming/outgoing edge that are not connected despite having common permissions
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* n = (*i).second;
const EdgeVector& incoming = n->getIncomingEdges();
const EdgeVector& outgoing = n->getOutgoingEdges();
for (EdgeVector::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
NBEdge* inEdge = *j;
const SVCPermissions inPerm = inEdge->getPermissions();
for (EdgeVector::const_iterator k = outgoing.begin(); k != outgoing.end(); ++k) {
NBEdge* outEdge = *k;
const SVCPermissions outPerm = outEdge->getPermissions();
const SVCPermissions commonPerm = inPerm & outPerm;
if (commonPerm != 0 && commonPerm != SVC_PEDESTRIAN && !inEdge->isConnectedTo(outEdge)) {
device
<< idSupplier.getNext() << "\t"
<< 1 << "\t" // permanent id
<< UNDEFINED << "\t"
<< 1 << "\t"
<< getAllowedTypes(SVCAll) << "\t"
<< inEdge->getID() << "\t" << outEdge->getID() << "\n";
}
}
}
}
device.close();
}
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
// ===========================================================================
// ---------------------------------------------------------------------------
// 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::writeStreetSigns(const OptionsCont& oc, NBEdgeCont& ec) {
OutputDevice& device = OutputDevice::getDevice(oc.getString("street-sign-output"));
device.writeXMLHeader("pois", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/poi_file.xsd\"");
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
NBEdge* e = (*i).second;
const std::vector<NBSign>& signs = e->getSigns();
for (std::vector<NBSign>::const_iterator it = signs.begin(); it != signs.end(); ++it) {
it->writeAsPOI(device, e);
}
}
device.close();
}
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
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();
}
}
void
NWWriter_DlrNavteq::writeNodesUnsplitted(const OptionsCont& oc, NBNodeCont& nc, NBEdgeCont& ec) {
// For "real" nodes we simply use the node id.
// For internal nodes (geometry vectors describing edge geometry in the parlance of this format)
// we use the id of the edge and do not bother with
// compression (each direction gets its own internal node).
// XXX add option for generating numerical ids in case the input network has string ids and the target process needs integers
OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_nodes_unsplitted.txt");
writeHeader(device, oc);
const GeoConvHelper& gch = GeoConvHelper::getFinal();
const bool haveGeo = gch.usingGeoProjection();
const SUMOReal geoScale = pow(10.0f, haveGeo ? 5 : 2); // see NIImporter_DlrNavteq::GEO_SCALE
device.setPrecision(0);
if (!haveGeo) {
WRITE_WARNING("DlrNavteq node data will be written in (floating point) cartesian coordinates");
}
// write format specifier
device << "# NODE_ID\tIS_BETWEEN_NODE\tamount_of_geocoordinates\tx1\ty1\t[x2 y2 ... xn yn]\n";
// write normal nodes
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* n = (*i).second;
Position pos = n->getPosition();
gch.cartesian2geo(pos);
pos.mul(geoScale);
device << n->getID() << "\t0\t1\t" << pos.x() << "\t" << pos.y() << "\n";
}
// write "internal" nodes
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
NBEdge* e = (*i).second;
const PositionVector& geom = e->getGeometry();
if (geom.size() > 2) {
std::string internalNodeID = e->getID();
if (internalNodeID == UNDEFINED ||
(nc.retrieve(internalNodeID) != 0)) {
// need to invent a new name to avoid clashing with the id of a 'real' node or a reserved name
internalNodeID += "_geometry";
}
device << internalNodeID << "\t1\t" << geom.size() - 2;
for (size_t ii = 1; ii < geom.size() - 1; ++ii) {
Position pos = geom[(int)ii];
gch.cartesian2geo(pos);
pos.mul(geoScale);
device << "\t" << pos.x() << "\t" << pos.y();
}
device << "\n";
}
}
device.close();
}
/**
* 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();
}
void
NWWriter_XML::writeTrafficLights(const OptionsCont& oc, NBTrafficLightLogicCont& tc, NBEdgeCont& ec) {
OutputDevice& device = OutputDevice::getDevice(oc.getString("plain-output-prefix") + ".tll.xml");
device.writeXMLHeader("tlLogics", NWFrame::MAJOR_VERSION + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://sumo-sim.org/xsd/tllogic_file.xsd\"");
NWWriter_SUMO::writeTrafficLights(device, tc);
// we also need to remember the associations between tlLogics and connections
// since the information in con.xml is insufficient
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
NBEdge* e = (*i).second;
// write this edge's tl-controlled connections
const std::vector<NBEdge::Connection> connections = e->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator c = connections.begin(); c != connections.end(); ++c) {
if (c->tlID != "") {
NWWriter_SUMO::writeConnection(device, *e, *c, false, NWWriter_SUMO::TLL);
}
}
}
device.close();
}
void
NWWriter_XML::writeJoinedJunctions(const OptionsCont& oc, NBNodeCont& nc) {
OutputDevice& device = OutputDevice::getDevice(oc.getString("junctions.join-output"));
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\"");
const std::vector<std::set<std::string> >& clusters = nc.getJoinedClusters();
for (std::vector<std::set<std::string> >::const_iterator it = clusters.begin(); it != clusters.end(); it++) {
assert((*it).size() > 0);
device.openTag(SUMO_TAG_JOIN);
// prepare string
std::ostringstream oss;
for (std::set<std::string>::const_iterator it_id = it->begin(); it_id != it->end(); it_id++) {
oss << *it_id << " ";
}
// remove final space
std::string ids = oss.str();
device.writeAttr(SUMO_ATTR_NODES, ids.substr(0, ids.size() - 1));
device.closeTag();
}
device.close();
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods
// ---------------------------------------------------------------------------
void
NWWriter_MATSim::writeNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
// check whether a matsim-file shall be generated
if (!oc.isSet("matsim-output")) {
return;
}
OutputDevice& device = OutputDevice::getDevice(oc.getString("matsim-output"));
device << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
device << "<!DOCTYPE network SYSTEM \"http://www.matsim.org/files/dtd/network_v1.dtd\">\n\n";
device << "<network name=\"NAME\">\n"; // !!! name
// write nodes
device << " <nodes>\n";
NBNodeCont& nc = nb.getNodeCont();
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
device << " <node id=\"" << (*i).first
<< "\" x=\"" << (*i).second->getPosition().x()
<< "\" y=\"" << (*i).second->getPosition().y()
<< "\"/>\n";
}
device << " </nodes>\n";
// write edges
device << " <links capperiod=\"01:00:00\">\n";
NBEdgeCont& ec = nb.getEdgeCont();
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
device << " <link id=\"" << (*i).first
<< "\" from=\"" << (*i).second->getFromNode()->getID()
<< "\" to=\"" << (*i).second->getToNode()->getID()
<< "\" length=\"" << (*i).second->getLoadedLength()
<< "\" capacity=\"" << (oc.getFloat("lanes-from-capacity.norm") * (*i).second->getNumLanes())
<< "\" freespeed=\"" << (*i).second->getSpeed()
<< "\" permlanes=\"" << (*i).second->getNumLanes()
<< "\"/>\n";
}
device << " </links>\n";
//
device << "</network>\n"; // !!! name
device.close();
}
void
loadJTRDefinitions(RONet &net, OptionsCont &oc) {
// load the turning definitions (and possible sink definition)
if (oc.isSet("turn-definition")) {
ROJTRTurnDefLoader loader(net);
if (!XMLSubSys::runParser(loader, oc.getString("turn-definition"))) {
throw ProcessError();
}
}
if (MsgHandler::getErrorInstance()->wasInformed() && oc.getBool("dismiss-loading-errors")) {
MsgHandler::getErrorInstance()->clear();
}
// parse sink edges specified at the input/within the configuration
if (oc.isSet("sinks")) {
std::vector<std::string> edges = oc.getStringVector("sinks");
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->setType(ROEdge::ET_SINK);
}
}
}
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
}
// ===========================================================================
// 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();
}
}
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
}
// ===========================================================================
// 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);
// 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;
}
}
