void
ROPerson::addTrip(const ROEdge* const from, const ROEdge* const to, const SVCPermissions modeSet,
const std::string& vTypes, const double departPos, const double arrivalPos, const std::string& busStop, double walkFactor) {
PersonTrip* trip = new PersonTrip(from, to, modeSet, departPos, arrivalPos, busStop, walkFactor);
RONet* net = RONet::getInstance();
SUMOVehicleParameter pars;
pars.departProcedure = DEPART_TRIGGERED;
for (StringTokenizer st(vTypes); st.hasNext();) {
pars.vtypeid = st.next();
pars.parametersSet |= VEHPARS_VTYPE_SET;
SUMOVTypeParameter* type = net->getVehicleTypeSecure(pars.vtypeid);
if (type == nullptr) {
delete trip;
throw InvalidArgument("The vehicle type '" + pars.vtypeid + "' in a trip for person '" + getID() + "' is not known.");
}
pars.id = getID() + "_" + toString(trip->getVehicles().size());
trip->addVehicle(new ROVehicle(pars, new RORouteDef("!" + pars.id, 0, false, false), type, net));
}
if (trip->getVehicles().empty()) {
if ((modeSet & SVC_PASSENGER) != 0) {
pars.id = getID() + "_0";
trip->addVehicle(new ROVehicle(pars, new RORouteDef("!" + pars.id, 0, false, false), net->getVehicleTypeSecure(DEFAULT_VTYPE_ID), net));
}
if ((modeSet & SVC_BICYCLE) != 0) {
pars.id = getID() + "_b0";
pars.vtypeid = DEFAULT_BIKETYPE_ID;
pars.parametersSet |= VEHPARS_VTYPE_SET;
trip->addVehicle(new ROVehicle(pars, new RORouteDef("!" + pars.id, 0, false, false), net->getVehicleTypeSecure(DEFAULT_BIKETYPE_ID), net));
}
}
myPlan.push_back(trip);
}
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();
}
}
}
void
ROLoader::processAllRoutesWithBulkRouter(SUMOTime /* start */, SUMOTime end,
RONet& net, SUMOAbstractRouter<ROEdge, ROVehicle>& router) {
myLoaders.loadNext(SUMOTime_MAX);
RouteAggregator::processAllRoutes(net, router);
net.saveAndRemoveRoutesUntil(myOptions, router, end);
}
void
ROLoader::openRoutes(RONet& net) {
// build loader
// load relevant elements from additinal file
bool ok = openTypedRoutes("additional-files", net);
// load sumo-routes when wished
ok &= openTypedRoutes("route-files", net);
// load the XML-trip definitions when wished
ok &= openTypedRoutes("trip-files", net);
// load the sumo-alternative file when wished
ok &= openTypedRoutes("alternative-files", net);
// load the amount definitions if wished
ok &= openTypedRoutes("flow-files", net);
// check
if (ok) {
myLoaders.loadNext(string2time(myOptions.getString("begin")));
if (!MsgHandler::getErrorInstance()->wasInformed() && !net.furtherStored()) {
throw ProcessError("No route input specified or all routes were invalid.");
}
// skip routes prior to the begin time
if (!myOptions.getBool("unsorted-input")) {
WRITE_MESSAGE("Skipped until: " + time2string(myLoaders.getFirstLoadTime()));
}
}
}
/**
* 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();
}
/**
* 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,
const std::vector<double>& turnDefs) {
// load the net
ROJTREdgeBuilder builder;
loader.loadNet(net, builder);
// set the turn defaults
for (const auto& i : net.getEdgeMap()) {
static_cast<ROJTREdge*>(i.second)->setTurnDefaults(turnDefs);
}
}
/**
* 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,
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);
}
}
void
ROLoader::processRoutes(SUMOTime start, SUMOTime end,
RONet& net, SUMOAbstractRouter<ROEdge, ROVehicle>& router) {
SUMOTime absNo = end - start;
// skip routes that begin before the simulation's begin
// loop till the end
bool endReached = false;
bool errorOccured = false;
const SUMOTime firstStep = myLoaders.getFirstLoadTime();
SUMOTime lastStep = firstStep;
for (SUMOTime time = firstStep; time < end && !errorOccured && !endReached; time += DELTA_T) {
writeStats(time, start, absNo);
myLoaders.loadNext(time);
net.saveAndRemoveRoutesUntil(myOptions, router, time);
endReached = !net.furtherStored();
lastStep = time;
errorOccured = MsgHandler::getErrorInstance()->wasInformed() && !myOptions.getBool("ignore-errors");
}
if (myLogSteps) {
WRITE_MESSAGE("Routes found between time steps " + time2string(firstStep) + " and " + time2string(lastStep) + ".");
}
}
/**
* 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();
}
/**
* 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);
}
}
bool
ROLoader::loadWeights(RONet& net, const std::string& optionName,
const std::string& measure, bool useLanes) {
// check whether the file exists
if (!myOptions.isUsableFileList(optionName)) {
return false;
}
// build and prepare the weights handler
std::vector<SAXWeightsHandler::ToRetrieveDefinition*> retrieverDefs;
// travel time, first (always used)
EdgeFloatTimeLineRetriever_EdgeTravelTime ttRetriever(net);
retrieverDefs.push_back(new SAXWeightsHandler::ToRetrieveDefinition("traveltime", !useLanes, ttRetriever));
// the measure to use, then
EdgeFloatTimeLineRetriever_EdgeWeight eRetriever(net);
if (measure != "traveltime") {
std::string umeasure = measure;
if (measure == "CO" || measure == "CO2" || measure == "HC" || measure == "PMx" || measure == "NOx" || measure == "fuel") {
umeasure = measure + "_perVeh";
}
retrieverDefs.push_back(new SAXWeightsHandler::ToRetrieveDefinition(umeasure, !useLanes, eRetriever));
}
// set up handler
SAXWeightsHandler handler(retrieverDefs, "");
// go through files
std::vector<std::string> files = myOptions.getStringVector(optionName);
for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
PROGRESS_BEGIN_MESSAGE("Loading precomputed net weights from '" + *fileIt + "'");
if (XMLSubSys::runParser(handler, *fileIt)) {
PROGRESS_DONE_MESSAGE();
} else {
WRITE_MESSAGE("failed.");
return false;
}
}
// build edge-internal time lines
const std::map<std::string, ROEdge*>& edges = net.getEdgeMap();
for (std::map<std::string, ROEdge*>::const_iterator i = edges.begin(); i != edges.end(); ++i) {
(*i).second->buildTimeLines(measure);
}
return true;
}
/**
* 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;
}
}
/**
* 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;
}
}