SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
NBEdge.h
Go to the documentation of this file.
1 /****************************************************************************/
9 // The representation of a single edge during network building
10 /****************************************************************************/
11 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
12 // Copyright (C) 2001-2015 DLR (http://www.dlr.de/) and contributors
13 /****************************************************************************/
14 //
15 // This file is part of SUMO.
16 // SUMO is free software: you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation, either version 3 of the License, or
19 // (at your option) any later version.
20 //
21 /****************************************************************************/
22 #ifndef NBEdge_h
23 #define NBEdge_h
24 
25 
26 // ===========================================================================
27 // included modules
28 // ===========================================================================
29 #ifdef _MSC_VER
30 #include <windows_config.h>
31 #else
32 #include <config.h>
33 #endif
34 
35 #include <map>
36 #include <vector>
37 #include <string>
38 #include <set>
39 #include <utils/common/Named.h>
43 #include <utils/geom/Bresenham.h>
45 #include <utils/geom/Line.h>
48 #include "NBCont.h"
49 #include "NBHelpers.h"
50 #include "NBSign.h"
51 
52 
53 // ===========================================================================
54 // class declarations
55 // ===========================================================================
56 class NBNode;
57 class NBConnection;
58 class NBNodeCont;
59 class NBEdgeCont;
60 class OutputDevice;
61 class GNELane;
62 
63 
64 // ===========================================================================
65 // class definitions
66 // ===========================================================================
71 class NBEdge : public Named, public Parameterised {
73  friend class NBEdgeSuccessorBuilder;
74  friend class NBEdgeCont;
75 
77  friend class GNELane;
78  friend class GNEEdge;
79 
80 public:
81 
104  };
105 
106 
117  };
118 
119 
123  struct Lane {
124  Lane(NBEdge* e) :
126  endOffset(e->getEndOffset()), width(e->getLaneWidth()) {}
140  std::string origID;
141 
142  };
143 
144 
148  struct Connection {
154  Connection(int fromLane_, NBEdge* toEdge_, int toLane_)
155  : fromLane(fromLane_), toEdge(toEdge_), toLane(toLane_),
156  mayDefinitelyPass(false), haveVia(false) { }
157 
159 
160 
162  int fromLane;
166  int toLane;
168  std::string tlID;
170  unsigned int tlLinkNo;
173 
174 
175  std::string origID;
176 
177  std::string id;
180 
181  bool haveVia;
182  std::string viaID;
185 
186  std::vector<unsigned int> foeInternalLinks;
187  std::string foeIncomingLanes;
188 
190  unsigned int internalLaneIndex;
191 
192  std::string getInternalLaneID() const;
193 
194  };
195 
197  static std::pair<SUMOReal, SUMOReal> laneOffset(const Position& from,
198  const Position& to, SUMOReal laneCenterOffset, bool leftHand);
199 
206 
212  static const SUMOReal ANGLE_LOOKAHEAD;
213 
214 public:
233  NBEdge(const std::string& id,
234  NBNode* from, NBNode* to, std::string type,
235  SUMOReal speed, unsigned int nolanes, int priority,
236  SUMOReal width, SUMOReal offset,
237  const std::string& streetName = "",
239 
240 
261  NBEdge(const std::string& id,
262  NBNode* from, NBNode* to, std::string type,
263  SUMOReal speed, unsigned int nolanes, int priority,
264  SUMOReal width, SUMOReal offset,
265  PositionVector geom,
266  const std::string& streetName = "",
268  bool tryIgnoreNodePositions = false);
269 
281  NBEdge(const std::string& id,
282  NBNode* from, NBNode* to,
283  NBEdge* tpl,
284  const PositionVector& geom = PositionVector(),
285  int numLanes = -1);
286 
287 
290  ~NBEdge();
291 
292 
308  void reinit(NBNode* from, NBNode* to, const std::string& type,
309  SUMOReal speed, unsigned int nolanes, int priority,
310  PositionVector geom, SUMOReal width, SUMOReal offset,
311  const std::string& streetName,
313  bool tryIgnoreNodePositions = false);
314 
319  void reinitNodes(NBNode* from, NBNode* to);
320 
321 
324 
329  void reshiftPosition(SUMOReal xoff, SUMOReal yoff);
331 
332 
333 
336  void setLeftHanded() {
337  myAmLeftHand = true;
338  }
339 
340 
342 
343 
347  unsigned int getNumLanes() const {
348  return (unsigned int) myLanes.size();
349  }
350 
351 
355  int getPriority() const {
356  return myPriority;
357  }
358 
359 
363  NBNode* getFromNode() const {
364  return myFrom;
365  }
366 
367 
371  NBNode* getToNode() const {
372  return myTo;
373  }
374 
375 
380  inline SUMOReal getStartAngle() const {
381  return myStartAngle;
382  }
383 
384 
389  inline SUMOReal getEndAngle() const {
390  return myEndAngle;
391  }
392 
393 
395 
399  inline SUMOReal getTotalAngle() const {
400  return myTotalAngle;
401  }
402 
406  SUMOReal getLength() const {
407  return myLength;
408  }
409 
410 
416  return myLoadedLength > 0 ? myLoadedLength : myLength;
417  }
418 
419 
423  bool hasLoadedLength() const {
424  return myLoadedLength > 0;
425  }
426 
427 
431  SUMOReal getSpeed() const {
432  return mySpeed;
433  }
434 
435 
442  return myStep;
443  }
444 
445 
450  return myLaneWidth;
451  }
452 
456  SUMOReal getLaneWidth(int lane) const;
457 
458 
461  SUMOReal getTotalWidth() const;
462 
465  const std::string& getStreetName() const {
466  return myStreetName;
467  }
468 
471  void setStreetName(const std::string& name) {
472  myStreetName = name;
473  }
474 
479  return myEndOffset;
480  }
481 
485  SUMOReal getEndOffset(int lane) const;
486 
490  return mySignalOffset;
491  }
492 
495  void setSignalOffset(SUMOReal offset) {
496  mySignalOffset = offset;
497  }
498 
502  const std::string& getTypeName() const {
503  return myType;
504  }
505 
506 
510  const std::vector<NBEdge::Lane>& getLanes() const {
511  return myLanes;
512  }
514 
519  int getFirstNonPedestrianLaneIndex(int direction, bool exclusive = false) const;
520  NBEdge::Lane getFirstNonPedestrianLane(int direction) const;
521 
524 
526 
527 
531  const PositionVector& getGeometry() const {
532  return myGeom;
533  }
534 
535 
537  const PositionVector getInnerGeometry() const;
538 
539 
542  bool hasDefaultGeometry() const;
543 
544 
550  bool hasDefaultGeometryEndpoints() const;
551 
552 
563  void setGeometry(const PositionVector& g, bool inner = false);
564 
565 
575  void addGeometryPoint(int index, const Position& p);
576 
580  void shiftPositionAtNode(NBNode* node, NBEdge* opposite);
581 
591  void computeEdgeShape();
592 
593 
597  const PositionVector& getLaneShape(unsigned int i) const;
598 
599 
605 
606 
612  return myLaneSpreadFunction;
613  }
614 
615 
621  bool splitGeometry(NBEdgeCont& ec, NBNodeCont& nc);
622 
623 
627  void reduceGeometry(const SUMOReal minDist);
628 
629 
635  void checkGeometry(const SUMOReal maxAngle, const SUMOReal minRadius, bool fix);
637 
638 
639 
642 
657  bool addEdge2EdgeConnection(NBEdge* dest);
658 
659 
680  bool addLane2LaneConnection(unsigned int fromLane, NBEdge* dest,
681  unsigned int toLane, Lane2LaneInfoType type,
682  bool mayUseSameDestination = false,
683  bool mayDefinitelyPass = false);
684 
685 
703  bool addLane2LaneConnections(unsigned int fromLane,
704  NBEdge* dest, unsigned int toLane, unsigned int no,
705  Lane2LaneInfoType type, bool invalidatePrevious = false,
706  bool mayDefinitelyPass = false);
707 
708 
719  void setConnection(unsigned int lane, NBEdge* destEdge,
720  unsigned int destLane,
721  Lane2LaneInfoType type,
722  bool mayUseSameDestination = false,
723  bool mayDefinitelyPass = false);
724 
725 
726 
735  std::vector<Connection> getConnectionsFromLane(unsigned int lane) const;
736 
737 
746  bool hasConnectionTo(NBEdge* destEdge, unsigned int destLane, int fromLane = -1) const;
747 
748 
755  bool isConnectedTo(NBEdge* e);
756 
757 
761  const std::vector<Connection>& getConnections() const {
762  return myConnections;
763  }
764 
765 
769  std::vector<Connection>& getConnections() {
770  return myConnections;
771  }
772 
773 
778 
779 
784 
785 
789  std::vector<int> getConnectionLanes(NBEdge* currentOutgoing) const;
790 
791 
795 
796 
800 
801 
807  void remapConnections(const EdgeVector& incoming);
808 
809 
816  void removeFromConnections(NBEdge* toEdge, int fromLane = -1, int toLane = -1, bool tryLater = false);
817 
818  void invalidateConnections(bool reallowSetting = false);
819 
820  void replaceInConnections(NBEdge* which, NBEdge* by, unsigned int laneOff);
821  void replaceInConnections(NBEdge* which, const std::vector<NBEdge::Connection>& origConns);
822  void copyConnectionsFrom(NBEdge* src);
823 
825  void shiftToLanesToEdge(NBEdge* to, unsigned int laneOff);
827 
828 
829 
835  bool isTurningDirectionAt(const NBEdge* const edge) const;
836 
837 
842  void setTurningDestination(NBEdge* e, bool onlyPossible = false);
843 
844 
845 
848 
853  }
854 
855 
859  bool isMacroscopicConnector() const {
861  }
862 
863 
866  void setIsInnerEdge() {
867  myAmInnerEdge = true;
868  }
869 
870 
874  bool isInnerEdge() const {
875  return myAmInnerEdge;
876  }
878 
879 
880 
881 
887  void setJunctionPriority(const NBNode* const node, int prio);
888 
889 
899  int getJunctionPriority(const NBNode* const node) const;
900 
901  void setLoadedLength(SUMOReal val);
903 
904 
905  const std::string& getTypeID() const {
906  return myType;
907  }
908 
910  bool needsLaneSpecificOutput() const;
911 
913  bool hasRestrictions() const;
914 
916  bool hasLaneSpecificPermissions() const;
917 
919  bool hasLaneSpecificSpeed() const;
920 
922  bool hasLaneSpecificEndOffset() const;
923 
925  bool hasLaneSpecificWidth() const;
926 
928  bool computeEdge2Edges(bool noLeftMovers);
929 
931  bool computeLanes2Edges(const bool buildCrossingsAndWalkingAreas);
932 
935  bool recheckLanes(const bool buildCrossingsAndWalkingAreas);
936 
945  void appendTurnaround(bool noTLSControlled);
946 
947 
948 
952  NBNode* tryGetNodeAtPosition(SUMOReal pos, SUMOReal tolerance = 5.0) const;
953 
954 
956 
957  bool lanesWereAssigned() const;
958 
959  bool mayBeTLSControlled(int fromLane, NBEdge* toEdge, int toLane) const;
960 
962  bool setControllingTLInformation(const NBConnection& c, const std::string& tlID);
963 
966 
968  PositionVector& into);
969 
971  PositionVector getCWBoundaryLine(const NBNode& n) const;
972 
974  PositionVector getCCWBoundaryLine(const NBNode& n) const;
975 
976  bool expandableBy(NBEdge* possContinuation) const;
977  void append(NBEdge* continuation);
978 
979  bool hasSignalisedConnectionTo(const NBEdge* const e) const;
980 
981 
982  void moveOutgoingConnectionsFrom(NBEdge* e, unsigned int laneOff);
983 
984  /* @brief return the turn destination if it exists
985  * @param[in] possibleDestination Wether myPossibleTurnDestination should be returned if no turnaround connection
986  * exists
987  */
988  NBEdge* getTurnDestination(bool possibleDestination = false) const;
989 
990  std::string getLaneID(unsigned int lane) const;
991 
992  std::string getLaneIDInsecure(unsigned int lane) const;
993 
994  SUMOReal getLaneSpeed(unsigned int lane) const;
995 
996  bool isNearEnough2BeJoined2(NBEdge* e, SUMOReal threshold) const;
997 
998 
1006  SUMOReal getAngleAtNode(const NBNode* const node) const;
1007 
1008 
1017  SUMOReal getAngleAtNodeToCenter(const NBNode* const node) const;
1018 
1019 
1020  void incLaneNo(unsigned int by);
1021 
1022  void decLaneNo(unsigned int by, int dir = 0);
1023 
1024  void markAsInLane2LaneState();
1025 
1027  void addSidewalk(SUMOReal width);
1028 
1030  void setPermissions(SVCPermissions permissions, int lane = -1);
1031 
1032  void setPreferredVehicleClass(SVCPermissions permissions, int lane = -1);
1033 
1035  void allowVehicleClass(int lane, SUMOVehicleClass vclass);
1037  void disallowVehicleClass(int lane, SUMOVehicleClass vclass);
1038 
1039  void preferVehicleClass(int lane, SUMOVehicleClass vclass);
1040 
1041 
1043  void setLaneWidth(int lane, SUMOReal width);
1044 
1046  void setEndOffset(int lane, SUMOReal offset);
1047 
1049  void setSpeed(int lane, SUMOReal speed);
1050 
1052  SVCPermissions getPermissions(int lane = -1) const;
1053 
1054  void disableConnection4TLS(int fromLane, NBEdge* toEdge, int toLane);
1055 
1056 
1057  // returns a reference to the internal structure for the convenience of NETEDIT
1058  Lane& getLaneStruct(unsigned int lane) {
1059  return myLanes[lane];
1060  }
1061 
1062  // returns a reference to the internal structure for the convenience of NETEDIT
1063  const Lane& getLaneStruct(unsigned int lane) const {
1064  return myLanes[lane];
1065  }
1066 
1067  /* declares connections as fully loaded. This is needed to avoid recomputing connections
1068  * if an edge has no connections intentionally. */
1071  }
1072 
1073  /* @brief fill connection attributes shape, viaShape, ...
1074  *
1075  * @param[in,out] edgeIndex The number of connections already handled
1076  * @param[in,out] splitIndex The number of via edges already built
1077  * @param[in] tryIgnoreNodePositions Does not add node geometries if geom.size()>=2
1078  */
1079  void buildInnerEdges(const NBNode& n, unsigned int noInternalNoSplits, unsigned int& linkIndex, unsigned int& splitIndex);
1080 
1081  inline const std::vector<NBSign>& getSigns() const {
1082  return mySigns;
1083  }
1084 
1085  inline void addSign(NBSign sign) {
1086  mySigns.push_back(sign);
1087  }
1088 
1089 
1090 private:
1097  private:
1099  std::map<NBEdge*, std::vector<unsigned int> > myConnections;
1100 
1103 
1104  public:
1107  : myTransitions(transitions) { }
1108 
1111 
1113  void execute(const unsigned int lane, const unsigned int virtEdge);
1114 
1115  const std::map<NBEdge*, std::vector<unsigned int> >& getBuiltConnections() const {
1116  return myConnections;
1117  }
1118 
1119  private:
1122 
1125 
1126  };
1127 
1128 
1137  public:
1140 
1143  std::vector<Direction> myDirs;
1144 
1145  public:
1147  MainDirections(const EdgeVector& outgoing,
1148  NBEdge* parent, NBNode* to);
1149 
1151  ~MainDirections();
1152 
1155  bool empty() const;
1156 
1159  bool includes(Direction d) const;
1160 
1161  private:
1164 
1167 
1168  };
1169 
1171  PositionVector computeLaneShape(unsigned int lane, SUMOReal offset);
1172 
1174  //std::pair<SUMOReal, SUMOReal> laneOffset(const Position& from, const Position& to, SUMOReal laneCenterOffset);
1175 
1176  void computeLaneShapes();
1177 
1178 
1179 
1180 private:
1196  void init(unsigned int noLanes, bool tryIgnoreNodePositions);
1197 
1198 
1200  void divideOnEdges(const EdgeVector* outgoing, const bool buildCrossingsAndWalkingAreas);
1201 
1204  std::vector<unsigned int>* prepareEdgePriorities(
1205  const EdgeVector* outgoing);
1206 
1208  unsigned int computePrioritySum(std::vector<unsigned int>* priorities);
1209 
1210 
1213 
1216  void moveConnectionToLeft(unsigned int lane, const bool buildCrossingsAndWalkingAreas);
1217 
1220  void moveConnectionToRight(unsigned int lane, const bool buildCrossingsAndWalkingAreas);
1221 
1223  bool canMoveConnection(const Connection& con, unsigned int newFromLane, const bool buildCrossingsAndWalkingAreas) const;
1225 
1226 
1231  PositionVector startShapeAt(const PositionVector& laneShape, const NBNode* startNode) const;
1232 
1234  void computeAngle();
1235 
1236 
1237  /* @brief compute the first intersection point between the given lane
1238  * geometries considering their rspective widths */
1239  static SUMOReal firstIntersection(const PositionVector& v1, const PositionVector& v2, SUMOReal width2);
1240 
1241 private:
1246 
1248  std::string myType;
1249 
1252 
1255 
1260 
1263 
1266 
1270  std::vector<Connection> myConnections;
1271 
1274  std::vector<Connection> myConnectionsToDelete;
1275 
1280 
1283 
1286 
1289 
1292 
1295 
1298 
1302  std::vector<Lane> myLanes;
1303 
1306 
1309 
1310 
1313 
1316 
1320  int toLane;
1321  };
1322 
1323  std::vector<TLSDisabledConnection> myTLSDisabledConnections;
1324 
1325 
1327  std::string myStreetName;
1328 
1329 
1331  std::vector<NBSign> mySigns;
1332 
1335 
1336 public:
1341  public:
1344 
1345  bool operator()(const TLSDisabledConnection& e) const {
1346  if (e.to != myDefinition.to) {
1347  return false;
1348  }
1349  if (e.fromLane != myDefinition.fromLane) {
1350  return false;
1351  }
1352  if (e.toLane != myDefinition.toLane) {
1353  return false;
1354  }
1355  return true;
1356  }
1357 
1358  private:
1360 
1361  private:
1364 
1365  };
1366 
1367 
1368 
1373  public:
1375  connections_toedge_finder(NBEdge* const edge2find) : myEdge2Find(edge2find) { }
1376 
1377  bool operator()(const Connection& c) const {
1378  return c.toEdge == myEdge2Find;
1379  }
1380 
1381  private:
1383 
1384  private:
1387 
1388  };
1389 
1394  public:
1396  connections_toedgelane_finder(NBEdge* const edge2find, int lane2find, int fromLane2find) :
1397  myEdge2Find(edge2find),
1398  myLane2Find(lane2find),
1399  myFromLane2Find(fromLane2find) { }
1400 
1401  bool operator()(const Connection& c) const {
1402  return c.toEdge == myEdge2Find && c.toLane == myLane2Find && (myFromLane2Find < 0 || c.fromLane == myFromLane2Find);
1403  }
1404 
1405  private:
1409 
1410  private:
1413 
1414  };
1415 
1416 
1421  public:
1423  connections_finder(int fromLane, NBEdge* const edge2find, int lane2find) : myFromLane(fromLane), myEdge2Find(edge2find), myLane2Find(lane2find) { }
1424 
1425  bool operator()(const Connection& c) const {
1426  return c.fromLane == myFromLane && c.toEdge == myEdge2Find && c.toLane == myLane2Find;
1427  }
1428 
1429  private:
1433 
1434  private:
1437 
1438  };
1439 
1444  public:
1446  connections_fromlane_finder(int lane2find) : myLane2Find(lane2find) { }
1447 
1448  bool operator()(const Connection& c) const {
1449  return c.fromLane == myLane2Find;
1450  }
1451 
1452  private:
1454 
1455  private:
1458 
1459  };
1460 
1464  static bool connections_sorter(const Connection& c1, const Connection& c2);
1465 
1471  public:
1474 
1475  public:
1477  int operator()(const Connection& c1, const Connection& c2) const;
1478 
1479  private:
1482  };
1483 
1484 private:
1486  NBEdge(const NBEdge& s);
1487 
1489  NBEdge& operator=(const NBEdge& s);
1490 
1491 
1492 };
1493 
1494 
1495 #endif
1496 
1497 /****************************************************************************/
1498 
ToEdgeConnectionsAdder(const EdgeVector &transitions)
constructor
Definition: NBEdge.h:1106
NBEdge::Lane getFirstNonPedestrianLane(int direction) const
Definition: NBEdge.cpp:2330
std::string id
Definition: NBEdge.h:177
void invalidateConnections(bool reallowSetting=false)
Definition: NBEdge.cpp:896
const PositionVector & getLaneShape(unsigned int i) const
Returns the shape of the nth lane.
Definition: NBEdge.cpp:510
std::vector< Lane > myLanes
Lane information.
Definition: NBEdge.h:1302
bool includes(Direction d) const
Definition: NBEdge.cpp:162
bool hasConnectionTo(NBEdge *destEdge, unsigned int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
Definition: NBEdge.cpp:759
const std::string & getTypeID() const
Definition: NBEdge.h:905
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
Definition: NBEdge.cpp:1822
SUMOReal endOffset
This lane's offset to the intersection begin.
Definition: NBEdge.h:136
A structure which describes a connection between edges or lanes.
Definition: NBEdge.h:148
int toLane
The lane the connections yields in.
Definition: NBEdge.h:166
static const SUMOReal UNSPECIFIED_WIDTH
unspecified lane width
Definition: NBEdge.h:201
SUMOReal myTotalAngle
Definition: NBEdge.h:1259
A class representing a single street sign.
Definition: NBSign.h:51
connections_finder(int fromLane, NBEdge *const edge2find, int lane2find)
constructor
Definition: NBEdge.h:1423
std::string foeIncomingLanes
Definition: NBEdge.h:187
PositionVector shape
The lane's shape.
Definition: NBEdge.h:128
SUMOReal myEndOffset
This edges's offset to the intersection begin (will be applied to all lanes)
Definition: NBEdge.h:1294
std::vector< TLSDisabledConnection > myTLSDisabledConnections
Definition: NBEdge.h:1323
connections_relative_edgelane_sorter(NBEdge *e)
constructor
Definition: NBEdge.h:1473
~NBEdge()
Destructor.
Definition: NBEdge.cpp:375
static const SUMOReal UNSPECIFIED_SIGNAL_OFFSET
unspecified signal offset
Definition: NBEdge.h:210
LaneSpreadFunction myLaneSpreadFunction
The information about how to spread the lanes.
Definition: NBEdge.h:1291
SUMOReal viaVmax
Definition: NBEdge.h:183
void sortOutgoingConnectionsByAngle()
sorts the outgoing connections by their angle relative to their junction
Definition: NBEdge.cpp:841
const std::string & getTypeName() const
Returns the type name.
Definition: NBEdge.h:502
std::string viaID
Definition: NBEdge.h:182
void addSign(NBSign sign)
Definition: NBEdge.h:1085
NBEdge * toEdge
The edge the connections yields in.
Definition: NBEdge.h:164
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
Definition: NBEdge.cpp:400
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
NBNode * myTo
Definition: NBEdge.h:1251
The relationships between edges are computed/loaded.
Definition: NBEdge.h:95
bool empty() const
Definition: NBEdge.cpp:156
void appendTurnaround(bool noTLSControlled)
Add a connection to the previously computed turnaround, if wished.
Definition: NBEdge.cpp:1741
connections_toedge_finder & operator=(const connections_toedge_finder &s)
invalidated assignment operator
bool operator()(const TLSDisabledConnection &e) const
Definition: NBEdge.h:1345
std::vector< NBSign > mySigns
the street signs along this edge
Definition: NBEdge.h:1331
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
Definition: NBEdge.cpp:1493
void setLaneWidth(int lane, SUMOReal width)
set lane specific width (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2156
void moveConnectionToRight(unsigned int lane, const bool buildCrossingsAndWalkingAreas)
Definition: NBEdge.cpp:1018
void setSpeed(int lane, SUMOReal speed)
set lane specific speed (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2211
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition: NBEdge.h:510
void moveOutgoingConnectionsFrom(NBEdge *e, unsigned int laneOff)
Definition: NBEdge.cpp:1783
~ToEdgeConnectionsAdder()
destructor
Definition: NBEdge.h:1110
void addSidewalk(SUMOReal width)
add a pedestrian sidewalk of the given width and shift existing connctions
Definition: NBEdge.cpp:2339
SUMOReal getEndAngle() const
Returns the angle at the end of the edge The angle is computed in computeAngle()
Definition: NBEdge.h:389
int SVCPermissions
The representation of a single edge during network building.
Definition: NBEdge.h:71
void reinitNodes(NBNode *from, NBNode *to)
Resets nodes but keeps all other values the same (used when joining)
Definition: NBEdge.cpp:311
void clearControllingTLInformation()
clears tlID for all connections
Definition: NBEdge.cpp:1887
Lane2LaneInfoType
Modes of setting connections between lanes.
Definition: NBEdge.h:110
void declareConnectionsAsLoaded()
Definition: NBEdge.h:1069
bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const
Definition: NBEdge.cpp:1811
bool hasDefaultGeometryEndpoints() const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
Definition: NBEdge.cpp:406
bool operator()(const Connection &c) const
Definition: NBEdge.h:1401
void incLaneNo(unsigned int by)
Definition: NBEdge.cpp:2069
PositionVector getCCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going counter-clock-wise around the given node ...
Definition: NBEdge.cpp:1923
static std::pair< SUMOReal, SUMOReal > laneOffset(const Position &from, const Position &to, SUMOReal laneCenterOffset, bool leftHand)
Computes the offset from the edge shape on the current segment.
Definition: NBEdge.cpp:1394
bool addLane2LaneConnections(unsigned int fromLane, NBEdge *dest, unsigned int toLane, unsigned int no, Lane2LaneInfoType type, bool invalidatePrevious=false, bool mayDefinitelyPass=false)
Builds no connections starting at the given lanes.
Definition: NBEdge.cpp:671
void setStreetName(const std::string &name)
sets the street name of this edge
Definition: NBEdge.h:471
static const SUMOReal UNSPECIFIED_SPEED
unspecified lane speed
Definition: NBEdge.h:205
std::vector< Direction > myDirs
Definition: NBEdge.h:1143
void buildInnerEdges(const NBNode &n, unsigned int noInternalNoSplits, unsigned int &linkIndex, unsigned int &splitIndex)
Definition: NBEdge.cpp:1042
void markAsInLane2LaneState()
Definition: NBEdge.cpp:2110
SUMOReal getTotalWidth() const
Returns the combined width of all lanes of this edge.
Definition: NBEdge.cpp:2180
bool addLane2LaneConnection(unsigned int fromLane, NBEdge *dest, unsigned int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false)
Adds a connection between the specified this edge's lane and an approached one.
Definition: NBEdge.cpp:649
Lanes to lanes - relationships are computed; should be recheked.
Definition: NBEdge.h:99
PositionVector computeLaneShape(unsigned int lane, SUMOReal offset)
Computes the shape for the given lane.
Definition: NBEdge.cpp:1333
SUMOReal getLaneWidth() const
Returns the default width of lanes of this edge.
Definition: NBEdge.h:449
std::string getLaneIDInsecure(unsigned int lane) const
Definition: NBEdge.cpp:2055
void setPermissions(SVCPermissions permissions, int lane=-1)
set allowed/disallowed classes for the given lane or for all lanes if -1 is given ...
Definition: NBEdge.cpp:2227
int myFromJunctionPriority
The priority normalised for the node the edge is outgoing of.
Definition: NBEdge.h:1282
void computeLaneShapes()
Computes the offset from the edge shape on the current segment.
Definition: NBEdge.cpp:1287
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
Definition: NBEdge.h:172
tls_disable_finder(const TLSDisabledConnection &tpl)
constructor
Definition: NBEdge.h:1343
bool isInnerEdge() const
Returns whether this edge was marked as being within an intersection.
Definition: NBEdge.h:874
PositionVector myGeom
The geometry for the edge.
Definition: NBEdge.h:1288
void remapConnections(const EdgeVector &incoming)
Remaps the connection in a way that allows the removal of it.
Definition: NBEdge.cpp:853
const SVCPermissions SVCAll
void divideOnEdges(const EdgeVector *outgoing, const bool buildCrossingsAndWalkingAreas)
Definition: NBEdge.cpp:1593
static const SUMOReal UNSPECIFIED_OFFSET
unspecified lane offset
Definition: NBEdge.h:203
std::vector< Connection > getConnectionsFromLane(unsigned int lane) const
Returns connections from a given lane.
Definition: NBEdge.cpp:747
friend class GNEEdge
Definition: NBEdge.h:78
MainDirections & operator=(const MainDirections &)
Invalidated assignment operator.
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
Definition: NBEdge.cpp:413
static SUMOReal firstIntersection(const PositionVector &v1, const PositionVector &v2, SUMOReal width2)
Definition: NBEdge.cpp:1199
void setSignalOffset(SUMOReal offset)
sets the offset of a traffic signal from the end of this edge
Definition: NBEdge.h:495
void moveConnectionToLeft(unsigned int lane, const bool buildCrossingsAndWalkingAreas)
Definition: NBEdge.cpp:993
const EdgeVector & myTransitions
the transition from the virtual lane to the edge it belongs to
Definition: NBEdge.h:1102
The connection was computed and validated.
Definition: NBEdge.h:116
PositionVector startShapeAt(const PositionVector &laneShape, const NBNode *startNode) const
Definition: NBEdge.cpp:469
SUMOReal vmax
Definition: NBEdge.h:179
const std::vector< NBSign > & getSigns() const
Definition: NBEdge.h:1081
The edge has been loaded, nothing is computed yet.
Definition: NBEdge.h:93
int myToJunctionPriority
The priority normalised for the node the edge is incoming in.
Definition: NBEdge.h:1285
EdgeVector getConnectedEdges() const
Returns the list of outgoing edges unsorted.
Definition: NBEdge.cpp:815
PositionVector shape
Definition: NBEdge.h:178
SUMOReal speed
The speed allowed on this lane.
Definition: NBEdge.h:130
bool operator()(const Connection &c) const
Definition: NBEdge.h:1377
SUMOReal getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
Definition: NBEdge.h:415
An (internal) definition of a single lane of an edge.
Definition: NBEdge.h:123
SUMOReal mySpeed
The maximal speed.
Definition: NBEdge.h:1265
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
Definition: NBEdge.h:132
bool addEdge2EdgeConnection(NBEdge *dest)
Adds a connection to another edge.
Definition: NBEdge.cpp:625
bool recheckLanes(const bool buildCrossingsAndWalkingAreas)
Definition: NBEdge.cpp:1556
bool myAmMacroscopicConnector
Information whether this edge is a (macroscopic) connector.
Definition: NBEdge.h:1315
bool isConnectedTo(NBEdge *e)
Returns the information whethe a connection to the given edge has been added (or computed) ...
Definition: NBEdge.cpp:765
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
Definition: NBEdge.cpp:391
bool computeLanes2Edges(const bool buildCrossingsAndWalkingAreas)
computes the edge, step2: computation of which lanes approach the edges)
Definition: NBEdge.cpp:1532
void reshiftPosition(SUMOReal xoff, SUMOReal yoff)
Applies an offset to the edge.
Definition: NBEdge.cpp:380
NBEdge * myTurnDestination
The turn destination edge (if a connection exists)
Definition: NBEdge.h:1277
const std::map< NBEdge *, std::vector< unsigned int > > & getBuiltConnections() const
Definition: NBEdge.h:1115
const Lane & getLaneStruct(unsigned int lane) const
Definition: NBEdge.h:1063
friend class NBEdgeSuccessorBuilder
Definition: NBEdge.h:73
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
Definition: NBEdge.h:103
int operator()(const Connection &c1, const Connection &c2) const
comparing operation
Definition: NBEdge.cpp:171
bool hasLaneSpecificSpeed() const
whether lanes differ in speed
Definition: NBEdge.cpp:1482
int getPriority() const
Returns the priority of the edge.
Definition: NBEdge.h:355
void checkGeometry(const SUMOReal maxAngle, const SUMOReal minRadius, bool fix)
Check the angles of successive geometry segments.
Definition: NBEdge.cpp:579
std::string getLaneID(unsigned int lane) const
Definition: NBEdge.cpp:2048
bool myAmLeftHand
Whether this edge is a left-hand edge.
Definition: NBEdge.h:1308
void addCrossingPointsAsIncomingWithGivenOutgoing(NBEdge *o, PositionVector &into)
std::string tlID
The id of the traffic light that controls this connection.
Definition: NBEdge.h:168
SVCPermissions preferred
List of vehicle types that are preferred on this lane.
Definition: NBEdge.h:134
std::string getInternalLaneID() const
Definition: NBEdge.cpp:76
int fromLane
The lane the connections starts at.
Definition: NBEdge.h:162
bool canMoveConnection(const Connection &con, unsigned int newFromLane, const bool buildCrossingsAndWalkingAreas) const
whether the connection can originate on newFromLane
Definition: NBEdge.cpp:984
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
TLSDisabledConnection myDefinition
Definition: NBEdge.h:1359
NBEdge & operator=(const NBEdge &s)
invalidated assignment operator
A list of positions.
SUMOReal myEndAngle
Definition: NBEdge.h:1258
tls_disable_finder & operator=(const tls_disable_finder &s)
invalidated assignment operator
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
Definition: NBEdge.cpp:1457
bool lanesWereAssigned() const
Definition: NBEdge.cpp:1799
static bool connections_sorter(const Connection &c1, const Connection &c2)
Definition: NBEdge.cpp:2285
std::vector< unsigned int > foeInternalLinks
Definition: NBEdge.h:186
std::vector< Connection > & getConnections()
Returns the connections.
Definition: NBEdge.h:769
unsigned int getNumLanes() const
Returns the number of lanes.
Definition: NBEdge.h:347
EdgeBuildingStep
Current state of the edge within the building process.
Definition: NBEdge.h:89
NBEdge * myPossibleTurnDestination
The edge that would be the turn destination if there was one.
Definition: NBEdge.h:1279
void setAsMacroscopicConnector()
Marks this edge as a macroscopic connector.
Definition: NBEdge.h:851
PositionVector getCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going clock-wise around the given node
Definition: NBEdge.cpp:1905
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition: NBEdge.h:423
friend class GNELane
Definition: NBEdge.h:77
EdgeBuildingStep getStep() const
The building step of this edge.
Definition: NBEdge.h:441
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
Definition: NBEdge.cpp:1756
void setLeftHanded()
Marks this edge to be left-handed.
Definition: NBEdge.h:336
SUMOReal myLaneWidth
This width of this edge's lanes.
Definition: NBEdge.h:1297
int myPriority
The priority of the edge.
Definition: NBEdge.h:1262
int getFirstNonPedestrianLaneIndex(int direction, bool exclusive=false) const
return the first lane with permissions other than SVC_PEDESTRIAN and 0
Definition: NBEdge.cpp:2297
void init(unsigned int noLanes, bool tryIgnoreNodePositions)
Initialization routines common to all constructors.
Definition: NBEdge.cpp:331
Storage for edges, including some functionality operating on multiple edges.
Definition: NBEdgeCont.h:66
std::string origID
Definition: NBEdge.h:175
bool needsLaneSpecificOutput() const
whether at least one lane has values differing from the edges values
Definition: NBEdge.cpp:1504
Connection(int fromLane_, NBEdge *toEdge_, int toLane_)
Constructor.
Definition: NBEdge.h:154
ToEdgeConnectionsAdder & operator=(const ToEdgeConnectionsAdder &)
Invalidated assignment operator.
EdgeBuildingStep myStep
The building step.
Definition: NBEdge.h:1245
unsigned int computePrioritySum(std::vector< unsigned int > *priorities)
Definition: NBEdge.cpp:1731
connections_toedge_finder(NBEdge *const edge2find)
constructor
Definition: NBEdge.h:1375
SUMOReal getAngleAtNodeToCenter(const NBNode *const node) const
Returns the angle of from the node shape center to where the edge meets the node shape.
Definition: NBEdge.cpp:1257
std::vector< Connection > myConnections
List of connections to following edges.
Definition: NBEdge.h:1270
void setLoadedLength(SUMOReal val)
Definition: NBEdge.cpp:2270
connections_fromlane_finder(int lane2find)
constructor
Definition: NBEdge.h:1446
The connection was given by the user.
Definition: NBEdge.h:114
An upper class for objects with additional parameters.
Definition: Parameterised.h:47
SUMOReal getSignalOffset() const
Returns the offset of a traffic signal from the end of this edge.
Definition: NBEdge.h:489
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false)
Removes the specified connection(s)
Definition: NBEdge.cpp:869
connections_toedgelane_finder & operator=(const connections_toedgelane_finder &s)
invalidated assignment operator
SUMOReal getEndOffset() const
Returns the offset to the destination node.
Definition: NBEdge.h:478
bool myAmInnerEdge
Information whether this is a junction-inner edge.
Definition: NBEdge.h:1312
Base class for objects which have an id.
Definition: Named.h:45
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
Definition: NBEdge.cpp:1225
SUMOReal myLoadedLength
An optional length to use (-1 if not valid)
Definition: NBEdge.h:1305
std::string origID
An original ID, if given (.
Definition: NBEdge.h:140
bool hasRestrictions() const
whether at least one lane has restrictions
Definition: NBEdge.cpp:1446
std::map< NBEdge *, std::vector< unsigned int > > myConnections
map of edges to this edge's lanes that reach them
Definition: NBEdge.h:1099
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition: NBEdge.cpp:2255
SUMOReal getCrossingAngle(NBNode *node)
return the angle for computing pedestrian crossings at the given node
Definition: NBEdge.cpp:2314
Lane(NBEdge *e)
Definition: NBEdge.h:124
void setTurningDestination(NBEdge *e, bool onlyPossible=false)
Sets the turing destination at the given edge.
Definition: NBEdge.cpp:1272
void decLaneNo(unsigned int by, int dir=0)
Definition: NBEdge.cpp:2084
NBNode * getToNode() const
Returns the destination node of the edge.
Definition: NBEdge.h:371
#define sign(a)
Definition: polyfonts.c:68
std::vector< int > getConnectionLanes(NBEdge *currentOutgoing) const
Returns the list of lanes that may be used to reach the given edge.
Definition: NBEdge.cpp:827
void execute(const unsigned int lane, const unsigned int virtEdge)
executes a bresenham - step
Definition: NBEdge.cpp:84
void computeEdgeShape()
Recomputeds the lane shapes to terminate at the node shape For every lane the intersection with the f...
Definition: NBEdge.cpp:427
void disableConnection4TLS(int fromLane, NBEdge *toEdge, int toLane)
Definition: NBEdge.cpp:1895
PositionVector viaShape
Definition: NBEdge.h:184
SUMOReal getMaxLaneOffset()
Definition: NBEdge.cpp:1805
static const SUMOReal UNSPECIFIED_LOADED_LENGTH
no length override given
Definition: NBEdge.h:208
std::vector< NBEdge * > EdgeVector
Definition: NBCont.h:41
std::vector< unsigned int > * prepareEdgePriorities(const EdgeVector *outgoing)
Definition: NBEdge.cpp:1689
NBEdge * myEdge
the edge to compute the relative angle of
Definition: NBEdge.h:1481
SUMOReal myLength
The length of the edge.
Definition: NBEdge.h:1254
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
Definition: NBEdge.cpp:2241
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition: NBEdge.h:531
The edge has been loaded and connections shall not be added.
Definition: NBEdge.h:91
std::vector< Connection > myConnectionsToDelete
List of connections marked for delayed removal.
Definition: NBEdge.h:1274
bool isMacroscopicConnector() const
Returns whether this edge was marked as a macroscopic connector.
Definition: NBEdge.h:859
connections_toedgelane_finder(NBEdge *const edge2find, int lane2find, int fromLane2find)
constructor
Definition: NBEdge.h:1396
void reduceGeometry(const SUMOReal minDist)
Removes points with a distance lesser than the given.
Definition: NBEdge.cpp:573
void setJunctionPriority(const NBNode *const node, int prio)
Sets the junction priority of the edge.
Definition: NBEdge.cpp:1235
void replaceInConnections(NBEdge *which, NBEdge *by, unsigned int laneOff)
Definition: NBEdge.cpp:908
const EdgeVector * getConnectedSorted()
Returns the list of outgoing edges without the turnaround sorted in clockwise direction.
Definition: NBEdge.cpp:778
NBEdge *const myEdge2Find
Definition: NBEdge.h:1431
void setIsInnerEdge()
Marks this edge being within an intersection.
Definition: NBEdge.h:866
void sortOutgoingConnectionsByIndex()
sorts the outgoing connections by their from-lane-index and their to-lane-index
Definition: NBEdge.cpp:847
std::string myType
The type of the edge.
Definition: NBEdge.h:1248
SUMOReal mySignalOffset
the offset of a traffic light signal from the end of this edge (-1 for None)
Definition: NBEdge.h:1334
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
void append(NBEdge *continuation)
Definition: NBEdge.cpp:2003
unsigned int tlLinkNo
The index of this connection within the controlling traffic light.
Definition: NBEdge.h:170
connections_finder & operator=(const connections_finder &s)
invalidated assignment operator
SUMOReal getLaneSpeed(unsigned int lane) const
Definition: NBEdge.cpp:1281
void shiftToLanesToEdge(NBEdge *to, unsigned int laneOff)
modifify the toLane for all connections to the given edge
Definition: NBEdge.cpp:2373
NBNode * tryGetNodeAtPosition(SUMOReal pos, SUMOReal tolerance=5.0) const
Returns the node at the given edges length (using an epsilon) When no node is existing at the given p...
Definition: NBEdge.cpp:1769
The connection was computed.
Definition: NBEdge.h:112
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
Definition: NBEdge.h:611
SUMOReal myStartAngle
The angles of the edge.
Definition: NBEdge.h:1257
SUMOReal getTotalAngle() const
get the angle as measure from the start to the end of this edge
Definition: NBEdge.h:399
Represents a single node (junction) during network building.
Definition: NBNode.h:75
void dismissVehicleClassInformation()
Definition: NBEdge.cpp:2276
Lane & getLaneStruct(unsigned int lane)
Definition: NBEdge.h:1058
bool hasSignalisedConnectionTo(const NBEdge *const e) const
Definition: NBEdge.cpp:2028
Lanes to lanes - relationships are computed; no recheck is necessary/wished.
Definition: NBEdge.h:101
bool hasLaneSpecificWidth() const
whether lanes differ in width
Definition: NBEdge.cpp:1471
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
void setEndOffset(int lane, SUMOReal offset)
set lane specific end-offset (negative lane implies set for all lanes)
Definition: NBEdge.cpp:2195
Direction
enum of possible directions
Definition: NBEdge.h:1139
#define SUMOReal
Definition: config.h:218
bool isNearEnough2BeJoined2(NBEdge *e, SUMOReal threshold) const
Definition: NBEdge.cpp:2061
void preferVehicleClass(int lane, SUMOVehicleClass vclass)
Definition: NBEdge.cpp:2143
void allowVehicleClass(int lane, SUMOVehicleClass vclass)
set allowed class for the given lane or for all lanes if -1 is given
Definition: NBEdge.cpp:2117
void addGeometryPoint(int index, const Position &p)
Adds a further geometry point.
Definition: NBEdge.cpp:522
connections_fromlane_finder & operator=(const connections_fromlane_finder &s)
invalidated assignment operator
void computeAngle()
computes the angle of this edge and stores it in myAngle
Definition: NBEdge.cpp:1405
SUMOReal getSpeed() const
Returns the speed allowed on this edge.
Definition: NBEdge.h:431
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:64
SUMOReal getStartAngle() const
Returns the angle at the start of the edge The angle is computed in computeAngle() ...
Definition: NBEdge.h:380
bool computeEdge2Edges(bool noLeftMovers)
computes the edge (step1: computation of approached edges)
Definition: NBEdge.cpp:1511
void setConnection(unsigned int lane, NBEdge *destEdge, unsigned int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false)
Adds a connection to a certain lane of a certain edge.
Definition: NBEdge.cpp:688
unsigned int internalLaneIndex
The lane index of this internal lane within the internal edge.
Definition: NBEdge.h:190
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
Definition: NBEdge.cpp:516
bool operator()(const Connection &c) const
Definition: NBEdge.h:1425
NBEdge(const std::string &id, NBNode *from, NBNode *to, std::string type, SUMOReal speed, unsigned int nolanes, int priority, SUMOReal width, SUMOReal offset, const std::string &streetName="", LaneSpreadFunction spread=LANESPREAD_RIGHT)
Constructor.
Definition: NBEdge.cpp:182
Lanes to edges - relationships are computed/loaded.
Definition: NBEdge.h:97
std::string myStreetName
The street name (or whatever arbitrary string you wish to attach)
Definition: NBEdge.h:1327
const std::string & getStreetName() const
Returns the street name of this edge.
Definition: NBEdge.h:465
const std::vector< Connection > & getConnections() const
Returns the connections.
Definition: NBEdge.h:761
NBNode * myFrom
The source and the destination node.
Definition: NBEdge.h:1251
bool expandableBy(NBEdge *possContinuation) const
Definition: NBEdge.cpp:1941
NBEdge * getTurnDestination(bool possibleDestination=false) const
Definition: NBEdge.cpp:2039
~MainDirections()
destructor
Definition: NBEdge.cpp:152
void shiftPositionAtNode(NBNode *node, NBEdge *opposite)
shift geometry at the given node to avoid overlap
Definition: NBEdge.cpp:2384
bool operator()(const Connection &c) const
Definition: NBEdge.h:1448
void disallowVehicleClass(int lane, SUMOVehicleClass vclass)
set disallowed class for the given lane or for all lanes if -1 is given
Definition: NBEdge.cpp:2130
MainDirections(const EdgeVector &outgoing, NBEdge *parent, NBNode *to)
constructor
Definition: NBEdge.cpp:115
SUMOReal width
This lane's width.
Definition: NBEdge.h:138
void copyConnectionsFrom(NBEdge *src)
Definition: NBEdge.cpp:977
void reinit(NBNode *from, NBNode *to, const std::string &type, SUMOReal speed, unsigned int nolanes, int priority, PositionVector geom, SUMOReal width, SUMOReal offset, const std::string &streetName, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false)
Resets initial values.
Definition: NBEdge.cpp:263
static const SUMOReal ANGLE_LOOKAHEAD
the distance at which to take the default angle
Definition: NBEdge.h:212
SUMOReal getLength() const
Returns the computed length of the edge.
Definition: NBEdge.h:406
SUMOReal getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
Definition: NBEdge.cpp:1245
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition: NBEdge.h:363
bool splitGeometry(NBEdgeCont &ec, NBNodeCont &nc)
Splits this edge at geometry points.
Definition: NBEdge.cpp:528