void
NWFrame::writeNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
long before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Writing network");
NWWriter_SUMO::writeNetwork(oc, nb);
NWWriter_Amitran::writeNetwork(oc, nb);
NWWriter_MATSim::writeNetwork(oc, nb);
NWWriter_OpenDrive::writeNetwork(oc, nb);
NWWriter_DlrNavteq::writeNetwork(oc, nb);
NWWriter_XML::writeNetwork(oc, nb);
PROGRESS_TIME_MESSAGE(before);
}
bool
NLBuilder::load(const std::string& mmlWhat, const bool isNet) {
if (!myOptions.isUsableFileList(mmlWhat)) {
return false;
}
std::vector<std::string> files = myOptions.getStringVector(mmlWhat);
for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
PROGRESS_BEGIN_MESSAGE("Loading " + mmlWhat + " from '" + *fileIt + "'");
long before = SysUtils::getCurrentMillis();
if (!XMLSubSys::runParser(myXMLHandler, *fileIt, isNet)) {
WRITE_MESSAGE("Loading of " + mmlWhat + " failed.");
return false;
}
PROGRESS_TIME_MESSAGE(before);
}
return true;
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static interface
// ---------------------------------------------------------------------------
void
PCLoaderXML::loadIfSet(OptionsCont& oc, PCPolyContainer& toFill,
PCTypeMap& tm) {
if (!oc.isSet("xml-files")) {
return;
}
PCLoaderXML handler(toFill, tm, oc);
// parse file(s)
std::vector<std::string> files = oc.getStringVector("xml");
for (std::vector<std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
if (!FileHelpers::isReadable(*file)) {
throw ProcessError("Could not open xml-file '" + *file + "'.");
}
const long before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Parsing XML from '" + *file + "'");
if (!XMLSubSys::runParser(handler, *file)) {
throw ProcessError();
}
PROGRESS_TIME_MESSAGE(before);
}
}
void
NBNetBuilder::moveToOrigin(GeoConvHelper& geoConvHelper, bool lefthand) {
long before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Moving network to origin");
Boundary boundary = geoConvHelper.getConvBoundary();
const SUMOReal x = -boundary.xmin();
const SUMOReal y = -(lefthand ? boundary.ymax() : boundary.ymin());
//if (lefthand) {
// y = boundary.ymax();
//}
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
(*i).second->reshiftPosition(x, y);
}
for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
(*i).second->reshiftPosition(x, y);
}
for (std::map<std::string, NBDistrict*>::const_iterator i = myDistrictCont.begin(); i != myDistrictCont.end(); ++i) {
(*i).second->reshiftPosition(x, y);
}
geoConvHelper.moveConvertedBy(x, y);
PROGRESS_TIME_MESSAGE(before);
}
bool
NLBuilder::build() {
// try to build the net
if (!load("net-file", true)) {
return false;
}
// check whether the loaded net agrees with the simulation options
if (myOptions.getBool("no-internal-links") && myXMLHandler.haveSeenInternalEdge()) {
WRITE_WARNING("Network contains internal links but option --no-internal-links is set. Vehicles will 'jump' across junctions and thus underestimate route lengths and travel times.");
}
if (myOptions.getString("lanechange.duration") != "0" && myXMLHandler.haveSeenNeighs()) {
throw ProcessError("Network contains explicit neigh lanes which do not work together with option --lanechange.duration.");
}
buildNet();
// @note on loading order constraints:
// - additional-files before route-files and state-files due to referencing
// - additional-files before weight-files since the latter might contain intermodal edge data and the intermodal net depends on the stops and public transport from the additionals
// load additional net elements (sources, detectors, ...)
if (myOptions.isSet("additional-files")) {
if (!load("additional-files")) {
return false;
}
// load shapes with separate handler
NLShapeHandler sh("", myNet.getShapeContainer());
if (!ShapeHandler::loadFiles(myOptions.getStringVector("additional-files"), sh)) {
return false;
}
if (myXMLHandler.haveSeenAdditionalSpeedRestrictions()) {
myNet.getEdgeControl().setAdditionalRestrictions();
}
}
// load weights if wished
if (myOptions.isSet("weight-files")) {
if (!myOptions.isUsableFileList("weight-files")) {
return false;
}
// build and prepare the weights handler
std::vector<SAXWeightsHandler::ToRetrieveDefinition*> retrieverDefs;
// travel time, first (always used)
EdgeFloatTimeLineRetriever_EdgeTravelTime ttRetriever(myNet);
retrieverDefs.push_back(new SAXWeightsHandler::ToRetrieveDefinition("traveltime", true, ttRetriever));
// the measure to use, then
EdgeFloatTimeLineRetriever_EdgeEffort eRetriever(myNet);
std::string measure = myOptions.getString("weight-attribute");
if (!myOptions.isDefault("weight-attribute")) {
if (measure == "CO" || measure == "CO2" || measure == "HC" || measure == "PMx" || measure == "NOx" || measure == "fuel" || measure == "electricity") {
measure += "_perVeh";
}
retrieverDefs.push_back(new SAXWeightsHandler::ToRetrieveDefinition(measure, true, eRetriever));
}
// set up handler
SAXWeightsHandler handler(retrieverDefs, "");
// start parsing; for each file in the list
std::vector<std::string> files = myOptions.getStringVector("weight-files");
for (std::vector<std::string>::iterator i = files.begin(); i != files.end(); ++i) {
// report about loading when wished
WRITE_MESSAGE("Loading weights from '" + *i + "'...");
// parse the file
if (!XMLSubSys::runParser(handler, *i)) {
return false;
}
}
}
// load the previous state if wished
if (myOptions.isSet("load-state")) {
long before = SysUtils::getCurrentMillis();
const std::string& f = myOptions.getString("load-state");
PROGRESS_BEGIN_MESSAGE("Loading state from '" + f + "'");
MSStateHandler h(f, string2time(myOptions.getString("load-state.offset")));
XMLSubSys::runParser(h, f);
if (myOptions.isDefault("begin")) {
myOptions.set("begin", time2string(h.getTime()));
if (TraCIServer::getInstance() != 0) {
TraCIServer::getInstance()->setTargetTime(h.getTime());
}
}
if (MsgHandler::getErrorInstance()->wasInformed()) {
return false;
}
if (h.getTime() != string2time(myOptions.getString("begin"))) {
WRITE_WARNING("State was written at a different time " + time2string(h.getTime()) + " than the begin time " + myOptions.getString("begin") + "!");
}
PROGRESS_TIME_MESSAGE(before);
}
// load routes
if (myOptions.isSet("route-files") && string2time(myOptions.getString("route-steps")) <= 0) {
if (!load("route-files")) {
return false;
}
}
// optionally switch off traffic lights
if (myOptions.getBool("tls.all-off")) {
myNet.getTLSControl().switchOffAll();
}
WRITE_MESSAGE("Loading done.");
return true;
}
void
NBNetBuilder::compute(OptionsCont& oc,
const std::set<std::string>& explicitTurnarounds,
bool removeElements) {
GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing();
const bool lefthand = oc.getBool("lefthand");
if (lefthand) {
mirrorX();
};
// MODIFYING THE SETS OF NODES AND EDGES
// Removes edges that are connecting the same node
long before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Removing self-loops");
myNodeCont.removeSelfLoops(myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
//
if (oc.exists("remove-edges.isolated") && oc.getBool("remove-edges.isolated")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Finding isolated roads");
myNodeCont.removeIsolatedRoads(myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
}
//
if (oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload")) {
if (oc.isSet("keep-edges.explicit") || oc.isSet("keep-edges.input-file")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Removing unwished edges");
myEdgeCont.removeUnwishedEdges(myDistrictCont);
PROGRESS_TIME_MESSAGE(before);
}
}
if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) {
// preliminary geometry computations to determine the length of edges
// This depends on turning directions and sorting of edge list
// in case junctions are joined geometry computations have to be repeated
// preliminary roundabout computations to avoid damaging roundabouts via junctions.join or ramps.guess
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false);
NBNodesEdgesSorter::sortNodesEdges(myNodeCont);
myEdgeCont.computeLaneShapes();
myNodeCont.computeNodeShapes();
myEdgeCont.computeEdgeShapes();
if (oc.getBool("roundabouts.guess")) {
myEdgeCont.guessRoundabouts();
}
const std::set<EdgeSet>& roundabouts = myEdgeCont.getRoundabouts();
for (std::set<EdgeSet>::const_iterator it_round = roundabouts.begin();
it_round != roundabouts.end(); ++it_round) {
std::vector<std::string> nodeIDs;
for (EdgeSet::const_iterator it_edge = it_round->begin(); it_edge != it_round->end(); ++it_edge) {
nodeIDs.push_back((*it_edge)->getToNode()->getID());
}
myNodeCont.addJoinExclusion(nodeIDs);
}
}
// join junctions (may create new "geometry"-nodes so it needs to come before removing these
if (oc.exists("junctions.join-exclude") && oc.isSet("junctions.join-exclude")) {
myNodeCont.addJoinExclusion(oc.getStringVector("junctions.join-exclude"));
}
unsigned int numJoined = myNodeCont.joinLoadedClusters(myDistrictCont, myEdgeCont, myTLLCont);
if (oc.getBool("junctions.join")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Joining junction clusters");
numJoined += myNodeCont.joinJunctions(oc.getFloat("junctions.join-dist"), myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
}
if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) {
// reset geometry to avoid influencing subsequent steps (ramps.guess)
myEdgeCont.computeLaneShapes();
}
if (numJoined > 0) {
// bit of a misnomer since we're already done
WRITE_MESSAGE(" Joined " + toString(numJoined) + " junction cluster(s).");
}
//
if (removeElements) {
unsigned int no = 0;
const bool removeGeometryNodes = oc.exists("geometry.remove") && oc.getBool("geometry.remove");
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Removing empty nodes" + std::string(removeGeometryNodes ? " and geometry nodes" : ""));
// removeUnwishedNodes needs turnDirections. @todo: try to call this less often
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false);
no = myNodeCont.removeUnwishedNodes(myDistrictCont, myEdgeCont, myTLLCont, removeGeometryNodes);
PROGRESS_TIME_MESSAGE(before);
WRITE_MESSAGE(" " + toString(no) + " nodes removed.");
}
// MOVE TO ORIGIN
// compute new boundary after network modifications have taken place
Boundary boundary;
for (std::map<std::string, NBNode*>::const_iterator it = myNodeCont.begin(); it != myNodeCont.end(); ++it) {
boundary.add(it->second->getPosition());
}
for (std::map<std::string, NBEdge*>::const_iterator it = myEdgeCont.begin(); it != myEdgeCont.end(); ++it) {
boundary.add(it->second->getGeometry().getBoxBoundary());
}
geoConvHelper.setConvBoundary(boundary);
if (!oc.getBool("offset.disable-normalization") && oc.isDefault("offset.x") && oc.isDefault("offset.y")) {
moveToOrigin(geoConvHelper, lefthand);
}
geoConvHelper.computeFinal(lefthand); // information needed for location element fixed at this point
if (oc.exists("geometry.min-dist") && oc.isSet("geometry.min-dist")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Reducing geometries");
myEdgeCont.reduceGeometries(oc.getFloat("geometry.min-dist"));
PROGRESS_TIME_MESSAGE(before);
}
// @note: removing geometry can create similar edges so joinSimilarEdges must come afterwards
// @note: likewise splitting can destroy similarities so joinSimilarEdges must come before
if (removeElements && oc.getBool("edges.join")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Joining similar edges");
myNodeCont.joinSimilarEdges(myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
}
if (oc.getBool("opposites.guess")) {
PROGRESS_BEGIN_MESSAGE("guessing opposite direction edges");
myEdgeCont.guessOpposites();
PROGRESS_DONE_MESSAGE();
}
//
if (oc.exists("geometry.split") && oc.getBool("geometry.split")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Splitting geometry edges");
myEdgeCont.splitGeometry(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
}
// turning direction
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing turning directions");
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
// correct edge geometries to avoid overlap
myNodeCont.avoidOverlap();
// guess ramps
if ((oc.exists("ramps.guess") && oc.getBool("ramps.guess")) || (oc.exists("ramps.set") && oc.isSet("ramps.set"))) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Guessing and setting on-/off-ramps");
NBNodesEdgesSorter::sortNodesEdges(myNodeCont);
NBRampsComputer::computeRamps(*this, oc);
PROGRESS_TIME_MESSAGE(before);
}
// guess sidewalks
if (oc.getBool("sidewalks.guess") || oc.getBool("sidewalks.guess.from-permissions")) {
const int sidewalks = myEdgeCont.guessSidewalks(oc.getFloat("default.sidewalk-width"),
oc.getFloat("sidewalks.guess.min-speed"),
oc.getFloat("sidewalks.guess.max-speed"),
oc.getBool("sidewalks.guess.from-permissions"));
WRITE_MESSAGE("Guessed " + toString(sidewalks) + " sidewalks.");
}
// check whether any not previously setable connections may be set now
myEdgeCont.recheckPostProcessConnections();
// remap ids if wished
if (oc.getBool("numerical-ids")) {
int numChangedEdges = myEdgeCont.mapToNumericalIDs();
int numChangedNodes = myNodeCont.mapToNumericalIDs();
if (numChangedEdges + numChangedNodes > 0) {
WRITE_MESSAGE("Remapped " + toString(numChangedEdges) + " edge IDs and " + toString(numChangedNodes) + " node IDs.");
}
}
//
if (oc.exists("geometry.max-angle")) {
myEdgeCont.checkGeometries(
DEG2RAD(oc.getFloat("geometry.max-angle")),
oc.getFloat("geometry.min-radius"),
oc.getBool("geometry.min-radius.fix"));
}
// GEOMETRY COMPUTATION
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Sorting nodes' edges");
NBNodesEdgesSorter::sortNodesEdges(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
myEdgeCont.computeLaneShapes();
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing node shapes");
if (oc.exists("geometry.junction-mismatch-threshold")) {
myNodeCont.computeNodeShapes(oc.getFloat("geometry.junction-mismatch-threshold"));
} else {
myNodeCont.computeNodeShapes();
}
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing edge shapes");
myEdgeCont.computeEdgeShapes();
PROGRESS_TIME_MESSAGE(before);
// resort edges based on the node and edge shapes
NBNodesEdgesSorter::sortNodesEdges(myNodeCont, true);
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false);
// APPLY SPEED MODIFICATIONS
if (oc.exists("speed.offset")) {
const SUMOReal speedOffset = oc.getFloat("speed.offset");
const SUMOReal speedFactor = oc.getFloat("speed.factor");
if (speedOffset != 0 || speedFactor != 1 || oc.isSet("speed.minimum")) {
const SUMOReal speedMin = oc.isSet("speed.minimum") ? oc.getFloat("speed.minimum") : -std::numeric_limits<SUMOReal>::infinity();
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Applying speed modifications");
for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
(*i).second->setSpeed(-1, MAX2((*i).second->getSpeed() * speedFactor + speedOffset, speedMin));
}
PROGRESS_TIME_MESSAGE(before);
}
}
// CONNECTIONS COMPUTATION
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing node types");
NBNodeTypeComputer::computeNodeTypes(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
//
bool haveCrossings = false;
if (oc.getBool("crossings.guess")) {
haveCrossings = true;
int crossings = 0;
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
crossings += (*i).second->guessCrossings();
}
WRITE_MESSAGE("Guessed " + toString(crossings) + " pedestrian crossings.");
}
if (!haveCrossings) {
// recheck whether we had crossings in the input
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
if (i->second->getCrossings().size() > 0) {
haveCrossings = true;
break;
}
}
}
if (oc.isDefault("no-internal-links") && !haveCrossings && myHaveLoadedNetworkWithoutInternalEdges) {
oc.set("no-internal-links", "true");
}
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing priorities");
NBEdgePriorityComputer::computeEdgePriorities(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing approached edges");
myEdgeCont.computeEdge2Edges(oc.getBool("no-left-connections"));
PROGRESS_TIME_MESSAGE(before);
//
if (oc.getBool("roundabouts.guess")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Guessing and setting roundabouts");
const int numGuessed = myEdgeCont.guessRoundabouts();
if (numGuessed > 0) {
WRITE_MESSAGE(" Guessed " + toString(numGuessed) + " roundabout(s).");
}
PROGRESS_TIME_MESSAGE(before);
}
myEdgeCont.markRoundabouts();
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing approaching lanes");
myEdgeCont.computeLanes2Edges();
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Dividing of lanes on approached lanes");
myNodeCont.computeLanes2Lanes();
myEdgeCont.sortOutgoingLanesConnections();
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Processing turnarounds");
if (!oc.getBool("no-turnarounds")) {
myEdgeCont.appendTurnarounds(oc.getBool("no-turnarounds.tls"));
} else {
myEdgeCont.appendTurnarounds(explicitTurnarounds, oc.getBool("no-turnarounds.tls"));
}
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Rechecking of lane endings");
myEdgeCont.recheckLanes();
PROGRESS_TIME_MESSAGE(before);
if (haveCrossings && !oc.getBool("no-internal-links")) {
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
i->second->buildCrossingsAndWalkingAreas();
}
}
// GUESS TLS POSITIONS
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Assigning nodes to traffic lights");
if (oc.isSet("tls.set")) {
std::vector<std::string> tlControlledNodes = oc.getStringVector("tls.set");
TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(oc.getString("tls.default-type"));
for (std::vector<std::string>::const_iterator i = tlControlledNodes.begin(); i != tlControlledNodes.end(); ++i) {
NBNode* node = myNodeCont.retrieve(*i);
if (node == 0) {
WRITE_WARNING("Building a tl-logic for junction '" + *i + "' is not possible." + "\n The junction '" + *i + "' is not known.");
} else {
myNodeCont.setAsTLControlled(node, myTLLCont, type);
}
}
}
myNodeCont.guessTLs(oc, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
//
if (oc.getBool("tls.join")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Joining traffic light nodes");
myNodeCont.joinTLS(myTLLCont, oc.getFloat("tls.join-dist"));
PROGRESS_TIME_MESSAGE(before);
}
// COMPUTING RIGHT-OF-WAY AND TRAFFIC LIGHT PROGRAMS
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing traffic light control information");
myTLLCont.setTLControllingInformation(myEdgeCont, myNodeCont);
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing node logics");
myNodeCont.computeLogics(myEdgeCont, oc);
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing traffic light logics");
std::pair<unsigned int, unsigned int> numbers = myTLLCont.computeLogics(oc);
PROGRESS_TIME_MESSAGE(before);
std::string progCount = "";
if (numbers.first != numbers.second) {
progCount = "(" + toString(numbers.second) + " programs) ";
}
WRITE_MESSAGE(" " + toString(numbers.first) + " traffic light(s) " + progCount + "computed.");
//
if (oc.isSet("street-sign-output")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Generating street signs");
myEdgeCont.generateStreetSigns();
PROGRESS_TIME_MESSAGE(before);
}
// FINISHING INNER EDGES
if (!oc.getBool("no-internal-links")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Building inner edges");
for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
(*i).second->sortOutgoingConnectionsByIndex();
}
// walking areas shall only be built if crossings are wished as well
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
(*i).second->buildInnerEdges();
}
PROGRESS_TIME_MESSAGE(before);
}
if (lefthand) {
mirrorX();
};
// report
WRITE_MESSAGE("-----------------------------------------------------");
WRITE_MESSAGE("Summary:");
myNodeCont.printBuiltNodesStatistics();
WRITE_MESSAGE(" Network boundaries:");
WRITE_MESSAGE(" Original boundary : " + toString(geoConvHelper.getOrigBoundary()));
WRITE_MESSAGE(" Applied offset : " + toString(geoConvHelper.getOffsetBase()));
WRITE_MESSAGE(" Converted boundary : " + toString(geoConvHelper.getConvBoundary()));
WRITE_MESSAGE("-----------------------------------------------------");
NBRequest::reportWarnings();
// report on very large networks
if (MAX2(geoConvHelper.getConvBoundary().xmax(), geoConvHelper.getConvBoundary().ymax()) > 1000000 ||
MIN2(geoConvHelper.getConvBoundary().xmin(), geoConvHelper.getConvBoundary().ymin()) < -1000000) {
WRITE_WARNING("Network contains very large coordinates and will probably flicker in the GUI. Check for outlying nodes and make sure the network is shifted to the coordinate origin");
}
}