SUMO - Simulation of Urban MObility
NBNetBuilder.cpp
Go to the documentation of this file.
1 /****************************************************************************/
12 // Instance responsible for building networks
13 /****************************************************************************/
14 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
15 // Copyright (C) 2001-2016 DLR (http://www.dlr.de/) and contributors
16 /****************************************************************************/
17 //
18 // This file is part of SUMO.
19 // SUMO is free software: you can redistribute it and/or modify
20 // it under the terms of the GNU General Public License as published by
21 // the Free Software Foundation, either version 3 of the License, or
22 // (at your option) any later version.
23 //
24 /****************************************************************************/
25 
26 
27 // ===========================================================================
28 // included modules
29 // ===========================================================================
30 #ifdef _MSC_VER
31 #include <windows_config.h>
32 #else
33 #include <config.h>
34 #endif
35 
36 #include <string>
37 #include <fstream>
38 #include "NBNetBuilder.h"
39 #include "NBNodeCont.h"
40 #include "NBEdgeCont.h"
42 #include "NBDistrictCont.h"
43 #include "NBDistrict.h"
44 #include "NBDistribution.h"
45 #include "NBRequest.h"
46 #include "NBTypeCont.h"
51 #include <utils/common/SysUtils.h>
52 #include <utils/common/ToString.h>
54 #include "NBAlgorithms.h"
55 #include "NBAlgorithms_Ramps.h"
56 #include "NBHeightMapper.h"
57 
58 #ifdef CHECK_MEMORY_LEAKS
59 #include <foreign/nvwa/debug_new.h>
60 #endif // CHECK_MEMORY_LEAKS
61 
62 
63 // ===========================================================================
64 // method definitions
65 // ===========================================================================
67  myEdgeCont(myTypeCont),
68  myHaveLoadedNetworkWithoutInternalEdges(false) {
69 }
70 
71 
73 
74 
75 void
77  // apply options to type control
78  myTypeCont.setDefaults(oc.getInt("default.lanenumber"), oc.getFloat("default.speed"), oc.getInt("default.priority"));
79  // apply options to edge control
81  // apply options to traffic light logics control
83 }
84 
85 
86 void
88  const std::set<std::string>& explicitTurnarounds,
89  bool removeElements) {
91 
92 
93  const bool lefthand = oc.getBool("lefthand");
94  if (lefthand) {
95  mirrorX();
96  };
97 
98  // MODIFYING THE SETS OF NODES AND EDGES
99 
100  // Removes edges that are connecting the same node
101  long before = SysUtils::getCurrentMillis();
102  PROGRESS_BEGIN_MESSAGE("Removing self-loops");
104  PROGRESS_TIME_MESSAGE(before);
105  //
106  if (oc.exists("remove-edges.isolated") && oc.getBool("remove-edges.isolated")) {
107  before = SysUtils::getCurrentMillis();
108  PROGRESS_BEGIN_MESSAGE("Finding isolated roads");
110  PROGRESS_TIME_MESSAGE(before);
111  }
112  //
113  if (oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload")) {
114  if (oc.isSet("keep-edges.explicit") || oc.isSet("keep-edges.input-file")) {
115  before = SysUtils::getCurrentMillis();
116  PROGRESS_BEGIN_MESSAGE("Removing unwished edges");
118  PROGRESS_TIME_MESSAGE(before);
119  }
120  }
121  if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) {
122  // preliminary geometry computations to determine the length of edges
123  // This depends on turning directions and sorting of edge list
124  // in case junctions are joined geometry computations have to be repeated
125  // preliminary roundabout computations to avoid damaging roundabouts via junctions.join or ramps.guess
131  if (oc.getBool("roundabouts.guess")) {
133  }
134  const std::set<EdgeSet>& roundabouts = myEdgeCont.getRoundabouts();
135  for (std::set<EdgeSet>::const_iterator it_round = roundabouts.begin();
136  it_round != roundabouts.end(); ++it_round) {
137  std::vector<std::string> nodeIDs;
138  for (EdgeSet::const_iterator it_edge = it_round->begin(); it_edge != it_round->end(); ++it_edge) {
139  nodeIDs.push_back((*it_edge)->getToNode()->getID());
140  }
141  myNodeCont.addJoinExclusion(nodeIDs);
142  }
143  }
144  // join junctions (may create new "geometry"-nodes so it needs to come before removing these
145  if (oc.exists("junctions.join-exclude") && oc.isSet("junctions.join-exclude")) {
146  myNodeCont.addJoinExclusion(oc.getStringVector("junctions.join-exclude"));
147  }
149  if (oc.getBool("junctions.join")) {
150  before = SysUtils::getCurrentMillis();
151  PROGRESS_BEGIN_MESSAGE("Joining junction clusters");
152  numJoined += myNodeCont.joinJunctions(oc.getFloat("junctions.join-dist"), myDistrictCont, myEdgeCont, myTLLCont);
153  PROGRESS_TIME_MESSAGE(before);
154  }
155  if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) {
156  // reset geometry to avoid influencing subsequent steps (ramps.guess)
158  }
159  if (numJoined > 0) {
160  // bit of a misnomer since we're already done
161  WRITE_MESSAGE(" Joined " + toString(numJoined) + " junction cluster(s).");
162  }
163  //
164  if (removeElements) {
165  unsigned int no = 0;
166  const bool removeGeometryNodes = oc.exists("geometry.remove") && oc.getBool("geometry.remove");
167  before = SysUtils::getCurrentMillis();
168  PROGRESS_BEGIN_MESSAGE("Removing empty nodes" + std::string(removeGeometryNodes ? " and geometry nodes" : ""));
169  // removeUnwishedNodes needs turnDirections. @todo: try to call this less often
172  PROGRESS_TIME_MESSAGE(before);
173  WRITE_MESSAGE(" " + toString(no) + " nodes removed.");
174  }
175 
176  // MOVE TO ORIGIN
177  // compute new boundary after network modifications have taken place
178  Boundary boundary;
179  for (std::map<std::string, NBNode*>::const_iterator it = myNodeCont.begin(); it != myNodeCont.end(); ++it) {
180  boundary.add(it->second->getPosition());
181  }
182  for (std::map<std::string, NBEdge*>::const_iterator it = myEdgeCont.begin(); it != myEdgeCont.end(); ++it) {
183  boundary.add(it->second->getGeometry().getBoxBoundary());
184  }
185  geoConvHelper.setConvBoundary(boundary);
186 
187  if (!oc.getBool("offset.disable-normalization") && oc.isDefault("offset.x") && oc.isDefault("offset.y")) {
188  moveToOrigin(geoConvHelper, lefthand);
189  }
190  geoConvHelper.computeFinal(lefthand); // information needed for location element fixed at this point
191 
192  if (oc.exists("geometry.min-dist") && oc.isSet("geometry.min-dist")) {
193  before = SysUtils::getCurrentMillis();
194  PROGRESS_BEGIN_MESSAGE("Reducing geometries");
195  myEdgeCont.reduceGeometries(oc.getFloat("geometry.min-dist"));
196  PROGRESS_TIME_MESSAGE(before);
197  }
198  // @note: removing geometry can create similar edges so joinSimilarEdges must come afterwards
199  // @note: likewise splitting can destroy similarities so joinSimilarEdges must come before
200  if (removeElements && oc.getBool("edges.join")) {
201  before = SysUtils::getCurrentMillis();
202  PROGRESS_BEGIN_MESSAGE("Joining similar edges");
205  PROGRESS_TIME_MESSAGE(before);
206  }
207  //
208  if (oc.exists("geometry.split") && oc.getBool("geometry.split")) {
209  before = SysUtils::getCurrentMillis();
210  PROGRESS_BEGIN_MESSAGE("Splitting geometry edges");
212  PROGRESS_TIME_MESSAGE(before);
213  }
214  // turning direction
215  before = SysUtils::getCurrentMillis();
216  PROGRESS_BEGIN_MESSAGE("Computing turning directions");
218  PROGRESS_TIME_MESSAGE(before);
219  // correct edge geometries to avoid overlap
221  // guess ramps
222  if ((oc.exists("ramps.guess") && oc.getBool("ramps.guess")) || (oc.exists("ramps.set") && oc.isSet("ramps.set"))) {
223  before = SysUtils::getCurrentMillis();
224  PROGRESS_BEGIN_MESSAGE("Guessing and setting on-/off-ramps");
227  PROGRESS_TIME_MESSAGE(before);
228  }
229  // guess sidewalks
230  if (oc.getBool("sidewalks.guess") || oc.getBool("sidewalks.guess.from-permissions")) {
231  const int sidewalks = myEdgeCont.guessSidewalks(oc.getFloat("default.sidewalk-width"),
232  oc.getFloat("sidewalks.guess.min-speed"),
233  oc.getFloat("sidewalks.guess.max-speed"),
234  oc.getBool("sidewalks.guess.from-permissions"));
235  WRITE_MESSAGE("Guessed " + toString(sidewalks) + " sidewalks.");
236  }
237 
238  // check whether any not previously setable connections may be set now
240  //
241  if (oc.exists("geometry.max-angle")) {
243  DEG2RAD(oc.getFloat("geometry.max-angle")),
244  oc.getFloat("geometry.min-radius"),
245  oc.getBool("geometry.min-radius.fix"));
246  }
247 
248  // GEOMETRY COMPUTATION
249  //
250  before = SysUtils::getCurrentMillis();
251  PROGRESS_BEGIN_MESSAGE("Sorting nodes' edges");
253  PROGRESS_TIME_MESSAGE(before);
255  //
256  before = SysUtils::getCurrentMillis();
257  PROGRESS_BEGIN_MESSAGE("Computing node shapes");
258  if (oc.exists("geometry.junction-mismatch-threshold")) {
259  myNodeCont.computeNodeShapes(oc.getFloat("geometry.junction-mismatch-threshold"));
260  } else {
262  }
263  PROGRESS_TIME_MESSAGE(before);
264  //
265  before = SysUtils::getCurrentMillis();
266  PROGRESS_BEGIN_MESSAGE("Computing edge shapes");
268  PROGRESS_TIME_MESSAGE(before);
269  // resort edges based on the node and edge shapes
272 
273  // APPLY SPEED MODIFICATIONS
274  if (oc.exists("speed.offset")) {
275  const SUMOReal speedOffset = oc.getFloat("speed.offset");
276  const SUMOReal speedFactor = oc.getFloat("speed.factor");
277  if (speedOffset != 0 || speedFactor != 1) {
278  before = SysUtils::getCurrentMillis();
279  PROGRESS_BEGIN_MESSAGE("Applying speed modifications");
280  for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
281  (*i).second->setSpeed(-1, (*i).second->getSpeed() * speedFactor + speedOffset);
282  }
283  PROGRESS_TIME_MESSAGE(before);
284  }
285  }
286 
287  // CONNECTIONS COMPUTATION
288  //
289  before = SysUtils::getCurrentMillis();
290  PROGRESS_BEGIN_MESSAGE("Computing node types");
292  PROGRESS_TIME_MESSAGE(before);
293  //
294  bool haveCrossings = false;
295  if (oc.getBool("crossings.guess")) {
296  haveCrossings = true;
297  int crossings = 0;
298  for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
299  crossings += (*i).second->guessCrossings();
300  }
301  WRITE_MESSAGE("Guessed " + toString(crossings) + " pedestrian crossings.");
302  }
303  if (!haveCrossings) {
304  // recheck whether we had crossings in the input
305  for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
306  if (i->second->getCrossings().size() > 0) {
307  haveCrossings = true;
308  break;
309  }
310  }
311  }
312 
313  if (oc.isDefault("no-internal-links") && !haveCrossings && myHaveLoadedNetworkWithoutInternalEdges) {
314  oc.set("no-internal-links", "true");
315  }
316 
317  //
318  before = SysUtils::getCurrentMillis();
319  PROGRESS_BEGIN_MESSAGE("Computing priorities");
321  PROGRESS_TIME_MESSAGE(before);
322  //
323  before = SysUtils::getCurrentMillis();
324  PROGRESS_BEGIN_MESSAGE("Computing approached edges");
325  myEdgeCont.computeEdge2Edges(oc.getBool("no-left-connections"));
326  PROGRESS_TIME_MESSAGE(before);
327  //
328  if (oc.getBool("roundabouts.guess")) {
329  before = SysUtils::getCurrentMillis();
330  PROGRESS_BEGIN_MESSAGE("Guessing and setting roundabouts");
331  const int numGuessed = myEdgeCont.guessRoundabouts();
332  if (numGuessed > 0) {
333  WRITE_MESSAGE(" Guessed " + toString(numGuessed) + " roundabout(s).");
334  }
335  PROGRESS_TIME_MESSAGE(before);
336  }
338  //
339  before = SysUtils::getCurrentMillis();
340  PROGRESS_BEGIN_MESSAGE("Computing approaching lanes");
342  PROGRESS_TIME_MESSAGE(before);
343  //
344  before = SysUtils::getCurrentMillis();
345  PROGRESS_BEGIN_MESSAGE("Dividing of lanes on approached lanes");
348  PROGRESS_TIME_MESSAGE(before);
349  //
350  before = SysUtils::getCurrentMillis();
351  PROGRESS_BEGIN_MESSAGE("Processing turnarounds");
352  if (!oc.getBool("no-turnarounds")) {
353  myEdgeCont.appendTurnarounds(oc.getBool("no-turnarounds.tls"));
354  } else {
355  myEdgeCont.appendTurnarounds(explicitTurnarounds, oc.getBool("no-turnarounds.tls"));
356  }
357  PROGRESS_TIME_MESSAGE(before);
358  //
359  before = SysUtils::getCurrentMillis();
360  PROGRESS_BEGIN_MESSAGE("Rechecking of lane endings");
362  PROGRESS_TIME_MESSAGE(before);
363 
364  if (haveCrossings && !oc.getBool("no-internal-links")) {
365  for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
366  i->second->buildCrossingsAndWalkingAreas();
367  }
368  }
369 
370  // GUESS TLS POSITIONS
371  before = SysUtils::getCurrentMillis();
372  PROGRESS_BEGIN_MESSAGE("Assigning nodes to traffic lights");
373  if (oc.isSet("tls.set")) {
374  std::vector<std::string> tlControlledNodes = oc.getStringVector("tls.set");
376  for (std::vector<std::string>::const_iterator i = tlControlledNodes.begin(); i != tlControlledNodes.end(); ++i) {
377  NBNode* node = myNodeCont.retrieve(*i);
378  if (node == 0) {
379  WRITE_WARNING("Building a tl-logic for junction '" + *i + "' is not possible." + "\n The junction '" + *i + "' is not known.");
380  } else {
382  }
383  }
384  }
386  PROGRESS_TIME_MESSAGE(before);
387  //
388  if (oc.getBool("tls.join")) {
389  before = SysUtils::getCurrentMillis();
390  PROGRESS_BEGIN_MESSAGE("Joining traffic light nodes");
391  myNodeCont.joinTLS(myTLLCont, oc.getFloat("tls.join-dist"));
392  PROGRESS_TIME_MESSAGE(before);
393  }
394 
395 
396  // COMPUTING RIGHT-OF-WAY AND TRAFFIC LIGHT PROGRAMS
397  //
398  before = SysUtils::getCurrentMillis();
399  PROGRESS_BEGIN_MESSAGE("Computing traffic light control information");
401  PROGRESS_TIME_MESSAGE(before);
402  //
403  before = SysUtils::getCurrentMillis();
404  PROGRESS_BEGIN_MESSAGE("Computing node logics");
406  PROGRESS_TIME_MESSAGE(before);
407  //
408  before = SysUtils::getCurrentMillis();
409  PROGRESS_BEGIN_MESSAGE("Computing traffic light logics");
410  std::pair<unsigned int, unsigned int> numbers = myTLLCont.computeLogics(oc);
411  PROGRESS_TIME_MESSAGE(before);
412  std::string progCount = "";
413  if (numbers.first != numbers.second) {
414  progCount = "(" + toString(numbers.second) + " programs) ";
415  }
416  WRITE_MESSAGE(" " + toString(numbers.first) + " traffic light(s) " + progCount + "computed.");
417  //
418  if (oc.isSet("street-sign-output")) {
419  before = SysUtils::getCurrentMillis();
420  PROGRESS_BEGIN_MESSAGE("Generating street signs");
422  PROGRESS_TIME_MESSAGE(before);
423  }
424 
425  // FINISHING INNER EDGES
426  if (!oc.getBool("no-internal-links")) {
427  before = SysUtils::getCurrentMillis();
428  PROGRESS_BEGIN_MESSAGE("Building inner edges");
429  for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
430  (*i).second->sortOutgoingConnectionsByIndex();
431  }
432  // walking areas shall only be built if crossings are wished as well
433  for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
434  (*i).second->buildInnerEdges();
435  }
436  PROGRESS_TIME_MESSAGE(before);
437  }
438  if (lefthand) {
439  mirrorX();
440  };
441 
442  // report
443  WRITE_MESSAGE("-----------------------------------------------------");
444  WRITE_MESSAGE("Summary:");
446  WRITE_MESSAGE(" Network boundaries:");
447  WRITE_MESSAGE(" Original boundary : " + toString(geoConvHelper.getOrigBoundary()));
448  WRITE_MESSAGE(" Applied offset : " + toString(geoConvHelper.getOffsetBase()));
449  WRITE_MESSAGE(" Converted boundary : " + toString(geoConvHelper.getConvBoundary()));
450  WRITE_MESSAGE("-----------------------------------------------------");
452  // report on very large networks
453  if (MAX2(geoConvHelper.getConvBoundary().xmax(), geoConvHelper.getConvBoundary().ymax()) > 1000000 ||
454  MIN2(geoConvHelper.getConvBoundary().xmin(), geoConvHelper.getConvBoundary().ymin()) < -1000000) {
455  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");
456  }
457 }
458 
459 
460 void
461 NBNetBuilder::moveToOrigin(GeoConvHelper& geoConvHelper, bool lefthand) {
462  long before = SysUtils::getCurrentMillis();
463  PROGRESS_BEGIN_MESSAGE("Moving network to origin");
464  Boundary boundary = geoConvHelper.getConvBoundary();
465  const SUMOReal x = -boundary.xmin();
466  const SUMOReal y = -(lefthand ? boundary.ymax() : boundary.ymin());
467  //if (lefthand) {
468  // y = boundary.ymax();
469  //}
470  for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
471  (*i).second->reshiftPosition(x, y);
472  }
473  for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
474  (*i).second->reshiftPosition(x, y);
475  }
476  for (std::map<std::string, NBDistrict*>::const_iterator i = myDistrictCont.begin(); i != myDistrictCont.end(); ++i) {
477  (*i).second->reshiftPosition(x, y);
478  }
479  geoConvHelper.moveConvertedBy(x, y);
480  PROGRESS_TIME_MESSAGE(before);
481 }
482 
483 
484 void
486  // mirror the network along the X-axis
487  for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
488  (*i).second->mirrorX();
489  }
490  for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
491  (*i).second->mirrorX();
492  }
493  for (std::map<std::string, NBDistrict*>::const_iterator i = myDistrictCont.begin(); i != myDistrictCont.end(); ++i) {
494  (*i).second->mirrorX();
495  }
496 }
497 
498 
499 bool
500 NBNetBuilder::transformCoordinates(Position& from, bool includeInBoundary, GeoConvHelper* from_srs) {
501  Position orig(from);
502  bool ok = GeoConvHelper::getProcessing().x2cartesian(from, includeInBoundary);
503  if (ok) {
504  const NBHeightMapper& hm = NBHeightMapper::get();
505  if (hm.ready()) {
506  if (from_srs != 0 && from_srs->usingGeoProjection()) {
507  from_srs->cartesian2geo(orig);
508  }
509  SUMOReal z = hm.getZ(orig);
510  from = Position(from.x(), from.y(), z);
511  }
512  }
513  return ok;
514 }
515 
516 
517 bool
518 NBNetBuilder::transformCoordinates(PositionVector& from, bool includeInBoundary, GeoConvHelper* from_srs) {
519  const SUMOReal maxLength = OptionsCont::getOptions().getFloat("geometry.max-segment-length");
520  if (maxLength > 0 && from.size() > 1) {
521  // transformation to cartesian coordinates must happen before we can check segment length
522  PositionVector copy = from;
523  for (int i = 0; i < (int) from.size(); i++) {
524  transformCoordinates(copy[i], false);
525  }
526  // check lengths and insert new points where needed (in the original
527  // coordinate system)
528  int inserted = 0;
529  for (int i = 0; i < (int)copy.size() - 1; i++) {
530  Position start = from[i + inserted];
531  Position end = from[i + inserted + 1];
532  SUMOReal length = copy[i].distanceTo(copy[i + 1]);
533  const Position step = (end - start) * (maxLength / length);
534  int steps = 0;
535  while (length > maxLength) {
536  length -= maxLength;
537  steps++;
538  from.insert(from.begin() + i + inserted + 1, start + (step * steps));
539  inserted++;
540  }
541  }
542  // now perform the transformation again so that height mapping can be
543  // performed for the new points
544  }
545  bool ok = true;
546  for (int i = 0; i < (int) from.size(); i++) {
547  ok = ok && transformCoordinates(from[i], includeInBoundary, from_srs);
548  }
549  return ok;
550 }
551 
552 /****************************************************************************/
NBNetBuilder()
Constructor.
NBTypeCont myTypeCont
The used container for street types.
Definition: NBNetBuilder.h:237
int guessSidewalks(SUMOReal width, SUMOReal minSpeed, SUMOReal maxSpeed, bool fromPermissions)
add sidwalks to edges within the given limits or permissions and return the number of edges affected ...
void joinSimilarEdges(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins edges connecting the same nodes.
Definition: NBNodeCont.cpp:180
std::vector< std::string > getStringVector(const std::string &name) const
Returns the list of string-vector-value of the named option (only for Option_String) ...
void removeSelfLoops(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes self-loop edges (edges where the source and the destination node are the same) ...
Definition: NBNodeCont.cpp:168
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
Definition: NBEdgeCont.cpp:585
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
Definition: NBEdgeCont.cpp:959
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
void setConvBoundary(const Boundary &boundary)
sets the converted boundary
static bool transformCoordinates(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=0)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
NBJoinedEdgesMap myJoinedEdges
Map of joined edges.
Definition: NBNetBuilder.h:249
void addJoinExclusion(const std::vector< std::string > &ids, bool check=false)
Definition: NBNodeCont.cpp:450
bool ready() const
returns whether the NBHeightMapper has data
unsigned int removeUnwishedNodes(NBDistrictCont &dc, NBEdgeCont &ec, NBJoinedEdgesMap &je, NBTrafficLightLogicCont &tlc, bool removeGeometryNodes)
Removes "unwished" nodes.
Definition: NBNodeCont.cpp:319
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
Definition: NBEdgeCont.cpp:941
void mirrorX()
mirror the network along the X-axis
SUMOReal getZ(const Position &geo) const
returns height for the given geo coordinate (WGS84)
int guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
Definition: NBEdgeCont.cpp:834
void compute(OptionsCont &oc, const std::set< std::string > &explicitTurnarounds=std::set< std::string >(), bool removeElements=true)
Performs the network building steps.
static void computeFinal(bool lefthand=false)
compute the location attributes which will be used for output based on the loaded location data...
unsigned int joinJunctions(SUMOReal maxDist, NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins junctions that are very close together.
Definition: NBNodeCont.cpp:508
~NBNetBuilder()
Destructor.
SUMOReal ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:124
static GeoConvHelper & getProcessing()
the coordinate transformation to use for input conversion and processing
Definition: GeoConvHelper.h:98
bool x2cartesian(Position &from, bool includeInBoundary=true)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
SUMOReal xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:112
std::pair< unsigned int, unsigned int > computeLogics(OptionsCont &oc)
Computes the traffic light logics using the stored definitions and stores the results.
T MAX2(T a, T b)
Definition: StdDefs.h:75
void generateStreetSigns()
assigns street signs to edges based on toNode types
Definition: NBEdgeCont.cpp:985
void recheckPostProcessConnections()
Try to set any stored connections.
Definition: NBEdgeCont.cpp:763
void guessTLs(OptionsCont &oc, NBTrafficLightLogicCont &tlc)
Guesses which junctions or junction clusters shall be controlled by tls.
Definition: NBNodeCont.cpp:839
SUMOReal getFloat(const std::string &name) const
Returns the SUMOReal-value of the named option (only for Option_Float)
void avoidOverlap()
fix overlap
Definition: NBNodeCont.cpp:390
static void sortNodesEdges(NBNodeCont &nc, bool useNodeShape=false)
Sorts a node&#39;s edges clockwise regarding driving direction.
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
Definition: NBEdgeCont.cpp:601
SUMOReal x() const
Returns the x-position.
Definition: Position.h:63
SUMOReal xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:118
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:48
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
void checkGeometries(const SUMOReal maxAngle, const SUMOReal minRadius, bool fix)
Definition: NBEdgeCont.cpp:566
void computeLogics(const NBEdgeCont &ec, OptionsCont &oc)
build the list of outgoing edges and lanes
static const NBHeightMapper & get()
return the singleton instance (maybe 0)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
static void reportWarnings()
reports warnings if any occured
Definition: NBRequest.cpp:775
#define PROGRESS_TIME_MESSAGE(before)
Definition: MsgHandler.h:204
void reduceGeometries(const SUMOReal minDist)
Definition: NBEdgeCont.cpp:558
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:198
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
static methods for processing the coordinates conversion for the current net
Definition: GeoConvHelper.h:60
void computeLanes2Lanes()
divides the incoming lanes on outgoing lanes
std::map< std::string, NBDistrict * >::const_iterator begin() const
Returns the pointer to the begin of the stored districts.
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
Definition: NBEdgeCont.cpp:530
void joinTLS(NBTrafficLightLogicCont &tlc, SUMOReal maxdist)
Builds clusters of tls-controlled junctions and joins the control if possible.
static StringBijection< TrafficLightType > TrafficLightTypes
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
std::map< std::string, NBDistrict * >::const_iterator end() const
Returns the pointer to the end of the stored districts.
static void computeEdgePriorities(NBNodeCont &nc)
Computes edge priorities within a node.
A list of positions.
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
Definition: NBEdgeCont.cpp:81
NBEdgeCont myEdgeCont
The used container for edges.
Definition: NBNetBuilder.h:240
unsigned int joinLoadedClusters(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins loaded junction clusters (see NIXMLNodesHandler)
Definition: NBNodeCont.cpp:484
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
Definition: NBEdgeCont.cpp:593
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
Definition: NBEdgeCont.cpp:641
NBTrafficLightLogicCont myTLLCont
The used container for traffic light logics.
Definition: NBNetBuilder.h:243
T MIN2(T a, T b)
Definition: StdDefs.h:69
#define PROGRESS_BEGIN_MESSAGE(msg)
Definition: MsgHandler.h:202
void splitGeometry(NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
Definition: NBEdgeCont.cpp:547
const Position getOffsetBase() const
Returns the network base.
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Definition: NBNodeCont.h:135
#define DEG2RAD(x)
Definition: GeomHelper.h:45
const Boundary & getConvBoundary() const
Returns the converted boundary.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:54
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:190
void setAsTLControlled(NBNode *node, NBTrafficLightLogicCont &tlc, TrafficLightType type, std::string id="")
Sets the given node as being controlled by a tls.
void add(SUMOReal x, SUMOReal y)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:76
static void computeRamps(NBNetBuilder &nb, OptionsCont &oc)
Computes highway on-/off-ramps (if wished)
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
void appendTurnarounds(bool noTLSControlled)
Appends turnarounds to all edges stored in the container.
Definition: NBEdgeCont.cpp:617
static void computeNodeTypes(NBNodeCont &nc)
Computes node types.
void moveToOrigin(GeoConvHelper &geoConvHelper, bool lefthand)
shift network so its lower left corner is at 0,0
void removeIsolatedRoads(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes sequences of edges that are not connected with a junction. Simple roads without junctions som...
Definition: NBNodeCont.cpp:225
SUMOReal y() const
Returns the y-position.
Definition: Position.h:68
A storage for options typed value containers)
Definition: OptionsCont.h:108
void computeNodeShapes(SUMOReal mismatchThreshold=-1)
Compute the junction shape for this node.
void computeEdgeShapes()
Computes the shapes of all edges stored in the container.
Definition: NBEdgeCont.cpp:633
Represents a single node (junction) during network building.
Definition: NBNode.h:74
T get(const std::string &str) const
static void computeTurnDirections(NBNodeCont &nc, bool warn=true)
Computes turnaround destinations for all edges (if exist)
NBDistrictCont myDistrictCont
The used container for districts.
Definition: NBNetBuilder.h:246
#define SUMOReal
Definition: config.h:213
SUMOReal ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:130
const Boundary & getOrigBoundary() const
Returns the original boundary.
void init(NBEdgeCont &ec)
Initialises the map using the list of edge names.
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
Definition: NBNodeCont.cpp:109
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
Definition: NBEdgeCont.cpp:609
static long getCurrentMillis()
Returns the current time in milliseconds.
Definition: SysUtils.cpp:50
void printBuiltNodesStatistics() const
Prints statistics about built nodes.
bool myHaveLoadedNetworkWithoutInternalEdges
whether a .net.xml without internal edges was loaded
Definition: NBNetBuilder.h:252
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:201
NBNodeCont myNodeCont
The used container for nodes.
Definition: NBNetBuilder.h:234
void setTLControllingInformation(const NBEdgeCont &ec, const NBNodeCont &nc)
Informs the edges about being controlled by a tls.
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
Definition: NBNodeCont.h:127
Set z-values for all network positions based on data from a height map.
void moveConvertedBy(SUMOReal x, SUMOReal y)
Shifts the converted boundary by the given amounts.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
void setDefaults(int defaultNumLanes, SUMOReal defaultSpeed, int defaultPriority)
Sets the default values.
Definition: NBTypeCont.cpp:51
TrafficLightType
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.