bool
GNELoadThread::initOptions() {
OptionsCont& oc = OptionsCont::getOptions();
fillOptions(oc);
if (myFile != "") {
if (myLoadNet) {
oc.set("sumo-net-file", myFile);
} else {
oc.set("configuration-file", myFile);
}
}
setDefaultOptions(oc);
try {
OptionsIO::getOptions();
if (!oc.isSet("output-file")) {
oc.set("output-file", oc.getString("sumo-net-file"));
}
return true;
} catch (ProcessError& e) {
if (std::string(e.what()) != std::string("Process Error") && std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
WRITE_ERROR("Failed to parse options.");
}
return false;
}
/* -------------------------------------------------------------------------
* main
* ----------------------------------------------------------------------- */
int
main(int argc, char** argv) {
OptionsCont& oc = OptionsCont::getOptions();
// give some application descriptions
oc.setApplicationDescription("Road network importer / builder for the road traffic simulation SUMO.");
oc.setApplicationName("netconvert", "SUMO netconvert Version " + (std::string)VERSION_STRING);
int ret = 0;
try {
XMLSubSys::init(false);
fillOptions();
OptionsIO::getOptions(true, argc, argv);
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
MsgHandler::initOutputOptions();
if (!checkOptions()) {
throw ProcessError();
}
RandHelper::initRandGlobal();
NBNetBuilder nb;
nb.applyOptions(oc);
// load data
NILoader nl(nb);
nl.load(oc);
if (oc.getBool("ignore-errors")) {
MsgHandler::getErrorInstance()->clear();
}
// check whether any errors occured
if (MsgHandler::getErrorInstance()->wasInformed()) {
throw ProcessError();
}
nb.compute(oc);
if(oc.getAnyVerbosity())
std::cout<<"Writing output file..."<<std::endl;
NWFrame::writeNetwork(oc, nb);
if(oc.getAnyVerbosity())
std::cout<<"Output file writed"<<std::endl;
} catch (ProcessError& e) {
if (std::string(e.what()) != std::string("Process Error") && std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
NBDistribution::clear();
OutputDevice::closeAll();
SystemFrame::close();
// report about ending
if (ret == 0) {
std::cout << "Success." << std::endl;
}
return ret;
}
int
main(int argc, char** argv) {
OptionsCont& oc = OptionsCont::getOptions();
// give some application descriptions
oc.setApplicationDescription("Road network generator for the microscopic road traffic simulation SUMO.");
oc.setApplicationName("netgen", "SUMO netgen Version " + (std::string)VERSION_STRING);
int ret = 0;
try {
// initialise the application system (messaging, xml, options)
XMLSubSys::init(false);
fillOptions();
OptionsIO::getOptions(true, argc, argv);
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
MsgHandler::initOutputOptions();
if (!checkOptions()) {
throw ProcessError();
}
RandHelper::initRandGlobal();
NBNetBuilder nb;
nb.applyOptions(oc);
// build the netgen-network description
NGNet* net = buildNetwork(nb);
// ... and we have to do this...
oc.resetWritable();
// transfer to the netbuilding structures
net->toNB();
delete net;
// report generated structures
WRITE_MESSAGE(" Generation done;");
WRITE_MESSAGE(" " + toString<int>(nb.getNodeCont().size()) + " nodes generated.");
WRITE_MESSAGE(" " + toString<int>(nb.getEdgeCont().size()) + " edges generated.");
nb.compute(oc);
NWFrame::writeNetwork(oc, nb);
} catch (ProcessError& e) {
if (std::string(e.what()) != std::string("Process Error") && std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
OutputDevice::closeAll();
SystemFrame::close();
if (ret == 0) {
std::cout << "Success." << std::endl;
}
return ret;
}
choseWaveToExtract::choseWaveToExtract(QWidget *parent) :
QDialog(parent),
ui(new Ui::choseWaveToExtract)
{
ui->setupUi(this);
funcGetCalibration(&daCalib);
fillOptions();
}
/* -------------------------------------------------------------------------
* main
* ----------------------------------------------------------------------- */
int
main(int argc, char** argv) {
OptionsCont& oc = OptionsCont::getOptions();
// give some application descriptions
oc.setApplicationDescription("Network importer / builder for the microscopic, multi-modal traffic simulation SUMO.");
oc.setApplicationName("netconvert", "Eclipse SUMO netconvert Version " VERSION_STRING);
int ret = 0;
try {
XMLSubSys::init();
fillOptions();
OptionsIO::setArgs(argc, argv);
OptionsIO::getOptions();
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
XMLSubSys::setValidation(oc.getString("xml-validation"), oc.getString("xml-validation.net"));
MsgHandler::initOutputOptions();
if (!checkOptions()) {
throw ProcessError();
}
RandHelper::initRandGlobal();
// build the projection
if (!GeoConvHelper::init(oc)) {
throw ProcessError("Could not build projection!");
}
NBNetBuilder nb;
nb.applyOptions(oc);
// load data
NILoader nl(nb);
nl.load(oc);
if (oc.getBool("ignore-errors")) {
MsgHandler::getErrorInstance()->clear();
}
// check whether any errors occurred
if (MsgHandler::getErrorInstance()->wasInformed()) {
throw ProcessError();
}
nb.compute(oc);
// check whether any errors occurred
if (MsgHandler::getErrorInstance()->wasInformed()) {
throw ProcessError();
}
NWFrame::writeNetwork(oc, nb);
} catch (const ProcessError& e) {
if (std::string(e.what()) != std::string("Process Error") && std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (const std::exception& e) {
if (std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
DistributionCont::clear();
SystemFrame::close();
// report about ending
if (ret == 0) {
std::cout << "Success." << std::endl;
}
return ret;
}
/* -------------------------------------------------------------------------
* main
* ----------------------------------------------------------------------- */
int
main(int argc, char** argv) {
OptionsCont& oc = OptionsCont::getOptions();
// give some application descriptions
oc.setApplicationDescription("Importer of O/D-matrices for the road traffic simulation SUMO.");
oc.setApplicationName("od2trips", "SUMO od2trips Version " + (std::string)VERSION_STRING);
int ret = 0;
try {
// initialise subsystems
XMLSubSys::init();
fillOptions();
OptionsIO::getOptions(true, argc, argv);
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
XMLSubSys::setValidation(oc.getString("xml-validation"), oc.getString("xml-validation.net"));
MsgHandler::initOutputOptions();
if (!checkOptions()) {
throw ProcessError();
}
RandHelper::initRandGlobal();
// load the districts
// check whether the user gave a net filename
if (!oc.isSet("net-file")) {
throw ProcessError("You must supply a network or districts file ('-n').");
}
// get the file name and set it
ODDistrictCont districts;
districts.loadDistricts(oc.getString("net-file"));
if (districts.size() == 0) {
throw ProcessError("No districts loaded.");
}
// load the matrix
ODMatrix matrix(districts);
matrix.loadMatrix(oc);
if (matrix.getNoLoaded() == 0) {
throw ProcessError("No vehicles loaded.");
}
if (MsgHandler::getErrorInstance()->wasInformed() && !oc.getBool("ignore-errors")) {
throw ProcessError("Loading failed.");
}
WRITE_MESSAGE(toString(matrix.getNoLoaded()) + " vehicles loaded.");
// apply a curve if wished
if (oc.isSet("timeline")) {
matrix.applyCurve(matrix.parseTimeLine(oc.getStringVector("timeline"), oc.getBool("timeline.day-in-hours")));
}
// write
bool haveOutput = false;
if (OutputDevice::createDeviceByOption("output-file", "routes", "routes_file.xsd")) {
matrix.write(string2time(oc.getString("begin")), string2time(oc.getString("end")),
OutputDevice::getDeviceByOption("output-file"),
oc.getBool("spread.uniform"), oc.getBool("ignore-vehicle-type"),
oc.getString("prefix"), !oc.getBool("no-step-log"));
haveOutput = true;
}
if (OutputDevice::createDeviceByOption("flow-output", "routes", "routes_file.xsd")) {
matrix.writeFlows(string2time(oc.getString("begin")), string2time(oc.getString("end")),
OutputDevice::getDeviceByOption("flow-output"),
oc.getBool("ignore-vehicle-type"), oc.getString("prefix"));
haveOutput = true;
}
if (!haveOutput) {
throw ProcessError("No output file given.");
}
WRITE_MESSAGE(toString(matrix.getNoDiscarded()) + " vehicles discarded.");
WRITE_MESSAGE(toString(matrix.getNoWritten()) + " vehicles written.");
} catch (const ProcessError& e) {
if (std::string(e.what()) != std::string("Process Error") && std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (const std::exception& e) {
if (std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
SystemFrame::close();
if (ret == 0) {
std::cout << "Success." << std::endl;
}
return ret;
}
int
main(int argc, char **argv) {
OptionsCont &oc = OptionsCont::getOptions();
oc.setApplicationDescription("Importer of polygons and POIs for the road traffic simulation SUMO.");
oc.setApplicationName("polyconvert", "SUMO polyconvert Version " + (std::string)VERSION_STRING);
int ret = 0;
try {
// initialise subsystems
XMLSubSys::init(false);
fillOptions();
OptionsIO::getOptions(true, argc, argv);
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
MsgHandler::initOutputOptions();
// build the projection
Boundary origNetBoundary, pruningBoundary;
Position2D netOffset;
std::string proj;
PCNetProjectionLoader::loadIfSet(oc, netOffset, origNetBoundary, pruningBoundary, proj);
if (proj != "") {
if (oc.isDefault("proj")) {
oc.set("proj", proj);
}
if (oc.isDefault("x-offset-to-apply")) {
oc.set("x-offset-to-apply", toString(netOffset.x()));
}
if (oc.isDefault("y-offset-to-apply")) {
oc.set("y-offset-to-apply", toString(netOffset.y()));
}
}
#ifdef HAVE_PROJ
unsigned numProjections = oc.getBool("proj.simple") + oc.getBool("proj.utm") + oc.getBool("proj.dhdn") + (oc.getString("proj").length() > 1);
if ((oc.isSet("osm-files") || oc.isSet("dlr-navteq-poly-files") || oc.isSet("dlr-navteq-poi-files")) && numProjections == 0) {
oc.set("proj.utm", true);
}
if ((oc.isSet("dlr-navteq-poly-files") || oc.isSet("dlr-navteq-poi-files")) && oc.isDefault("proj.shift")) {
oc.set("proj.shift", std::string("5"));
}
#endif
if (!GeoConvHelper::init(oc)) {
throw ProcessError("Could not build projection!");
}
// check whether the input shall be pruned
bool prune = false;
if (oc.getBool("prune.on-net")) {
if (!oc.isSet("net")) {
throw ProcessError("In order to prune the input on the net, you have to supply a network.");
}
bool ok = true;
// !!! no proper error handling
Boundary offsets = GeomConvHelper::parseBoundaryReporting(oc.getString("prune.on-net.offsets"), "--prune.on-net.offsets", 0, ok);
pruningBoundary = Boundary(
pruningBoundary.xmin()+offsets.xmin(),
pruningBoundary.ymin()+offsets.ymin(),
pruningBoundary.xmax()+offsets.xmax(),
pruningBoundary.ymax()+offsets.ymax());
prune = true;
}
if (oc.isSet("prune.boundary")) {
bool ok = true;
// !!! no proper error handling
pruningBoundary = GeomConvHelper::parseBoundaryReporting(oc.getString("prune.boundary"), "--prune.boundary", 0, ok);
prune = true;
}
PCPolyContainer toFill(prune, pruningBoundary, oc.getStringVector("remove"));
// read in the type defaults
PCTypeMap tm;
if (oc.isSet("typemap")) {
PCTypeDefHandler handler(oc, tm);
if (!XMLSubSys::runParser(handler, oc.getString("typemap"))) {
// something failed
throw ProcessError();
}
}
// read in the data
PCLoaderXML::loadIfSet(oc, toFill, tm); // SUMO-XML
PCLoaderOSM::loadIfSet(oc, toFill, tm); // OSM-XML
PCLoaderDlrNavteq::loadIfSet(oc, toFill, tm); // Elmar-files
PCLoaderVisum::loadIfSet(oc, toFill, tm); // VISUM
PCLoaderArcView::loadIfSet(oc, toFill, tm); // shape-files
// check whether any errors occured
if (!MsgHandler::getErrorInstance()->wasInformed()) {
// no? ok, save
toFill.save(oc.getString("output"));
} else {
throw ProcessError();
}
} catch (ProcessError &e) {
if (std::string(e.what())!=std::string("Process Error") && std::string(e.what())!=std::string("")) {
MsgHandler::getErrorInstance()->inform(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
SystemFrame::close();
// report about ending
if (ret==0) {
std::cout << "Success." << std::endl;
}
return ret;
}