Eclipse SUMO - Simulation of Urban MObility
NBNode.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-2020 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 /****************************************************************************/
21 // The representation of a single node
22 /****************************************************************************/
23 #pragma once
24 #include <config.h>
25 
26 #include <vector>
27 #include <deque>
28 #include <utility>
29 #include <string>
30 #include <set>
31 #include <memory>
32 #include <utils/common/StdDefs.h>
33 #include <utils/common/Named.h>
34 #include <utils/geom/Bresenham.h>
35 #include <utils/geom/GeomHelper.h>
37 #include <utils/geom/Position.h>
40 #include "NBEdge.h"
41 #include "NBConnection.h"
42 #include "NBConnectionDefs.h"
43 #include "NBContHelper.h"
44 
45 
46 // ===========================================================================
47 // class declarations
48 // ===========================================================================
49 class NBRequest;
50 class NBDistrict;
51 class OptionsCont;
53 class NBTypeCont;
55 class NBDistrictCont;
56 class OutputDevice;
57 
58 
59 // ===========================================================================
60 // class definitions
61 // ===========================================================================
66 class NBNode : public Named, public Parameterised {
67  friend class NBNodeCont;
68  friend class GNEJunction; // < used for visualization (NETEDIT)
69  friend class NBNodesEdgesSorter; // < sorts the edges
70  friend class NBNodeTypeComputer; // < computes type
71  friend class NBEdgePriorityComputer; // < computes priorities of edges per intersection
72 
73 public:
86  public:
91  ApproachingDivider(const EdgeVector& approaching, NBEdge* currentOutgoing);
92 
95 
97  int numAvailableLanes() const {
98  return (int)myAvailableLanes.size();
99  }
100 
102  void execute(const int src, const int dest);
103 
105  std::deque<int>* spread(const std::vector<int>& approachingLanes, int dest) const;
106 
107  private:
110 
113 
115  std::vector<int> myAvailableLanes;
116 
119 
120  private:
123 
124  };
125 
129  class Crossing final : public Parameterised {
130  public:
132  Crossing(const NBNode* _node, const EdgeVector& _edges, double _width, bool _priority, int _customTLIndex, int _customTLIndex2, const PositionVector& _customShape);
134  const NBNode* node;
140  double customWidth;
142  double width;
144  std::string id;
146  std::string prevWalkingArea;
148  std::string nextWalkingArea;
150  bool priority;
160  std::string tlID;
162  bool valid;
163  };
164 
165 
169  struct WalkingArea {
171  WalkingArea(const std::string& _id, double _width) :
172  id(_id),
173  width(_width) {
174  }
176  std::string id;
178  double width;
184  std::vector<std::string> nextCrossings;
186  std::vector<std::string> nextSidewalks;
188  std::vector<std::string> prevSidewalks;
190  bool hasCustomShape = false;
192  int minNextCrossingEdges = std::numeric_limits<int>::max();
194  int minPrevCrossingEdges = std::numeric_limits<int>::max();
195  };
196 
198  std::set<const NBEdge*, ComparatorIdLess> edges;
200  };
201 
203  static const int FORWARD;
204  static const int BACKWARD;
205 
207  static const double UNSPECIFIED_RADIUS;
208 
210  static const int AVOID_WIDE_RIGHT_TURN;
211  static const int AVOID_WIDE_LEFT_TURN;
212  static const int FOUR_CONTROL_POINTS;
214  static const int SCURVE_IGNORE;
215 
216 public:
222  NBNode(const std::string& id, const Position& position, SumoXMLNodeType type);
223 
229  NBNode(const std::string& id, const Position& position, NBDistrict* district = 0);
230 
232  ~NBNode();
233 
240  void reinit(const Position& position, SumoXMLNodeType type,
241  bool updateEdgeGeometries = false);
242 
246  const Position& getPosition() const {
247  return myPosition;
248  }
249 
251  Position getCenter() const;
252 
254  const EdgeVector& getIncomingEdges() const {
255  return myIncomingEdges;
256  }
257 
259  const EdgeVector& getOutgoingEdges() const {
260  return myOutgoingEdges;
261  }
262 
264  const EdgeVector& getEdges() const {
265  return myAllEdges;
266  }
267 
272  return myType;
273  }
274 
276  double getRadius() const {
277  return myRadius;
278  }
279 
281  bool getKeepClear() const {
282  return myKeepClear;
283  }
284 
287  return myRightOfWay;
288  }
289 
292  return myFringeType;
293  }
294 
296  const std::string& getName() const {
297  return myName;
298  }
300 
303 
307 
310 
312  void removeTrafficLights(bool setAsPriority = false);
313 
317  bool isTLControlled() const {
318  return myTrafficLights.size() != 0;
319  }
320 
322  const std::set<NBTrafficLightDefinition*>& getControllingTLS() const {
323  return myTrafficLights;
324  }
325 
327  void invalidateTLS(NBTrafficLightLogicCont& tlCont, bool removedConnections, bool addedConnections);
328 
330  void shiftTLConnectionLaneIndex(NBEdge* edge, int offset, int threshold = -1);
332 
333 
336 
348 
349 
352 
356  void reshiftPosition(double xoff, double yoff);
357 
359  void mirrorX();
361 
363  void addIncomingEdge(NBEdge* edge);
364 
366  void addOutgoingEdge(NBEdge* edge);
367 
369  void computeLanes2Lanes();
370 
372  void computeLogic(const NBEdgeCont& ec);
373 
375  void computeLogic2(bool checkLaneFoes);
376 
378  void computeKeepClear();
379 
381  bool writeLogic(OutputDevice& into) const;
382 
384  const std::string getFoes(int linkIndex) const;
385 
387  const std::string getResponse(int linkIndex) const;
388 
390  bool hasConflict() const;
391 
393  Position getEmptyDir() const;
394 
399  bool hasIncoming(const NBEdge* const e) const;
400 
405  bool hasOutgoing(const NBEdge* const e) const;
406 
408  NBEdge* getOppositeIncoming(NBEdge* e) const;
409 
412 
415 
417  void removeDoubleEdges();
418 
420  NBEdge* getConnectionTo(NBNode* n) const;
421 
423  void addSortedLinkFoes(const NBConnection& mayDrive, const NBConnection& mustStop);
424 
426  NBEdge* getPossiblySplittedIncoming(const std::string& edgeid);
427 
429  NBEdge* getPossiblySplittedOutgoing(const std::string& edgeid);
430 
432  void removeEdge(NBEdge* edge, bool removeFromConnections = true);
433 
443  bool isLeftMover(const NBEdge* const from, const NBEdge* const to) const;
444 
453  bool mustBrake(const NBEdge* const from, const NBEdge* const to, int fromLane, int toLane, bool includePedCrossings) const;
454 
461  bool mustBrakeForCrossing(const NBEdge* const from, const NBEdge* const to, const Crossing& crossing) const;
462 
464  static bool rightTurnConflict(const NBEdge* from, const NBEdge* to, int fromLane,
465  const NBEdge* prohibitorFrom, const NBEdge* prohibitorTo, int prohibitorFromLane);
466 
468  bool mergeConflictYields(const NBEdge* from, int fromLane, int fromLaneFoe, NBEdge* to, int toLane) const;
469 
471  bool mergeConflict(const NBEdge* from, const NBEdge::Connection& con,
472  const NBEdge* prohibitorFrom, const NBEdge::Connection& prohibitorCon, bool foes) const;
473 
475  bool turnFoes(const NBEdge* from, const NBEdge* to, int fromLane,
476  const NBEdge* from2, const NBEdge* to2, int fromLane2,
477  bool lefthand = false) const;
478 
487  bool forbids(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
488  const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
489  bool regardNonSignalisedLowerPriority) const;
490 
498  bool foes(const NBEdge* const from1, const NBEdge* const to1,
499  const NBEdge* const from2, const NBEdge* const to2) const;
500 
507  LinkDirection getDirection(const NBEdge* const incoming, const NBEdge* const outgoing, bool leftHand = false) const;
508 
510  LinkState getLinkState(const NBEdge* incoming, NBEdge* outgoing,
511  int fromLane, int toLane, bool mayDefinitelyPass, const std::string& tlID) const;
512 
516  void computeNodeShape(double mismatchThreshold);
517 
520 
522  const PositionVector& getShape() const;
523 
525  void setCustomShape(const PositionVector& shape);
526 
528  void setRadius(double radius) {
529  myRadius = radius;
530  }
531 
533  void setKeepClear(bool keepClear) {
534  myKeepClear = keepClear;
535  }
536 
538  void setRightOfWay(RightOfWay rightOfWay) {
539  myRightOfWay = rightOfWay;
540  }
541 
543  void setFringeType(FringeType fringeType) {
544  myFringeType = fringeType;
545  }
546 
548  void setName(const std::string& name) {
549  myName = name;
550  }
551 
553  bool hasCustomShape() const {
554  return myHaveCustomPoly;
555  }
556 
558  bool checkIsRemovable() const;
559 
561  bool checkIsRemovableReporting(std::string& reason) const;
562 
564  std::vector<std::pair<NBEdge*, NBEdge*> > getEdgesToJoin() const;
565 
567  bool isNearDistrict() const;
568 
570  bool isDistrict() const;
571 
573  bool needsCont(const NBEdge* fromE, const NBEdge* otherFromE,
574  const NBEdge::Connection& c, const NBEdge::Connection& otherC) const;
575 
577  bool tlsContConflict(const NBEdge* from, const NBEdge::Connection& c,
578  const NBEdge* foeFrom, const NBEdge::Connection& foe) const;
579 
580 
588  PositionVector computeInternalLaneShape(const NBEdge* fromE, const NBEdge::Connection& con, int numPoints, NBNode* recordError = 0, int shapeFlag = 0) const;
589 
600  PositionVector computeSmoothShape(const PositionVector& begShape, const PositionVector& endShape, int numPoints,
601  bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
602  NBNode* recordError = 0, int shapeFlag = 0) const;
604  static PositionVector bezierControlPoints(const PositionVector& begShape, const PositionVector& endShape,
605  bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
606  bool& ok, NBNode* recordError = 0, double straightThresh = DEG2RAD(5),
607  int shapeFlag = 0);
608 
609 
611  double getDisplacementError() const {
612  return myDisplacementError;
613  }
614 
616  void replaceIncoming(NBEdge* which, NBEdge* by, int laneOff);
617 
619  void replaceIncoming(const EdgeVector& which, NBEdge* by);
620 
622  void replaceOutgoing(NBEdge* which, NBEdge* by, int laneOff);
623 
625  void replaceOutgoing(const EdgeVector& which, NBEdge* by);
626 
628  int guessCrossings();
629 
630  /* @brief check whether a crossing should be build for the candiate edges and build 0 to n crossings
631  * @param[in] candidates The candidate vector of edges to be crossed
632  * @return The number of crossings built
633  * */
634  int checkCrossing(EdgeVector candidates);
635 
638 
640  void buildInnerEdges();
641 
645  int buildCrossings();
646 
650  void buildWalkingAreas(int cornerDetail, double joinMinDist);
651 
654 
656  EdgeVector edgesBetween(const NBEdge* e1, const NBEdge* e2) const;
657 
659  bool crossingBetween(const NBEdge* e1, const NBEdge* e2) const;
660 
662  bool alreadyConnectedPaths(const NBEdge* e1, const NBEdge* e2, double dist) const;
663 
666  return myBlockedConnections;
667  }
668 
670  bool geometryLike() const;
671  bool geometryLike(const EdgeVector& incoming, const EdgeVector& outgoing) const;
672 
674  void setRoundabout();
675 
677  bool isRoundabout() const;
678 
680  NBNode::Crossing* addCrossing(EdgeVector edges, double width, bool priority, int tlIndex = -1, int tlIndex2 = -1,
681  const PositionVector& customShape = PositionVector::EMPTY, bool fromSumoNet = false);
682 
684  void addWalkingAreaShape(EdgeVector edges, const PositionVector& shape);
685 
687  void removeCrossing(const EdgeVector& edges);
688 
690  void discardAllCrossings(bool rejectAll);
691 
693  void discardWalkingareas();
694 
698  }
699 
701  std::vector<Crossing*> getCrossings() const;
702  inline const std::vector<std::unique_ptr<Crossing> >& getCrossingsIncludingInvalid() const {
703  return myCrossings;
704  }
705 
707  inline const std::vector<WalkingArea>& getWalkingAreas() const {
708  return myWalkingAreas;
709  }
710 
711  const std::vector<WalkingAreaCustomShape>& getWalkingAreaCustomShapes() const {
713  }
714 
716  Crossing* getCrossing(const std::string& id) const;
717 
719  Crossing* getCrossing(const EdgeVector& edges, bool hardFail = true) const;
720 
721  /* @brief set tl indices of this nodes crossing starting at the given index
722  * @return Whether a custom index was used
723  */
724  bool setCrossingTLIndices(const std::string& tlID, int startIndex);
725 
727  int numNormalConnections() const;
728 
730  void avoidOverlap();
731 
733  bool rightOnRedConflict(int index, int foeIndex) const;
734 
736  void sortEdges(bool useNodeShape);
737 
739  int getConnectionIndex(const NBEdge* from, const NBEdge::Connection& con) const;
740 
746  public:
748  explicit nodes_by_id_sorter() { }
749 
751  int operator()(NBNode* n1, NBNode* n2) const {
752  return n1->getID() < n2->getID();
753  }
754  };
755 
760  public:
763 
765  int operator()(NBEdge* e1, NBEdge* e2) const {
766  UNUSED_PARAMETER(e2);
767  return e1->getFromNode() == myNode;
768  }
769 
770  private:
773 
774  };
775 
777  static std::string getNodeIDFromInternalLane(const std::string id);
778 
779 
781  static bool isTrafficLight(SumoXMLNodeType type);
782 
784  bool isSimpleContinuation(bool checkLaneNumbers = true, bool checkWidth = false) const;
785 
787  void markBentPriority(bool isBent) {
788  myIsBentPriority = isBent;
789  }
790 
792  bool isBentPriority() const {
793  return myIsBentPriority;
794  }
795 
797  bool typeWasGuessed() const {
798  return myTypeWasGuessed;
799  }
800 
802  bool isConstantWidthTransition() const;
803 
805  std::vector<std::pair<Position, std::string> > getEndPoints() const;
806 
807 private:
810 
812  void getEdgesThatApproach(NBEdge* currentOutgoing, EdgeVector& approaching);
813 
815  void replaceInConnectionProhibitions(NBEdge* which, NBEdge* by, int whichLaneOff, int byLaneOff);
816 
818  void remapRemoved(NBTrafficLightLogicCont& tc, NBEdge* removed, const EdgeVector& incoming, const EdgeVector& outgoing);
819 
821  bool forbidsPedestriansAfter(std::vector<std::pair<NBEdge*, bool> > normalizedLanes, int startIndex);
822 
825 
827  static bool isLongEnough(NBEdge* out, double minLength);
828 
831 
833  void displaceShapeAtWidthChange(const NBEdge* from, const NBEdge::Connection& con, PositionVector& fromShape, PositionVector& toShape) const;
834 
836  static bool includes(const std::set<NBEdge*, ComparatorIdLess>& super,
837  const std::set<const NBEdge*, ComparatorIdLess>& sub);
838 
839  NBEdge* getNextCompatibleOutgoing(const NBEdge* incoming, SVCPermissions vehPerm, EdgeVector::const_iterator start, bool clockwise) const;
840 
842  void getReduction(const NBEdge* in, const NBEdge* out, int& inOffset, int& outOffset, int& reduction) const;
843 
845  int addedLanesRight(NBEdge* out, int addedLanes) const;
846 
847 private:
850 
853 
856 
859 
861  std::vector<std::unique_ptr<Crossing> > myCrossings;
862 
864  std::vector<WalkingArea> myWalkingAreas;
865 
867  std::vector<WalkingAreaCustomShape> myWalkingAreaCustomShapes;
868 
871 
874 
877 
880 
883 
886 
888  std::set<NBTrafficLightDefinition*> myTrafficLights;
889 
891  double myRadius;
892 
895 
898 
901 
903  std::string myName;
904 
907 
910 
913 
914  /* @brief whether this junction is a bent priority junction (main direction turns)
915  * @note see NBEdgePriorityComputer
916  */
918 
921 
922 private:
924  NBNode(const NBNode& s);
925 
927  NBNode& operator=(const NBNode& s);
928 };
#define DEG2RAD(x)
Definition: GeomHelper.h:35
std::map< NBConnection, NBConnectionVector > NBConnectionProhibits
Definition of a container for connection block dependencies Includes a list of all connections which ...
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:34
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
FringeType
algorithms for computing right of way
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
RightOfWay
algorithms for computing right of way
const double INVALID_DOUBLE
Definition: StdDefs.h:62
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:29
A container for districts.
A class representing a single district.
Definition: NBDistrict.h:62
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:59
The representation of a single edge during network building.
Definition: NBEdge.h:91
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:509
Computes lane-2-lane connections.
Definition: NBNode.h:85
ApproachingDivider & operator=(const ApproachingDivider &)=delete
Invalidated assignment operator.
bool myIsBikeEdge
whether the outgoing edge is exclusively used by bikes
Definition: NBNode.h:118
ApproachingDivider(const EdgeVector &approaching, NBEdge *currentOutgoing)
Constructor.
Definition: NBNode.cpp:95
~ApproachingDivider()
Destructor.
Definition: NBNode.cpp:127
const EdgeVector & myApproaching
The list of edges that approach the current edge.
Definition: NBNode.h:109
int numAvailableLanes() const
@ get number of avaliable lanes
Definition: NBNode.h:97
std::deque< int > * spread(const std::vector< int > &approachingLanes, int dest) const
the method that spreads the wished number of lanes from the the lane given by the bresenham-call to b...
Definition: NBNode.cpp:164
NBEdge * myCurrentOutgoing
The approached current edge.
Definition: NBNode.h:112
void execute(const int src, const int dest)
the bresenham-callback
Definition: NBNode.cpp:131
std::vector< int > myAvailableLanes
The available lanes to which connections shall be built.
Definition: NBNode.h:115
A definition of a pedestrian crossing.
Definition: NBNode.h:129
Crossing(const NBNode *_node, const EdgeVector &_edges, double _width, bool _priority, int _customTLIndex, int _customTLIndex2, const PositionVector &_customShape)
constructor
Definition: NBNode.cpp:236
const NBNode * node
The parent node of this crossing.
Definition: NBNode.h:134
int tlLinkIndex
the traffic light index of this crossing (if controlled)
Definition: NBNode.h:154
std::string tlID
The id of the traffic light that controls this connection.
Definition: NBNode.h:160
PositionVector customShape
optional customShape for this crossing
Definition: NBNode.h:152
std::string id
the (edge)-id of this crossing
Definition: NBNode.h:144
std::string prevWalkingArea
the lane-id of the previous walkingArea
Definition: NBNode.h:146
std::string nextWalkingArea
the lane-id of the next walkingArea
Definition: NBNode.h:148
PositionVector shape
The crossing's shape.
Definition: NBNode.h:138
int customTLIndex
the custom traffic light index of this crossing (if controlled)
Definition: NBNode.h:157
int customTLIndex2
Definition: NBNode.h:158
bool priority
whether the pedestrians have priority
Definition: NBNode.h:150
int tlLinkIndex2
Definition: NBNode.h:155
EdgeVector edges
The edges being crossed.
Definition: NBNode.h:136
double width
This crossing's width.
Definition: NBNode.h:142
bool valid
whether this crossing is valid (and can be written to the net.xml). This is needed for netedit becaus...
Definition: NBNode.h:162
double customWidth
This crossing's width.
Definition: NBNode.h:140
Sorts outgoing before incoming edges.
Definition: NBNode.h:759
NBNode * myNode
The node to compute the relative angle of.
Definition: NBNode.h:772
int operator()(NBEdge *e1, NBEdge *e2) const
operator of selection
Definition: NBNode.h:765
edge_by_direction_sorter(NBNode *n)
constructor
Definition: NBNode.h:762
Used for sorting the cells by the begin time they describe.
Definition: NBNode.h:745
nodes_by_id_sorter()
Constructor.
Definition: NBNode.h:748
int operator()(NBNode *n1, NBNode *n2) const
Comparing operator.
Definition: NBNode.h:751
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:58
Represents a single node (junction) during network building.
Definition: NBNode.h:66
LinkState getLinkState(const NBEdge *incoming, NBEdge *outgoing, int fromLane, int toLane, bool mayDefinitelyPass, const std::string &tlID) const
get link state
Definition: NBNode.cpp:2156
void addIncomingEdge(NBEdge *edge)
adds an incoming edge
Definition: NBNode.cpp:458
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream's direction.
Definition: NBNode.cpp:2078
static const int FOUR_CONTROL_POINTS
Definition: NBNode.h:212
static const int AVOID_INTERSECTING_LEFT_TURNS
Definition: NBNode.h:213
bool hasIncoming(const NBEdge *const e) const
Returns whether the given edge ends at this node.
Definition: NBNode.cpp:1651
void avoidOverlap()
fix overlap
Definition: NBNode.cpp:3409
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
Definition: NBNode.cpp:1724
void buildInnerEdges()
build internal lanes, pedestrian crossings and walking areas
Definition: NBNode.cpp:2619
std::vector< WalkingAreaCustomShape > myWalkingAreaCustomShapes
Vector of custom walking areas shapes.
Definition: NBNode.h:867
double getDisplacementError() const
compute the displacement error during s-curve computation
Definition: NBNode.h:611
RightOfWay getRightOfWay() const
Returns hint on how to compute right of way.
Definition: NBNode.h:286
Position getCenter() const
Returns a position that is guaranteed to lie within the node shape.
Definition: NBNode.cpp:3348
bool mustBrake(const NBEdge *const from, const NBEdge *const to, int fromLane, int toLane, bool includePedCrossings) const
Returns the information whether the described flow must let any other flow pass.
Definition: NBNode.cpp:1799
void removeCrossing(const EdgeVector &edges)
remove a pedestrian crossing from this node (identified by its edges)
Definition: NBNode.cpp:3256
NBEdge * getNextCompatibleOutgoing(const NBEdge *incoming, SVCPermissions vehPerm, EdgeVector::const_iterator start, bool clockwise) const
Definition: NBNode.cpp:2053
bool isSimpleContinuation(bool checkLaneNumbers=true, bool checkWidth=false) const
check if node is a simple continuation
Definition: NBNode.cpp:478
int getConnectionIndex(const NBEdge *from, const NBEdge::Connection &con) const
return the index of the given connection
Definition: NBNode.cpp:3329
void reinit(const Position &position, SumoXMLNodeType type, bool updateEdgeGeometries=false)
Resets initial values.
Definition: NBNode.cpp:306
int numNormalConnections() const
return the number of lane-to-lane connections at this junction (excluding crossings)
Definition: NBNode.cpp:3314
bool setCrossingTLIndices(const std::string &tlID, int startIndex)
Definition: NBNode.cpp:3298
static const double UNSPECIFIED_RADIUS
unspecified lane width
Definition: NBNode.h:207
Crossing * getCrossing(const std::string &id) const
return the crossing with the given id
Definition: NBNode.cpp:3270
NBNode(const std::string &id, const Position &position, SumoXMLNodeType type)
Constructor.
Definition: NBNode.cpp:255
void invalidateIncomingConnections()
invalidate incoming connections
Definition: NBNode.cpp:1783
bool forbidsPedestriansAfter(std::vector< std::pair< NBEdge *, bool > > normalizedLanes, int startIndex)
return whether there is a non-sidewalk lane after the given index;
Definition: NBNode.cpp:2549
bool needsCont(const NBEdge *fromE, const NBEdge *otherFromE, const NBEdge::Connection &c, const NBEdge::Connection &otherC) const
whether an internal junction should be built at from and respect other
Definition: NBNode.cpp:844
FringeType getFringeType() const
Returns fringe type.
Definition: NBNode.h:291
void buildCrossingsAndWalkingAreas()
build crossings, and walkingareas. Also removes invalid loaded crossings if wished
Definition: NBNode.cpp:2560
std::string myName
The intersection name (or whatever arbitrary string you wish to attach)
Definition: NBNode.h:903
static const int BACKWARD
Definition: NBNode.h:204
bool rightOnRedConflict(int index, int foeIndex) const
whether the given index must yield to the foeIndex while turing right on a red light
Definition: NBNode.cpp:3432
SumoXMLNodeType getType() const
Returns the type of this node.
Definition: NBNode.h:271
const std::string & getName() const
Returns intersection name.
Definition: NBNode.h:296
void computeLogic2(bool checkLaneFoes)
compute right-of-way logic for all lane-to-lane connections
Definition: NBNode.cpp:957
void setRightOfWay(RightOfWay rightOfWay)
set method for computing right-of-way
Definition: NBNode.h:538
bool myTypeWasGuessed
whether the node type was guessed rather than loaded
Definition: NBNode.h:920
void setCustomShape(const PositionVector &shape)
set the junction shape
Definition: NBNode.cpp:2291
void computeNodeShape(double mismatchThreshold)
Compute the junction shape for this node.
Definition: NBNode.cpp:1040
void buildWalkingAreas(int cornerDetail, double joinMinDist)
build pedestrian walking areas and set connections from/to walkingAreas
Definition: NBNode.cpp:2739
static std::string getNodeIDFromInternalLane(const std::string id)
returns the node id for internal lanes, crossings and walkingareas
Definition: NBNode.cpp:3389
void remapRemoved(NBTrafficLightLogicCont &tc, NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing)
remap removed
Definition: NBNode.cpp:1972
int buildCrossings()
build pedestrian crossings
Definition: NBNode.cpp:2642
SumoXMLNodeType myType
The type of the junction.
Definition: NBNode.h:870
EdgeVector myOutgoingEdges
Vector of outgoing edges.
Definition: NBNode.h:855
bool myKeepClear
whether the junction area must be kept clear
Definition: NBNode.h:894
static bool isTrafficLight(SumoXMLNodeType type)
return whether the given type is a traffic light
Definition: NBNode.cpp:3424
void discardWalkingareas()
discard previously built walkingareas (required for repeated computation by netedit)
Definition: NBNode.cpp:2613
void computeLogic(const NBEdgeCont &ec)
computes the node's type, logic and traffic light
Definition: NBNode.cpp:918
NBRequest * myRequest
Node requests.
Definition: NBNode.h:885
void mirrorX()
mirror coordinates along the x-axis
Definition: NBNode.cpp:345
void invalidateOutgoingConnections()
invalidate outgoing connections
Definition: NBNode.cpp:1791
std::vector< std::pair< Position, std::string > > getEndPoints() const
return list of unique endpoint coordinates of all edges at this node
Definition: NBNode.cpp:3527
static bool rightTurnConflict(const NBEdge *from, const NBEdge *to, int fromLane, const NBEdge *prohibitorFrom, const NBEdge *prohibitorTo, int prohibitorFromLane)
return whether the given laneToLane connection is a right turn which must yield to a bicycle crossing...
Definition: NBNode.cpp:1819
std::vector< std::pair< NBEdge *, NBEdge * > > getEdgesToJoin() const
get edges to join
Definition: NBNode.cpp:2262
void setKeepClear(bool keepClear)
set the keepClear flag
Definition: NBNode.h:533
bool myHaveCustomPoly
whether this nodes shape was set by the user
Definition: NBNode.h:882
Position getEmptyDir() const
Returns something like the most unused direction Should only be used to add source or sink nodes.
Definition: NBNode.cpp:1755
NBNode::Crossing * addCrossing(EdgeVector edges, double width, bool priority, int tlIndex=-1, int tlIndex2=-1, const PositionVector &customShape=PositionVector::EMPTY, bool fromSumoNet=false)
add a pedestrian crossing to this node
Definition: NBNode.cpp:3244
static const int AVOID_WIDE_RIGHT_TURN
flags for controlling shape generation
Definition: NBNode.h:210
int myCrossingsLoadedFromSumoNet
number of crossings loaded from a sumo net
Definition: NBNode.h:909
bool forbids(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
Definition: NBNode.cpp:1955
bool alreadyConnectedPaths(const NBEdge *e1, const NBEdge *e2, double dist) const
return true if the given pedestrian paths are connected at another junction within dist
Definition: NBNode.cpp:3146
bool mustBrakeForCrossing(const NBEdge *const from, const NBEdge *const to, const Crossing &crossing) const
Returns the information whether the described flow must brake for the given crossing.
Definition: NBNode.cpp:1813
bool hasConflict() const
whether there are conflicting streams of traffic at this node
Definition: NBNode.cpp:1022
void removeTrafficLights(bool setAsPriority=false)
Removes all references to traffic lights that control this tls.
Definition: NBNode.cpp:381
void replaceInConnectionProhibitions(NBEdge *which, NBEdge *by, int whichLaneOff, int byLaneOff)
replace incoming connections prohibitions
Definition: NBNode.cpp:1578
bool mergeConflictYields(const NBEdge *from, int fromLane, int fromLaneFoe, NBEdge *to, int toLane) const
whether one of multple connections from the same edge targeting the same lane must yield
Definition: NBNode.cpp:1870
const std::vector< std::unique_ptr< Crossing > > & getCrossingsIncludingInvalid() const
Definition: NBNode.h:702
void replaceOutgoing(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurences of the first edge within the list of outgoing by the second Connections are remap...
Definition: NBNode.cpp:1509
void getReduction(const NBEdge *in, const NBEdge *out, int &inOffset, int &outOffset, int &reduction) const
get the reduction in driving lanes at this junction
Definition: NBNode.cpp:1415
EdgeVector myAllEdges
Vector of incoming and outgoing edges.
Definition: NBNode.h:858
void computeKeepClear()
compute keepClear status for all connections
Definition: NBNode.cpp:964
int numCrossingsFromSumoNet() const
get num of crossings from sumo net
Definition: NBNode.h:696
NBNode & operator=(const NBNode &s)
invalidated assignment operator
void sortEdges(bool useNodeShape)
sort all edge containers for this node
Definition: NBNode.cpp:3443
RightOfWay myRightOfWay
how to compute right of way for this node
Definition: NBNode.h:897
bool myIsBentPriority
Definition: NBNode.h:917
std::set< NBTrafficLightDefinition * > myTrafficLights
traffic lights of node
Definition: NBNode.h:888
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
Definition: NBNode.h:259
double myRadius
the turning radius (for all corners) at this node in m.
Definition: NBNode.h:891
static bool includes(const std::set< NBEdge *, ComparatorIdLess > &super, const std::set< const NBEdge *, ComparatorIdLess > &sub)
returns whether sub is a subset of super
Definition: NBNode.cpp:3112
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node)
Definition: NBNode.h:264
PositionVector computeSmoothShape(const PositionVector &begShape, const PositionVector &endShape, int numPoints, bool isTurnaround, double extrapolateBeg, double extrapolateEnd, NBNode *recordError=0, int shapeFlag=0) const
Compute a smooth curve between the given geometries.
Definition: NBNode.cpp:513
bool hasCustomShape() const
return whether the shape was set by the user
Definition: NBNode.h:553
bool isLeftMover(const NBEdge *const from, const NBEdge *const to) const
Computes whether the given connection is a left mover across the junction.
Definition: NBNode.cpp:1936
int removeSelfLoops(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes edges which are both incoming and outgoing into this node.
Definition: NBNode.cpp:425
bool checkCrossingDuplicated(EdgeVector edges)
return true if there already exist a crossing with the same edges as the input
Definition: NBNode.cpp:2532
void setRoundabout()
update the type of this node as a roundabout
Definition: NBNode.cpp:3227
bool mergeConflict(const NBEdge *from, const NBEdge::Connection &con, const NBEdge *prohibitorFrom, const NBEdge::Connection &prohibitorCon, bool foes) const
whether multple connections from the same edge target the same lane
Definition: NBNode.cpp:1881
bool myDiscardAllCrossings
whether to discard all pedestrian crossings
Definition: NBNode.h:906
void invalidateTLS(NBTrafficLightLogicCont &tlCont, bool removedConnections, bool addedConnections)
causes the traffic light to be computed anew
Definition: NBNode.cpp:394
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
Definition: NBNode.h:254
std::vector< Crossing * > getCrossings() const
return this junctions pedestrian crossings
Definition: NBNode.cpp:2585
void addSortedLinkFoes(const NBConnection &mayDrive, const NBConnection &mustStop)
add shorted link FOES
Definition: NBNode.cpp:1681
Position myPosition
The position the node lies at.
Definition: NBNode.h:849
bool isBentPriority() const
return whether a priority road turns at this node
Definition: NBNode.h:792
void replaceIncoming(NBEdge *which, NBEdge *by, int laneOff)
Replaces occurences of the first edge within the list of incoming by the second Connections are remap...
Definition: NBNode.cpp:1545
bool turnFoes(const NBEdge *from, const NBEdge *to, int fromLane, const NBEdge *from2, const NBEdge *to2, int fromLane2, bool lefthand=false) const
return whether the given laneToLane connection originate from the same edge and are in conflict due t...
Definition: NBNode.cpp:1890
void discardAllCrossings(bool rejectAll)
discard all current (and optionally future) crossings
Definition: NBNode.cpp:2603
bool hasOutgoing(const NBEdge *const e) const
Returns whether the given edge starts at this node.
Definition: NBNode.cpp:1657
bool writeLogic(OutputDevice &into) const
writes the XML-representation of the logic as a bitset-logic XML representation
Definition: NBNode.cpp:993
void setRadius(double radius)
set the turning radius
Definition: NBNode.h:528
NBEdge * getPossiblySplittedOutgoing(const std::string &edgeid)
get possibly splitted outgoing edge
Definition: NBNode.cpp:1711
NBNode(const NBNode &s)
invalidated copy constructor
void addOutgoingEdge(NBEdge *edge)
adds an outgoing edge
Definition: NBNode.cpp:468
bool isConstantWidthTransition() const
detects whether a given junction splits or merges lanes while keeping constant road width
Definition: NBNode.cpp:787
std::vector< std::unique_ptr< Crossing > > myCrossings
Vector of crossings.
Definition: NBNode.h:861
void removeJoinedTrafficLights()
remove all traffic light definitions that are part of a joined tls
Definition: NBNode.cpp:903
bool crossingBetween(const NBEdge *e1, const NBEdge *e2) const
return true if the given edges are connected by a crossing
Definition: NBNode.cpp:3125
bool isDistrict() const
check if node is a district
Definition: NBNode.cpp:2331
NBDistrict * myDistrict
The district the node is the centre of.
Definition: NBNode.h:876
const std::set< NBTrafficLightDefinition * > & getControllingTLS() const
Returns the traffic lights that were assigned to this node (The set of tls that control this node)
Definition: NBNode.h:322
void computeLanes2Lanes()
computes the connections of lanes to edges
Definition: NBNode.cpp:1079
void reshiftPosition(double xoff, double yoff)
Applies an offset to the node.
Definition: NBNode.cpp:332
void setName(const std::string &name)
set intersection name
Definition: NBNode.h:548
double myDisplacementError
geometry error after computation of internal lane shapes
Definition: NBNode.h:912
static const int AVOID_WIDE_LEFT_TURN
Definition: NBNode.h:211
void removeTrafficLight(NBTrafficLightDefinition *tlDef)
Removes the given traffic light from this node.
Definition: NBNode.cpp:374
void markBentPriority(bool isBent)
mark whether a priority road turns at this node
Definition: NBNode.h:787
bool typeWasGuessed() const
return whether a priority road turns at this node
Definition: NBNode.h:797
const std::string getResponse(int linkIndex) const
get the 'response' string (right-of-way bit set) of the right-of-way logic
Definition: NBNode.cpp:1013
void addWalkingAreaShape(EdgeVector edges, const PositionVector &shape)
add custom shape for walkingArea
Definition: NBNode.cpp:3183
static bool isLongEnough(NBEdge *out, double minLength)
check if is long enough
Definition: NBNode.cpp:1470
bool tlsContConflict(const NBEdge *from, const NBEdge::Connection &c, const NBEdge *foeFrom, const NBEdge::Connection &foe) const
whether the connection must yield if the foe remains on the intersection after its phase ends
Definition: NBNode.cpp:893
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:2285
void setPriorityJunctionPriorities()
sets the priorites in case of a priority junction
std::vector< WalkingArea > myWalkingAreas
Vector of walking areas.
Definition: NBNode.h:864
NBConnectionProhibits myBlockedConnections
The container for connection block dependencies.
Definition: NBNode.h:873
void updateSurroundingGeometry()
update geometry of node and surrounding edges
Definition: NBNode.cpp:1031
int addedLanesRight(NBEdge *out, int addedLanes) const
check whether this edge has extra lanes on the right side
Definition: NBNode.cpp:1423
const Position & getPosition() const
Definition: NBNode.h:246
FringeType myFringeType
fringe type of this node
Definition: NBNode.h:900
double getRadius() const
Returns the turning radius of this node.
Definition: NBNode.h:276
bool checkIsRemovable() const
check if node is removable
Definition: NBNode.cpp:2189
bool isRoundabout() const
return whether this node is part of a roundabout
Definition: NBNode.cpp:3234
const NBConnectionProhibits & getProhibitions()
get prohibitions (BLocked connections)
Definition: NBNode.h:665
static const int FORWARD
edge directions (for pedestrian related stuff)
Definition: NBNode.h:203
bool checkIsRemovableReporting(std::string &reason) const
check if node is removable and return reason if not
Definition: NBNode.cpp:2195
void displaceShapeAtWidthChange(const NBEdge *from, const NBEdge::Connection &con, PositionVector &fromShape, PositionVector &toShape) const
displace lane shapes to account for change in lane width at this node
Definition: NBNode.cpp:795
bool foes(const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const
Returns the information whether the given flows cross.
Definition: NBNode.cpp:1965
void removeDoubleEdges()
remove duble edges
Definition: NBNode.cpp:1613
PositionVector myPoly
the (outer) shape of the junction
Definition: NBNode.h:879
NBEdge * getConnectionTo(NBNode *n) const
get connection to certain node
Definition: NBNode.cpp:2303
void getEdgesThatApproach(NBEdge *currentOutgoing, EdgeVector &approaching)
returns a list of edges which are connected to the given outgoing edge
Definition: NBNode.cpp:1487
void setFringeType(FringeType fringeType)
set method for computing right-of-way
Definition: NBNode.h:543
EdgeVector getEdgesSortedByAngleAtNodeCenter() const
returns the list of all edges sorted clockwise by getAngleAtNodeToCenter
Definition: NBNode.cpp:3366
const std::vector< WalkingAreaCustomShape > & getWalkingAreaCustomShapes() const
Definition: NBNode.h:711
EdgeVector edgesBetween(const NBEdge *e1, const NBEdge *e2) const
return all edges that lie clockwise between the given edges
Definition: NBNode.cpp:3167
PositionVector computeInternalLaneShape(const NBEdge *fromE, const NBEdge::Connection &con, int numPoints, NBNode *recordError=0, int shapeFlag=0) const
Compute the shape for an internal lane.
Definition: NBNode.cpp:705
~NBNode()
Destructor.
Definition: NBNode.cpp:300
NBEdge * getPossiblySplittedIncoming(const std::string &edgeid)
get possibly splitted incoming edge
Definition: NBNode.cpp:1698
void shiftTLConnectionLaneIndex(NBEdge *edge, int offset, int threshold=-1)
patches loaded signal plans by modifying lane indices above threshold by the given offset
Definition: NBNode.cpp:417
bool geometryLike() const
whether this is structurally similar to a geometry node
Definition: NBNode.cpp:3192
bool isNearDistrict() const
@chech if node is near district
Definition: NBNode.cpp:2314
EdgeVector myIncomingEdges
Vector of incoming edges.
Definition: NBNode.h:852
const std::vector< WalkingArea > & getWalkingAreas() const
return this junctions pedestrian walking areas
Definition: NBNode.h:707
int checkCrossing(EdgeVector candidates)
Definition: NBNode.cpp:2441
void addTrafficLight(NBTrafficLightDefinition *tlDef)
Adds a traffic light to the list of traffic lights that control this node.
Definition: NBNode.cpp:364
int guessCrossings()
guess pedestrian crossings and return how many were guessed
Definition: NBNode.cpp:2337
bool isTLControlled() const
Returns whether this node is controlled by any tls.
Definition: NBNode.h:317
bool getKeepClear() const
Returns the keepClear flag.
Definition: NBNode.h:281
static const int SCURVE_IGNORE
Definition: NBNode.h:214
const std::string getFoes(int linkIndex) const
get the 'foes' string (conflict bit set) of the right-of-way logic
Definition: NBNode.cpp:1003
NBEdge * getOppositeIncoming(NBEdge *e) const
returns the opposite incoming edge of certain edge
Definition: NBNode.cpp:1663
static PositionVector bezierControlPoints(const PositionVector &begShape, const PositionVector &endShape, bool isTurnaround, double extrapolateBeg, double extrapolateEnd, bool &ok, NBNode *recordError=0, double straightThresh=DEG2RAD(5), int shapeFlag=0)
get bezier control points
Definition: NBNode.cpp:540
The base class for traffic light logic definitions.
A container for traffic light definitions and built programs.
A storage for available edgeTypes of edges.
Definition: NBTypeCont.h:52
Base class for objects which have an id.
Definition: Named.h:53
const std::string & getID() const
Returns the id.
Definition: Named.h:73
A storage for options typed value containers)
Definition: OptionsCont.h:89
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:60
An upper class for objects with additional parameters.
Definition: Parameterised.h:39
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:36
A list of positions.
static const PositionVector EMPTY
empty Vector
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:188
std::set< const NBEdge *, ComparatorIdLess > edges
Definition: NBNode.h:198
A definition of a pedestrian walking area.
Definition: NBNode.h:169
int minPrevCrossingEdges
minimum number of edges crossed by incoming crossings
Definition: NBNode.h:194
std::vector< std::string > nextSidewalks
the lane-id of the next sidewalk lane or ""
Definition: NBNode.h:186
std::vector< std::string > prevSidewalks
the lane-id of the previous sidewalk lane or ""
Definition: NBNode.h:188
std::string id
the (edge)-id of this walkingArea
Definition: NBNode.h:176
WalkingArea(const std::string &_id, double _width)
constructor
Definition: NBNode.h:171
bool hasCustomShape
whether this walkingArea has a custom shape
Definition: NBNode.h:190
double width
This lane's width.
Definition: NBNode.h:178
std::vector< std::string > nextCrossings
the lane-id of the next crossing(s)
Definition: NBNode.h:184
PositionVector shape
The polygonal shape.
Definition: NBNode.h:182
double length
This lane's width.
Definition: NBNode.h:180
int minNextCrossingEdges
minimum number of edges crossed by nextCrossings
Definition: NBNode.h:192