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-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 /****************************************************************************/
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  double width;
201  };
202 
204  static const int FORWARD;
205  static const int BACKWARD;
206 
208  static const double UNSPECIFIED_RADIUS;
209 
211  static const int AVOID_WIDE_RIGHT_TURN;
212  static const int AVOID_WIDE_LEFT_TURN;
213  static const int FOUR_CONTROL_POINTS;
215  static const int SCURVE_IGNORE;
216  static const int INDIRECT_LEFT;
217 
218 public:
224  NBNode(const std::string& id, const Position& position, SumoXMLNodeType type);
225 
231  NBNode(const std::string& id, const Position& position, NBDistrict* district = 0);
232 
234  ~NBNode();
235 
242  void reinit(const Position& position, SumoXMLNodeType type,
243  bool updateEdgeGeometries = false);
244 
248  const Position& getPosition() const {
249  return myPosition;
250  }
251 
253  Position getCenter() const;
254 
256  const EdgeVector& getIncomingEdges() const {
257  return myIncomingEdges;
258  }
259 
261  const EdgeVector& getOutgoingEdges() const {
262  return myOutgoingEdges;
263  }
264 
266  const EdgeVector& getEdges() const {
267  return myAllEdges;
268  }
269 
274  return myType;
275  }
276 
278  double getRadius() const {
279  return myRadius;
280  }
281 
283  bool getKeepClear() const {
284  return myKeepClear;
285  }
286 
289  return myRightOfWay;
290  }
291 
294  return myFringeType;
295  }
296 
298  const std::string& getName() const {
299  return myName;
300  }
302 
305 
309 
312 
314  void removeTrafficLights(bool setAsPriority = false);
315 
319  bool isTLControlled() const {
320  return myTrafficLights.size() != 0;
321  }
322 
324  const std::set<NBTrafficLightDefinition*>& getControllingTLS() const {
325  return myTrafficLights;
326  }
327 
329  void invalidateTLS(NBTrafficLightLogicCont& tlCont, bool removedConnections, bool addedConnections);
330 
332  void shiftTLConnectionLaneIndex(NBEdge* edge, int offset, int threshold = -1);
334 
335 
338 
350 
351 
354 
358  void reshiftPosition(double xoff, double yoff);
359 
361  void mirrorX();
363 
365  void addIncomingEdge(NBEdge* edge);
366 
368  void addOutgoingEdge(NBEdge* edge);
369 
371  void computeLanes2Lanes();
372 
374  void computeLogic(const NBEdgeCont& ec);
375 
377  void computeLogic2(bool checkLaneFoes);
378 
380  void computeKeepClear();
381 
383  bool writeLogic(OutputDevice& into) const;
384 
386  const std::string getFoes(int linkIndex) const;
387 
389  const std::string getResponse(int linkIndex) const;
390 
392  bool hasConflict() const;
393 
395  Position getEmptyDir() const;
396 
401  bool hasIncoming(const NBEdge* const e) const;
402 
407  bool hasOutgoing(const NBEdge* const e) const;
408 
410  NBEdge* getOppositeIncoming(NBEdge* e) const;
411 
413  void invalidateIncomingConnections(bool reallowSetting = false);
414 
416  void invalidateOutgoingConnections(bool reallowSetting = false);
417 
419  void removeDoubleEdges();
420 
422  NBEdge* getConnectionTo(NBNode* n) const;
423 
425  void addSortedLinkFoes(const NBConnection& mayDrive, const NBConnection& mustStop);
426 
428  NBEdge* getPossiblySplittedIncoming(const std::string& edgeid);
429 
431  NBEdge* getPossiblySplittedOutgoing(const std::string& edgeid);
432 
434  void removeEdge(NBEdge* edge, bool removeFromConnections = true);
435 
445  bool isLeftMover(const NBEdge* const from, const NBEdge* const to) const;
446 
455  bool mustBrake(const NBEdge* const from, const NBEdge* const to, int fromLane, int toLane, bool includePedCrossings) const;
456 
463  bool mustBrakeForCrossing(const NBEdge* const from, const NBEdge* const to, const Crossing& crossing) const;
464 
466  bool brakeForCrossingOnExit(const NBEdge* to) const;
467 
469  static bool rightTurnConflict(const NBEdge* from, const NBEdge* to, int fromLane,
470  const NBEdge* prohibitorFrom, const NBEdge* prohibitorTo, int prohibitorFromLane);
471 
473  bool mergeConflictYields(const NBEdge* from, int fromLane, int fromLaneFoe, NBEdge* to, int toLane) const;
474 
476  bool mergeConflict(const NBEdge* from, const NBEdge::Connection& con,
477  const NBEdge* prohibitorFrom, const NBEdge::Connection& prohibitorCon, bool foes) const;
478 
480  bool turnFoes(const NBEdge* from, const NBEdge* to, int fromLane,
481  const NBEdge* from2, const NBEdge* to2, int fromLane2,
482  bool lefthand = false) const;
483 
492  bool forbids(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
493  const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
494  bool regardNonSignalisedLowerPriority) const;
495 
503  bool foes(const NBEdge* const from1, const NBEdge* const to1,
504  const NBEdge* const from2, const NBEdge* const to2) const;
505 
512  LinkDirection getDirection(const NBEdge* const incoming, const NBEdge* const outgoing, bool leftHand = false) const;
513 
515  LinkState getLinkState(const NBEdge* incoming, NBEdge* outgoing,
516  int fromLane, int toLane, bool mayDefinitelyPass, const std::string& tlID) const;
517 
521  void computeNodeShape(double mismatchThreshold);
522 
525 
527  const PositionVector& getShape() const;
528 
530  void setCustomShape(const PositionVector& shape);
531 
533  void setRadius(double radius) {
534  myRadius = radius;
535  }
536 
538  void setKeepClear(bool keepClear) {
539  myKeepClear = keepClear;
540  }
541 
543  void setRightOfWay(RightOfWay rightOfWay) {
544  myRightOfWay = rightOfWay;
545  }
546 
548  void setFringeType(FringeType fringeType) {
549  myFringeType = fringeType;
550  }
551 
553  void setName(const std::string& name) {
554  myName = name;
555  }
556 
558  bool hasCustomShape() const {
559  return myHaveCustomPoly;
560  }
561 
563  bool checkIsRemovable() const;
564 
566  bool checkIsRemovableReporting(std::string& reason) const;
567 
569  std::vector<std::pair<NBEdge*, NBEdge*> > getEdgesToJoin() const;
570 
572  bool isNearDistrict() const;
573 
575  bool isDistrict() const;
576 
578  bool needsCont(const NBEdge* fromE, const NBEdge* otherFromE,
579  const NBEdge::Connection& c, const NBEdge::Connection& otherC) const;
580 
582  bool tlsContConflict(const NBEdge* from, const NBEdge::Connection& c,
583  const NBEdge* foeFrom, const NBEdge::Connection& foe) const;
584 
585 
593  PositionVector computeInternalLaneShape(const NBEdge* fromE, const NBEdge::Connection& con, int numPoints, NBNode* recordError = 0, int shapeFlag = 0) const;
594 
605  PositionVector computeSmoothShape(const PositionVector& begShape, const PositionVector& endShape, int numPoints,
606  bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
607  NBNode* recordError = 0, int shapeFlag = 0) const;
609  static PositionVector bezierControlPoints(const PositionVector& begShape, const PositionVector& endShape,
610  bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
611  bool& ok, NBNode* recordError = 0, double straightThresh = DEG2RAD(5),
612  int shapeFlag = 0);
613 
615  PositionVector indirectLeftShape(const PositionVector& begShape, const PositionVector& endShape, int numPoints) const;
616 
618  double getDisplacementError() const {
619  return myDisplacementError;
620  }
621 
623  void replaceIncoming(NBEdge* which, NBEdge* by, int laneOff);
624 
626  void replaceIncoming(const EdgeVector& which, NBEdge* by);
627 
629  void replaceOutgoing(NBEdge* which, NBEdge* by, int laneOff);
630 
632  void replaceOutgoing(const EdgeVector& which, NBEdge* by);
633 
635  int guessCrossings();
636 
637  /* @brief check whether a crossing should be build for the candiate edges and build 0 to n crossings
638  * @param[in] candidates The candidate vector of edges to be crossed
639  * @return The number of crossings built
640  * */
641  int checkCrossing(EdgeVector candidates);
642 
645 
647  void buildInnerEdges();
648 
652  int buildCrossings();
653 
657  void buildWalkingAreas(int cornerDetail, double joinMinDist);
658 
661 
663  EdgeVector edgesBetween(const NBEdge* e1, const NBEdge* e2) const;
664 
666  bool crossingBetween(const NBEdge* e1, const NBEdge* e2) const;
667 
669  bool alreadyConnectedPaths(const NBEdge* e1, const NBEdge* e2, double dist) const;
670 
673  return myBlockedConnections;
674  }
675 
677  bool geometryLike() const;
678  bool geometryLike(const EdgeVector& incoming, const EdgeVector& outgoing) const;
679 
681  void setRoundabout();
682 
684  bool isRoundabout() const;
685 
687  NBNode::Crossing* addCrossing(EdgeVector edges, double width, bool priority, int tlIndex = -1, int tlIndex2 = -1,
688  const PositionVector& customShape = PositionVector::EMPTY, bool fromSumoNet = false);
689 
691  void addWalkingAreaShape(EdgeVector edges, const PositionVector& shape, double width);
692 
694  void removeCrossing(const EdgeVector& edges);
695 
697  void discardAllCrossings(bool rejectAll);
698 
700  void discardWalkingareas();
701 
705  }
706 
708  std::vector<Crossing*> getCrossings() const;
709  inline const std::vector<std::unique_ptr<Crossing> >& getCrossingsIncludingInvalid() const {
710  return myCrossings;
711  }
712 
714  inline const std::vector<WalkingArea>& getWalkingAreas() const {
715  return myWalkingAreas;
716  }
717 
718  const std::vector<WalkingAreaCustomShape>& getWalkingAreaCustomShapes() const {
720  }
721 
723  Crossing* getCrossing(const std::string& id) const;
724 
726  Crossing* getCrossing(const EdgeVector& edges, bool hardFail = true) const;
727 
728  /* @brief set tl indices of this nodes crossing starting at the given index
729  * @return Whether a custom index was used
730  */
731  bool setCrossingTLIndices(const std::string& tlID, int startIndex);
732 
734  int numNormalConnections() const;
735 
737  void avoidOverlap();
738 
740  bool rightOnRedConflict(int index, int foeIndex) const;
741 
743  void sortEdges(bool useNodeShape);
744 
746  int getConnectionIndex(const NBEdge* from, const NBEdge::Connection& con) const;
747 
753  public:
755  explicit nodes_by_id_sorter() { }
756 
758  int operator()(NBNode* n1, NBNode* n2) const {
759  return n1->getID() < n2->getID();
760  }
761  };
762 
767  public:
770 
772  int operator()(NBEdge* e1, NBEdge* e2) const {
773  UNUSED_PARAMETER(e2);
774  return e1->getFromNode() == myNode;
775  }
776 
777  private:
780 
781  };
782 
784  static bool isTrafficLight(SumoXMLNodeType type);
785 
787  bool isSimpleContinuation(bool checkLaneNumbers = true, bool checkWidth = false) const;
788 
790  void markBentPriority(bool isBent) {
791  myIsBentPriority = isBent;
792  }
793 
795  bool isBentPriority() const {
796  return myIsBentPriority;
797  }
798 
800  bool typeWasGuessed() const {
801  return myTypeWasGuessed;
802  }
803 
805  bool isConstantWidthTransition() const;
806 
808  std::vector<std::pair<Position, std::string> > getEndPoints() const;
809 
810 private:
813 
815  void getEdgesThatApproach(NBEdge* currentOutgoing, EdgeVector& approaching);
816 
818  void replaceInConnectionProhibitions(NBEdge* which, NBEdge* by, int whichLaneOff, int byLaneOff);
819 
821  void remapRemoved(NBTrafficLightLogicCont& tc, NBEdge* removed, const EdgeVector& incoming, const EdgeVector& outgoing);
822 
824  bool forbidsPedestriansAfter(std::vector<std::pair<NBEdge*, bool> > normalizedLanes, int startIndex);
825 
828 
830  static bool isLongEnough(NBEdge* out, double minLength);
831 
834 
836  void displaceShapeAtWidthChange(const NBEdge* from, const NBEdge::Connection& con, PositionVector& fromShape, PositionVector& toShape) const;
837 
839  static bool includes(const std::set<NBEdge*, ComparatorIdLess>& super,
840  const std::set<const NBEdge*, ComparatorIdLess>& sub);
841 
842  NBEdge* getNextCompatibleOutgoing(const NBEdge* incoming, SVCPermissions vehPerm, EdgeVector::const_iterator start, bool clockwise) const;
843 
845  void recheckVClassConnections(NBEdge* currentOutgoing);
846 
848  void getReduction(const NBEdge* in, const NBEdge* out, int& inOffset, int& outOffset, int& reduction) const;
849 
851  int addedLanesRight(NBEdge* out, int addedLanes) const;
852 
854  bool isStraighter(const NBEdge* const incoming, const double angle, const SVCPermissions vehPerm, const int modeLanes, const NBEdge* const candidate) const;
855 
856 private:
859 
862 
865 
868 
870  std::vector<std::unique_ptr<Crossing> > myCrossings;
871 
873  std::vector<WalkingArea> myWalkingAreas;
874 
876  std::vector<WalkingAreaCustomShape> myWalkingAreaCustomShapes;
877 
880 
883 
886 
889 
892 
895 
897  std::set<NBTrafficLightDefinition*> myTrafficLights;
898 
900  double myRadius;
901 
904 
907 
910 
912  std::string myName;
913 
916 
919 
922 
923  /* @brief whether this junction is a bent priority junction (main direction turns)
924  * @note see NBEdgePriorityComputer
925  */
927 
930 
931 private:
933  NBNode(const NBNode& s);
934 
936  NBNode& operator=(const NBNode& s);
937 };
#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:35
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
FringeType
classifying boundary nodes
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:63
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:30
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:534
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:96
~ApproachingDivider()
Destructor.
Definition: NBNode.cpp:128
const EdgeVector & myApproaching
The list of edges that approach the current edge.
Definition: NBNode.h:109
int numAvailableLanes() const
@ get number of available 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:165
NBEdge * myCurrentOutgoing
The approached current edge.
Definition: NBNode.h:112
void execute(const int src, const int dest)
the bresenham-callback
Definition: NBNode.cpp:132
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:237
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:766
NBNode * myNode
The node to compute the relative angle of.
Definition: NBNode.h:779
int operator()(NBEdge *e1, NBEdge *e2) const
operator of selection
Definition: NBNode.h:772
edge_by_direction_sorter(NBNode *n)
constructor
Definition: NBNode.h:769
Used for sorting the cells by the begin time they describe.
Definition: NBNode.h:752
nodes_by_id_sorter()
Constructor.
Definition: NBNode.h:755
int operator()(NBNode *n1, NBNode *n2) const
Comparing operator.
Definition: NBNode.h:758
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:2286
void addIncomingEdge(NBEdge *edge)
adds an incoming edge
Definition: NBNode.cpp:459
void invalidateOutgoingConnections(bool reallowSetting=false)
invalidate outgoing connections
Definition: NBNode.cpp:1884
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:2221
static const int FOUR_CONTROL_POINTS
Definition: NBNode.h:213
static const int AVOID_INTERSECTING_LEFT_TURNS
Definition: NBNode.h:214
bool hasIncoming(const NBEdge *const e) const
Returns whether the given edge ends at this node.
Definition: NBNode.cpp:1744
void addWalkingAreaShape(EdgeVector edges, const PositionVector &shape, double width)
add custom shape for walkingArea
Definition: NBNode.cpp:3333
void avoidOverlap()
fix overlap
Definition: NBNode.cpp:3540
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
Definition: NBNode.cpp:1817
void buildInnerEdges()
build internal lanes, pedestrian crossings and walking areas
Definition: NBNode.cpp:2759
std::vector< WalkingAreaCustomShape > myWalkingAreaCustomShapes
Vector of custom walking areas shapes.
Definition: NBNode.h:876
double getDisplacementError() const
compute the displacement error during s-curve computation
Definition: NBNode.h:618
RightOfWay getRightOfWay() const
Returns hint on how to compute right of way.
Definition: NBNode.h:288
Position getCenter() const
Returns a position that is guaranteed to lie within the node shape.
Definition: NBNode.cpp:3499
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:1892
void removeCrossing(const EdgeVector &edges)
remove a pedestrian crossing from this node (identified by its edges)
Definition: NBNode.cpp:3407
NBEdge * getNextCompatibleOutgoing(const NBEdge *incoming, SVCPermissions vehPerm, EdgeVector::const_iterator start, bool clockwise) const
Definition: NBNode.cpp:2159
bool isSimpleContinuation(bool checkLaneNumbers=true, bool checkWidth=false) const
check if node is a simple continuation
Definition: NBNode.cpp:479
int getConnectionIndex(const NBEdge *from, const NBEdge::Connection &con) const
return the index of the given connection
Definition: NBNode.cpp:3480
void reinit(const Position &position, SumoXMLNodeType type, bool updateEdgeGeometries=false)
Resets initial values.
Definition: NBNode.cpp:307
int numNormalConnections() const
return the number of lane-to-lane connections at this junction (excluding crossings)
Definition: NBNode.cpp:3465
bool setCrossingTLIndices(const std::string &tlID, int startIndex)
Definition: NBNode.cpp:3449
static const double UNSPECIFIED_RADIUS
unspecified lane width
Definition: NBNode.h:208
Crossing * getCrossing(const std::string &id) const
return the crossing with the given id
Definition: NBNode.cpp:3421
NBNode(const std::string &id, const Position &position, SumoXMLNodeType type)
Constructor.
Definition: NBNode.cpp:256
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:2689
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:875
void recheckVClassConnections(NBEdge *currentOutgoing)
ensure connectivity for all vClasses
Definition: NBNode.cpp:1403
FringeType getFringeType() const
Returns fringe type.
Definition: NBNode.h:293
void buildCrossingsAndWalkingAreas()
build crossings, and walkingareas. Also removes invalid loaded crossings if wished
Definition: NBNode.cpp:2700
std::string myName
The intersection name (or whatever arbitrary string you wish to attach)
Definition: NBNode.h:912
static const int BACKWARD
Definition: NBNode.h:205
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:3563
SumoXMLNodeType getType() const
Returns the type of this node.
Definition: NBNode.h:273
const std::string & getName() const
Returns intersection name.
Definition: NBNode.h:298
void computeLogic2(bool checkLaneFoes)
compute right-of-way logic for all lane-to-lane connections
Definition: NBNode.cpp:991
void setRightOfWay(RightOfWay rightOfWay)
set method for computing right-of-way
Definition: NBNode.h:543
bool myTypeWasGuessed
whether the node type was guessed rather than loaded
Definition: NBNode.h:929
void setCustomShape(const PositionVector &shape)
set the junction shape
Definition: NBNode.cpp:2424
void computeNodeShape(double mismatchThreshold)
Compute the junction shape for this node.
Definition: NBNode.cpp:1075
void buildWalkingAreas(int cornerDetail, double joinMinDist)
build pedestrian walking areas and set connections from/to walkingAreas
Definition: NBNode.cpp:2879
void remapRemoved(NBTrafficLightLogicCont &tc, NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing)
remap removed
Definition: NBNode.cpp:2078
int buildCrossings()
build pedestrian crossings
Definition: NBNode.cpp:2782
SumoXMLNodeType myType
The type of the junction.
Definition: NBNode.h:879
EdgeVector myOutgoingEdges
Vector of outgoing edges.
Definition: NBNode.h:864
bool myKeepClear
whether the junction area must be kept clear
Definition: NBNode.h:903
static bool isTrafficLight(SumoXMLNodeType type)
return whether the given type is a traffic light
Definition: NBNode.cpp:3555
void discardWalkingareas()
discard previously built walkingareas (required for repeated computation by netedit)
Definition: NBNode.cpp:2753
void computeLogic(const NBEdgeCont &ec)
computes the node's type, logic and traffic light
Definition: NBNode.cpp:952
void invalidateIncomingConnections(bool reallowSetting=false)
invalidate incoming connections
Definition: NBNode.cpp:1876
NBRequest * myRequest
Node requests.
Definition: NBNode.h:894
void mirrorX()
mirror coordinates along the x-axis
Definition: NBNode.cpp:346
std::vector< std::pair< Position, std::string > > getEndPoints() const
return list of unique endpoint coordinates of all edges at this node
Definition: NBNode.cpp:3658
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:1925
std::vector< std::pair< NBEdge *, NBEdge * > > getEdgesToJoin() const
get edges to join
Definition: NBNode.cpp:2395
void setKeepClear(bool keepClear)
set the keepClear flag
Definition: NBNode.h:538
bool myHaveCustomPoly
whether this nodes shape was set by the user
Definition: NBNode.h:891
Position getEmptyDir() const
Returns something like the most unused direction Should only be used to add source or sink nodes.
Definition: NBNode.cpp:1848
PositionVector indirectLeftShape(const PositionVector &begShape, const PositionVector &endShape, int numPoints) const
compute shape of indirect left turn
Definition: NBNode.cpp:708
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:3395
static const int AVOID_WIDE_RIGHT_TURN
flags for controlling shape generation
Definition: NBNode.h:211
int myCrossingsLoadedFromSumoNet
number of crossings loaded from a sumo net
Definition: NBNode.h:918
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:2061
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:3296
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:1906
bool hasConflict() const
whether there are conflicting streams of traffic at this node
Definition: NBNode.cpp:1056
void removeTrafficLights(bool setAsPriority=false)
Removes all references to traffic lights that control this tls.
Definition: NBNode.cpp:382
void replaceInConnectionProhibitions(NBEdge *which, NBEdge *by, int whichLaneOff, int byLaneOff)
replace incoming connections prohibitions
Definition: NBNode.cpp:1671
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:1976
const std::vector< std::unique_ptr< Crossing > > & getCrossingsIncludingInvalid() const
Definition: NBNode.h:709
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:1602
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:1508
EdgeVector myAllEdges
Vector of incoming and outgoing edges.
Definition: NBNode.h:867
void computeKeepClear()
compute keepClear status for all connections
Definition: NBNode.cpp:998
int numCrossingsFromSumoNet() const
get num of crossings from sumo net
Definition: NBNode.h:703
NBNode & operator=(const NBNode &s)
invalidated assignment operator
void sortEdges(bool useNodeShape)
sort all edge containers for this node
Definition: NBNode.cpp:3574
RightOfWay myRightOfWay
how to compute right of way for this node
Definition: NBNode.h:906
bool myIsBentPriority
Definition: NBNode.h:926
std::set< NBTrafficLightDefinition * > myTrafficLights
traffic lights of node
Definition: NBNode.h:897
const EdgeVector & getOutgoingEdges() const
Returns this node's outgoing edges (The edges which start at this node)
Definition: NBNode.h:261
double myRadius
the turning radius (for all corners) at this node in m.
Definition: NBNode.h:900
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:3262
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node)
Definition: NBNode.h:266
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:514
bool hasCustomShape() const
return whether the shape was set by the user
Definition: NBNode.h:558
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:2042
int removeSelfLoops(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes edges which are both incoming and outgoing into this node.
Definition: NBNode.cpp:426
bool checkCrossingDuplicated(EdgeVector edges)
return true if there already exist a crossing with the same edges as the input
Definition: NBNode.cpp:2672
void setRoundabout()
update the type of this node as a roundabout
Definition: NBNode.cpp:3378
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:1987
bool myDiscardAllCrossings
whether to discard all pedestrian crossings
Definition: NBNode.h:915
void invalidateTLS(NBTrafficLightLogicCont &tlCont, bool removedConnections, bool addedConnections)
causes the traffic light to be computed anew
Definition: NBNode.cpp:395
const EdgeVector & getIncomingEdges() const
Returns this node's incoming edges (The edges which yield in this node)
Definition: NBNode.h:256
bool brakeForCrossingOnExit(const NBEdge *to) const
whether a connection to the given edge must brake for a crossing when leaving the intersection
Definition: NBNode.cpp:1911
std::vector< Crossing * > getCrossings() const
return this junctions pedestrian crossings
Definition: NBNode.cpp:2725
void addSortedLinkFoes(const NBConnection &mayDrive, const NBConnection &mustStop)
add shorted link FOES
Definition: NBNode.cpp:1774
Position myPosition
The position the node lies at.
Definition: NBNode.h:858
bool isBentPriority() const
return whether a priority road turns at this node
Definition: NBNode.h:795
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:1638
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:1996
void discardAllCrossings(bool rejectAll)
discard all current (and optionally future) crossings
Definition: NBNode.cpp:2743
bool hasOutgoing(const NBEdge *const e) const
Returns whether the given edge starts at this node.
Definition: NBNode.cpp:1750
bool writeLogic(OutputDevice &into) const
writes the XML-representation of the logic as a bitset-logic XML representation
Definition: NBNode.cpp:1027
void setRadius(double radius)
set the turning radius
Definition: NBNode.h:533
NBEdge * getPossiblySplittedOutgoing(const std::string &edgeid)
get possibly splitted outgoing edge
Definition: NBNode.cpp:1804
NBNode(const NBNode &s)
invalidated copy constructor
void addOutgoingEdge(NBEdge *edge)
adds an outgoing edge
Definition: NBNode.cpp:469
bool isConstantWidthTransition() const
detects whether a given junction splits or merges lanes while keeping constant road width
Definition: NBNode.cpp:818
std::vector< std::unique_ptr< Crossing > > myCrossings
Vector of crossings.
Definition: NBNode.h:870
bool isStraighter(const NBEdge *const incoming, const double angle, const SVCPermissions vehPerm, const int modeLanes, const NBEdge *const candidate) const
check whether the candidate edge is more likely to be the straight continuation
Definition: NBNode.cpp:2184
void removeJoinedTrafficLights()
remove all traffic light definitions that are part of a joined tls
Definition: NBNode.cpp:937
bool crossingBetween(const NBEdge *e1, const NBEdge *e2) const
return true if the given edges are connected by a crossing
Definition: NBNode.cpp:3275
bool isDistrict() const
check if node is a district
Definition: NBNode.cpp:2464
NBDistrict * myDistrict
The district the node is the centre of.
Definition: NBNode.h:885
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:324
void computeLanes2Lanes()
computes the connections of lanes to edges
Definition: NBNode.cpp:1114
void reshiftPosition(double xoff, double yoff)
Applies an offset to the node.
Definition: NBNode.cpp:333
void setName(const std::string &name)
set intersection name
Definition: NBNode.h:553
double myDisplacementError
geometry error after computation of internal lane shapes
Definition: NBNode.h:921
static const int AVOID_WIDE_LEFT_TURN
Definition: NBNode.h:212
void removeTrafficLight(NBTrafficLightDefinition *tlDef)
Removes the given traffic light from this node.
Definition: NBNode.cpp:375
void markBentPriority(bool isBent)
mark whether a priority road turns at this node
Definition: NBNode.h:790
bool typeWasGuessed() const
return whether a priority road turns at this node
Definition: NBNode.h:800
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:1047
static bool isLongEnough(NBEdge *out, double minLength)
check if is long enough
Definition: NBNode.cpp:1563
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:927
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:2418
void setPriorityJunctionPriorities()
sets the priorites in case of a priority junction
std::vector< WalkingArea > myWalkingAreas
Vector of walking areas.
Definition: NBNode.h:873
NBConnectionProhibits myBlockedConnections
The container for connection block dependencies.
Definition: NBNode.h:882
void updateSurroundingGeometry()
update geometry of node and surrounding edges
Definition: NBNode.cpp:1065
int addedLanesRight(NBEdge *out, int addedLanes) const
check whether this edge has extra lanes on the right side
Definition: NBNode.cpp:1516
const Position & getPosition() const
Definition: NBNode.h:248
FringeType myFringeType
fringe type of this node
Definition: NBNode.h:909
double getRadius() const
Returns the turning radius of this node.
Definition: NBNode.h:278
bool checkIsRemovable() const
check if node is removable
Definition: NBNode.cpp:2319
bool isRoundabout() const
return whether this node is part of a roundabout
Definition: NBNode.cpp:3385
const NBConnectionProhibits & getProhibitions()
get prohibitions (BLocked connections)
Definition: NBNode.h:672
static const int FORWARD
edge directions (for pedestrian related stuff)
Definition: NBNode.h:204
bool checkIsRemovableReporting(std::string &reason) const
check if node is removable and return reason if not
Definition: NBNode.cpp:2325
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:826
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:2071
void removeDoubleEdges()
remove duble edges
Definition: NBNode.cpp:1706
PositionVector myPoly
the (outer) shape of the junction
Definition: NBNode.h:888
NBEdge * getConnectionTo(NBNode *n) const
get connection to certain node
Definition: NBNode.cpp:2436
void getEdgesThatApproach(NBEdge *currentOutgoing, EdgeVector &approaching)
returns a list of edges which are connected to the given outgoing edge
Definition: NBNode.cpp:1580
void setFringeType(FringeType fringeType)
set method for computing right-of-way
Definition: NBNode.h:548
EdgeVector getEdgesSortedByAngleAtNodeCenter() const
returns the list of all edges sorted clockwise by getAngleAtNodeToCenter
Definition: NBNode.cpp:3517
const std::vector< WalkingAreaCustomShape > & getWalkingAreaCustomShapes() const
Definition: NBNode.h:718
EdgeVector edgesBetween(const NBEdge *e1, const NBEdge *e2) const
return all edges that lie clockwise between the given edges
Definition: NBNode.cpp:3317
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:733
~NBNode()
Destructor.
Definition: NBNode.cpp:301
NBEdge * getPossiblySplittedIncoming(const std::string &edgeid)
get possibly splitted incoming edge
Definition: NBNode.cpp:1791
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:418
bool geometryLike() const
whether this is structurally similar to a geometry node
Definition: NBNode.cpp:3343
bool isNearDistrict() const
@chech if node is near district
Definition: NBNode.cpp:2447
static const int INDIRECT_LEFT
Definition: NBNode.h:216
EdgeVector myIncomingEdges
Vector of incoming edges.
Definition: NBNode.h:861
const std::vector< WalkingArea > & getWalkingAreas() const
return this junctions pedestrian walking areas
Definition: NBNode.h:714
int checkCrossing(EdgeVector candidates)
Definition: NBNode.cpp:2581
void addTrafficLight(NBTrafficLightDefinition *tlDef)
Adds a traffic light to the list of traffic lights that control this node.
Definition: NBNode.cpp:365
int guessCrossings()
guess pedestrian crossings and return how many were guessed
Definition: NBNode.cpp:2470
bool isTLControlled() const
Returns whether this node is controlled by any tls.
Definition: NBNode.h:319
bool getKeepClear() const
Returns the keepClear flag.
Definition: NBNode.h:283
static const int SCURVE_IGNORE
Definition: NBNode.h:215
const std::string getFoes(int linkIndex) const
get the 'foes' string (conflict bit set) of the right-of-way logic
Definition: NBNode.cpp:1037
NBEdge * getOppositeIncoming(NBEdge *e) const
returns the opposite incoming edge of certain edge
Definition: NBNode.cpp:1756
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:544
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:54
const std::string & getID() const
Returns the id.
Definition: Named.h:74
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:61
An upper class for objects with additional parameters.
Definition: Parameterised.h:41
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
A list of positions.
static const PositionVector EMPTY
empty Vector
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:197
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