SUMO - Simulation of Urban MObility
NBNode.h
Go to the documentation of this file.
1 /****************************************************************************/
10 // The representation of a single node
11 /****************************************************************************/
12 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
13 // Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
14 /****************************************************************************/
15 //
16 // This file is part of SUMO.
17 // SUMO is free software: you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation, either version 3 of the License, or
20 // (at your option) any later version.
21 //
22 /****************************************************************************/
23 #ifndef NBNode_h
24 #define NBNode_h
25 
26 
27 // ===========================================================================
28 // included modules
29 // ===========================================================================
30 #ifdef _MSC_VER
31 #include <windows_config.h>
32 #else
33 #include <config.h>
34 #endif
35 
36 #include <vector>
37 #include <deque>
38 #include <utility>
39 #include <string>
40 #include <set>
41 #include <utils/common/StdDefs.h>
42 #include <utils/common/Named.h>
43 #include <utils/geom/Bresenham.h>
44 #include <utils/geom/GeomHelper.h>
46 #include <utils/geom/Position.h>
49 #include "NBEdge.h"
50 #include "NBConnection.h"
51 #include "NBConnectionDefs.h"
52 #include "NBContHelper.h"
53 
54 
55 // ===========================================================================
56 // class declarations
57 // ===========================================================================
58 class NBRequest;
59 class NBDistrict;
60 class OptionsCont;
62 class NBTypeCont;
64 class NBDistrictCont;
65 class OutputDevice;
66 
67 
68 // ===========================================================================
69 // class definitions
70 // ===========================================================================
75 class NBNode : public Named {
76  friend class NBNodeCont;
77  friend class GNEJunction; // < used for visualization (NETEDIT)
78  friend class NBNodesEdgesSorter; // < sorts the edges
79  friend class NBNodeTypeComputer; // < computes type
80  friend class NBEdgePriorityComputer; // < computes priorities of edges per intersection
81  friend class NBNodeShapeComputer; // < computes node's shape
82 
83 public:
85  typedef std::map<std::string, PositionVector> CustomShapeMap;
86 
99  private:
102 
105 
107  std::vector<int> myAvailableLanes;
108 
109  public:
114  ApproachingDivider(EdgeVector* approaching, NBEdge* currentOutgoing);
115 
118 
120  int numAvailableLanes() const {
121  return (int)myAvailableLanes.size();
122  }
123 
125  void execute(const int src, const int dest);
126 
128  std::deque<int>* spread(const std::vector<int>& approachingLanes, int dest) const;
129 
130  };
131 
135  struct Crossing {
137  Crossing(const NBNode* _node, const EdgeVector& _edges, double _width, bool _priority) :
138  node(_node),
139  edges(_edges),
140  width(_width),
141  priority(_priority),
142  tlLinkNo(-1) {
143  }
145  const NBNode* node;
151  double width;
153  std::string id;
155  std::string prevWalkingArea;
157  std::string nextWalkingArea;
159  bool priority;
161  int tlLinkNo;
163  std::string tlID;
164  };
165 
166 
170  struct WalkingArea {
172  WalkingArea(const std::string& _id, double _width) :
173  id(_id),
174  width(_width),
175  nextCrossing("") {
176  }
178  std::string id;
180  double width;
182  double length;
186  std::string nextCrossing;
188  std::vector<std::string> nextSidewalks;
190  std::vector<std::string> prevSidewalks;
191  };
192 
194  static const int FORWARD;
195  static const int BACKWARD;
197  static const double DEFAULT_CROSSING_WIDTH;
198 
200  static const double UNSPECIFIED_RADIUS;
201 
202 public:
208  NBNode(const std::string& id, const Position& position, SumoXMLNodeType type);
209 
215  NBNode(const std::string& id, const Position& position, NBDistrict* district = 0);
216 
218  ~NBNode();
219 
226  void reinit(const Position& position, SumoXMLNodeType type,
227  bool updateEdgeGeometries = false);
228 
232  const Position& getPosition() const {
233  return myPosition;
234  }
235 
237  Position getCenter() const;
238 
240  const EdgeVector& getIncomingEdges() const {
241  return myIncomingEdges;
242  }
243 
245  const EdgeVector& getOutgoingEdges() const {
246  return myOutgoingEdges;
247  }
248 
250  const EdgeVector& getEdges() const {
251  return myAllEdges;
252  }
253 
258  return myType;
259  }
260 
262  double getRadius() const {
263  return myRadius;
264  }
265 
267  bool getKeepClear() const {
268  return myKeepClear;
269  }
271 
274 
278 
281 
283  void removeTrafficLights();
284 
288  bool isTLControlled() const {
289  return myTrafficLights.size() != 0;
290  }
291 
295  bool isJoinedTLSControlled() const;
296 
298  const std::set<NBTrafficLightDefinition*>& getControllingTLS() const {
299  return myTrafficLights;
300  }
301 
304 
306  void shiftTLConnectionLaneIndex(NBEdge* edge, int offset);
308 
309 
312 
324 
325 
328 
332  void reshiftPosition(double xoff, double yoff);
333 
335  void mirrorX();
337 
339  void addIncomingEdge(NBEdge* edge);
340 
342  void addOutgoingEdge(NBEdge* edge);
343 
345  void computeLanes2Lanes();
346 
348  void computeLogic(const NBEdgeCont& ec, OptionsCont& oc);
349 
351  bool writeLogic(OutputDevice& into, const bool checkLaneFoes) const;
352 
354  Position getEmptyDir() const;
355 
360  bool hasIncoming(const NBEdge* const e) const;
361 
366  bool hasOutgoing(const NBEdge* const e) const;
367 
369  NBEdge* getOppositeIncoming(NBEdge* e) const;
370 
373 
376 
378  void removeDoubleEdges();
379 
381  NBEdge* getConnectionTo(NBNode* n) const;
382 
384  void addSortedLinkFoes(const NBConnection& mayDrive, const NBConnection& mustStop);
385 
387  NBEdge* getPossiblySplittedIncoming(const std::string& edgeid);
388 
390  NBEdge* getPossiblySplittedOutgoing(const std::string& edgeid);
391 
393  void removeEdge(NBEdge* edge, bool removeFromConnections = true);
394 
404  bool isLeftMover(const NBEdge* const from, const NBEdge* const to) const;
405 
414  bool mustBrake(const NBEdge* const from, const NBEdge* const to, int fromLane, int toLane, bool includePedCrossings) const;
415 
422  bool mustBrakeForCrossing(const NBEdge* const from, const NBEdge* const to, const Crossing& crossing) const;
423 
425  static bool rightTurnConflict(const NBEdge* from, const NBEdge* to, int fromLane,
426  const NBEdge* prohibitorFrom, const NBEdge* prohibitorTo, int prohibitorFromLane,
427  bool lefthand = false);
428 
437  bool forbids(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
438  const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
439  bool regardNonSignalisedLowerPriority) const;
440 
448  bool foes(const NBEdge* const from1, const NBEdge* const to1,
449  const NBEdge* const from2, const NBEdge* const to2) const;
450 
457  LinkDirection getDirection(const NBEdge* const incoming, const NBEdge* const outgoing, bool leftHand = false) const;
458 
460  LinkState getLinkState(const NBEdge* incoming, NBEdge* outgoing,
461  int fromLane, int toLane, bool mayDefinitelyPass, const std::string& tlID) const;
462 
466  void computeNodeShape(double mismatchThreshold);
467 
469  const PositionVector& getShape() const;
470 
472  void setCustomShape(const PositionVector& shape);
473 
475  void setCustomLaneShape(const std::string& laneID, const PositionVector& shape);
476 
478  const CustomShapeMap& getCustomLaneShapes() const {
479  return myCustomLaneShapes;
480  }
481 
483  void setRadius(double radius) {
484  myRadius = radius;
485  }
486 
488  void setKeepClear(bool keepClear) {
489  myKeepClear = keepClear;
490  }
491 
493  bool hasCustomShape() const {
494  return myHaveCustomPoly;
495  }
496 
498  bool checkIsRemovable() const;
499 
501  std::vector<std::pair<NBEdge*, NBEdge*> > getEdgesToJoin() const;
502 
504  bool isNearDistrict() const;
505 
507  bool isDistrict() const;
508 
510  bool needsCont(const NBEdge* fromE, const NBEdge* otherFromE,
511  const NBEdge::Connection& c, const NBEdge::Connection& otherC) const;
512 
520  PositionVector computeInternalLaneShape(NBEdge* fromE, const NBEdge::Connection& con, int numPoints, NBNode* recordError = 0) const;
521 
532  PositionVector computeSmoothShape(const PositionVector& begShape, const PositionVector& endShape, int numPoints,
533  bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
534  NBNode* recordError = 0) const;
536  static PositionVector bezierControlPoints(const PositionVector& begShape, const PositionVector& endShape,
537  bool isTurnaround, double extrapolateBeg, double extrapolateEnd,
538  bool& ok, NBNode* recordError = 0, double straightThresh = DEG2RAD(5));
539 
540 
542  double getDisplacementError() const {
543  return myDisplacementError;
544  }
545 
547  void replaceIncoming(NBEdge* which, NBEdge* by, int laneOff);
548 
550  void replaceIncoming(const EdgeVector& which, NBEdge* by);
551 
553  void replaceOutgoing(NBEdge* which, NBEdge* by, int laneOff);
554 
556  void replaceOutgoing(const EdgeVector& which, NBEdge* by);
557 
559  int guessCrossings();
560 
561  /* @brief check whether a crossing should be build for the candiate edges and build 0 to n crossings
562  * @param[in] candidates The candidate vector of edges to be crossed
563  * @return The number of crossings built
564  * */
565  int checkCrossing(EdgeVector candidates);
566 
569 
571  void buildInnerEdges();
572 
576  int buildCrossings();
577 
581  void buildWalkingAreas(int cornerDetail);
582 
584  void buildCrossingsAndWalkingAreas(bool discardInvalid = true);
585 
587  EdgeVector edgesBetween(const NBEdge* e1, const NBEdge* e2) const;
588 
590  bool crossingBetween(const NBEdge* e1, const NBEdge* e2) const;
591 
594  return myBlockedConnections;
595  }
596 
598  bool geometryLike() const;
599 
601  void setRoundabout();
602 
604  void addCrossing(EdgeVector edges, double width, bool priority, bool fromSumoNet = false);
605 
607  void removeCrossing(const EdgeVector& edges);
608 
611  myDiscardAllCrossings = true;
612  }
613 
617  }
618 
620  inline const std::vector<Crossing>& getCrossings() const {
621  return myCrossings;
622  }
623 
625  inline const std::vector<WalkingArea>& getWalkingAreas() const {
626  return myWalkingAreas;
627  }
628 
630  const Crossing& getCrossing(const std::string& id) const;
631 
633  Crossing& getCrossingRef(const std::string& id);
634 
636  void setCrossingTLIndices(const std::string& tlID, int startIndex);
637 
639  int numNormalConnections() const;
640 
642  void avoidOverlap();
643 
645  bool rightOnRedConflict(int index, int foeIndex) const;
646 
648  void sortEdges(bool useNodeShape);
649 
651  int getConnectionIndex(const NBEdge* from, const NBEdge::Connection& con) const;
652 
658  public:
660  explicit nodes_by_id_sorter() { }
661 
663  int operator()(NBNode* n1, NBNode* n2) const {
664  return n1->getID() < n2->getID();
665  }
666  };
667 
672  public:
674  explicit edge_by_direction_sorter(NBNode* n) : myNode(n) {}
675 
677  int operator()(NBEdge* e1, NBEdge* e2) const {
678  UNUSED_PARAMETER(e2);
679  return e1->getFromNode() == myNode;
680  }
681 
682  private:
685 
686  };
687 
689  static std::string getNodeIDFromInternalLane(const std::string id);
690 
691 
693  static bool isTrafficLight(SumoXMLNodeType type);
694 
696  bool isSimpleContinuation(bool checkLaneNumbers = true) const;
697 
698 
699 private:
702 
704  EdgeVector* getEdgesThatApproach(NBEdge* currentOutgoing);
705 
707  void replaceInConnectionProhibitions(NBEdge* which, NBEdge* by, int whichLaneOff, int byLaneOff);
708 
710  void remapRemoved(NBTrafficLightLogicCont& tc, NBEdge* removed, const EdgeVector& incoming, const EdgeVector& outgoing);
711 
713  bool forbidsPedestriansAfter(std::vector<std::pair<NBEdge*, bool> > normalizedLanes, int startIndex);
714 
717 
719  static bool isLongEnough(NBEdge* out, double minLength);
720 
721 private:
724 
727 
730 
733 
735  std::vector<Crossing> myCrossings;
736 
738  std::vector<WalkingArea> myWalkingAreas;
739 
742 
745 
748 
751 
754 
757 
759  std::set<NBTrafficLightDefinition*> myTrafficLights;
760 
762  double myRadius;
763 
766 
768  CustomShapeMap myCustomLaneShapes;
769 
772 
775 
778 
779 private:
781  NBNode(const NBNode& s);
782 
784  NBNode& operator=(const NBNode& s);
785 };
786 
787 
788 #endif
789 
790 /****************************************************************************/
791 
bool getKeepClear() const
Returns the keepClear flag.
Definition: NBNode.h:267
int operator()(NBEdge *e1, NBEdge *e2) const
operator of selection
Definition: NBNode.h:677
int getConnectionIndex(const NBEdge *from, const NBEdge::Connection &con) const
return the index of the given connection
Definition: NBNode.cpp:2603
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:164
LinkState getLinkState(const NBEdge *incoming, NBEdge *outgoing, int fromLane, int toLane, bool mayDefinitelyPass, const std::string &tlID) const
get link state
Definition: NBNode.cpp:1613
void setRoundabout()
update the type of this node as a roundabout
Definition: NBNode.cpp:2536
int numNormalConnections() const
return the number of lane-to-lane connections at this junction (excluding crossings) ...
Definition: NBNode.cpp:2597
std::vector< Crossing > myCrossings
Vector of crossings.
Definition: NBNode.h:735
WalkingArea(const std::string &_id, double _width)
constructor
Definition: NBNode.h:172
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:1461
ApproachingDivider(EdgeVector *approaching, NBEdge *currentOutgoing)
Constructor.
Definition: NBNode.cpp:94
int buildCrossings()
build pedestrian crossings
Definition: NBNode.cpp:2063
void shiftTLConnectionLaneIndex(NBEdge *edge, int offset)
patches loaded signal plans by modifying lane indices
Definition: NBNode.cpp:371
std::string id
the (edge)-id of this crossing
Definition: NBNode.h:153
PositionVector myPoly
the (outer) shape of the junction
Definition: NBNode.h:750
void execute(const int src, const int dest)
the bresenham-callback
Definition: NBNode.cpp:128
const NBConnectionProhibits & getProhibitions()
get prohibitions (BLocked connections)
Definition: NBNode.h:593
bool isDistrict() const
check if node is a district
Definition: NBNode.cpp:1781
SumoXMLNodeType myType
The type of the junction.
Definition: NBNode.h:741
const CustomShapeMap & getCustomLaneShapes() const
sets a custom shape for an internal lane
Definition: NBNode.h:478
A container for traffic light definitions and built programs.
void reinit(const Position &position, SumoXMLNodeType type, bool updateEdgeGeometries=false)
Resets initial values.
Definition: NBNode.cpp:262
~NBNode()
Destructor.
Definition: NBNode.cpp:256
PositionVector computeInternalLaneShape(NBEdge *fromE, const NBEdge::Connection &con, int numPoints, NBNode *recordError=0) const
Compute the shape for an internal lane.
Definition: NBNode.cpp:627
int myCrossingsLoadedFromSumoNet
number of crossings loaded from a sumo net
Definition: NBNode.h:774
This class computes shapes of junctions.
double length
This lane&#39;s width.
Definition: NBNode.h:182
void removeEdge(NBEdge *edge, bool removeFromConnections=true)
Removes edge from this node and optionally removes connections as well.
Definition: NBNode.cpp:1291
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:1365
void addIncomingEdge(NBEdge *edge)
adds an incoming edge
Definition: NBNode.cpp:412
bool hasCustomShape() const
return whether the shape was set by the user
Definition: NBNode.h:493
The representation of a single edge during network building.
Definition: NBEdge.h:71
static const double DEFAULT_CROSSING_WIDTH
default width of pedetrian crossings
Definition: NBNode.h:197
const std::vector< Crossing > & getCrossings() const
return this junctions pedestrian crossings
Definition: NBNode.h:620
static const double UNSPECIFIED_RADIUS
unspecified lane width
Definition: NBNode.h:200
Used for sorting the cells by the begin time they describe.
Definition: NBNode.h:657
A container for districts.
The base class for traffic light logic definitions.
static bool isLongEnough(NBEdge *out, double minLength)
check if is long enough
Definition: NBNode.cpp:1037
void removeDoubleEdges()
remove duble edges
Definition: NBNode.cpp:1180
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:2706
PositionVector shape
The lane&#39;s shape.
Definition: NBNode.h:149
edge_by_direction_sorter(NBNode *n)
constructor
Definition: NBNode.h:674
void buildWalkingAreas(int cornerDetail)
build pedestrian walking areas and set connections from/to walkingAreas
Definition: NBNode.cpp:2145
std::string id
the (edge)-id of this walkingArea
Definition: NBNode.h:178
const std::string & getID() const
Returns the id.
Definition: Named.h:66
void mirrorX()
mirror coordinates along the x-axis
Definition: NBNode.cpp:295
int numCrossingsFromSumoNet() const
get num of crossings from sumo net
Definition: NBNode.h:615
void removeTrafficLight(NBTrafficLightDefinition *tlDef)
Removes the given traffic light from this node.
Definition: NBNode.cpp:320
void setCustomShape(const PositionVector &shape)
set the junction shape
Definition: NBNode.cpp:1722
NBConnectionProhibits myBlockedConnections
The container for connection block dependencies.
Definition: NBNode.h:744
void addOutgoingEdge(NBEdge *edge)
adds an outgoing edge
Definition: NBNode.cpp:422
const Crossing & getCrossing(const std::string &id) const
return the crossing with the given id
Definition: NBNode.cpp:2567
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:38
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:1076
void sortEdges(bool useNodeShape)
sort all edge containers for this node
Definition: NBNode.cpp:2719
Position getCenter() const
Returns a position that is guaranteed to lie within the node shape.
Definition: NBNode.cpp:2622
static bool rightTurnConflict(const NBEdge *from, const NBEdge *to, int fromLane, const NBEdge *prohibitorFrom, const NBEdge *prohibitorTo, int prohibitorFromLane, bool lefthand=false)
return whether the given laneToLane connection is a right turn which must yield to a bicycle crossing...
Definition: NBNode.cpp:1385
const EdgeVector & getOutgoingEdges() const
Returns this node&#39;s outgoing edges (The edges which start at this node)
Definition: NBNode.h:245
bool priority
whether the pedestrians have priority
Definition: NBNode.h:159
NBRequest * myRequest
Node requests.
Definition: NBNode.h:756
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)...
CustomShapeMap myCustomLaneShapes
custom lane shapes
Definition: NBNode.h:768
NBDistrict * myDistrict
The district the node is the centre of.
Definition: NBNode.h:747
A class representing a single district.
Definition: NBDistrict.h:72
std::map< std::string, PositionVector > CustomShapeMap
map for custon shapes
Definition: NBNode.h:85
NBEdge * getConnectionTo(NBNode *n) const
get connection to certain node
Definition: NBNode.cpp:1739
EdgeVector myAllEdges
Vector of incoming and outgoing edges.
Definition: NBNode.h:732
void computeLanes2Lanes()
computes the connections of lanes to edges
Definition: NBNode.cpp:813
void setRadius(double radius)
set the turning radius
Definition: NBNode.h:483
bool isTLControlled() const
Returns whether this node is controlled by any tls.
Definition: NBNode.h:288
bool writeLogic(OutputDevice &into, const bool checkLaneFoes) const
writes the XML-representation of the logic as a bitset-logic XML representation
Definition: NBNode.cpp:771
void invalidateIncomingConnections()
invalidate incoming connections
Definition: NBNode.cpp:1349
void removeCrossing(const EdgeVector &edges)
remove a pedestrian crossing from this node (identified by its edges)
Definition: NBNode.cpp:2553
void setPriorityJunctionPriorities()
sets the priorites in case of a priority junction
void computeNodeShape(double mismatchThreshold)
Compute the junction shape for this node.
Definition: NBNode.cpp:781
std::string prevWalkingArea
the lane-id of the previous walkingArea
Definition: NBNode.h:155
NBEdge * getPossiblySplittedIncoming(const std::string &edgeid)
get possibly splitted incoming edge
Definition: NBNode.cpp:1265
void buildCrossingsAndWalkingAreas(bool discardInvalid=true)
build crossings, and walkingareas. Also removes invalid loaded crossings if wished ...
Definition: NBNode.cpp:2008
int checkCrossing(EdgeVector candidates)
Definition: NBNode.cpp:1889
static const int FORWARD
edge directions (for pedestrian related stuff)
Definition: NBNode.h:194
void setCrossingTLIndices(const std::string &tlID, int startIndex)
set tl indices of this nodes crossing starting at the given index
Definition: NBNode.cpp:2588
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
A list of positions.
bool crossingBetween(const NBEdge *e1, const NBEdge *e2) const
return true if the given edges are connected by a crossing
Definition: NBNode.cpp:2478
void invalidateOutgoingConnections()
invalidate outgoing connections
Definition: NBNode.cpp:1357
int operator()(NBNode *n1, NBNode *n2) const
Comparing operator.
Definition: NBNode.h:663
const EdgeVector & getEdges() const
Returns all edges which participate in this node (Edges that start or end at this node) ...
Definition: NBNode.h:250
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
void removeTrafficLights()
Removes all references to traffic lights that control this tls.
Definition: NBNode.cpp:327
EdgeVector * getEdgesThatApproach(NBEdge *currentOutgoing)
returns a list of edges which are connected to the given outgoing edge
Definition: NBNode.cpp:1053
bool geometryLike() const
whether this is structurally similar to a geometry node
Definition: NBNode.cpp:2511
std::set< NBTrafficLightDefinition * > myTrafficLights
traffic lights of node
Definition: NBNode.h:759
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:66
void setCustomLaneShape(const std::string &laneID, const PositionVector &shape)
sets a custom shape for an internal lane
Definition: NBNode.cpp:1729
std::string nextCrossing
the lane-id of the next crossing
Definition: NBNode.h:186
Crossing(const NBNode *_node, const EdgeVector &_edges, double _width, bool _priority)
constructor
Definition: NBNode.h:137
bool hasOutgoing(const NBEdge *const e) const
Returns whether the given edge starts at this node.
Definition: NBNode.cpp:1224
bool myDiscardAllCrossings
whether to discard all pedestrian crossings
Definition: NBNode.h:771
NBNode * myNode
The node to compute the relative angle of.
Definition: NBNode.h:684
#define DEG2RAD(x)
Definition: GeomHelper.h:45
void replaceInConnectionProhibitions(NBEdge *which, NBEdge *by, int whichLaneOff, int byLaneOff)
replace incoming connections prohibitions
Definition: NBNode.cpp:1145
double myRadius
the turning radius (for all corners) at this node in m.
Definition: NBNode.h:762
EdgeVector myIncomingEdges
Vector of incoming edges.
Definition: NBNode.h:726
void setKeepClear(bool keepClear)
set the keepClear flag
Definition: NBNode.h:488
Base class for objects which have an id.
Definition: Named.h:46
bool hasIncoming(const NBEdge *const e) const
Returns whether the given edge ends at this node.
Definition: NBNode.cpp:1218
double getDisplacementError() const
compute the displacement error during s-curve computation
Definition: NBNode.h:542
void avoidOverlap()
fix overlap
Definition: NBNode.cpp:2683
PositionVector computeSmoothShape(const PositionVector &begShape, const PositionVector &endShape, int numPoints, bool isTurnaround, double extrapolateBeg, double extrapolateEnd, NBNode *recordError=0) const
Compute a smooth curve between the given geometries.
Definition: NBNode.cpp:461
NBEdge * getPossiblySplittedOutgoing(const std::string &edgeid)
get possibly splitted outgoing edge
Definition: NBNode.cpp:1278
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing, bool leftHand=false) const
Returns the representation of the described stream&#39;s direction.
Definition: NBNode.cpp:1549
const PositionVector & getShape() const
retrieve the junction shape
Definition: NBNode.cpp:1716
EdgeVector myOutgoingEdges
Vector of outgoing edges.
Definition: NBNode.h:729
NBEdge * myCurrentOutgoing
The approached current edge.
Definition: NBNode.h:104
double myDisplacementError
geometry error after computation of internal lane shapes
Definition: NBNode.h:777
static const int BACKWARD
Definition: NBNode.h:195
nodes_by_id_sorter()
Constructor.
Definition: NBNode.h:660
void addTrafficLight(NBTrafficLightDefinition *tlDef)
Adds a traffic light to the list of traffic lights that control this node.
Definition: NBNode.cpp:310
double width
This lane&#39;s width.
Definition: NBNode.h:151
bool myHaveCustomPoly
whether this nodes shape was set by the user
Definition: NBNode.h:753
Position myPosition
The position the node lies at.
Definition: NBNode.h:723
bool checkCrossingDuplicated(EdgeVector edges)
return true if already exist a crossing with the same edges as the input
Definition: NBNode.cpp:1980
std::map< NBConnection, NBConnectionVector > NBConnectionProhibits
Definition of a container for connection block dependencies Includes a list of all connections which ...
int removeSelfLoops(NBDistrictCont &dc, NBEdgeCont &ec, NBTrafficLightLogicCont &tc)
Removes edges which are both incoming and outgoing into this node.
Definition: NBNode.cpp:379
double getRadius() const
Returns the turning radius of this node.
Definition: NBNode.h:262
~ApproachingDivider()
Destructor.
Definition: NBNode.cpp:124
std::vector< WalkingArea > myWalkingAreas
Vector of walking areas.
Definition: NBNode.h:738
const EdgeVector & getIncomingEdges() const
Returns this node&#39;s incoming edges (The edges which yield in this node)
Definition: NBNode.h:240
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:1112
SumoXMLNodeType
Numbers representing special SUMO-XML-attribute values for representing node- (junction-) types used ...
bool isNearDistrict() const
if node is near district
Definition: NBNode.cpp:1750
bool myKeepClear
whether the junction area must be kept clear
Definition: NBNode.h:765
std::vector< int > myAvailableLanes
The available lanes to which connections shall be built.
Definition: NBNode.h:107
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:298
Sorts outgoing before incoming edges.
Definition: NBNode.h:671
int tlLinkNo
the traffic light index of this crossing (if controlled)
Definition: NBNode.h:161
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:41
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:1451
void buildInnerEdges()
build internal lanes, pedestrian crossings and walking areas
Definition: NBNode.cpp:2031
NBNode & operator=(const NBNode &s)
invalidated assignment operator
A definition of a pedestrian walking area.
Definition: NBNode.h:170
EdgeVector * myApproaching
The list of edges that approach the current edge.
Definition: NBNode.h:101
A storage for options typed value containers)
Definition: OptionsCont.h:99
const NBNode * node
The parent node of this crossing.
Definition: NBNode.h:145
SumoXMLNodeType getType() const
Returns the type of this node.
Definition: NBNode.h:257
Position getEmptyDir() const
Returns something like the most unused direction Should only be used to add source or sink nodes...
Definition: NBNode.cpp:1321
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:668
int numAvailableLanes() const
@ get number of avaliable lanes
Definition: NBNode.h:120
EdgeVector getEdgesSortedByAngleAtNodeCenter() const
returns the list of all edges sorted clockwise by getAngleAtNodeToCenter
Definition: NBNode.cpp:2640
const Position & getPosition() const
Definition: NBNode.h:232
EdgeVector edges
The edges being crossed.
Definition: NBNode.h:147
Represents a single node (junction) during network building.
Definition: NBNode.h:75
void addCrossing(EdgeVector edges, double width, bool priority, bool fromSumoNet=false)
add a pedestrian crossing to this node
Definition: NBNode.cpp:2544
int guessCrossings()
guess pedestrian crossings and return how many were guessed
Definition: NBNode.cpp:1787
A definition of a pedestrian crossing.
Definition: NBNode.h:135
const std::vector< WalkingArea > & getWalkingAreas() const
return this junctions pedestrian walking areas
Definition: NBNode.h:625
Crossing & getCrossingRef(const std::string &id)
return a reference to the crossing with the given id
Definition: NBNode.cpp:2577
void addSortedLinkFoes(const NBConnection &mayDrive, const NBConnection &mustStop)
add shorted link FOES
Definition: NBNode.cpp:1248
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
Computes lane-2-lane connections.
Definition: NBNode.h:98
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:1379
std::string tlID
The id of the traffic light that controls this connection.
Definition: NBNode.h:163
NBEdge * getOppositeIncoming(NBEdge *e) const
returns the opposite incoming edge of certain edge
Definition: NBNode.cpp:1230
bool isJoinedTLSControlled() const
Returns whether this node is controlled by a tls that spans over more than one node.
Definition: NBNode.cpp:336
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:1432
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:427
void computeLogic(const NBEdgeCont &ec, OptionsCont &oc)
computes the node&#39;s type, logic and traffic light
Definition: NBNode.cpp:718
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:63
void invalidateTLS(NBTrafficLightLogicCont &tlCont)
causes the traffic light to be computed anew
Definition: NBNode.cpp:350
std::string nextWalkingArea
the lane-id of the next walkingArea
Definition: NBNode.h:157
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:152
bool checkIsRemovable() const
check if node is removable
Definition: NBNode.cpp:1642
NBNode(const std::string &id, const Position &position, SumoXMLNodeType type)
Constructor.
Definition: NBNode.cpp:225
std::vector< std::pair< NBEdge *, NBEdge * > > getEdgesToJoin() const
get edges to join
Definition: NBNode.cpp:1693
static PositionVector bezierControlPoints(const PositionVector &begShape, const PositionVector &endShape, bool isTurnaround, double extrapolateBeg, double extrapolateEnd, bool &ok, NBNode *recordError=0, double straightThresh=DEG2RAD(5))
get bezier control points
Definition: NBNode.cpp:487
std::vector< std::string > prevSidewalks
the lane-id of the previous sidewalk lane or ""
Definition: NBNode.h:190
static bool isTrafficLight(SumoXMLNodeType type)
return whether the given type is a traffic light
Definition: NBNode.cpp:2698
std::vector< std::string > nextSidewalks
the lane-id of the next sidewalk lane or ""
Definition: NBNode.h:188
bool isSimpleContinuation(bool checkLaneNumbers=true) const
check if node is a simple continuation
Definition: NBNode.cpp:432
void reshiftPosition(double xoff, double yoff)
Applies an offset to the node.
Definition: NBNode.cpp:288
void remapRemoved(NBTrafficLightLogicCont &tc, NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing)
remap removed
Definition: NBNode.cpp:1468
void discardAllCrossings()
discard all crossings
Definition: NBNode.h:610
PositionVector shape
The polygonal shape.
Definition: NBNode.h:184
A storage for available types of edges.
Definition: NBTypeCont.h:62
double width
This lane&#39;s width.
Definition: NBNode.h:180
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:1997
EdgeVector edgesBetween(const NBEdge *e1, const NBEdge *e2) const
return all edges that lie clockwise between the given edges
Definition: NBNode.cpp:2495
static std::string getNodeIDFromInternalLane(const std::string id)
returns the node id for internal lanes, crossings and walkingareas
Definition: NBNode.cpp:2663