Eclipse SUMO - Simulation of Urban MObility
NBNetBuilder.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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>
29#include "NBNetBuilder.h"
30#include "NBNodeCont.h"
31#include "NBEdgeCont.h"
33#include "NBDistrictCont.h"
34#include "NBDistrict.h"
35#include "NBRequest.h"
36#include "NBTypeCont.h"
45#include "NBAlgorithms.h"
46#include "NBAlgorithms_Ramps.h"
48#include "NBHeightMapper.h"
49
50
51// ===========================================================================
52// method definitions
53// ===========================================================================
55 myEdgeCont(myTypeCont),
56 myNetworkHaveCrossings(false) {
57}
58
59
61
62
63void
65 // apply options to type control
66 myTypeCont.setEdgeTypeDefaults(oc.getInt("default.lanenumber"), oc.getFloat("default.lanewidth"), oc.getFloat("default.speed"), oc.getFloat("default.friction"),
67 oc.getInt("default.priority"), parseVehicleClasses(oc.getString("default.allow"), oc.getString("default.disallow")),
68 SUMOXMLDefinitions::LaneSpreadFunctions.get(oc.getString("default.spreadtype")));
69 // apply options to edge control
71 // apply options to traffic light logics control
73 NBEdge::setDefaultConnectionLength(oc.getFloat("default.connection-length"));
74}
75
76
77void
78NBNetBuilder::compute(OptionsCont& oc, const std::set<std::string>& explicitTurnarounds, bool mayAddOrRemove) {
80
81 const bool lefthand = oc.getBool("lefthand");
82 if (lefthand) {
83 mirrorX();
84 }
85
86 // MODIFYING THE SETS OF NODES AND EDGES
87 // Removes edges that are connecting the same node
88 long before = PROGRESS_BEGIN_TIME_MESSAGE("Removing self-loops");
91 if (mayAddOrRemove && oc.exists("remove-edges.isolated") && oc.getBool("remove-edges.isolated")) {
92 before = PROGRESS_BEGIN_TIME_MESSAGE("Finding isolated roads");
95 }
96 if (mayAddOrRemove && oc.exists("keep-edges.components") && oc.getInt("keep-edges.components") > 0) {
97 before = PROGRESS_BEGIN_TIME_MESSAGE("Finding largest components");
98 const bool hasStops = oc.exists("ptstop-output") && oc.isSet("ptstop-output") && myPTStopCont.size() > 0;
99 myNodeCont.removeComponents(myDistrictCont, myEdgeCont, oc.getInt("keep-edges.components"), hasStops);
100 PROGRESS_TIME_MESSAGE(before);
101 }
102 if (mayAddOrRemove && oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload")) {
103 if (oc.isSet("keep-edges.explicit") || oc.isSet("keep-edges.input-file")) {
104 before = PROGRESS_BEGIN_TIME_MESSAGE("Removing unwished edges");
106 PROGRESS_TIME_MESSAGE(before);
107 }
108 }
109 // Processing pt stops and lines
110 if (!myPTStopCont.getStops().empty()) {
111 before = PROGRESS_BEGIN_TIME_MESSAGE("Processing public transport stops");
112 if (!(oc.exists("ptline-output") && oc.isSet("ptline-output"))
113 && !oc.getBool("ptstop-output.no-bidi")) {
115 }
118 PROGRESS_TIME_MESSAGE(before);
119 }
120 if (mayAddOrRemove && oc.exists("keep-edges.components") && oc.getInt("keep-edges.components") > 0) {
121 // post process rail components unless they have stops
123 }
124
125 if (!myPTLineCont.getLines().empty()) {
126 before = PROGRESS_BEGIN_TIME_MESSAGE("Revising public transport stops based on pt lines");
128 PROGRESS_TIME_MESSAGE(before);
129 }
130
131 if (oc.exists("ptline-clean-up") && oc.getBool("ptline-clean-up")) {
132 before = PROGRESS_BEGIN_TIME_MESSAGE("Cleaning up public transport stops that are not served by any line");
134 PROGRESS_TIME_MESSAGE(before);
135 } else {
136 int numDeletedStops = myPTStopCont.cleanupDeleted(myEdgeCont);
137 if (numDeletedStops > 0) {
138 WRITE_WARNING("Removed " + toString(numDeletedStops) + " pt stops because they could not be assigned to the network");
139 }
140 }
141
142 if (!myPTStopCont.getStops().empty() && !oc.getBool("ptstop-output.no-bidi")) {
143 before = PROGRESS_BEGIN_TIME_MESSAGE("Align pt stop id signs with corresponding edge id signs");
145 PROGRESS_TIME_MESSAGE(before);
146 }
147
148 // analyze and fix railway topology
149 int numAddedBidi = 0;
150 if (oc.exists("railway.topology.all-bidi") && oc.getBool("railway.topology.all-bidi")) {
153 } else if (oc.exists("railway.topology.repair") && oc.getBool("railway.topology.repair")) {
154 // correct railway angles for angle-based connectivity heuristic
156 oc.getFloat("geometry.min-radius"), false,
157 oc.getBool("geometry.min-radius.fix.railways"), true);
160 }
161 if (numAddedBidi > 0) {
162 // update routes
164 }
165 if (oc.exists("railway.topology.direction-priority") && oc.getBool("railway.topology.direction-priority")) {
166 NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // recompute after new edges were added
168 } else if (oc.exists("railway.topology.extend-priority") && oc.getBool("railway.topology.extend-priority")) {
169 NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // recompute after new edges were added
171 }
172 if (oc.exists("railway.topology.output") && oc.isSet("railway.topology.output")) {
173 NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false); // recompute after new edges were added
175 }
176
177
178 if (mayAddOrRemove && oc.exists("edges.join-tram-dist") && oc.getFloat("edges.join-tram-dist") >= 0) {
179 // should come before joining junctions
180 before = PROGRESS_BEGIN_TIME_MESSAGE("Joining tram edges");
181 int numJoinedTramEdges = myEdgeCont.joinTramEdges(myDistrictCont, myPTStopCont, myPTLineCont, oc.getFloat("edges.join-tram-dist"));
182 PROGRESS_TIME_MESSAGE(before);
183 if (numJoinedTramEdges > 0) {
184 WRITE_MESSAGE(" Joined " + toString(numJoinedTramEdges) + " tram edges into roads.");
185 }
186 }
187 if (oc.getBool("junctions.join")
188 || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))
189 || oc.getBool("tls.guess.joining")
190 || (oc.exists("tls.guess-signals") && oc.getBool("tls.guess-signals"))) {
191 // preliminary geometry computations to determine the length of edges
192 // This depends on turning directions and sorting of edge list
193 // in case junctions are joined geometry computations have to be repeated
194 // preliminary roundabout computations to avoid damaging roundabouts via junctions.join or ramps.guess
200 if (oc.getBool("roundabouts.guess")) {
202 }
203 const std::set<EdgeSet>& roundabouts = myEdgeCont.getRoundabouts();
204 for (std::set<EdgeSet>::const_iterator it_round = roundabouts.begin();
205 it_round != roundabouts.end(); ++it_round) {
206 std::vector<std::string> nodeIDs;
207 for (EdgeSet::const_iterator it_edge = it_round->begin(); it_edge != it_round->end(); ++it_edge) {
208 nodeIDs.push_back((*it_edge)->getToNode()->getID());
209 }
211 }
213 } else if (myEdgeCont.hasGuessedRoundabouts() && oc.getBool("roundabouts.guess")) {
215 }
216 // join junctions (may create new "geometry"-nodes so it needs to come before removing these
217 if (mayAddOrRemove && oc.exists("junctions.join-exclude") && oc.isSet("junctions.join-exclude")) {
218 myNodeCont.addJoinExclusion(oc.getStringVector("junctions.join-exclude"));
219 }
221 if (mayAddOrRemove && oc.getBool("junctions.join")) {
222 before = PROGRESS_BEGIN_TIME_MESSAGE("Joining junction clusters");
223 numJoined += myNodeCont.joinJunctions(oc.getFloat("junctions.join-dist"), myDistrictCont, myEdgeCont, myTLLCont, myPTStopCont);
224 PROGRESS_TIME_MESSAGE(before);
225 }
226 if (numJoined > 0) {
227 WRITE_MESSAGE(" Joined " + toString(numJoined) + " junction cluster(s).");
228 }
229 if (mayAddOrRemove && oc.exists("junctions.join-same") && oc.getBool("junctions.join-same")) {
230 before = PROGRESS_BEGIN_TIME_MESSAGE("Joining junctions with identical coordinates");
232 PROGRESS_TIME_MESSAGE(before);
233 if (numJoined2 > 0) {
234 WRITE_MESSAGE(" Joined " + toString(numJoined2) + " junctions.");
235 }
236 }
237 //
238 if (mayAddOrRemove && oc.exists("join-lanes") && oc.getBool("join-lanes")) {
239 before = PROGRESS_BEGIN_TIME_MESSAGE("Joining lanes");
241 PROGRESS_TIME_MESSAGE(before);
242 WRITE_MESSAGE(" Joined lanes on " + toString(num) + " edges.");
243 }
244 //
245 if (mayAddOrRemove) {
246 const bool removeGeometryNodes = oc.exists("geometry.remove") && oc.getBool("geometry.remove");
247 before = PROGRESS_BEGIN_TIME_MESSAGE("Removing empty nodes" + std::string(removeGeometryNodes ? " and geometry nodes" : ""));
248 // removeUnwishedNodes needs turnDirections. @todo: try to call this less often
251 PROGRESS_TIME_MESSAGE(before);
252 WRITE_MESSAGE(" " + toString(numRemoved) + " nodes removed.");
253 }
254
255 // MOVE TO ORIGIN
256 // compute new boundary after network modifications have taken place
257 Boundary boundary;
258 for (std::map<std::string, NBNode*>::const_iterator it = myNodeCont.begin(); it != myNodeCont.end(); ++it) {
259 boundary.add(it->second->getPosition());
260 }
261 for (std::map<std::string, NBEdge*>::const_iterator it = myEdgeCont.begin(); it != myEdgeCont.end(); ++it) {
262 boundary.add(it->second->getGeometry().getBoxBoundary());
263 }
264 geoConvHelper.setConvBoundary(boundary);
265
266 if (!oc.getBool("offset.disable-normalization") && oc.isDefault("offset.x") && oc.isDefault("offset.y")) {
267 moveToOrigin(geoConvHelper, lefthand);
268 }
269 geoConvHelper.computeFinal(lefthand); // information needed for location element fixed at this point
270
271 if (oc.exists("geometry.min-dist") && !oc.isDefault("geometry.min-dist")) {
272 before = PROGRESS_BEGIN_TIME_MESSAGE("Reducing geometries");
273 myEdgeCont.reduceGeometries(oc.getFloat("geometry.min-dist"));
274 PROGRESS_TIME_MESSAGE(before);
275 }
276 // @note: removing geometry can create similar edges so joinSimilarEdges must come afterwards
277 // @note: likewise splitting can destroy similarities so joinSimilarEdges must come before
278 if (mayAddOrRemove && oc.getBool("edges.join")) {
279 before = PROGRESS_BEGIN_TIME_MESSAGE("Joining similar edges");
280 const bool removeDuplicates = oc.exists("junctions.join-same") && oc.getBool("junctions.join-same");
282 // now we may have new chances to remove geometry if wished
283 if (oc.exists("geometry.remove") && oc.getBool("geometry.remove")) {
285 }
286 PROGRESS_TIME_MESSAGE(before);
287 }
288 if (oc.getBool("opposites.guess")) {
289 PROGRESS_BEGIN_MESSAGE("guessing opposite direction edges");
292 }
293 //
294 if (mayAddOrRemove && oc.exists("geometry.split") && oc.getBool("geometry.split")) {
295 before = PROGRESS_BEGIN_TIME_MESSAGE("Splitting geometry edges");
297 // newly split junctions might also be joinable
298 PROGRESS_TIME_MESSAGE(before);
299 if (oc.getBool("junctions.join-same")) {
301 if (numJoined3 > 0) {
302 WRITE_MESSAGE(" Joined " + toString(numJoined3) + " junctions after splitting geometry.");
303 }
304 }
305 }
306 // turning direction
307 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing turning directions");
309 PROGRESS_TIME_MESSAGE(before);
310 // correct edge geometries to avoid overlap
311 if (oc.exists("geometry.avoid-overlap") && oc.getBool("geometry.avoid-overlap")) {
313 }
314
315 // GUESS TLS POSITIONS
316 before = PROGRESS_BEGIN_TIME_MESSAGE("Assigning nodes to traffic lights");
317 if (oc.isSet("tls.set")) {
318 std::vector<std::string> tlControlledNodes = oc.getStringVector("tls.set");
320 for (std::vector<std::string>::const_iterator i = tlControlledNodes.begin(); i != tlControlledNodes.end(); ++i) {
321 NBNode* node = myNodeCont.retrieve(*i);
322 if (node == nullptr) {
323 WRITE_WARNING("Building a tl-logic for junction '" + *i + "' is not possible." + "\n The junction '" + *i + "' is not known.");
324 } else {
326 }
327 }
328 }
330 PROGRESS_TIME_MESSAGE(before);
331
332 // guess ramps (after guessing tls because ramps should not be build at traffic lights)
333 const bool modifyRamps = mayAddOrRemove && (
334 (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))
335 || (oc.exists("ramps.set") && oc.isSet("ramps.set")));
336 if (modifyRamps || (oc.exists("ramps.guess-acceleration-lanes") && oc.getBool("ramps.guess-acceleration-lanes"))) {
338 if (modifyRamps) {
339 PROGRESS_BEGIN_MESSAGE("Guessing and setting on-/off-ramps");
340 }
342 NBRampsComputer::computeRamps(*this, oc, mayAddOrRemove);
343 if (modifyRamps) {
344 PROGRESS_TIME_MESSAGE(before);
345 }
346 }
347 // guess bike lanes
348 int addedLanes = 0;
349 if (mayAddOrRemove && ((oc.getBool("bikelanes.guess") || oc.getBool("bikelanes.guess.from-permissions")))) {
350 const int bikelanes = myEdgeCont.guessSpecialLanes(SVC_BICYCLE, oc.getFloat("default.bikelane-width"),
351 oc.getFloat("bikelanes.guess.min-speed"),
352 oc.getFloat("bikelanes.guess.max-speed"),
353 oc.getBool("bikelanes.guess.from-permissions"),
354 "bikelanes.guess.exclude",
355 myTLLCont);
356 WRITE_MESSAGE("Guessed " + toString(bikelanes) + " bike lanes.");
357 addedLanes += bikelanes;
358 }
359
360 // guess sidewalks
361 if (mayAddOrRemove && ((oc.getBool("sidewalks.guess") || oc.getBool("sidewalks.guess.from-permissions")))) {
362 const int sidewalks = myEdgeCont.guessSpecialLanes(SVC_PEDESTRIAN, oc.getFloat("default.sidewalk-width"),
363 oc.getFloat("sidewalks.guess.min-speed"),
364 oc.getFloat("sidewalks.guess.max-speed"),
365 oc.getBool("sidewalks.guess.from-permissions"),
366 "sidewalks.guess.exclude",
367 myTLLCont);
368 WRITE_MESSAGE("Guessed " + toString(sidewalks) + " sidewalks.");
369 addedLanes += sidewalks;
370 }
371 // check whether any not previously setable connections may be set now
373
374 // remap ids if wished
375 int numChangedEdges = myEdgeCont.remapIDs(oc.getBool("numerical-ids"), oc.isSet("reserved-ids"), oc.getString("prefix"), myPTStopCont);
376 int numChangedNodes = myNodeCont.remapIDs(oc.getBool("numerical-ids"), oc.isSet("reserved-ids"), oc.getString("prefix"), myTLLCont);
377 if (numChangedEdges + numChangedNodes > 0) {
378 WRITE_MESSAGE("Remapped " + toString(numChangedEdges) + " edge IDs and " + toString(numChangedNodes) + " node IDs.");
379 }
380
381 //
382 if (oc.exists("geometry.max-angle")) {
384 DEG2RAD(oc.getFloat("geometry.max-angle")),
385 oc.getFloat("geometry.min-radius"),
386 oc.getBool("geometry.min-radius.fix"),
387 oc.getBool("geometry.min-radius.fix.railways"));
388 }
389
390 // GEOMETRY COMPUTATION
391 //
392 before = PROGRESS_BEGIN_TIME_MESSAGE("Sorting nodes' edges");
394 PROGRESS_TIME_MESSAGE(before);
396 //
397 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing node shapes");
398 if (oc.exists("geometry.junction-mismatch-threshold")) {
399 myNodeCont.computeNodeShapes(oc.getFloat("geometry.junction-mismatch-threshold"));
400 } else {
402 }
403 PROGRESS_TIME_MESSAGE(before);
404 //
405 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing edge shapes");
406 myEdgeCont.computeEdgeShapes(oc.getBool("geometry.max-grade.fix") ? oc.getFloat("geometry.max-grade") / 100 : -1);
407 PROGRESS_TIME_MESSAGE(before);
408 // resort edges based on the node and edge shapes
411
412 // APPLY SPEED MODIFICATIONS
413 if (oc.exists("speed.offset")) {
414 const double speedOffset = oc.getFloat("speed.offset");
415 const double speedFactor = oc.getFloat("speed.factor");
416 const double speedMin = oc.getFloat("speed.minimum");
417 if (speedOffset != 0 || speedFactor != 1 || speedMin > 0) {
418 before = PROGRESS_BEGIN_TIME_MESSAGE("Applying speed modifications");
419 for (const auto& it : myEdgeCont) {
420 NBEdge* const e = it.second;
421 for (int i = 0; i < e->getNumLanes(); i++) {
422 e->setSpeed(i, MAX2(e->getLaneSpeed(i) * speedFactor + speedOffset, speedMin));
423 }
424 }
425 PROGRESS_TIME_MESSAGE(before);
426 }
427 }
428
429 // CONNECTIONS COMPUTATION
430 //
431 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing node types");
433 PROGRESS_TIME_MESSAGE(before);
434 //
435 myNetworkHaveCrossings = oc.getBool("walkingareas");
436 if (mayAddOrRemove && oc.getBool("crossings.guess")) {
438 int crossings = 0;
439 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
440 crossings += (*i).second->guessCrossings();
441 }
442 WRITE_MESSAGE("Guessed " + toString(crossings) + " pedestrian crossings.");
443 }
445 bool haveValidCrossings = false;
446 // recheck whether we had crossings in the input
447 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
448 if (i->second->getCrossings().size() > 0) {
450 haveValidCrossings = true;
451 break;
452 } else if (i->second->getCrossingsIncludingInvalid().size() > 0) {
454 }
455 }
456 if (myNetworkHaveCrossings && !haveValidCrossings) {
457 // initial crossings removed or invalidated, keep walkingareas
458 oc.resetWritable();
459 oc.set("walkingareas", "true");
460 }
461 }
462
463 if (!mayAddOrRemove && myNetworkHaveCrossings) {
464 // crossings added via netedit
465 oc.resetWritable();
466 oc.set("no-internal-links", "false");
467 }
468
469 //
470 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing priorities");
472 PROGRESS_TIME_MESSAGE(before);
473 //
474 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing approached edges");
475 myEdgeCont.computeEdge2Edges(oc.getBool("no-left-connections"));
476 PROGRESS_TIME_MESSAGE(before);
477 //
478 if (oc.getBool("roundabouts.guess")) {
479 before = PROGRESS_BEGIN_TIME_MESSAGE("Guessing and setting roundabouts");
480 const int numGuessed = myEdgeCont.guessRoundabouts();
481 if (numGuessed > 0) {
482 WRITE_MESSAGE(" Guessed " + toString(numGuessed) + " roundabout(s).");
483 }
484 PROGRESS_TIME_MESSAGE(before);
485 }
487 //
488 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing approaching lanes");
490 PROGRESS_TIME_MESSAGE(before);
491 //
492 before = PROGRESS_BEGIN_TIME_MESSAGE("Dividing of lanes on approached lanes");
495 PROGRESS_TIME_MESSAGE(before);
496 //
497 if (oc.getBool("fringe.guess")) {
498 before = PROGRESS_BEGIN_TIME_MESSAGE("Guessing Network fringe");
499 const int numGuessed = myNodeCont.guessFringe();
500 if (numGuessed > 0) {
501 WRITE_MESSAGE(" Guessed " + toString(numGuessed) + " fringe nodes.");
502 }
503 PROGRESS_TIME_MESSAGE(before);
504 }
505 //
506 before = PROGRESS_BEGIN_TIME_MESSAGE("Processing turnarounds");
507 if (!oc.getBool("no-turnarounds")) {
509 oc.getBool("no-turnarounds.tls"),
510 oc.getBool("no-turnarounds.fringe"),
511 oc.getBool("no-turnarounds.except-deadend"),
512 oc.getBool("no-turnarounds.except-turnlane"),
513 oc.getBool("no-turnarounds.geometry"));
514 } else {
515 myEdgeCont.appendTurnarounds(explicitTurnarounds, oc.getBool("no-turnarounds.tls"));
516 }
517 if (oc.exists("railway.topology.repair.stop-turn") && oc.getBool("railway.topology.repair.stop-turn")
518 && myPTStopCont.getStops().size() > 0) {
519 // allow direction reversal at all bidi-edges with stops
521 }
522 PROGRESS_TIME_MESSAGE(before);
523 //
524 before = PROGRESS_BEGIN_TIME_MESSAGE("Rechecking of lane endings");
526 PROGRESS_TIME_MESSAGE(before);
527
528 if (myNetworkHaveCrossings && !oc.getBool("no-internal-links")) {
529 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
530 i->second->buildCrossingsAndWalkingAreas();
531 }
532 } else {
533 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
534 // needed by netedit if the last crossings was deleted from the network
535 // and walkingareas have been invalidated since the last call to compute()
536 i->second->discardWalkingareas();
537 }
538 if (oc.getBool("no-internal-links")) {
539 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
540 i->second->discardAllCrossings(false);
541 }
542 }
543 }
544 // join traffic lights (after building connections)
545 if (oc.getBool("tls.join")) {
546 before = PROGRESS_BEGIN_TIME_MESSAGE("Joining traffic light nodes");
547 myNodeCont.joinTLS(myTLLCont, oc.getFloat("tls.join-dist"));
548 PROGRESS_TIME_MESSAGE(before);
549 }
550
551 // COMPUTING RIGHT-OF-WAY AND TRAFFIC LIGHT PROGRAMS
552 //
553 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing traffic light control information");
555 if (oc.exists("opendrive-files") && oc.isSet("opendrive-files")) {
557 }
558 PROGRESS_TIME_MESSAGE(before);
559 //
560 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing node logics");
562 PROGRESS_TIME_MESSAGE(before);
563
564 //
565 before = PROGRESS_BEGIN_TIME_MESSAGE("Computing traffic light logics");
566 std::pair<int, int> numbers = myTLLCont.computeLogics(oc);
567 PROGRESS_TIME_MESSAGE(before);
568 std::string progCount = "";
569 if (numbers.first != numbers.second) {
570 progCount = "(" + toString(numbers.second) + " programs) ";
571 }
572 WRITE_MESSAGE(" " + toString(numbers.first) + " traffic light(s) " + progCount + "computed.");
573
574 for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
575 (*i).second->sortOutgoingConnectionsByIndex();
576 }
577 // FINISHING INNER EDGES
578 std::set<NBTrafficLightDefinition*> largeNodeTLS;
579 if (!oc.getBool("no-internal-links")) {
580 before = PROGRESS_BEGIN_TIME_MESSAGE("Building inner edges");
581 // walking areas shall only be built if crossings are wished as well
582 for (const auto& item : myNodeCont) {
583 if (item.second->buildInnerEdges() > NBTrafficLightDefinition::MIN_YELLOW_SECONDS) {
584 const std::set<NBTrafficLightDefinition*>& tlDefs = item.second->getControllingTLS();
585 largeNodeTLS.insert(tlDefs.begin(), tlDefs.end());
586 }
587 }
588 PROGRESS_TIME_MESSAGE(before);
589 }
590 // PATCH NODE SHAPES
591 if (oc.getFloat("junctions.scurve-stretch") > 0) {
592 // @note: nodes have collected correction hints in buildInnerEdges()
593 before = PROGRESS_BEGIN_TIME_MESSAGE("stretching junctions to smooth geometries");
596 myEdgeCont.computeEdgeShapes(oc.getBool("geometry.max-grade.fix") ? oc.getFloat("geometry.max-grade") / 100 : -1);
597 for (const auto& item : myNodeCont) {
598 item.second->buildInnerEdges();
599 }
600 PROGRESS_TIME_MESSAGE(before);
601 }
602 // recheck phases for large junctions
603 for (NBTrafficLightDefinition* def : largeNodeTLS) {
605 }
606 // compute lane-to-lane node logics (require traffic lights and inner edges to be done)
608
609 // remove guessed traffic lights at junctions without conflicts (requires computeLogics2)
611
612 // compute keepClear status (requires computeLogics2)
614
615 //
616 if (oc.isSet("street-sign-output")) {
617 before = PROGRESS_BEGIN_TIME_MESSAGE("Generating street signs");
619 PROGRESS_TIME_MESSAGE(before);
620 }
621
622
623 if (lefthand != oc.getBool("flip-y-axis")) {
624 mirrorX();
625 };
626
627 if (oc.exists("geometry.check-overlap") && oc.getFloat("geometry.check-overlap") > 0) {
628 before = PROGRESS_BEGIN_TIME_MESSAGE("Checking overlapping edges");
629 myEdgeCont.checkOverlap(oc.getFloat("geometry.check-overlap"), oc.getFloat("geometry.check-overlap.vertical-threshold"));
630 PROGRESS_TIME_MESSAGE(before);
631 }
632 if (geoConvHelper.getConvBoundary().getZRange() > 0 && oc.getFloat("geometry.max-grade") > 0) {
633 before = PROGRESS_BEGIN_TIME_MESSAGE("Checking edge grade");
634 // user input is in %
635 myEdgeCont.checkGrade(oc.getFloat("geometry.max-grade") / 100);
636 PROGRESS_TIME_MESSAGE(before);
637 }
638
639 // find accesses for pt rail stops and add bidi-stops
640 if (!myPTStopCont.getStops().empty()) {
641 // re-adapt stop lanes after adding special lanes and cutting edge shapes at junction
644 int numBidiStops = 0;
645 if (!oc.getBool("ptstop-output.no-bidi")) {
647 }
648 PROGRESS_BEGIN_MESSAGE("Find accesses for pt rail stops");
649 double maxRadius = oc.getFloat("railway.access-distance");
650 double accessFactor = oc.getFloat("railway.access-factor");
651 int maxCount = oc.getInt("railway.max-accesses");
652 myPTStopCont.findAccessEdgesForRailStops(myEdgeCont, maxRadius, maxCount, accessFactor);
653 PROGRESS_TIME_MESSAGE(before);
654 if (numBidiStops > 0) {
656 }
657 }
659 // ensure that all turning lanes have sufficient permissions
661
662 if (oc.exists("ignore-change-restrictions") && !oc.isDefault("ignore-change-restrictions")) {
663 SVCPermissions ignoring = parseVehicleClasses(oc.getStringVector("ignore-change-restrictions"));
665 }
666
668 // report on very large networks
669 if (MAX2(geoConvHelper.getConvBoundary().xmax(), geoConvHelper.getConvBoundary().ymax()) > 1000000 ||
670 MIN2(geoConvHelper.getConvBoundary().xmin(), geoConvHelper.getConvBoundary().ymin()) < -1000000) {
671 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"));
672 }
673}
674
675
676void
677NBNetBuilder::moveToOrigin(GeoConvHelper& geoConvHelper, bool lefthand) {
678 long before = PROGRESS_BEGIN_TIME_MESSAGE("Moving network to origin");
679 Boundary boundary = geoConvHelper.getConvBoundary();
680 const double x = -boundary.xmin();
681 const double y = -(lefthand ? boundary.ymax() : boundary.ymin());
682 //if (lefthand) {
683 // y = boundary.ymax();
684 //}
685 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
686 (*i).second->reshiftPosition(x, y);
687 }
688 for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
689 (*i).second->reshiftPosition(x, y);
690 }
691 for (std::map<std::string, NBDistrict*>::const_iterator i = myDistrictCont.begin(); i != myDistrictCont.end(); ++i) {
692 (*i).second->reshiftPosition(x, y);
693 }
694 for (std::map<std::string, NBPTStop*>::const_iterator i = myPTStopCont.begin(); i != myPTStopCont.end(); ++i) {
695 (*i).second->reshiftPosition(x, y);
696 }
697 geoConvHelper.moveConvertedBy(x, y);
698 PROGRESS_TIME_MESSAGE(before);
699}
700
701
702void
704 // mirror the network along the X-axis
705 for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
706 (*i).second->mirrorX();
707 }
708 for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
709 (*i).second->mirrorX();
710 }
711 for (std::map<std::string, NBDistrict*>::const_iterator i = myDistrictCont.begin(); i != myDistrictCont.end(); ++i) {
712 (*i).second->mirrorX();
713 }
714 for (std::map<std::string, NBPTStop*>::const_iterator i = myPTStopCont.begin(); i != myPTStopCont.end(); ++i) {
715 (*i).second->mirrorX();
716 }
717}
718
719
720bool
721NBNetBuilder::transformCoordinate(Position& from, bool includeInBoundary, GeoConvHelper* from_srs) {
722 Position orig(from);
723 bool ok = true;
725 && GeoConvHelper::getLoaded().usingGeoProjection()
726 && from_srs != nullptr
727 && from_srs->usingGeoProjection()
728 && *from_srs != GeoConvHelper::getLoaded()) {
729 from_srs->cartesian2geo(from);
730 ok &= GeoConvHelper::getLoaded().x2cartesian(from, false);
731 }
732 if (from_srs == nullptr || !GeoConvHelper::getProcessing().usingGeoProjection()) {
733 // if getProcessing is not a geo-projection, assume it a cartesian transformation (i.e. shift)
734 ok &= GeoConvHelper::getProcessing().x2cartesian(from, includeInBoundary);
735
736 if (from_srs == nullptr && GeoConvHelper::getProcessing().usingGeoProjection()
738 && GeoConvHelper::getLoaded().usingGeoProjection()) {
739 // apply geo patch to loaded geo-network (offset must match)
740 from = from + GeoConvHelper::getLoaded().getOffset();
741 }
742 }
743 if (ok) {
745 if (hm.ready()) {
746 if (from_srs != nullptr && from_srs->usingGeoProjection()) {
747 from_srs->cartesian2geo(orig);
748 }
749 from.setz(hm.getZ(orig));
750 }
751 }
752 return ok;
753}
754
755
756bool
757NBNetBuilder::transformCoordinates(PositionVector& from, bool includeInBoundary, GeoConvHelper* from_srs) {
758 const double maxLength = OptionsCont::getOptions().getFloat("geometry.max-segment-length");
759 if (maxLength > 0 && from.size() > 1) {
760 // transformation to cartesian coordinates must happen before we can check segment length
761 PositionVector copy = from;
762 for (int i = 0; i < (int) from.size(); i++) {
763 transformCoordinate(copy[i], false);
764 }
765 addGeometrySegments(from, copy, maxLength);
766 }
767 bool ok = true;
768 for (int i = 0; i < (int) from.size(); i++) {
769 ok = ok && transformCoordinate(from[i], includeInBoundary, from_srs);
770 }
771 return ok;
772}
773
774int
775NBNetBuilder::addGeometrySegments(PositionVector& from, const PositionVector& cartesian, const double maxLength) {
776 // check lengths and insert new points where needed (in the original
777 // coordinate system)
778 int inserted = 0;
779 for (int i = 0; i < (int)cartesian.size() - 1; i++) {
780 Position start = from[i + inserted];
781 Position end = from[i + inserted + 1];
782 double length = cartesian[i].distanceTo(cartesian[i + 1]);
783 const Position step = (end - start) * (maxLength / length);
784 int steps = 0;
785 while (length > maxLength) {
786 length -= maxLength;
787 steps++;
788 from.insert(from.begin() + i + inserted + 1, start + (step * steps));
789 inserted++;
790 }
791 }
792 return inserted;
793}
794
795
796bool
798 // see GNELoadThread::fillOptions
799 return OptionsCont::getOptions().exists("new");
800}
801
802
803/****************************************************************************/
#define DEG2RAD(x)
Definition: GeomHelper.h:35
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:267
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define PROGRESS_BEGIN_TIME_MESSAGE(msg)
Definition: MsgHandler.h:271
#define TL(string)
Definition: MsgHandler.h:282
#define PROGRESS_TIME_MESSAGE(before)
Definition: MsgHandler.h:272
#define PROGRESS_DONE_MESSAGE()
Definition: MsgHandler.h:270
#define PROGRESS_BEGIN_MESSAGE(msg)
Definition: MsgHandler.h:269
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_PEDESTRIAN
pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
TrafficLightType
T MIN2(T a, T b)
Definition: StdDefs.h:71
T MAX2(T a, T b)
Definition: StdDefs.h:77
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
Definition: GeoConvHelper.h:53
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
Definition: GeoConvHelper.h:84
static int getNumLoaded()
Definition: GeoConvHelper.h:93
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
Definition: GeoConvHelper.h:89
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.
Definition: NBEdgeCont.cpp:934
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
Definition: NBEdgeCont.cpp:732
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
Definition: NBEdgeCont.cpp:814
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.
Definition: NBEdgeCont.cpp:806
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
Definition: NBEdgeCont.cpp:912
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:170
void updateAllChangeRestrictions(SVCPermissions ignoring)
modify all restrictions on lane changing for edges and connections
void recheckPostProcessConnections()
Try to set any stored connections.
void checkGeometries(const double maxAngle, const double minRadius, bool fix, bool fixRailways, bool silent=false)
Definition: NBEdgeCont.cpp:784
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
Definition: NBEdgeCont.cpp:830
void reduceGeometries(const double minDist)
Definition: NBEdgeCont.cpp:776
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:177
void splitGeometry(NBDistrictCont &dc, NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
Definition: NBEdgeCont.cpp:749
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
Definition: NBEdgeCont.cpp:822
int joinTramEdges(NBDistrictCont &dc, NBPTStopCont &sc, NBPTLineCont &lc, double maxDist)
join tram edges into adjacent lanes
void generateStreetSigns()
assigns street signs to edges based on toNode types
bool hasGuessedRoundabouts() const
Definition: NBEdgeCont.h:566
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.
Definition: NBEdgeCont.cpp:77
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.
Definition: NBEdgeCont.cpp:896
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
Definition: NBEdgeCont.cpp:958
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBPTStopCont &sc)
remap node IDs accoring to options –numerical-ids and –reserved-ids
void checkGrade(double threshold) const
check whether edges are to steep
The representation of a single edge during network building.
Definition: NBEdge.h:92
double getLaneSpeed(int lane) const
get lane speed
Definition: NBEdge.cpp:2135
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
Definition: NBEdge.cpp:4052
int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:526
static void setDefaultConnectionLength(double length)
Definition: NBEdge.h:396
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.
Definition: NBNetBuilder.h:237
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
Definition: NBNetBuilder.h:254
NBDistrictCont myDistrictCont
The used container for districts.
Definition: NBNetBuilder.h:240
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.
Definition: NBNetBuilder.h:246
NBEdgeCont myEdgeCont
The used container for edges.
Definition: NBNetBuilder.h:234
NBParkingCont myParkingCont
Definition: NBNetBuilder.h:248
~NBNetBuilder()
Destructor.
NBTypeCont myTypeCont
The used container for street types.
Definition: NBNetBuilder.h:231
NBPTStopCont myPTStopCont
The used container for pt stops.
Definition: NBNetBuilder.h:243
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.
Definition: NBNetBuilder.h:228
static bool runningNetedit()
whether netbuilding takes place in the context of NETEDIT
void removeRailComponents(NBDistrictCont &dc, NBEdgeCont &ec, NBPTStopCont &sc)
remove rail components after ptstops are built
Definition: NBNodeCont.cpp:416
void avoidOverlap()
fix overlap
Definition: NBNodeCont.cpp:537
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
void addJoinExclusion(const std::vector< std::string > &ids)
Definition: NBNodeCont.cpp:658
int joinLoadedClusters(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins loaded junction clusters (see NIXMLNodesHandler)
Definition: NBNodeCont.cpp:719
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBTrafficLightLogicCont &tlc)
remap node IDs accoring to options –numerical-ids and –reserved-ids
NBNode * retrieve(const std::string &id) const
Returns the node with the given name.
Definition: NBNodeCont.cpp:120
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.
Definition: NBNodeCont.cpp:457
std::map< std::string, NBNode * >::const_iterator end() const
Returns the pointer to the end of the stored nodes.
Definition: NBNodeCont.h:118
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.
Definition: NBNodeCont.cpp:191
void removeIsolatedRoads(NBDistrictCont &dc, NBEdgeCont &ec)
Removes sequences of edges that are not connected with a junction. Simple roads without junctions som...
Definition: NBNodeCont.cpp:242
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.
Definition: NBNodeCont.cpp:744
void computeLanes2Lanes()
divides the incoming lanes on outgoing lanes
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:179
int joinSameJunctions(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tlc)
Joins junctions with the same coordinates regardless of topology.
Definition: NBNodeCont.cpp:879
void removeComponents(NBDistrictCont &dc, NBEdgeCont &ec, const int numKeep, bool hasPTStops)
Checks the network for weak connectivity and removes all but the largest components....
Definition: NBNodeCont.cpp:330
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
Definition: NBPTLineCont.h:42
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
void postprocess(std::set< std::string > &usedStops)
std::map< std::string, NBPTStop * >::const_iterator begin() const
Returns the pointer to the begin of the stored pt stops.
Definition: NBPTStopCont.h:55
std::map< std::string, NBPTStop * >::const_iterator end() const
Returns the pointer to the end of the stored pt stops.
Definition: NBPTStopCont.h:62
int size() const
Returns the number of pt stops stored in this container.
Definition: NBPTStopCont.h:48
const std::map< std::string, NBPTStop * > & getStops() const
Definition: NBPTStopCont.h:66
void localizePTStops(NBEdgeCont &cont)
void alignIdSigns()
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 repairTopology(NBEdgeCont &ec, NBPTStopCont &sc, NBPTLineCont &lc)
static void extendDirectionPriority(NBEdgeCont &ec, bool fromUniDir)
static void analyzeTopology(NBEdgeCont &ec)
static int makeAllBidi(NBEdgeCont &ec)
static void computeRamps(NBNetBuilder &nb, OptionsCont &oc, bool mayAddOrRemove)
Computes highway on-/off-ramps (if wished)
static void reportWarnings()
reports warnings if any occurred
Definition: NBRequest.cpp:1066
The base class for traffic light logic definitions.
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)
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.
Definition: NBTypeCont.cpp:185
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.
Definition: OptionsCont.cpp:59
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
void setz(double z)
set position z
Definition: Position.h:80
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:47