Eclipse SUMO - Simulation of Urban MObility
NBEdgeCont.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
16 // Storage for edges, including some functionality operating on multiple edges
17 /****************************************************************************/
18 #ifndef NBEdgeCont_h
19 #define NBEdgeCont_h
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #include <config.h>
26 
27 #include <map>
28 #include <iostream>
29 #include <string>
30 #include <vector>
31 #include <set>
32 #include "NBCont.h"
37 
38 
39 // ===========================================================================
40 // class declarations
41 // ===========================================================================
42 class OptionsCont;
43 class OutputDevice;
44 class NBNodeCont;
45 class NBTypeCont;
46 class NBEdge;
47 class NBNode;
48 class NBDistrictCont;
50 class NBPTStopCont;
51 
52 
53 // ===========================================================================
54 // class definitions
55 // ===========================================================================
60 class NBEdgeCont {
61 public:
66 
67 
69  ~NBEdgeCont();
70 
71 
80  void applyOptions(OptionsCont& oc);
81 
82 
84  void clear();
85 
86 
87 
88 
91 
105  bool insert(NBEdge* edge, bool ignorePrunning = false);
106 
107 
116  NBEdge* retrieve(const std::string& id, bool retrieveExtracted = false) const;
117 
118 
129  NBEdge* retrievePossiblySplit(const std::string& id, bool downstream) const;
130 
131 
144  NBEdge* retrievePossiblySplit(const std::string& id, const std::string& hint, bool incoming) const;
145 
146 
157  NBEdge* retrievePossiblySplit(const std::string& id, double pos) const;
158 
159 
166  void erase(NBDistrictCont& dc, NBEdge* edge);
167 
168 
178  void extract(NBDistrictCont& dc, NBEdge* edge, bool remember = false);
179 
180 
184  std::map<std::string, NBEdge*>::const_iterator begin() const {
185  return myEdges.begin();
186  }
187 
188 
192  std::map<std::string, NBEdge*>::const_iterator end() const {
193  return myEdges.end();
194  }
196 
197 
198 
201 
205  struct Split {
207  std::vector<int> lanes;
209  double pos = INVALID_DOUBLE;
213  NBNode* node = nullptr;
215  std::string idBefore;
217  std::string idAfter;
219  std::string nameID;
221  double offset = 0.;
223  int offsetFactor = 1;
224  };
225 
226  void processSplits(NBEdge* e, std::vector<Split> splits,
228 
229 
243  bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node);
244 
245 
269  bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node,
270  const std::string& firstEdgeName, const std::string& secondEdgeName,
271  int noLanesFirstEdge, int noLanesSecondEdge,
272  const double speed = -1., const int changedLeft = 0);
273 
274 
290  bool splitAt(NBDistrictCont& dc, NBEdge* edge, double edgepos, NBNode* node,
291  const std::string& firstEdgeName, const std::string& secondEdgeName,
292  int noLanesFirstEdge, int noLanesSecondEdge,
293  const double speed = -1., const int changedLeft = 0);
295 
296 
297 
300 
304  int size() const {
305  return (int) myEdges.size();
306  }
307 
308 
313  std::vector<std::string> getAllNames() const;
314 
315 
319  int getNoEdgeSplits() const {
320  return myEdgesSplit;
321  }
323 
324 
325 
328 
334 
335 
344  void splitGeometry(NBDistrictCont& dc, NBNodeCont& nc);
345 
346 
351  void reduceGeometries(const double minDist);
352 
353 
360  void checkGeometries(const double maxAngle, const double minRadius, bool fix, bool fixRailways, bool silent = false);
362 
363 
364 
367 
376 
377 
386  void computeEdge2Edges(bool noLeftMovers);
387 
388 
396  void computeLanes2Edges();
397 
398 
406  void recheckLanes();
407 
408 
418  void appendTurnarounds(bool noTLSControlled, bool onlyDeadends, bool noGeometryLike);
419 
420 
427  void appendTurnarounds(const std::set<std::string>& ids, bool noTLSControlled);
428 
431  void appendRailwayTurnarounds(const NBPTStopCont& sc);
432 
433 
442  void computeEdgeShapes(double smoothElevationThreshold = -1);
443 
444 
453  void computeLaneShapes();
454 
455 
458  void clearControllingTLInformation() const;
459 
460 
469  NBTrafficLightLogicCont& tlc, EdgeVector edges);
470 
471 
474  void guessOpposites();
475 
476 
481  void recheckLaneSpread();
482 
484 
486  NBEdge* getOppositeByID(const std::string& edgeID) const;
487 
489  NBEdge* getByID(const std::string& edgeID) const;
490 
495  int guessRoundabouts();
496 
497 
501  bool wasIgnored(std::string id) const {
502  return myIgnoredEdges.count(id) != 0;
503  }
504 
506  void ignore(std::string id) {
507  myIgnoredEdges.insert(id);
508  }
509 
512  bool wasRemoved(std::string id) const {
513  return myExtractedEdges.count(id) != 0;
514  }
515 
518  void rename(NBEdge* edge, const std::string& newID);
519 
520 
521 
524 
538  void addPostProcessConnection(const std::string& from, int fromLane, const std::string& to, int toLane, bool mayDefinitelyPass,
539  bool keepClear, double contPos, double visibility, double speed,
540  const PositionVector& customShape,
541  bool uncontrolled,
542  bool warnOnly,
543  SVCPermissions permissions = SVC_UNSPECIFIED);
544 
545  bool hasPostProcessConnection(const std::string& from, const std::string& to = "");
546 
547 
552 
554  void generateStreetSigns();
555 
557  int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string& excludeOpt);
558 
559 
563  const std::set<EdgeSet> getRoundabouts() const;
564 
566  void addRoundabout(const EdgeSet& roundabout);
567 
569  void removeRoundabout(const NBNode* node);
570 
572  void markRoundabouts();
573 
575  void patchRoundabouts(NBEdge* orig, NBEdge* part1, NBEdge* part2, std::set<EdgeSet>& roundabouts);
576 
578  bool ignoreFilterMatch(NBEdge* edge);
579 
581  int remapIDs(bool numericaIDs, bool reservedIDs, const std::string& prefix, NBPTStopCont& sc);
582 
584  void checkOverlap(double threshold, double zThreshold) const;
585 
587  void checkGrade(double threshold) const;
588 
589 
596  EdgeVector getGeneratedFrom(const std::string& id) const;
597 
599  int joinLanes(SVCPermissions perms);
600 
602  EdgeVector getAllEdges() const;
604 
605 private:
607  static double formFactor(const EdgeVector& loopEdges);
608 
609 private:
612 
617  public:
625  PostProcessConnection(const std::string& from_, int fromLane_, const std::string& to_, int toLane_,
626  bool mayDefinitelyPass_, bool keepClear_, double contPos_, double visibility_, double speed_,
627  const PositionVector& customShape_,
628  bool uncontrolled_,
629  bool warnOnly_, SVCPermissions permissions_) :
630  from(from_), fromLane(fromLane_), to(to_), toLane(toLane_), mayDefinitelyPass(mayDefinitelyPass_), keepClear(keepClear_), contPos(contPos_),
631  visibility(visibility_),
632  speed(speed_),
633  customShape(customShape_),
634  uncontrolled(uncontrolled_),
635  permissions(permissions_),
636  warnOnly(warnOnly_)
637  {}
639  std::string from;
641  int fromLane;
643  std::string to;
645  int toLane;
649  bool keepClear;
651  double contPos;
653  double visibility;
655  double speed;
663  bool warnOnly;
664  };
665 
667  std::map<std::string, std::vector<PostProcessConnection> > myConnections;
668 
669 
671  typedef std::map<std::string, NBEdge*> EdgeCont;
672 
675 
678 
680  std::set<std::string> myIgnoredEdges;
681 
684 
687 
690 
693 
695  std::set<std::string> myEdges2Keep;
696 
698  std::set<std::string> myEdges2Remove;
699 
702 
705 
707  std::set<std::string> myTypes2Keep;
708 
710  std::set<std::string> myTypes2Remove;
711 
714 
718 
720  std::set<EdgeSet> myRoundabouts;
722  std::set<EdgeSet> myGuessedRoundabouts;
723 
727  class split_sorter {
728  public:
730  explicit split_sorter() { }
731 
733  int operator()(const Split& e1, const Split& e2) const {
734  return e1.pos < e2.pos;
735  }
736  };
737 
738 
739 private:
741  NBEdgeCont(const NBEdgeCont& s);
742 
744  NBEdgeCont& operator=(const NBEdgeCont& s);
745 
746 };
747 
748 
749 #endif
750 
751 /****************************************************************************/
752 
NBEdgeCont::split_sorter
Sorts splits by their position (increasing)
Definition: NBEdgeCont.h:727
NBEdgeCont::wasRemoved
bool wasRemoved(std::string id) const
Returns whether the edge with the id was deleted explicitly.
Definition: NBEdgeCont.h:512
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
SVC_UNSPECIFIED
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
Definition: SUMOVehicleClass.cpp:148
NBEdgeCont::~NBEdgeCont
~NBEdgeCont()
Destructor.
Definition: NBEdgeCont.cpp:67
NBPTStopCont
Definition: NBPTStopCont.h:27
NBEdgeCont::myTypeCont
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
Definition: NBEdgeCont.h:611
NBEdgeCont::myIgnoredEdges
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
Definition: NBEdgeCont.h:680
NBEdgeCont::Split::offsetFactor
int offsetFactor
direction in which to apply the offset (used by netgenerate for lefthand networks)
Definition: NBEdgeCont.h:223
NBEdgeCont::retrieve
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
Definition: NBEdgeCont.cpp:246
NBEdgeCont::myEdgesMinSpeed
double myEdgesMinSpeed
The minimum speed an edge may have in order to be kept (default: -1)
Definition: NBEdgeCont.h:689
NBEdgeCont
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:60
NBEdgeCont::addPostProcessConnection
void addPostProcessConnection(const std::string &from, int fromLane, const std::string &to, int toLane, bool mayDefinitelyPass, bool keepClear, double contPos, double visibility, double speed, const PositionVector &customShape, bool uncontrolled, bool warnOnly, SVCPermissions permissions=SVC_UNSPECIFIED)
Adds a connection which could not be set during loading.
Definition: NBEdgeCont.cpp:1052
NBEdgeCont::myExtractedEdges
EdgeCont myExtractedEdges
The extracted nodes which are kept for reference.
Definition: NBEdgeCont.h:677
NBTrafficLightLogicCont
A container for traffic light definitions and built programs.
Definition: NBTrafficLightLogicCont.h:57
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:63
NBEdgeCont::erase
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
Definition: NBEdgeCont.cpp:380
NBEdgeCont::getOppositeByID
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
Definition: NBEdgeCont.cpp:1038
NBEdgeCont::getNoEdgeSplits
int getNoEdgeSplits() const
Returns the number of edge splits.
Definition: NBEdgeCont.h:319
NBEdgeCont::ignore
void ignore(std::string id)
mark the given edge id as ignored
Definition: NBEdgeCont.h:506
EdgeVector
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:34
NBEdgeCont::applyOptions
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
Definition: NBEdgeCont.cpp:73
NBEdgeCont::checkGrade
void checkGrade(double threshold) const
check whether edges are to steep
Definition: NBEdgeCont.cpp:1559
NBEdgeCont::processSplits
void processSplits(NBEdge *e, std::vector< Split > splits, NBNodeCont &nc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc)
Definition: NBEdgeCont.cpp:412
NBEdgeCont::PostProcessConnection::fromLane
int fromLane
The number of the lane the connection starts at.
Definition: NBEdgeCont.h:641
NBEdgeCont::computeLaneShapes
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
Definition: NBEdgeCont.cpp:899
NBEdgeCont::myConnections
std::map< std::string, std::vector< PostProcessConnection > > myConnections
The list of connections to recheck.
Definition: NBEdgeCont.h:667
NBEdgeCont::patchRoundabouts
void patchRoundabouts(NBEdge *orig, NBEdge *part1, NBEdge *part2, std::set< EdgeSet > &roundabouts)
fix roundabout information after splitting an edge
Definition: NBEdgeCont.cpp:671
NBEdgeCont::getByID
NBEdge * getByID(const std::string &edgeID) const
Returns the edge with id if it exists.
Definition: NBEdgeCont.cpp:1045
NBEdgeCont::insert
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
Definition: NBEdgeCont.cpp:153
NBEdgeCont::Split::offset
double offset
lateral offset to edge geometry
Definition: NBEdgeCont.h:221
NamedRTree.h
NBEdgeCont::operator=
NBEdgeCont & operator=(const NBEdgeCont &s)
invalidated assignment operator
NBEdgeCont::Split::speed
double speed
The speed after this change.
Definition: NBEdgeCont.h:211
NBEdgeCont::markRoundabouts
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
Definition: NBEdgeCont.cpp:1377
PositionVector
A list of positions.
Definition: PositionVector.h:45
NBEdgeCont::PostProcessConnection::to
std::string to
The id of the edge the connection ends at.
Definition: NBEdgeCont.h:643
NBEdgeCont::myTypes2Remove
std::set< std::string > myTypes2Remove
Set of edges types which shall be removed.
Definition: NBEdgeCont.h:710
NBDistrictCont
A container for districts.
Definition: NBDistrictCont.h:52
NBEdgeCont::splitAt
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
Definition: NBEdgeCont.cpp:557
NBEdgeCont::ignoreFilterMatch
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
Definition: NBEdgeCont.cpp:174
RouterEdgeVector
std::vector< NBRouterEdge * > RouterEdgeVector
Definition: NBCont.h:42
NBEdgeCont::remapIDs
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBPTStopCont &sc)
remap node IDs accoring to options –numerical-ids and –reserved-ids
Definition: NBEdgeCont.cpp:1471
NBNodeCont
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:59
NBEdge
The representation of a single edge during network building.
Definition: NBEdge.h:91
NBEdgeCont::PostProcessConnection::PostProcessConnection
PostProcessConnection(const std::string &from_, int fromLane_, const std::string &to_, int toLane_, bool mayDefinitelyPass_, bool keepClear_, double contPos_, double visibility_, double speed_, const PositionVector &customShape_, bool uncontrolled_, bool warnOnly_, SVCPermissions permissions_)
Constructor.
Definition: NBEdgeCont.h:625
NBEdgeCont::myVehicleClasses2Keep
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
Definition: NBEdgeCont.h:701
NBEdgeCont::getGeneratedFrom
EdgeVector getGeneratedFrom(const std::string &id) const
Returns the edges which have been built by splitting the edge of the given id.
Definition: NBEdgeCont.cpp:1115
NBEdgeCont::joinSameNodeConnectingEdges
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
Definition: NBEdgeCont.cpp:907
NBEdgeCont::myEdges
EdgeCont myEdges
The instance of the dictionary (id->edge)
Definition: NBEdgeCont.h:674
NBEdgeCont::computeLanes2Edges
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
Definition: NBEdgeCont.cpp:790
NBEdgeCont::split_sorter::split_sorter
split_sorter()
Constructor.
Definition: NBEdgeCont.h:730
NBEdgeCont::checkOverlap
void checkOverlap(double threshold, double zThreshold) const
check whether edges overlap
Definition: NBEdgeCont.cpp:1530
NBEdgeCont::myEdges2Remove
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.
Definition: NBEdgeCont.h:698
NBEdgeCont::Split::node
NBNode * node
The new node that is created for this split.
Definition: NBEdgeCont.h:213
NBEdgeCont::generateStreetSigns
void generateStreetSigns()
assigns street signs to edges based on toNode types
Definition: NBEdgeCont.cpp:1403
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:218
NBEdgeCont::hasPostProcessConnection
bool hasPostProcessConnection(const std::string &from, const std::string &to="")
Definition: NBEdgeCont.cpp:1059
NBEdgeCont::EdgeCont
std::map< std::string, NBEdge * > EdgeCont
The type of the dictionary where an edge may be found by its id.
Definition: NBEdgeCont.h:671
NBEdgeCont::size
int size() const
Returns the number of edges.
Definition: NBEdgeCont.h:304
NBEdgeCont::guessRoundabouts
int guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
Definition: NBEdgeCont.cpp:1157
EdgeSet
std::set< NBEdge * > EdgeSet
container for unique edges
Definition: NBCont.h:49
SUMOVehicleClass.h
NBEdgeCont::PostProcessConnection::speed
double speed
custom speed for connection
Definition: NBEdgeCont.h:655
NBEdgeCont::myTypes2Keep
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
Definition: NBEdgeCont.h:707
NBEdgeCont::Split::lanes
std::vector< int > lanes
The lanes after this change.
Definition: NBEdgeCont.h:207
NBEdgeCont::recheckPostProcessConnections
void recheckPostProcessConnections()
Try to set any stored connections.
Definition: NBEdgeCont.cpp:1077
NBEdgeCont::clear
void clear()
Deletes all edges.
Definition: NBEdgeCont.cpp:138
NBEdgeCont::retrievePossiblySplit
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
Definition: NBEdgeCont.cpp:282
NBEdgeCont::myNeedGeoTransformedPruningBoundary
bool myNeedGeoTransformedPruningBoundary
whether a geo transform has been applied to the pruning boundary
Definition: NBEdgeCont.h:716
UtilExceptions.h
NBEdgeCont::removeUnwishedEdges
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
Definition: NBEdgeCont.cpp:700
NBEdgeCont::recheckLanes
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
Definition: NBEdgeCont.cpp:798
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
NBEdgeCont::splitGeometry
void splitGeometry(NBDistrictCont &dc, NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
Definition: NBEdgeCont.cpp:717
NBEdgeCont::appendTurnarounds
void appendTurnarounds(bool noTLSControlled, bool onlyDeadends, bool noGeometryLike)
Appends turnarounds to all edges stored in the container.
Definition: NBEdgeCont.cpp:838
NBEdgeCont::myPruningBoundary
PositionVector myPruningBoundary
Boundary within which an edge must be located in order to be kept.
Definition: NBEdgeCont.h:713
NBEdgeCont::PostProcessConnection::toLane
int toLane
The number of the lane the connection ends at.
Definition: NBEdgeCont.h:645
NBEdgeCont::Split::pos
double pos
The position of this change.
Definition: NBEdgeCont.h:209
NBEdgeCont::end
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:192
NBEdgeCont::getAllEdges
EdgeVector getAllEdges() const
return all edges
Definition: NBEdgeCont.cpp:1599
NBEdgeCont::appendRailwayTurnarounds
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
Definition: NBEdgeCont.cpp:854
NBEdgeCont::getAllNames
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
Definition: NBEdgeCont.cpp:689
NBEdgeCont::PostProcessConnection::uncontrolled
bool uncontrolled
whether this connection shall not be controlled by a traffic light
Definition: NBEdgeCont.h:659
NBEdgeCont::sortOutgoingLanesConnections
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
Definition: NBEdgeCont.cpp:774
NBEdgeCont::reduceGeometries
void reduceGeometries(const double minDist)
Definition: NBEdgeCont.cpp:744
NBEdgeCont::myEdges2Keep
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
Definition: NBEdgeCont.h:695
NBEdgeCont::rename
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
Definition: NBEdgeCont.cpp:399
NBTypeCont
A storage for available types of edges.
Definition: NBTypeCont.h:54
NBEdgeCont::myRoundabouts
std::set< EdgeSet > myRoundabouts
Edges marked as belonging to a roundabout by the user (each EdgeVector is a roundabout)
Definition: NBEdgeCont.h:720
NBEdgeCont::PostProcessConnection
A structure representing a connection between two lanes.
Definition: NBEdgeCont.h:616
NBEdgeCont::NBEdgeCont
NBEdgeCont(NBTypeCont &tc)
Constructor.
Definition: NBEdgeCont.cpp:58
NBEdgeCont::guessSpecialLanes
int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string &excludeOpt)
add sidwalks to edges within the given limits or permissions and return the number of edges affected
Definition: NBEdgeCont.cpp:1443
NBEdgeCont::extract
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
Definition: NBEdgeCont.cpp:387
NBEdgeCont::recheckLaneSpread
void recheckLaneSpread()
Rechecks whether the lane spread is proper.
Definition: NBEdgeCont.cpp:1024
NBEdgeCont::formFactor
static double formFactor(const EdgeVector &loopEdges)
compute the form factor for a loop of edges
Definition: NBEdgeCont.cpp:1334
INVALID_DOUBLE
const double INVALID_DOUBLE
Definition: StdDefs.h:62
NBEdgeCont::Split::idAfter
std::string idAfter
The id for the edge after the split.
Definition: NBEdgeCont.h:217
NBEdgeCont::computeEdgeShapes
void computeEdgeShapes(double smoothElevationThreshold=-1)
Computes the shapes of all edges stored in the container.
Definition: NBEdgeCont.cpp:875
NBEdgeCont::myEdgesSplit
int myEdgesSplit
the number of splits of edges during the building
Definition: NBEdgeCont.h:683
NBEdgeCont::joinLanes
int joinLanes(SVCPermissions perms)
join adjacent lanes with the given permissions
Definition: NBEdgeCont.cpp:1588
config.h
NBEdgeCont::addRoundabout
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
Definition: NBEdgeCont.cpp:1353
NBEdgeCont::split_sorter::operator()
int operator()(const Split &e1, const Split &e2) const
Comparing operator.
Definition: NBEdgeCont.h:733
NBEdgeCont::myVehicleClasses2Remove
SVCPermissions myVehicleClasses2Remove
Set of vehicle types which need not be supported (edges which allow ONLY these are removed)
Definition: NBEdgeCont.h:704
NBEdgeCont::removeRoundabout
void removeRoundabout(const NBNode *node)
remove roundabout that contains the given node
Definition: NBEdgeCont.cpp:1364
NBEdgeCont::PostProcessConnection::contPos
double contPos
custom position for internal junction on this connection
Definition: NBEdgeCont.h:651
NBEdgeCont::guessOpposites
void guessOpposites()
Sets opposite lane information for geometrically close edges.
Definition: NBEdgeCont.cpp:994
NBEdgeCont::checkGeometries
void checkGeometries(const double maxAngle, const double minRadius, bool fix, bool fixRailways, bool silent=false)
Definition: NBEdgeCont.cpp:752
NBNode
Represents a single node (junction) during network building.
Definition: NBNode.h:67
NBEdgeCont::computeEdge2Edges
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
Definition: NBEdgeCont.cpp:782
NBEdgeCont::PostProcessConnection::visibility
double visibility
custom foe visiblity for connection
Definition: NBEdgeCont.h:653
NBEdgeCont::PostProcessConnection::warnOnly
bool warnOnly
whether a failure to set this connection is a warning or an error
Definition: NBEdgeCont.h:663
NBEdgeCont::PostProcessConnection::permissions
SVCPermissions permissions
custom permissions for connection
Definition: NBEdgeCont.h:661
NBEdgeCont::myRemoveEdgesAfterJoining
bool myRemoveEdgesAfterJoining
Whether edges shall be joined first, then removed.
Definition: NBEdgeCont.h:692
NBEdgeCont::Split
A structure which describes changes of lane number or speed along the road.
Definition: NBEdgeCont.h:205
NBEdgeCont::begin
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:184
NBEdgeCont::PostProcessConnection::customShape
PositionVector customShape
custom shape for connection
Definition: NBEdgeCont.h:657
PositionVector.h
NBEdgeCont::Split::idBefore
std::string idBefore
The id for the edge before the split.
Definition: NBEdgeCont.h:215
NBEdgeCont::PostProcessConnection::from
std::string from
The id of the edge the connection starts at.
Definition: NBEdgeCont.h:639
NBEdgeCont::myGuessedRoundabouts
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
Definition: NBEdgeCont.h:722
NBEdgeCont::getRoundabouts
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
Definition: NBEdgeCont.cpp:1345
NBEdgeCont::wasIgnored
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition: NBEdgeCont.h:501
NBEdgeCont::PostProcessConnection::mayDefinitelyPass
bool mayDefinitelyPass
Whether the connection may be passed without braking.
Definition: NBEdgeCont.h:647
NBCont.h
NBEdgeCont::PostProcessConnection::keepClear
bool keepClear
Whether the connection may be passed without braking.
Definition: NBEdgeCont.h:649
NBEdgeCont::getAllRouterEdges
RouterEdgeVector getAllRouterEdges() const
Definition: NBEdgeCont.cpp:1609
NBEdgeCont::Split::nameID
std::string nameID
the default node id
Definition: NBEdgeCont.h:219
NBEdgeCont::clearControllingTLInformation
void clearControllingTLInformation() const
Clears information about controlling traffic lights for all connenections of all edges.
Definition: NBEdgeCont.cpp:766