Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
NBNetBuilder.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
23// Instance responsible for building networks
24/****************************************************************************/
25#include <config.h>
26
27#include <string>
28#include <fstream>
37#include "NBAlgorithms.h"
38#include "NBAlgorithms_Ramps.h"
40#include "NBHeightMapper.h"
41#include "NBNodeCont.h"
42#include "NBEdgeCont.h"
43#include "NBPTStop.h"
45#include "NBDistrictCont.h"
46#include "NBDistrict.h"
47#include "NBRequest.h"
48#include "NBTypeCont.h"
49#include "NBNetBuilder.h"
50
51
52// ===========================================================================
53// method definitions
54// ===========================================================================
56 myEdgeCont(myTypeCont),
57 myNetworkHaveCrossings(false) {
58}
59
60
62
63
64void
66 // apply options to type control
67 myTypeCont.setEdgeTypeDefaults(oc.getInt("default.lanenumber"), oc.getFloat("default.lanewidth"), oc.getFloat("default.speed"), oc.getFloat("default.friction"),
68 oc.getInt("default.priority"), parseVehicleClasses(oc.getString("default.allow"), oc.getString("default.disallow")),
69 SUMOXMLDefinitions::LaneSpreadFunctions.get(oc.getString("default.spreadtype")));
70 // apply options to edge control
72 // apply options to traffic light logics control
74 NBEdge::setDefaultConnectionLength(oc.getFloat("default.connection-length"));
75}
76
77
78void
79NBNetBuilder::compute(OptionsCont& oc, const std::set<std::string>& explicitTurnarounds, bool mayAddOrRemove) {
80 // reset shapes and angles for stable netedit computation
83 }
84
86
87 const bool lefthand = oc.getBool("lefthand");
88 if (lefthand) {
89 mirrorX();
90 }
91
92 // MODIFYING THE SETS OF NODES AND EDGES
93 // Removes edges that are connecting the same node
94 long before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Removing self-loops"));
95 int numRemovedEdges = 0;
98 if (mayAddOrRemove && oc.exists("remove-edges.isolated") && oc.getBool("remove-edges.isolated")) {
99 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Finding isolated roads"));
101 PROGRESS_TIME_MESSAGE(before);
102 }
103 if (mayAddOrRemove && oc.exists("keep-edges.components") && oc.getInt("keep-edges.components") > 0) {
104 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Finding largest components"));
105 const bool hasStops = oc.exists("ptstop-output") && oc.isSet("ptstop-output") && !myPTStopCont.getStops().empty();
106 numRemovedEdges += myNodeCont.removeComponents(myDistrictCont, myEdgeCont, oc.getInt("keep-edges.components"), hasStops);
107 PROGRESS_TIME_MESSAGE(before);
108 }
109 if (mayAddOrRemove && oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload")) {
110 // pre-process lines to set permissions
111 if (!myPTLineCont.getLines().empty()) {
112 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Revising public transport stops based on pt lines"));
114 PROGRESS_TIME_MESSAGE(before);
115 }
116 if (oc.isSet("keep-edges.explicit") || oc.isSet("keep-edges.input-file")) {
117 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Removing unwished edges"));
119 PROGRESS_TIME_MESSAGE(before);
120 }
121 const int removed = myEdgeCont.removeEdgesBySpeed(myDistrictCont);
122 if (removed > 0) {
123 numRemovedEdges += removed;
124 WRITE_MESSAGEF(TL(" Removed % edges because by minimum speed."), removed);
125 }
127 if (removed2 > 0) {
128 numRemovedEdges += removed2;
129 WRITE_MESSAGEF(TL(" Removed % edges based on vClass."), removed2);
130 }
131 }
132 if (mayAddOrRemove && oc.getFloat("keep-lanes.min-width") > 0.) {
133 const int removed = myEdgeCont.removeLanesByWidth(myDistrictCont, oc.getFloat("keep-lanes.min-width"));
134 if (removed > 0) {
135 numRemovedEdges += removed;
136 WRITE_MESSAGEF(TL(" Removed % edges because of lane width."), removed);
137 }
138 }
139 // Processing pt stops and lines
140 if (!myPTStopCont.getStops().empty()) {
141 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Processing public transport stops"));
142 if (!(oc.exists("ptline-output") && oc.isSet("ptline-output"))
143 && !oc.getBool("ptstop-output.no-bidi")) {
145 }
148 PROGRESS_TIME_MESSAGE(before);
149 }
150 if (mayAddOrRemove && oc.exists("keep-edges.components") && oc.getInt("keep-edges.components") > 0) {
151 // post process rail components unless they have stops
153 }
154 // removal is done, clean up roundabouts
155 if (numRemovedEdges > 0) {
157 }
158
159 if (!myPTLineCont.getLines().empty()) {
160 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Revising public transport stops based on pt lines"));
162 PROGRESS_TIME_MESSAGE(before);
163 }
164
165 if (oc.exists("ptline-clean-up") && oc.getBool("ptline-clean-up")) {
166 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Cleaning up public transport stops that are not served by any line"));
168 PROGRESS_TIME_MESSAGE(before);
169 } else {
170 int numDeletedStops = myPTStopCont.cleanupDeleted(myEdgeCont);
171 if (numDeletedStops > 0) {
172 WRITE_WARNINGF(TL("Removed % pt stops because they could not be assigned to the network"), toString(numDeletedStops));
173 }
174 }
175
176 if (!myPTStopCont.getStops().empty() && !oc.getBool("ptstop-output.no-bidi")) {
177 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Align pt stop id signs with corresponding edge id signs"));
179 PROGRESS_TIME_MESSAGE(before);
180 }
181 // analyze and fix railway topology
182 int numAddedBidi = 0;
183 if (oc.exists("railway.topology.all-bidi") && oc.getBool("railway.topology.all-bidi")) {
186 } else if (oc.exists("railway.topology.repair") && oc.getBool("railway.topology.repair")) {
187 // correct railway angles for angle-based connectivity heuristic
189 oc.getFloat("geometry.min-radius"), false,
190 oc.getBool("geometry.min-radius.fix.railways"), true);
193 }
195 if (numAddedBidi > 0) {
196 // update routes
198 }
199 if (oc.exists("railway.topology.direction-priority") && oc.getBool("railway.topology.direction-priority")) {
200 NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // recompute after new edges were added
202 } else if (oc.exists("railway.topology.extend-priority") && oc.getBool("railway.topology.extend-priority")) {
203 NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // recompute after new edges were added
205 }
206 if (oc.exists("railway.topology.output") && oc.isSet("railway.topology.output")) {
207 NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // recompute after new edges were added
209 }
210 if (oc.exists("railway.geometry.straighten") && oc.getBool("railway.geometry.straighten")) {
211 NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // recompute after new edges were added
213 }
214
215
216 if (mayAddOrRemove && oc.exists("edges.join-tram-dist") && oc.getFloat("edges.join-tram-dist") >= 0) {
217 // should come before joining junctions
218 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Joining tram edges"));
219 int numJoinedTramEdges = myEdgeCont.joinTramEdges(myDistrictCont, myPTStopCont, myPTLineCont, oc.getFloat("edges.join-tram-dist"));
220 PROGRESS_TIME_MESSAGE(before);
221 if (numJoinedTramEdges > 0) {
222 WRITE_MESSAGEF(TL(" Joined % tram edges into roads."), toString(numJoinedTramEdges));
223 }
224 }
225 if (oc.getBool("junctions.join")
226 || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))
227 || oc.getBool("tls.guess.joining")
228 || (oc.exists("tls.guess-signals") && oc.getBool("tls.guess-signals"))) {
229 // preliminary geometry computations to determine the length of edges
230 // This depends on turning directions and sorting of edge list
231 // in case junctions are joined geometry computations have to be repeated
232 // preliminary roundabout computations to avoid damaging roundabouts via junctions.join or ramps.guess
238 if (oc.getBool("roundabouts.guess")) {
240 }
241 const std::set<EdgeSet>& roundabouts = myEdgeCont.getRoundabouts();
242 for (std::set<EdgeSet>::const_iterator it_round = roundabouts.begin();
243 it_round != roundabouts.end(); ++it_round) {
244 std::vector<std::string> nodeIDs;
245 for (EdgeSet::const_iterator it_edge = it_round->begin(); it_edge != it_round->end(); ++it_edge) {
246 nodeIDs.push_back((*it_edge)->getToNode()->getID());
247 }
249 }
251 } else if ((myEdgeCont.hasGuessedRoundabouts() || oc.getBool("crossings.guess")) && oc.getBool("roundabouts.guess")) {
254 }
255 // join junctions (may create new "geometry"-nodes so it needs to come before removing these
256 if (mayAddOrRemove && oc.exists("junctions.join-exclude") && oc.isSet("junctions.join-exclude")) {
257 myNodeCont.addJoinExclusion(oc.getStringVector("junctions.join-exclude"));
258 }
260 if (mayAddOrRemove && oc.getBool("junctions.join")) {
261 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Joining junction clusters"));
262 numJoined += myNodeCont.joinJunctions(oc.getFloat("junctions.join-dist"), myDistrictCont, myEdgeCont, myTLLCont, myPTStopCont);
263 PROGRESS_TIME_MESSAGE(before);
264 }
265 if (numJoined > 0) {
266 WRITE_MESSAGEF(TL(" Joined % junction cluster(s)."), toString(numJoined));
267 }
268 if (mayAddOrRemove && oc.exists("junctions.join-same") && oc.getBool("junctions.join-same")) {
269 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Joining junctions with identical coordinates"));
271 PROGRESS_TIME_MESSAGE(before);
272 if (numJoined2 > 0) {
273 WRITE_MESSAGEF(TL(" Joined % junctions."), toString(numJoined2));
274 }
275 }
276 //
277 if (mayAddOrRemove && oc.exists("join-lanes") && oc.getBool("join-lanes")) {
278 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Joining lanes"));
280 PROGRESS_TIME_MESSAGE(before);
281 WRITE_MESSAGEF(TL(" Joined lanes on % edges."), toString(num));
282 }
283 //
284 if (mayAddOrRemove) {
285 const bool removeGeometryNodes = oc.exists("geometry.remove") && oc.getBool("geometry.remove");
286 before = PROGRESS_BEGIN_TIME_MESSAGE("Removing empty nodes" + std::string(removeGeometryNodes ? " and geometry nodes" : ""));
287 // removeUnwishedNodes needs turnDirections. @todo: try to call this less often
290 PROGRESS_TIME_MESSAGE(before);
291 WRITE_MESSAGEF(TL(" % nodes removed."), toString(numRemoved));
292 }
293
294 // MOVE TO ORIGIN
295 // compute new boundary after network modifications have taken place
296 Boundary boundary;
297 for (std::map<std::string, NBNode*>::const_iterator it = myNodeCont.begin(); it != myNodeCont.end(); ++it) {
298 boundary.add(it->second->getPosition());
299 }
300 for (std::map<std::string, NBEdge*>::const_iterator it = myEdgeCont.begin(); it != myEdgeCont.end(); ++it) {
301 boundary.add(it->second->getGeometry().getBoxBoundary());
302 }
303 geoConvHelper.setConvBoundary(boundary);
304
305 if (!oc.getBool("offset.disable-normalization") && oc.isDefault("offset.x") && oc.isDefault("offset.y")) {
306 moveToOrigin(geoConvHelper, lefthand);
307 }
308 geoConvHelper.computeFinal(lefthand); // information needed for location element fixed at this point
309
310 if (oc.exists("geometry.min-dist") && !oc.isDefault("geometry.min-dist")) {
311 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Reducing geometries"));
312 myEdgeCont.reduceGeometries(oc.getFloat("geometry.min-dist"));
313 PROGRESS_TIME_MESSAGE(before);
314 }
315 // @note: removing geometry can create similar edges so joinSimilarEdges must come afterwards
316 // @note: likewise splitting can destroy similarities so joinSimilarEdges must come before
317 if (mayAddOrRemove && oc.getBool("edges.join")) {
318 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Joining similar edges"));
319 const bool removeDuplicates = oc.exists("junctions.join-same") && oc.getBool("junctions.join-same");
321 // now we may have new chances to remove geometry if wished
322 if (oc.exists("geometry.remove") && oc.getBool("geometry.remove")) {
324 }
325 PROGRESS_TIME_MESSAGE(before);
326 }
327 if (oc.getBool("opposites.guess")) {
328 PROGRESS_BEGIN_MESSAGE(TL("guessing opposite direction edges"));
331 }
332 //
333 if (mayAddOrRemove && oc.exists("geometry.split") && oc.getBool("geometry.split")) {
334 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Splitting geometry edges"));
336 // newly split junctions might also be joinable
337 PROGRESS_TIME_MESSAGE(before);
338 if (oc.getBool("junctions.join-same")) {
340 if (numJoined3 > 0) {
341 WRITE_MESSAGEF(TL(" Joined % junctions after splitting geometry."), toString(numJoined3));
342 }
343 }
344 }
345 // turning direction
346 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing turning directions"));
348 PROGRESS_TIME_MESSAGE(before);
349 // correct edge geometries to avoid overlap
350 if (oc.exists("geometry.avoid-overlap") && oc.getBool("geometry.avoid-overlap")) {
352 }
353
354 // GUESS TLS POSITIONS
355 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Assigning nodes to traffic lights"));
356 if (oc.isSet("tls.set")) {
357 std::vector<std::string> tlControlledNodes = oc.getStringVector("tls.set");
359 for (std::vector<std::string>::const_iterator i = tlControlledNodes.begin(); i != tlControlledNodes.end(); ++i) {
360 NBNode* node = myNodeCont.retrieve(*i);
361 if (node == nullptr) {
362 WRITE_WARNING("Building a tl-logic for junction '" + *i + "' is not possible." + "\n The junction '" + *i + "' is not known.");
363 } else {
365 }
366 }
367 }
369 PROGRESS_TIME_MESSAGE(before);
370
371 // guess ramps (after guessing tls because ramps should not be build at traffic lights)
372 const bool modifyRamps = mayAddOrRemove && (
373 (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))
374 || (oc.exists("ramps.set") && oc.isSet("ramps.set")));
375 if (modifyRamps || (oc.exists("ramps.guess-acceleration-lanes") && oc.getBool("ramps.guess-acceleration-lanes"))) {
377 if (modifyRamps) {
378 PROGRESS_BEGIN_MESSAGE(TL("Guessing and setting on-/off-ramps"));
379 }
382 rc.computeRamps(*this, oc, mayAddOrRemove);
383
384 if (modifyRamps) {
385 PROGRESS_TIME_MESSAGE(before);
386 }
387 }
388 // guess bike lanes
389 if (mayAddOrRemove && ((oc.getBool("bikelanes.guess") || oc.getBool("bikelanes.guess.from-permissions")))) {
390 const int bikelanes = myEdgeCont.guessSpecialLanes(SVC_BICYCLE, oc.getFloat("default.bikelane-width"),
391 oc.getFloat("bikelanes.guess.min-speed"),
392 oc.getFloat("bikelanes.guess.max-speed"),
393 oc.getBool("bikelanes.guess.from-permissions"),
394 "bikelanes.guess.exclude",
395 myTLLCont);
396 WRITE_MESSAGEF(TL("Guessed % bike lanes."), toString(bikelanes));
397 }
398
399 // guess sidewalks
400 if (mayAddOrRemove && ((oc.getBool("sidewalks.guess") || oc.getBool("sidewalks.guess.from-permissions")))) {
401 const int sidewalks = myEdgeCont.guessSpecialLanes(SVC_PEDESTRIAN, oc.getFloat("default.sidewalk-width"),
402 oc.getFloat("sidewalks.guess.min-speed"),
403 oc.getFloat("sidewalks.guess.max-speed"),
404 oc.getBool("sidewalks.guess.from-permissions"),
405 "sidewalks.guess.exclude",
406 myTLLCont);
407 WRITE_MESSAGEF(TL("Guessed % sidewalks."), toString(sidewalks));
408 }
409 // check whether any not previously setable connections may be set now
411
412 // remap ids if wished
413 if (mayAddOrRemove) {
414 int numChangedEdges = myEdgeCont.remapIDs(oc.getBool("numerical-ids"), oc.isSet("reserved-ids"), oc.getString("prefix"), myPTStopCont);
415 int numChangedNodes = myNodeCont.remapIDs(oc.getBool("numerical-ids"), oc.isSet("reserved-ids"), oc.getString("prefix"), myTLLCont);
416 if (numChangedEdges + numChangedNodes > 0) {
417 WRITE_MESSAGEF(TL("Remapped % edge IDs and % node IDs."), toString(numChangedEdges), toString(numChangedNodes));
418 }
419 }
420
421 //
422 if (oc.exists("geometry.max-angle")) {
424 DEG2RAD(oc.getFloat("geometry.max-angle")),
425 oc.getBool("geometry.max-angle.fix"),
426 oc.getFloat("geometry.min-radius"),
427 oc.getBool("geometry.min-radius.fix"),
428 oc.getBool("geometry.min-radius.fix.railways"));
429 }
430
431 // GEOMETRY COMPUTATION
432 //
433 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Sorting nodes' edges"));
435 PROGRESS_TIME_MESSAGE(before);
437 //
438 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing node shapes"));
439 if (oc.exists("geometry.junction-mismatch-threshold")) {
440 myNodeCont.computeNodeShapes(oc.getFloat("geometry.junction-mismatch-threshold"));
441 } else {
443 }
444 PROGRESS_TIME_MESSAGE(before);
445 //
446 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing edge shapes"));
447 myEdgeCont.computeEdgeShapes(oc.getBool("geometry.max-grade.fix") ? oc.getFloat("geometry.max-grade") / 100 : -1);
448 PROGRESS_TIME_MESSAGE(before);
449 // resort edges based on the node and edge shapes
452
453 // APPLY SPEED MODIFICATIONS
454 if (oc.exists("speed.offset")) {
455 const double speedOffset = oc.getFloat("speed.offset");
456 const double speedFactor = oc.getFloat("speed.factor");
457 const double speedMin = oc.getFloat("speed.minimum");
458 if (speedOffset != 0 || speedFactor != 1 || speedMin > 0) {
459 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Applying speed modifications"));
460 for (const auto& it : myEdgeCont) {
461 NBEdge* const e = it.second;
462 for (int i = 0; i < e->getNumLanes(); i++) {
463 e->setSpeed(i, MAX2(e->getLaneSpeed(i) * speedFactor + speedOffset, speedMin));
464 }
465 }
466 PROGRESS_TIME_MESSAGE(before);
467 }
468 }
469
470 // CONNECTIONS COMPUTATION
471 //
472 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing node types"));
474 PROGRESS_TIME_MESSAGE(before);
475 //
476 myNetworkHaveCrossings = oc.getBool("walkingareas");
477 if (mayAddOrRemove && oc.getBool("crossings.guess")) {
479 int crossings = 0;
480 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
481 crossings += (*i).second->guessCrossings();
482 }
483 WRITE_MESSAGEF(TL("Guessed % pedestrian crossings."), toString(crossings));
484 }
486 bool haveValidCrossings = false;
487 // recheck whether we had crossings in the input
488 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
489 if (i->second->getCrossings().size() > 0) {
491 haveValidCrossings = true;
492 break;
493 } else if (i->second->getCrossingsIncludingInvalid().size() > 0) {
495 }
496 }
497 if (myNetworkHaveCrossings && !haveValidCrossings) {
498 // initial crossings removed or invalidated, keep walkingareas
499 oc.resetWritable();
500 oc.set("walkingareas", "true");
501 }
502 }
503
504 if (!mayAddOrRemove && myNetworkHaveCrossings) {
505 // crossings added via netedit
506 oc.resetWritable();
507 oc.set("no-internal-links", "false");
508 }
509
510 //
511 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing priorities"));
513 PROGRESS_TIME_MESSAGE(before);
514 //
515 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing approached edges"));
516 myEdgeCont.computeEdge2Edges(oc.getBool("no-left-connections"));
517 PROGRESS_TIME_MESSAGE(before);
518 //
519 if (oc.getBool("roundabouts.guess")) {
520 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Guessing and setting roundabouts"));
521 const int numGuessed = myEdgeCont.guessRoundabouts();
522 if (numGuessed > 0) {
523 WRITE_MESSAGEF(TL(" Guessed % roundabout(s)."), toString(numGuessed));
524 }
525 PROGRESS_TIME_MESSAGE(before);
526 }
528 //
529 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing approaching lanes"));
531 PROGRESS_TIME_MESSAGE(before);
532 //
533 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Dividing of lanes on approached lanes"));
536 PROGRESS_TIME_MESSAGE(before);
537 //
538 if (oc.getBool("fringe.guess")) {
539 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Guessing Network fringe"));
540 const int numGuessed = myNodeCont.guessFringe();
541 if (numGuessed > 0) {
542 WRITE_MESSAGEF(TL(" Guessed % fringe nodes."), toString(numGuessed));
543 }
544 PROGRESS_TIME_MESSAGE(before);
545 }
546 //
547 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Processing turnarounds"));
548 if (!oc.getBool("no-turnarounds")) {
550 oc.getBool("no-turnarounds.tls"),
551 oc.getBool("no-turnarounds.fringe"),
552 oc.getBool("no-turnarounds.except-deadend"),
553 oc.getBool("no-turnarounds.except-turnlane"),
554 oc.getBool("no-turnarounds.geometry"));
555 } else {
556 myEdgeCont.appendTurnarounds(explicitTurnarounds, oc.getBool("no-turnarounds.tls"));
557 }
558 if (oc.exists("railway.topology.repair.stop-turn") && oc.getBool("railway.topology.repair.stop-turn")
559 && myPTStopCont.getStops().size() > 0) {
560 // allow direction reversal at all bidi-edges with stops
562 }
563 PROGRESS_TIME_MESSAGE(before);
564 //
565 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Rechecking of lane endings"));
567 PROGRESS_TIME_MESSAGE(before);
568
569 if (myNetworkHaveCrossings && !oc.getBool("no-internal-links")) {
570 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
571 i->second->buildCrossingsAndWalkingAreas();
572 }
573 } else {
574 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
575 // needed by netedit if the last crossings was deleted from the network
576 // and walkingareas have been invalidated since the last call to compute()
577 i->second->discardWalkingareas();
578 }
579 if (oc.getBool("no-internal-links")) {
580 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
581 i->second->discardAllCrossings(false);
582 }
583 }
584 }
585 // join traffic lights (after building connections)
586 if (oc.getBool("tls.join")) {
587 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Joining traffic light nodes"));
588 myNodeCont.joinTLS(myTLLCont, oc.getFloat("tls.join-dist"));
589 PROGRESS_TIME_MESSAGE(before);
590 }
591
592 // COMPUTING RIGHT-OF-WAY AND TRAFFIC LIGHT PROGRAMS
593 //
594 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing traffic light control information"));
596 if (oc.exists("opendrive-files") && oc.isSet("opendrive-files")) {
598 }
599 PROGRESS_TIME_MESSAGE(before);
600 //
601 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing node logics"));
603 PROGRESS_TIME_MESSAGE(before);
604
605 //
606 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Computing traffic light logics"));
607 std::pair<int, int> numbers = myTLLCont.computeLogics(oc);
608 PROGRESS_TIME_MESSAGE(before);
609 std::string progCount = "";
610 if (numbers.first != numbers.second) {
611 progCount = "(" + toString(numbers.second) + " programs) ";
612 }
613 WRITE_MESSAGEF(TL(" % traffic light(s) %computed."), toString(numbers.first), progCount);
614 if (oc.exists("opendrive-files") && oc.isSet("opendrive-files") && oc.getBool("opendrive.signal-groups")) {
616 }
617
618 for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
619 (*i).second->sortOutgoingConnectionsByIndex();
620 }
621 // FINISHING INNER EDGES
622 std::set<NBTrafficLightDefinition*> largeNodeTLS;
623 if (!oc.getBool("no-internal-links")) {
624 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Building inner edges"));
625 // walking areas shall only be built if crossings are wished as well
626 for (const auto& item : myNodeCont) {
627 if (item.second->buildInnerEdges() > NBTrafficLightDefinition::MIN_YELLOW_SECONDS) {
628 const std::set<NBTrafficLightDefinition*>& tlDefs = item.second->getControllingTLS();
629 largeNodeTLS.insert(tlDefs.begin(), tlDefs.end());
630 }
631 }
632 PROGRESS_TIME_MESSAGE(before);
633 }
634 // PATCH NODE SHAPES
635 if (oc.getFloat("junctions.scurve-stretch") > 0) {
636 // @note: nodes have collected correction hints in buildInnerEdges()
637 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("stretching junctions to smooth geometries"));
640 myEdgeCont.computeEdgeShapes(oc.getBool("geometry.max-grade.fix") ? oc.getFloat("geometry.max-grade") / 100 : -1);
641 for (const auto& item : myNodeCont) {
642 item.second->buildInnerEdges();
643 }
644 PROGRESS_TIME_MESSAGE(before);
645 }
646 if (myEdgeCont.getNumEdgeSplits() > 0 && !oc.getBool("no-internal-links")) {
647 // edges with custom lengths were split, this has to take into account
648 // internal edge lengths (after geometry computation)
650 }
651 // recheck phases for large junctions
652 for (NBTrafficLightDefinition* def : largeNodeTLS) {
654 }
655 // compute lane-to-lane node logics (require traffic lights and inner edges to be done)
657
658 // remove guessed traffic lights at junctions without conflicts (requires computeLogics2)
660
661 // compute keepClear status (requires computeLogics2)
663
664 //
665 if (oc.isSet("street-sign-output")) {
666 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Generating street signs"));
668 PROGRESS_TIME_MESSAGE(before);
669 }
670
671
672 if (lefthand != oc.getBool("flip-y-axis")) {
673 mirrorX();
674 }
675
676 if (oc.exists("geometry.check-overlap") && oc.getFloat("geometry.check-overlap") > 0) {
677 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Checking overlapping edges"));
678 myEdgeCont.checkOverlap(oc.getFloat("geometry.check-overlap"), oc.getFloat("geometry.check-overlap.vertical-threshold"));
679 PROGRESS_TIME_MESSAGE(before);
680 }
681 if (geoConvHelper.getConvBoundary().getZRange() > 0 && oc.getFloat("geometry.max-grade") > 0) {
682 before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Checking edge grade"));
683 // user input is in %
684 myEdgeCont.checkGrade(oc.getFloat("geometry.max-grade") / 100);
685 PROGRESS_TIME_MESSAGE(before);
686 }
687
688 // find accesses for pt rail stops and add bidi-stops
689 if (!myPTStopCont.getStops().empty()) {
690 // re-adapt stop lanes after adding special lanes and cutting edge shapes at junction
693 int numBidiStops = 0;
694 if (!oc.getBool("ptstop-output.no-bidi")) {
696 }
697 PROGRESS_BEGIN_MESSAGE(TL("Find accesses for pt rail stops"));
698 double maxRadius = oc.getFloat("railway.access-distance");
699 double accessFactor = oc.getFloat("railway.access-factor");
700 int maxCount = oc.getInt("railway.max-accesses");
701 myPTStopCont.findAccessEdgesForRailStops(myEdgeCont, maxRadius, maxCount, accessFactor);
702 PROGRESS_TIME_MESSAGE(before);
703 if (numBidiStops > 0) {
705 }
706 }
708 // ensure that all turning lanes have sufficient permissions
710
711 if (oc.exists("ignore-change-restrictions") && !oc.isDefault("ignore-change-restrictions")) {
712 SVCPermissions ignoring = parseVehicleClasses(oc.getStringVector("ignore-change-restrictions"));
714 }
715
717 // report on very large networks
718 if (MAX2(geoConvHelper.getConvBoundary().xmax(), geoConvHelper.getConvBoundary().ymax()) > 1000000 ||
719 MIN2(geoConvHelper.getConvBoundary().xmin(), geoConvHelper.getConvBoundary().ymin()) < -1000000) {
720 WRITE_WARNING(TL("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"));
721 }
722
723 // clean up OSM processing params
724 if (oc.exists("osm-files") && oc.isSet("osm-files")) {
725 for (auto item : myEdgeCont) {
726 item.second->unsetParameter(NBTrafficLightDefinition::OSM_DIRECTION);
727 }
728 }
729}
730
731
732void
733NBNetBuilder::moveToOrigin(GeoConvHelper& geoConvHelper, bool lefthand) {
734 long before = PROGRESS_BEGIN_TIME_MESSAGE(TL("Moving network to origin"));
735 Boundary boundary = geoConvHelper.getConvBoundary();
736 const double x = -boundary.xmin();
737 const double y = -(lefthand ? boundary.ymax() : boundary.ymin());
738 //if (lefthand) {
739 // y = boundary.ymax();
740 //}
741 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
742 (*i).second->reshiftPosition(x, y);
743 }
744 for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
745 (*i).second->reshiftPosition(x, y);
746 }
747 for (std::map<std::string, NBDistrict*>::const_iterator i = myDistrictCont.begin(); i != myDistrictCont.end(); ++i) {
748 (*i).second->reshiftPosition(x, y);
749 }
750 for (const auto& stopIt : myPTStopCont.getStops()) {
751 stopIt.second->reshiftPosition(x, y);
752 }
753 geoConvHelper.moveConvertedBy(x, y);
754 PROGRESS_TIME_MESSAGE(before);
755}
756
757
758void
760 // mirror the network along the X-axis
761 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
762 (*i).second->mirrorX();
763 }
764 for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
765 (*i).second->mirrorX();
766 }
767 for (std::map<std::string, NBDistrict*>::const_iterator i = myDistrictCont.begin(); i != myDistrictCont.end(); ++i) {
768 (*i).second->mirrorX();
769 }
770 for (const auto& stopIt : myPTStopCont.getStops()) {
771 stopIt.second->mirrorX();
772 }
773}
774
775
776bool
777NBNetBuilder::transformCoordinate(Position& from, bool includeInBoundary, GeoConvHelper* from_srs) {
778 Position orig(from);
779 bool ok = true;
781 && GeoConvHelper::getLoaded().usingGeoProjection()
782 && from_srs != nullptr
783 && from_srs->usingGeoProjection()
784 && *from_srs != GeoConvHelper::getLoaded()) {
785 from_srs->cartesian2geo(from);
786 ok &= GeoConvHelper::getLoaded().x2cartesian(from, false);
787 }
788 if (from_srs == nullptr || !GeoConvHelper::getProcessing().usingGeoProjection()) {
789 // if getProcessing is not a geo-projection, assume it a cartesian transformation (i.e. shift)
790 ok &= GeoConvHelper::getProcessing().x2cartesian(from, includeInBoundary);
791
792 if (from_srs == nullptr && GeoConvHelper::getProcessing().usingGeoProjection()
794 && GeoConvHelper::getLoaded().usingGeoProjection()) {
795 // apply geo patch to loaded geo-network (offset must match)
796 from = from + GeoConvHelper::getLoaded().getOffset();
797 }
798 }
799 if (ok) {
801 if (hm.ready()) {
802 if (from_srs != nullptr && from_srs->usingGeoProjection()) {
803 from_srs->cartesian2geo(orig);
804 }
805 from.setz(hm.getZ(orig));
806 }
807 }
808 const double eps = 1e-6;
809 from.set(std::round(from.x() / eps) * eps, std::round(from.y() / eps) * eps, std::round(from.z() / eps) * eps);
810 return ok;
811}
812
813
814bool
815NBNetBuilder::transformCoordinates(PositionVector& from, bool includeInBoundary, GeoConvHelper* from_srs) {
816 const double maxLength = OptionsCont::getOptions().getFloat("geometry.max-segment-length");
817 if (maxLength > 0 && from.size() > 1) {
818 // transformation to cartesian coordinates must happen before we can check segment length
819 PositionVector copy = from;
820 for (int i = 0; i < (int) from.size(); i++) {
821 transformCoordinate(copy[i], false);
822 }
823 addGeometrySegments(from, copy, maxLength);
824 }
825 bool ok = true;
826 for (int i = 0; i < (int) from.size(); i++) {
827 ok = ok && transformCoordinate(from[i], includeInBoundary, from_srs);
828 }
829 return ok;
830}
831
832
833int
834NBNetBuilder::addGeometrySegments(PositionVector& from, const PositionVector& cartesian, const double maxLength) {
835 // check lengths and insert new points where needed (in the original
836 // coordinate system)
837 int inserted = 0;
838 for (int i = 0; i < (int)cartesian.size() - 1; i++) {
839 Position start = from[i + inserted];
840 Position end = from[i + inserted + 1];
841 double length = cartesian[i].distanceTo(cartesian[i + 1]);
842 const Position step = (end - start) * (maxLength / length);
843 int steps = 0;
844 while (length > maxLength) {
845 length -= maxLength;
846 steps++;
847 from.insert(from.begin() + i + inserted + 1, start + (step * steps));
848 inserted++;
849 }
850 }
851 return inserted;
852}
853
854
855bool
857 // see GNELoadThread::fillOptions
858 return OptionsCont::getOptions().exists("new");
859}
860
861
862/****************************************************************************/
#define DEG2RAD(x)
Definition GeomHelper.h:35
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:296
#define WRITE_MESSAGEF(...)
Definition MsgHandler.h:298
#define WRITE_WARNING(msg)
Definition MsgHandler.h:295
#define PROGRESS_BEGIN_TIME_MESSAGE(msg)
Definition MsgHandler.h:301
#define TL(string)
Definition MsgHandler.h:315
#define PROGRESS_TIME_MESSAGE(before)
Definition MsgHandler.h:302
#define PROGRESS_DONE_MESSAGE()
Definition MsgHandler.h:300
#define PROGRESS_BEGIN_MESSAGE(msg)
Definition MsgHandler.h:299
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_PEDESTRIAN
pedestrian
T MIN2(T a, T b)
Definition StdDefs.h:76
T MAX2(T a, T b)
Definition StdDefs.h:82
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
A class that stores a 2D geometrical boundary.
Definition Boundary.h:39
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition Boundary.cpp:78
double ymin() const
Returns minimum y-coordinate.
Definition Boundary.cpp:130
double xmin() const
Returns minimum x-coordinate.
Definition Boundary.cpp:118
double ymax() const
Returns maximum y-coordinate.
Definition Boundary.cpp:136
double xmax() const
Returns maximum x-coordinate.
Definition Boundary.cpp:124
double getZRange() const
Returns the elevation range of the boundary (z-axis)
Definition Boundary.cpp:166
static methods for processing the coordinates conversion for the current net
const Position getOffset() const
Returns the network offset.
void setConvBoundary(const Boundary &boundary)
sets the converted boundary
bool x2cartesian(Position &from, bool includeInBoundary=true)
Converts the given coordinate into a cartesian and optionally update myConvBoundary.
void cartesian2geo(Position &cartesian) const
Converts the given cartesian (shifted) position to its geo (lat/long) representation.
void moveConvertedBy(double x, double y)
Shifts the converted boundary by the given amounts.
static GeoConvHelper & getProcessing()
the coordinate transformation to use for input conversion and processing
static int getNumLoaded()
static void computeFinal(bool lefthand=false)
compute the location attributes which will be used for output based on the loaded location data,...
bool usingGeoProjection() const
Returns whether a transformation from geo to metric coordinates will be performed.
const Boundary & getConvBoundary() const
Returns the converted boundary.
static GeoConvHelper & getLoaded()
the coordinate transformation that was loaded fron an input file
std::map< std::string, NBDistrict * >::const_iterator end() const
Returns the pointer to the end of the stored districts.
std::map< std::string, NBDistrict * >::const_iterator begin() const
Returns the pointer to the begin of the stored districts.
void computeEdgeShapes(double smoothElevationThreshold=-1)
Computes the shapes of all edges stored in the container.
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
int guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition NBEdgeCont.h:171
void updateAllChangeRestrictions(SVCPermissions ignoring)
modify all restrictions on lane changing for edges and connections
void recheckPostProcessConnections()
Try to set any stored connections.
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
void checkGeometries(const double maxAngle, bool fixAngle, const double minRadius, bool fix, bool fixRailways, bool silent=false)
void reduceGeometries(const double minDist)
void cleanupRoundabouts()
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition NBEdgeCont.h:178
void splitGeometry(NBDistrictCont &dc, NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
int getNumEdgeSplits() const
Returns the number of edge splits.
Definition NBEdgeCont.h:311
int joinTramEdges(NBDistrictCont &dc, NBPTStopCont &sc, NBPTLineCont &lc, double maxDist)
join tram edges into adjacent lanes
int removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
void generateStreetSigns()
assigns street signs to edges based on toNode types
bool hasGuessedRoundabouts() const
check if there is guessed roundabouts
Definition NBEdgeCont.h:547
void computeAngles()
compute all edge angles
void guessOpposites()
Sets opposite lane information for geometrically close edges.
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
int joinLanes(SVCPermissions perms)
join adjacent lanes with the given permissions
void checkOverlap(double threshold, double zThreshold) const
check whether edges overlap
int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string &excludeOpt, NBTrafficLightLogicCont &tlc)
add sidwalks to edges within the given limits or permissions and return the number of edges affected
void appendTurnarounds(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike)
Appends turnarounds to all edges stored in the container.
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
void fixSplitCustomLength()
adapt custom lengths of split edges to account for intersection size
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBPTStopCont &sc)
remap node IDs accoring to options –numerical-ids and –reserved-ids
int removeLanesByWidth(NBDistrictCont &dc, const double minWidth)
int removeEdgesBySpeed(NBDistrictCont &dc)
return number of edges removed
void checkGrade(double threshold) const
check whether edges are to steep
int removeEdgesByPermissions(NBDistrictCont &dc)
The representation of a single edge during network building.
Definition NBEdge.h:92
double getLaneSpeed(int lane) const
get lane speed
Definition NBEdge.cpp:2209
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
Definition NBEdge.cpp:4294
int getNumLanes() const
Returns the number of lanes.
Definition NBEdge.h:520
static void setDefaultConnectionLength(double length)
Definition NBEdge.h:390
static void computeEdgePriorities(NBNodeCont &nc)
Computes edge priorities within a node.
Set z-values for all network positions based on data from a height map.
double getZ(const Position &geo) const
returns height for the given geo coordinate (WGS84)
static const NBHeightMapper & get()
return the singleton instance (maybe 0)
bool ready() const
returns whether the NBHeightMapper has data
static bool transformCoordinates(PositionVector &from, bool includeInBoundary=true, GeoConvHelper *from_srs=nullptr)
void mirrorX()
mirror the network along the X-axis
NBNetBuilder()
Constructor.
NBTrafficLightLogicCont myTLLCont
The used container for traffic light logics.
void moveToOrigin(GeoConvHelper &geoConvHelper, bool lefthand)
shift network so its lower left corner is at 0,0
bool myNetworkHaveCrossings
flag to indicate that network has crossings
NBDistrictCont myDistrictCont
The used container for districts.
static int addGeometrySegments(PositionVector &from, const PositionVector &cartesian, const double maxLength)
insertion geometry points to ensure maximum segment length between points
NBPTLineCont myPTLineCont
The used container for pt stops.
NBEdgeCont myEdgeCont
The used container for edges.
NBParkingCont myParkingCont
~NBNetBuilder()
Destructor.
NBTypeCont myTypeCont
The used container for street types.
NBPTStopCont myPTStopCont
The used container for pt stops.
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
static bool transformCoordinate(Position &from, bool includeInBoundary=true, GeoConvHelper *from_srs=nullptr)
transforms loaded coordinates handles projections, offsets (using GeoConvHelper) and import of height...
void compute(OptionsCont &oc, const std::set< std::string > &explicitTurnarounds=std::set< std::string >(), bool mayAddOrRemove=true)
Performs the network building steps.
NBNodeCont myNodeCont
The used container for nodes.
static bool runningNetedit()
whether netbuilding takes place in the context of netedit
void avoidOverlap()
fix overlap
int removeRailComponents(NBDistrictCont &dc, NBEdgeCont &ec, NBPTStopCont &sc)
std::map< std::string, NBNode * >::const_iterator begin() const
Returns the pointer to the begin of the stored nodes.
Definition NBNodeCont.h:113
void recheckGuessedTLS(NBTrafficLightLogicCont &tlc)
recheck myGuessedTLS after node logics are computed
void computeKeepClear()
compute keepClear status for all connections
int removeSelfLoops(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes self-loop edges (edges where the source and the destination node are the same)
void addJoinExclusion(const std::vector< std::string > &ids)
int joinLoadedClusters(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins loaded junction clusters (see NIXMLNodesHandler)
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBTrafficLightLogicCont &tlc)
remap node IDs according to options –numerical-ids and –reserved-ids
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
void joinTLS(NBTrafficLightLogicCont &tlc, double maxdist)
Builds clusters of tls-controlled junctions and joins the control if possible.
int removeUnwishedNodes(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc, NBPTStopCont &sc, NBPTLineCont &lc, NBParkingCont &pc, bool removeGeometryNodes)
Removes "unwished" nodes.
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Definition NBNodeCont.h:118
int removeComponents(NBDistrictCont &dc, NBEdgeCont &ec, const int numKeep, bool hasPTStops)
Checks the network for weak connectivity and removes all but the largest components....
void computeLogics2(const NBEdgeCont &ec, OptionsCont &oc)
compute right-of-way logic for all lane-to-lane connections
void joinSimilarEdges(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc, bool removeDuplicates)
Joins edges connecting the same nodes.
int removeIsolatedRoads(NBDistrictCont &dc, NBEdgeCont &ec)
Removes sequences of edges that are not connected with a junction. Simple roads without junctions som...
void setAsTLControlled(NBNode *node, NBTrafficLightLogicCont &tlc, TrafficLightType type, std::string id="")
Sets the given node as being controlled by a tls.
void computeLogics(const NBEdgeCont &ec)
build the list of outgoing edges and lanes
void computeNodeShapes(double mismatchThreshold=-1)
Compute the junction shape for this node.
void guessTLs(OptionsCont &oc, NBTrafficLightLogicCont &tlc)
Guesses which junctions or junction clusters shall be controlled by tls.
int guessFringe()
guess and mark fringe nodes
int joinJunctions(double maxDist, NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc, NBPTStopCont &sc)
Joins junctions that are very close together.
void computeLanes2Lanes()
divides the incoming lanes on outgoing lanes
int joinSameJunctions(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins junctions with the same coordinates regardless of topology.
bool resetNodeShapes()
reset all node shapes
Represents a single node (junction) during network building.
Definition NBNode.h:66
static void computeNodeTypes(NBNodeCont &nc, NBTrafficLightLogicCont &tlc)
Computes node types.
static void validateRailCrossings(NBNodeCont &nc, NBTrafficLightLogicCont &tlc)
Checks rail_crossing for validity.
static void sortNodesEdges(NBNodeCont &nc, bool useNodeShape=false)
Sorts a node's edges clockwise regarding driving direction.
void fixPermissions()
ensure that all turn lanes have sufficient permissions
void process(NBEdgeCont &ec, NBPTStopCont &sc, bool routeOnly=false)
std::set< std::string > & getServedPTStops()
const std::map< std::string, NBPTLine * > & getLines() const
void removeInvalidEdges(const NBEdgeCont &ec)
filter out edges that were removed due to –geometry.remove
void fixBidiStops(const NBEdgeCont &ec)
select the correct stop on superposed rail edges
int cleanupDeleted(NBEdgeCont &cont)
remove stops on non existing (removed) edges
const std::map< std::string, std::shared_ptr< NBPTStop > > & getStops() const
Returns an unmodifiable reference to the stored pt stops.
void postprocess(std::set< std::string > &usedStops)
void localizePTStops(NBEdgeCont &cont)
void assignEdgeForFloatingStops(NBEdgeCont &cont, double maxRadius)
void findAccessEdgesForRailStops(NBEdgeCont &cont, double maxRadius, int maxCount, double accessFactor)
int generateBidiStops(NBEdgeCont &cont)
duplicate stops for superposed rail edges and return the number of generated stops
void assignLanes(NBEdgeCont &cont)
static int straigthenCorrdidor(NBEdgeCont &ec, double maxAngle)
static int guessRailSignals(NBEdgeCont &ec, NBPTStopCont &sc)
static int repairTopology(NBEdgeCont &ec, NBPTStopCont &sc, NBPTLineCont &lc)
static void extendDirectionPriority(NBEdgeCont &ec, bool fromUniDir)
static void analyzeTopology(NBEdgeCont &ec)
static int makeAllBidi(NBEdgeCont &ec)
void computeRamps(NBNetBuilder &nb, OptionsCont &oc, bool mayAddOrRemove)
static void reportWarnings()
reports warnings if any occurred
The base class for traffic light logic definitions.
static const std::string OSM_DIRECTION
processing parameter for rail signal edges and nodes
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
void setOpenDriveSignalParameters()
set OpenDRIVE signal reference parameters after all link indices are known
bool computeSingleLogic(OptionsCont &oc, NBTrafficLightDefinition *def)
Computes a specific traffic light logic (using by netedit)
void applyOpenDriveControllers(OptionsCont &oc)
post processing of signal programs to group tl indices according to OpenDrive controllers (signal gro...
std::pair< int, int > computeLogics(OptionsCont &oc)
Computes the traffic light logics using the stored definitions and stores the results.
void setTLControllingInformation(const NBEdgeCont &ec, const NBNodeCont &nc)
Informs the edges about being controlled by a tls.
static void computeTurnDirections(NBNodeCont &nc, bool warn=true)
Computes turnaround destinations for all edges (if exist)
void setEdgeTypeDefaults(int defaultNumLanes, double defaultLaneWidth, double defaultSpeed, double defaultFriction, int defaultPriority, SVCPermissions defaultPermissions, LaneSpreadFunction defaultSpreadType)
Sets the default values.
A storage for options typed value containers)
Definition OptionsCont.h:89
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool exists(const std::string &name) const
Returns the information whether the named option is known.
bool set(const std::string &name, const std::string &value, const bool append=false)
Sets the given value for the named option.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
void resetWritable()
Resets all options to be writeable.
static OptionsCont & getOptions()
Retrieves the options.
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
void set(double x, double y)
set positions x and y
Definition Position.h:85
double x() const
Returns the x-position.
Definition Position.h:55
void setz(double z)
set position z
Definition Position.h:80
double z() const
Returns the z-position.
Definition Position.h:65
double y() const
Returns the y-position.
Definition Position.h:60
A list of positions.
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
T get(const std::string &str) const
static long getCurrentMillis()
Returns the current time in milliseconds.
Definition SysUtils.cpp:44