Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
NBEdge.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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/****************************************************************************/
20// The representation of a single edge during network building
21/****************************************************************************/
22#pragma once
23#include <config.h>
24
25#include <map>
26#include <vector>
27#include <string>
28#include <set>
29#include <cassert>
30#include <utils/common/Named.h>
38#include "NBCont.h"
39#include "NBHelpers.h"
40#include "NBSign.h"
41
42
43// ===========================================================================
44// class declarations
45// ===========================================================================
46class NBNode;
47class NBConnection;
48class NBNodeCont;
49class NBEdgeCont;
50class OutputDevice;
51class GNELane;
52class NBVehicle;
53
54
55// ===========================================================================
56// class definitions
57// ===========================================================================
63public:
64 virtual ~NBRouterEdge() {}
65 virtual const std::string& getID() const = 0;
66 virtual double getSpeed() const = 0;
67 virtual double getLength() const = 0;
68 virtual const NBRouterEdge* getBidiEdge() const = 0;
69 virtual int getNumericalID() const = 0;
71 virtual bool isInternal() const {
72 return false;
73 }
74 inline bool prohibits(const NBVehicle* const /*veh*/) const {
75 return false;
76 }
77 inline bool restricts(const NBVehicle* const /*veh*/) const {
78 return false;
79 }
80
81
82 static inline double getTravelTimeStatic(const NBRouterEdge* const edge, const NBVehicle* const /*veh*/, double /*time*/) {
83 return edge->getLength() / edge->getSpeed();
84 }
85};
86
87
92class NBEdge : public Named, public Parameterised, public NBRouterEdge {
93 friend class NBEdgeCont;
94
96 friend class GNELane;
97 friend class GNEEdge;
98 friend class GNEJunction;
99
100public:
101
125
126
130 enum class Lane2LaneInfoType {
132 COMPUTED,
134 USER,
137 };
138
139
143 struct Lane final : public Parameterised {
145 Lane(NBEdge* e, const std::string& _origID);
146
149
151 double speed;
152
154 double friction;
155
158
161
164
167
169 double endOffset;
170
174
176 double width;
177
179 std::string oppositeID;
180
183
185 // @note (see NIImporter_DlrNavteq::ConnectedLanesHandler)
187
190
192 std::string type;
193
195 int turnSigns = 0;
196 };
197
201 struct Connection final : public Parameterised, public NBRouterEdge {
207 Connection(int fromLane_, NBEdge* toEdge_, int toLane_, const bool mayDefinitelyPass_ = false);
208
211
214
217
219 std::string tlID;
220
222 int tlLinkIndex = -1;
223
225 int tlLinkIndex2 = -1;
226
229
232
235
238
241
242 // @brief custom friction for connection
244
247
250
253
256
259
261 bool indirectLeft = false;
262
264 std::string edgeType;
265
267 std::string id;
268
271
274
276 bool haveVia = false;
277
279 std::string viaID;
280
283
285 double viaLength = 0.;
286
288 std::vector<int> foeInternalLinks;
289
291 std::vector<std::string> foeIncomingLanes;
292
295
297 bool uncontrolled = false;
298
300 std::string getInternalLaneID() const;
301
303 std::string getDescription(const NBEdge* parent) const;
304
307
311 const std::string& getID() const {
312 return id;
313 }
314 double getSpeed() const {
315 return vmax;
316 }
317 // @brief needed for NBRouterEdge
318 double getLength() const {
319 return shape.length() + viaShape.length();
320 }
321 int getNumericalID() const {
322 throw ProcessError("NBEdge::Connection does not implement getNumericalID()");
323 }
324 const Connection* getBidiEdge() const {
325 return nullptr;
326 }
327 bool isInternal() const {
328 return true;
329 }
335 };
336
339
341 static const double UNSPECIFIED_WIDTH;
342
344 static const double UNSPECIFIED_OFFSET;
345
347 static const double UNSPECIFIED_SPEED;
348
350 static const double UNSPECIFIED_FRICTION;
351
353 static const double UNSPECIFIED_CONTPOS;
354
357
359 static const double UNSPECIFIED_LOADED_LENGTH;
360
362 static const double UNSPECIFIED_SIGNAL_OFFSET;
363
365 static const double ANGLE_LOOKAHEAD;
366
369
372
379
380 static void setDefaultConnectionLength(double length) {
382 }
383
384public:
404 NBEdge(const std::string& id,
405 NBNode* from, NBNode* to, std::string type,
406 double speed, double friction, int nolanes, int priority,
407 double width, double endOffset,
408 LaneSpreadFunction spread,
409 const std::string& streetName = "");
410
433 NBEdge(const std::string& id,
434 NBNode* from, NBNode* to, std::string type,
435 double speed, double friction, int nolanes, int priority,
436 double width, double endOffset,
437 PositionVector geom,
438 LaneSpreadFunction spread,
439 const std::string& streetName = "",
440 const std::string& origID = "",
441 bool tryIgnoreNodePositions = false);
442
454 NBEdge(const std::string& id,
455 NBNode* from, NBNode* to,
456 const NBEdge* tpl,
457 const PositionVector& geom = PositionVector(),
458 int numLanes = -1);
459
461 ~NBEdge();
462
463
479 void reinit(NBNode* from, NBNode* to, const std::string& type,
480 double speed, double friction, int nolanes, int priority,
481 PositionVector geom, double width, double endOffset,
482 const std::string& streetName,
483 LaneSpreadFunction spread,
484 bool tryIgnoreNodePositions = false);
485
490 void reinitNodes(NBNode* from, NBNode* to);
491
494
498 void reshiftPosition(double xoff, double yoff);
499
501 void mirrorX();
503
505
506
510 int getNumLanes() const {
511 return (int)myLanes.size();
512 }
513
517 int getPriority() const {
518 return myPriority;
519 }
520
522 void setPriority(int priority) {
523 myPriority = priority;
524 }
525
529 inline NBNode* getFromNode() const {
530 return myFrom;
531 }
532
536 inline NBNode* getToNode() const {
537 return myTo;
538 }
539
545 inline double getStartAngle() const {
546 return myStartAngle;
547 }
548
554 inline double getEndAngle() const {
555 return myEndAngle;
556 }
557
562 double getShapeStartAngle() const;
563
564
570 double getShapeEndAngle() const;
571
576 inline double getTotalAngle() const {
577 return myTotalAngle;
578 }
579
583 double getLength() const {
584 return myLength;
585 }
586
587
592 double getLoadedLength() const {
594 }
595
597 double getFinalLength() const;
598
602 bool hasLoadedLength() const {
603 return myLoadedLength > 0;
604 }
605
609 double getSpeed() const {
610 return mySpeed;
611 }
612
616 double getFriction() const {
617 return myFriction;
618 }
619
626 return myStep;
627 }
628
632 double getLaneWidth() const {
633 return myLaneWidth;
634 }
635
639 double getLaneWidth(int lane) const;
640
650 const NBNode& node,
651 const NBEdge::Connection& connection,
652 const NBEdge::Lane& successor,
653 bool isVia) const;
654
656 double getTotalWidth() const;
657
659 const std::string& getStreetName() const {
660 return myStreetName;
661 }
662
664 void setStreetName(const std::string& name) {
665 myStreetName = name;
666 }
667
669 double getDistance() const {
670 return myDistance;
671 }
672
674 double getDistancAt(double pos) const;
675
679 double getEndOffset() const {
680 return myEndOffset;
681 }
682
686 double getEndOffset(int lane) const;
687
691 const StopOffset& getEdgeStopOffset() const;
692
696 const StopOffset& getLaneStopOffset(int lane) const;
697
699 double getSignalOffset() const;
700
703 return mySignalPosition;
704 }
705
707 const NBNode* getSignalNode() const {
708 return mySignalNode;
709 }
710
712 void setSignalPosition(const Position& pos, const NBNode* signalNode) {
713 mySignalPosition = pos;
714 mySignalNode = signalNode;
715 }
716
720 const std::vector<NBEdge::Lane>& getLanes() const {
721 return myLanes;
722 }
724
729 int getFirstNonPedestrianLaneIndex(int direction, bool exclusive = false) const;
730
735 int getFirstNonPedestrianNonBicycleLaneIndex(int direction, bool exclusive = false) const;
736
738 int getSpecialLane(SVCPermissions permissions) const;
739
743 int getFirstAllowedLaneIndex(int direction) const;
744
746 NBEdge::Lane getFirstNonPedestrianLane(int direction) const;
747
749 std::set<SVCPermissions> getPermissionVariants(int iStart, int iEnd) const;
750
752 int getNumLanesThatAllow(SVCPermissions permissions) const;
753
755 bool allowsChangingLeft(int lane, SUMOVehicleClass vclass) const;
756
758 bool allowsChangingRight(int lane, SUMOVehicleClass vclass) const;
759
761 double getCrossingAngle(NBNode* node);
762
764 std::string getSidewalkID();
765
767
768
772 return myGeom;
773 }
774
776 const PositionVector getInnerGeometry() const;
777
779 bool hasDefaultGeometry() const;
780
786 bool hasDefaultGeometryEndpoints() const;
787
793 bool hasDefaultGeometryEndpointAtNode(const NBNode* node) const;
794
795 Position getEndpointAtNode(const NBNode* node) const;
796
807 void setGeometry(const PositionVector& g, bool inner = false);
808
818 void addGeometryPoint(int index, const Position& p);
819
821 void extendGeometryAtNode(const NBNode* node, double maxExtent);
822
824 void shortenGeometryAtNode(const NBNode* node, double reduction);
825
827 void shiftPositionAtNode(NBNode* node, NBEdge* opposite);
828
830 Position geometryPositionAtOffset(double offset) const;
831
841 void computeEdgeShape(double smoothElevationThreshold = -1);
842
846 const PositionVector& getLaneShape(int i) const;
847
853
859
863 void reduceGeometry(const double minDist);
864
870 void checkGeometry(const double maxAngle, const double minRadius, bool fix, bool silent);
872
875
889 bool addEdge2EdgeConnection(NBEdge* dest, bool overrideRemoval = false, SVCPermissions permission = SVC_UNSPECIFIED);
890
911 bool addLane2LaneConnection(int fromLane, NBEdge* dest,
912 int toLane, Lane2LaneInfoType type,
913 bool mayUseSameDestination = false,
914 bool mayDefinitelyPass = false,
916 double contPos = UNSPECIFIED_CONTPOS,
917 double visibility = UNSPECIFIED_VISIBILITY_DISTANCE,
918 double speed = UNSPECIFIED_SPEED,
919 double friction = UNSPECIFIED_FRICTION,
920 double length = myDefaultConnectionLength,
921 const PositionVector& customShape = PositionVector::EMPTY,
922 const bool uncontrolled = UNSPECIFIED_CONNECTION_UNCONTROLLED,
923 SVCPermissions permissions = SVC_UNSPECIFIED,
924 const bool indirectLeft = false,
925 const std::string& edgeType = "",
926 SVCPermissions changeLeft = SVC_UNSPECIFIED,
927 SVCPermissions changeRight = SVC_UNSPECIFIED,
928 bool postProcess = false);
929
947 bool addLane2LaneConnections(int fromLane,
948 NBEdge* dest, int toLane, int no,
949 Lane2LaneInfoType type, bool invalidatePrevious = false,
950 bool mayDefinitelyPass = false);
951
962 bool setConnection(int lane, NBEdge* destEdge,
963 int destLane,
965 bool mayUseSameDestination = false,
966 bool mayDefinitelyPass = false,
968 double contPos = UNSPECIFIED_CONTPOS,
969 double visibility = UNSPECIFIED_VISIBILITY_DISTANCE,
970 double speed = UNSPECIFIED_SPEED,
971 double friction = UNSPECIFIED_FRICTION,
972 double length = myDefaultConnectionLength,
973 const PositionVector& customShape = PositionVector::EMPTY,
974 const bool uncontrolled = UNSPECIFIED_CONNECTION_UNCONTROLLED,
975 SVCPermissions permissions = SVC_UNSPECIFIED,
976 bool indirectLeft = false,
977 const std::string& edgeType = "",
978 SVCPermissions changeLeft = SVC_UNSPECIFIED,
979 SVCPermissions changeRight = SVC_UNSPECIFIED,
980 bool postProcess = false);
981
992 std::vector<Connection> getConnectionsFromLane(int lane, const NBEdge* to = nullptr, int toLane = -1) const;
993
998 const Connection& getConnection(int fromLane, const NBEdge* to, int toLane) const;
999
1004 Connection& getConnectionRef(int fromLane, const NBEdge* to, int toLane);
1005
1014 bool hasConnectionTo(const NBEdge* destEdge, int destLane, int fromLane = -1) const;
1015
1022 bool isConnectedTo(const NBEdge* e, const bool ignoreTurnaround = false) const;
1023
1027 const std::vector<Connection>& getConnections() const {
1028 return myConnections;
1029 }
1030
1034 std::vector<Connection>& getConnections() {
1035 return myConnections;
1036 }
1037
1042
1047
1052
1056 std::vector<int> getConnectionLanes(NBEdge* currentOutgoing, bool withBikes = true) const;
1057
1060
1063
1069 void remapConnections(const EdgeVector& incoming);
1070
1078 void removeFromConnections(NBEdge* toEdge, int fromLane = -1, int toLane = -1, bool tryLater = false, const bool adaptToLaneRemoval = false, const bool keepPossibleTurns = false);
1079
1081 bool removeFromConnections(const NBEdge::Connection& connectionToRemove);
1082
1084 void invalidateConnections(bool reallowSetting = false);
1085
1087 void replaceInConnections(NBEdge* which, NBEdge* by, int laneOff);
1088
1090 void replaceInConnections(NBEdge* which, const std::vector<NBEdge::Connection>& origConns);
1091
1093 void copyConnectionsFrom(NBEdge* src);
1094
1096 void shiftToLanesToEdge(NBEdge* to, int laneOff);
1098
1104 bool isTurningDirectionAt(const NBEdge* const edge) const;
1105
1110 void setTurningDestination(NBEdge* e, bool onlyPossible = false);
1111
1118
1124 }
1125
1127 void setInsideTLS(bool inside) {
1128 myAmInTLS = inside;
1129 }
1130
1134 bool isInsideTLS() const {
1135 return myAmInTLS;
1136 }
1138
1144 void setJunctionPriority(const NBNode* const node, int prio);
1145
1155 int getJunctionPriority(const NBNode* const node) const;
1156
1158 void setLoadedLength(double val);
1159
1161 void setAverageLengthWithOpposite(double val);
1162
1165
1167 const std::string& getTypeID() const {
1168 return myType;
1169 }
1170
1172 bool needsLaneSpecificOutput() const;
1173
1175 bool hasPermissions() const;
1176
1178 bool hasLaneSpecificPermissions() const;
1179
1181 bool hasLaneSpecificSpeed() const;
1182
1184 bool hasLaneSpecificFriction() const;
1185
1187 bool hasLaneSpecificWidth() const;
1188
1190 bool hasLaneSpecificType() const;
1191
1193 bool hasLaneSpecificEndOffset() const;
1194
1196 bool hasLaneSpecificStopOffsets() const;
1197
1199 bool hasAccelLane() const;
1200
1202 bool hasCustomLaneShape() const;
1203
1205 bool hasLaneParams() const;
1206
1208 bool prohibitsChanging() const;
1209
1211 bool computeEdge2Edges(bool noLeftMovers);
1212
1214 bool computeLanes2Edges();
1215
1217 bool recheckLanes();
1218
1227 void appendTurnaround(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike, bool checkPermissions);
1228
1232 NBNode* tryGetNodeAtPosition(double pos, double tolerance = 5.0) const;
1233
1235 double getMaxLaneOffset();
1236
1238 bool lanesWereAssigned() const;
1239
1241 bool mayBeTLSControlled(int fromLane, NBEdge* toEdge, int toLane) const;
1242
1244 bool setControllingTLInformation(const NBConnection& c, const std::string& tlID);
1245
1248
1250 PositionVector getCWBoundaryLine(const NBNode& n) const;
1251
1254
1256 bool expandableBy(NBEdge* possContinuation, std::string& reason) const;
1257
1259 void append(NBEdge* continuation);
1260
1262 bool hasSignalisedConnectionTo(const NBEdge* const e) const;
1263
1265 void moveOutgoingConnectionsFrom(NBEdge* e, int laneOff);
1266
1267 /* @brief return the turn destination if it exists
1268 * @param[in] possibleDestination Wether myPossibleTurnDestination should be returned if no turnaround connection
1269 * exists
1270 */
1271 NBEdge* getTurnDestination(bool possibleDestination = false) const;
1272
1274 std::string getLaneID(int lane) const;
1275
1277 double getLaneSpeed(int lane) const;
1278
1280 double getLaneFriction(int lane) const;
1281
1283 bool isNearEnough2BeJoined2(NBEdge* e, double threshold) const;
1284
1292 double getAngleAtNode(const NBNode* const node) const;
1293
1299 double getAngleAtNodeNormalized(const NBNode* const node) const;
1300
1309 double getAngleAtNodeToCenter(const NBNode* const node) const;
1310
1312 void incLaneNo(int by);
1313
1315 void decLaneNo(int by);
1316
1318 void deleteLane(int index, bool recompute, bool shiftIndices);
1319
1321 void addLane(int index, bool recomputeShape, bool recomputeConnections, bool shiftIndices);
1322
1325
1327 void addSidewalk(double width);
1328
1330 void restoreSidewalk(std::vector<NBEdge::Lane> oldLanes, PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);
1331
1333 void addBikeLane(double width);
1334
1336 void restoreBikelane(std::vector<NBEdge::Lane> oldLanes, PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);
1337
1339 void addRestrictedLane(double width, SUMOVehicleClass vclass);
1340
1342 void setPermissions(SVCPermissions permissions, int lane = -1);
1343
1345 void setPreferredVehicleClass(SVCPermissions permissions, int lane = -1);
1346
1348 void setPermittedChanging(int lane, SVCPermissions changeLeft, SVCPermissions changeRight);
1349
1351 void allowVehicleClass(int lane, SUMOVehicleClass vclass);
1352
1354 void disallowVehicleClass(int lane, SUMOVehicleClass vclass);
1355
1357 void preferVehicleClass(int lane, SVCPermissions vclasses);
1358
1360 void setLaneWidth(int lane, double width);
1361
1363 void setLaneType(int lane, const std::string& type);
1364
1366 void setEndOffset(int lane, double offset);
1367
1369 void setSpeed(int lane, double speed);
1370
1372 void setFriction(int lane, double friction);
1373
1376 bool setEdgeStopOffset(int lane, const StopOffset& offset, bool overwrite = false);
1377
1379 void setAcceleration(int lane, bool accelRamp);
1380
1384 }
1385
1386 bool isOffRamp() const {
1387 return myIsOffRamp;
1388 }
1389
1391 void setLaneShape(int lane, const PositionVector& shape);
1392
1394 SVCPermissions getPermissions(int lane = -1) const;
1395
1397 void setOrigID(const std::string origID, const bool append, const int laneIdx = -1);
1398
1400 void setDistance(double distance) {
1401 myDistance = distance;
1402 }
1403
1405 void setBidi(bool isBidi) {
1406 myIsBidi = isBidi;
1407 }
1408
1410 bool isBidi() {
1411 return myIsBidi;
1412 }
1413
1414 // @brief returns a reference to the internal structure for the convenience of netedit
1415 Lane& getLaneStruct(int lane) {
1416 assert(lane >= 0);
1417 assert(lane < (int)myLanes.size());
1418 return myLanes[lane];
1419 }
1420
1421 // @brief returns a reference to the internal structure for the convenience of netedit
1422 const Lane& getLaneStruct(int lane) const {
1423 assert(lane >= 0);
1424 assert(lane < (int)myLanes.size());
1425 return myLanes[lane];
1426 }
1427
1432
1433 /* @brief fill connection attributes shape, viaShape, ...
1434 *
1435 * @param[in,out] edgeIndex The number of connections already handled
1436 * @param[in,out] splitIndex The number of via edges already built
1437 * @param[in] tryIgnoreNodePositions Does not add node geometries if geom.size()>=2
1438 */
1439 double buildInnerEdges(const NBNode& n, int noInternalNoSplits, int& linkIndex, int& splitIndex);
1440
1442 inline const std::vector<NBSign>& getSigns() const {
1443 return mySigns;
1444 }
1445
1447 inline void addSign(NBSign sign) {
1448 mySigns.push_back(sign);
1449 }
1450
1453
1455 void setNodeBorder(const NBNode* node, const Position& p, const Position& p2, bool rectangularCut);
1456 const PositionVector& getNodeBorder(const NBNode* node) const;
1457 void resetNodeBorder(const NBNode* node);
1458
1460 bool isBidiRail(bool ignoreSpread = false) const;
1461
1463 bool isBidiEdge(bool checkPotential = false) const;
1464
1466 bool isRailDeadEnd() const;
1467
1469 void debugPrintConnections(bool outgoing = true, bool incoming = false) const;
1470
1472 static double firstIntersection(const PositionVector& v1, const PositionVector& v2, double width1, double width2, const std::string& error = "", bool secondIntersection = false);
1473
1477 static PositionVector startShapeAt(const PositionVector& laneShape, const NBNode* startNode, PositionVector nodeShape);
1478
1480
1481
1482 static inline double getTravelTimeStatic(const NBEdge* const edge, const NBVehicle* const /*veh*/, double /*time*/) {
1483 return edge->getLength() / edge->getSpeed();
1484 }
1485
1486 static int getLaneIndexFromLaneID(const std::string laneID);
1487
1489 void setNumericalID(int index) {
1490 myIndex = index;
1491 }
1492
1497 int getNumericalID() const {
1498 return myIndex;
1499 }
1500
1501 const NBEdge* getBidiEdge() const {
1502 return isBidiRail() || isBidiEdge() ? myPossibleTurnDestination : nullptr;
1503 }
1504
1508
1509
1513
1515 const std::string& getID() const {
1516 return Named::getID();
1517 }
1518
1520 bool joinLanes(SVCPermissions perms);
1521
1523 void resetLaneShapes();
1524
1527
1530 NBEdge* getStraightContinuation(SVCPermissions permissions) const;
1531
1534 NBEdge* getStraightPredecessor(SVCPermissions permissions) const;
1535
1537 NBEdge* guessOpposite(bool reguess = false);
1538
1539
1540 const std::string& getTurnSignTarget() const {
1541 return myTurnSignTarget;
1542 }
1543
1544 void setTurnSignTarget(const std::string& target) {
1545 myTurnSignTarget = target;
1546 }
1547
1549 static EdgeVector filterByPermissions(const EdgeVector& edges, SVCPermissions permissions);
1550
1551private:
1556 private:
1558 std::map<NBEdge*, std::vector<int> > myConnections;
1559
1562
1563 public:
1566 : myTransitions(transitions) { }
1567
1570
1572 void execute(const int lane, const int virtEdge);
1573
1575 const std::map<NBEdge*, std::vector<int> >& getBuiltConnections() const {
1576 return myConnections;
1577 }
1578
1579 private:
1582
1585 };
1586
1587
1596 public:
1598 enum class Direction {
1599 RIGHTMOST,
1600 LEFTMOST,
1601 FORWARD
1602 };
1603
1604 public:
1606 MainDirections(const EdgeVector& outgoing, NBEdge* parent, NBNode* to, const std::vector<int>& availableLanes);
1607
1610
1612 int getStraightest() const {
1613 return myStraightest;
1614 }
1615
1617 bool empty() const;
1618
1620 bool includes(Direction d) const;
1621
1622 private:
1625
1627 std::vector<Direction> myDirs;
1628
1631
1634 };
1635
1637 PositionVector computeLaneShape(int lane, double offset) const;
1638
1640 void computeLaneShapes();
1641
1642private:
1659 void init(int noLanes, bool tryIgnoreNodePositions, const std::string& origID);
1660
1662 void divideOnEdges(const EdgeVector* outgoing);
1663
1665 void divideSelectedLanesOnEdges(const EdgeVector* outgoing, const std::vector<int>& availableLanes);
1666
1668 void addStraightConnections(const EdgeVector* outgoing, const std::vector<int>& availableLanes, const std::vector<int>& priorities);
1669
1671 const std::vector<int> prepareEdgePriorities(const EdgeVector* outgoing, const std::vector<int>& availableLanes);
1672
1675
1678 void moveConnectionToLeft(int lane);
1679
1683 void moveConnectionToRight(int lane);
1684
1686 bool canMoveConnection(const Connection& con, int newFromLane) const;
1688
1690 void computeAngle();
1691
1693 bool bothLeftTurns(LinkDirection dir, const NBEdge* otherFrom, LinkDirection dir2) const;
1694 bool haveIntersection(const NBNode& n, const PositionVector& shape, const NBEdge* otherFrom, const NBEdge::Connection& otherCon,
1695 int numPoints, double width1, double width2, int shapeFlag = 0) const;
1696
1698 bool hasRestrictedLane(SUMOVehicleClass vclass) const;
1699
1701 void restoreRestrictedLane(SUMOVehicleClass vclass, std::vector<NBEdge::Lane> oldLanes, PositionVector oldGeometry, std::vector<NBEdge::Connection> oldConnections);
1702
1704 double assignInternalLaneLength(std::vector<Connection>::iterator i, int numLanes, double lengthSum, bool averageLength);
1705
1707 std::vector<LinkDirection> decodeTurnSigns(int turnSigns);
1708
1710 bool applyTurnSigns();
1711
1712private:
1717
1719 std::string myType;
1720
1723
1725 std::string myTurnSignTarget;
1726
1728 double myLength;
1729
1736
1739
1741 double mySpeed;
1742
1745
1748
1752 std::vector<Connection> myConnections;
1753
1755 std::vector<Connection> myConnectionsToDelete;
1756
1759
1762
1765
1768
1771
1774
1777
1783
1786
1790 std::vector<Lane> myLanes;
1791
1794
1797
1800
1802 std::string myStreetName;
1803
1805 std::vector<NBSign> mySigns;
1806
1810
1816
1819
1822
1825
1826 // @brief a static list of successor edges. Set by NBEdgeCont and requires reset when the network changes
1828
1829 // @brief a static list of successor edges. Set by NBEdgeCont and requires reset when the network changes
1831
1832 // @brief default length for overriding connection lengths
1834
1835public:
1836
1839 public:
1841 connections_toedge_finder(const NBEdge* const edge2find, bool hasFromLane = false) :
1842 myHasFromLane(hasFromLane),
1843 myEdge2Find(edge2find) { }
1844
1846 bool operator()(const Connection& c) const {
1847 return c.toEdge == myEdge2Find && (!myHasFromLane || c.fromLane != -1);
1848 }
1849
1850 private:
1852 const bool myHasFromLane;
1853
1855 const NBEdge* const myEdge2Find;
1856 };
1857
1860 public:
1862 connections_toedgelane_finder(const NBEdge* const edge2find, int lane2find, int fromLane2find) :
1863 myEdge2Find(edge2find),
1864 myLane2Find(lane2find),
1865 myFromLane2Find(fromLane2find) { }
1866
1868 bool operator()(const Connection& c) const {
1869 return c.toEdge == myEdge2Find && c.toLane == myLane2Find && (myFromLane2Find < 0 || c.fromLane == myFromLane2Find);
1870 }
1871
1872 private:
1874 const NBEdge* const myEdge2Find;
1875
1878
1881 };
1882
1885 public:
1887 connections_finder(int fromLane, NBEdge* const edge2find, int lane2find, bool invertEdge2find = false) :
1888 myFromLane(fromLane), myEdge2Find(edge2find), myLane2Find(lane2find), myInvertEdge2find(invertEdge2find) { }
1889
1891 bool operator()(const Connection& c) const {
1892 return ((c.fromLane == myFromLane || myFromLane == -1)
1894 && (c.toLane == myLane2Find || myLane2Find == -1));
1895 }
1896
1897 private:
1900
1903
1906
1909 };
1910
1913 public:
1915 connections_conflict_finder(int fromLane, NBEdge* const edge2find, bool checkRight) :
1916 myFromLane(fromLane), myEdge2Find(edge2find), myCheckRight(checkRight) { }
1917
1919 bool operator()(const Connection& c) const {
1920 return (((myCheckRight && c.fromLane < myFromLane) || (!myCheckRight && c.fromLane > myFromLane))
1921 && c.fromLane >= 0 // already assigned
1922 && c.toEdge == myEdge2Find);
1923 }
1924
1925 private:
1928
1931
1934 };
1935
1938 public:
1940 connections_fromlane_finder(int lane2find) : myLane2Find(lane2find) { }
1941
1943 bool operator()(const Connection& c) const {
1944 return c.fromLane == myLane2Find;
1945 }
1946
1947 private:
1950
1951 private:
1954 };
1955
1957 static bool connections_sorter(const Connection& c1, const Connection& c2);
1958
1964 public:
1967
1968 public:
1970 int operator()(const Connection& c1, const Connection& c2) const;
1971
1972 private:
1975 };
1976
1977private:
1979 NBEdge(const NBEdge& s) = delete;
1980
1982 NBEdge& operator=(const NBEdge& s) = delete;
1983
1985 NBEdge();
1986};
std::vector< std::pair< const NBRouterEdge *, const NBRouterEdge * > > ConstRouterEdgePairVector
Definition NBCont.h:46
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition NBCont.h:42
KeepClear
keepClear status of connections
Definition NBCont.h:58
@ KEEPCLEAR_UNSPECIFIED
Definition NBCont.h:61
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_IGNORING
vehicles ignoring classes
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
LaneSpreadFunction
Numbers representing special SUMO-XML-attribute values Information how the edge's lateral offset shal...
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)....
#define UNUSED_PARAMETER(x)
Definition StdDefs.h:30
A road/street connecting two junctions (netedit-version)
Definition GNEEdge.h:53
This lane is powered by an underlying GNEEdge and basically knows how to draw itself.
Definition GNELane.h:46
Holds (- relative to the edge it is build from -!!!) the list of main directions a vehicle that drive...
Definition NBEdge.h:1595
bool empty() const
returns the information whether no following street has a higher priority
Definition NBEdge.cpp:222
MainDirections(const MainDirections &)=delete
Invalidated copy constructor.
bool includes(Direction d) const
returns the information whether the street in the given direction has a higher priority
Definition NBEdge.cpp:228
int getStraightest() const
returns the index of the straightmost among the given outgoing edges
Definition NBEdge.h:1612
std::vector< Direction > myDirs
list of the main direction within the following junction relative to the edge
Definition NBEdge.h:1627
~MainDirections()
destructor
Definition NBEdge.cpp:218
MainDirections & operator=(const MainDirections &)=delete
Invalidated assignment operator.
int myStraightest
the index of the straightmost among the given outgoing edges
Definition NBEdge.h:1624
Direction
enum of possible directions
Definition NBEdge.h:1598
A class that being a bresenham-callback assigns the incoming lanes to the edges.
Definition NBEdge.h:1555
const std::map< NBEdge *, std::vector< int > > & getBuiltConnections() const
get built connections
Definition NBEdge.h:1575
ToEdgeConnectionsAdder(const ToEdgeConnectionsAdder &)=delete
Invalidated copy constructor.
ToEdgeConnectionsAdder & operator=(const ToEdgeConnectionsAdder &)=delete
Invalidated assignment operator.
~ToEdgeConnectionsAdder()
destructor
Definition NBEdge.h:1569
ToEdgeConnectionsAdder(const EdgeVector &transitions)
constructor
Definition NBEdge.h:1565
const EdgeVector & myTransitions
the transition from the virtual lane to the edge it belongs to
Definition NBEdge.h:1561
void execute(const int lane, const int virtEdge)
executes a bresenham - step
Definition NBEdge.cpp:134
std::map< NBEdge *, std::vector< int > > myConnections
map of edges to this edge's lanes that reach them
Definition NBEdge.h:1558
NBEdge *const myEdge2Find
edge to find
Definition NBEdge.h:1930
bool operator()(const Connection &c) const
operator ()
Definition NBEdge.h:1919
connections_conflict_finder(int fromLane, NBEdge *const edge2find, bool checkRight)
constructor
Definition NBEdge.h:1915
bool myCheckRight
check if is right
Definition NBEdge.h:1933
int myFromLane
index of from lane
Definition NBEdge.h:1927
int myLane2Find
lane to find
Definition NBEdge.h:1905
bool operator()(const Connection &c) const
operator ()
Definition NBEdge.h:1891
connections_finder(int fromLane, NBEdge *const edge2find, int lane2find, bool invertEdge2find=false)
constructor
Definition NBEdge.h:1887
NBEdge *const myEdge2Find
edge to find
Definition NBEdge.h:1902
int myFromLane
index of from lane
Definition NBEdge.h:1899
bool myInvertEdge2find
invert edge to find
Definition NBEdge.h:1908
int myLane2Find
index of lane to find
Definition NBEdge.h:1949
bool operator()(const Connection &c) const
operator ()
Definition NBEdge.h:1943
connections_fromlane_finder & operator=(const connections_fromlane_finder &s)=delete
invalidated assignment operator
connections_fromlane_finder(int lane2find)
@briefconstructor
Definition NBEdge.h:1940
Class to sort edges by their angle.
Definition NBEdge.h:1963
NBEdge * myEdge
the edge to compute the relative angle of
Definition NBEdge.h:1974
int operator()(const Connection &c1, const Connection &c2) const
comparing operation
Definition NBEdge.cpp:237
connections_relative_edgelane_sorter(NBEdge *e)
constructor
Definition NBEdge.h:1966
connections_toedge_finder(const NBEdge *const edge2find, bool hasFromLane=false)
constructor
Definition NBEdge.h:1841
const bool myHasFromLane
check if has from lane
Definition NBEdge.h:1852
bool operator()(const Connection &c) const
operator ()
Definition NBEdge.h:1846
const NBEdge *const myEdge2Find
edge to find
Definition NBEdge.h:1855
bool operator()(const Connection &c) const
operator ()
Definition NBEdge.h:1868
int myFromLane2Find
from lane to find
Definition NBEdge.h:1880
const NBEdge *const myEdge2Find
edge to find
Definition NBEdge.h:1874
connections_toedgelane_finder(const NBEdge *const edge2find, int lane2find, int fromLane2find)
constructor
Definition NBEdge.h:1862
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:92
void setStreetName(const std::string &name)
sets the street name of this edge
Definition NBEdge.h:664
void reinit(NBNode *from, NBNode *to, const std::string &type, double speed, double friction, int nolanes, int priority, PositionVector geom, double width, double endOffset, const std::string &streetName, LaneSpreadFunction spread, bool tryIgnoreNodePositions=false)
Resets initial values.
Definition NBEdge.cpp:378
void addGeometryPoint(int index, const Position &p)
Adds a further geometry point.
Definition NBEdge.cpp:954
void mirrorX()
mirror coordinates along the x-axis
Definition NBEdge.cpp:562
void setPreferredVehicleClass(SVCPermissions permissions, int lane=-1)
set preferred Vehicle Class
Definition NBEdge.cpp:4209
double getLaneSpeed(int lane) const
get lane speed
Definition NBEdge.cpp:2129
NBEdge * guessOpposite(bool reguess=false)
set oppositeID and return opposite edge if found
Definition NBEdge.cpp:4738
void setPermittedChanging(int lane, SVCPermissions changeLeft, SVCPermissions changeRight)
set allowed classes for changing to the left and right from the given lane
Definition NBEdge.cpp:4223
double getLength() const
Returns the computed length of the edge.
Definition NBEdge.h:583
double myLaneWidth
This width of this edge's lanes.
Definition NBEdge.h:1785
SVCPermissions getPermissions(int lane=-1) const
get the union of allowed classes over all lanes or for a specific lane
Definition NBEdge.cpp:4232
std::vector< Connection > myConnectionsToDelete
List of connections marked for delayed removal.
Definition NBEdge.h:1755
const EdgeVector * getConnectedSorted()
Returns the list of outgoing edges without the turnaround sorted in clockwise direction.
Definition NBEdge.cpp:1278
double getDistancAt(double pos) const
get distance at the given offset
Definition NBEdge.cpp:4766
double myEndOffset
This edges's offset to the intersection begin (will be applied to all lanes)
Definition NBEdge.h:1776
const std::vector< Connection > & getConnections() const
Returns the connections.
Definition NBEdge.h:1027
int myToJunctionPriority
The priority normalised for the node the edge is incoming in.
Definition NBEdge.h:1767
const Position & getSignalPosition() const
Returns the position of a traffic signal on this edge.
Definition NBEdge.h:702
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:4195
bool isInsideTLS() const
Returns whether this edge was marked as being within an intersection.
Definition NBEdge.h:1134
StopOffset myEdgeStopOffset
A vClass specific stop offset - assumed of length 0 (unspecified) or 1. For the latter case the int i...
Definition NBEdge.h:1782
JunctionPriority
junction priority values set by setJunctionPriority
Definition NBEdge.h:374
@ ROUNDABOUT
Definition NBEdge.h:377
@ PRIORITY_ROAD
Definition NBEdge.h:376
@ MINOR_ROAD
Definition NBEdge.h:375
double getLoadedLength() const
Returns the length was set explicitly or the computed length if it wasn't set.
Definition NBEdge.h:592
double getCrossingAngle(NBNode *node)
return the angle for computing pedestrian crossings at the given node
Definition NBEdge.cpp:4384
const Lane & getLaneStruct(int lane) const
Definition NBEdge.h:1422
void addBikeLane(double width)
add a bicycle lane of the given width and shift existing connctions
Definition NBEdge.cpp:4437
bool expandableBy(NBEdge *possContinuation, std::string &reason) const
Check if Node is expandable.
Definition NBEdge.cpp:3685
double getLaneFriction(int lane) const
get lane friction of specified lane
Definition NBEdge.cpp:2135
void init(int noLanes, bool tryIgnoreNodePositions, const std::string &origID)
Initialization routines common to all constructors.
Definition NBEdge.cpp:455
void setSpeed(int lane, double speed)
set lane specific speed (negative lane implies set for all lanes)
Definition NBEdge.cpp:4147
void reinitNodes(NBNode *from, NBNode *to)
Resets nodes but keeps all other values the same (used when joining)
Definition NBEdge.cpp:429
double mySpeed
The maximal speed.
Definition NBEdge.h:1741
bool hasLaneSpecificFriction() const
whether lanes differ in friction
Definition NBEdge.cpp:2381
double getLaneWidth() const
Returns the default width of lanes of this edge.
Definition NBEdge.h:632
PositionVector getCWBoundaryLine(const NBNode &n) const
get the outer boundary of this edge when going clock-wise around the given node
Definition NBEdge.cpp:3649
NBNode * getToNode() const
Returns the destination node of the edge.
Definition NBEdge.h:536
std::vector< Connection > myConnections
List of connections to following edges.
Definition NBEdge.h:1752
Connection & getConnectionRef(int fromLane, const NBEdge *to, int toLane)
Returns reference to the specified connection This method goes through "myConnections" and returns th...
Definition NBEdge.cpp:1247
NBEdge()
constructor for dummy edge
Definition NBEdge.cpp:355
void divideOnEdges(const EdgeVector *outgoing)
divides the lanes on the outgoing edges
Definition NBEdge.cpp:3066
ConstRouterEdgePairVector myViaSuccessors
Definition NBEdge.h:1830
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:3667
double buildInnerEdges(const NBNode &n, int noInternalNoSplits, int &linkIndex, int &splitIndex)
Definition NBEdge.cpp:1622
static const double UNSPECIFIED_FRICTION
unspecified lane friction
Definition NBEdge.h:350
void incLaneNo(int by)
increment lane
Definition NBEdge.cpp:3928
static EdgeVector filterByPermissions(const EdgeVector &edges, SVCPermissions permissions)
return only those edges that permit at least one of the give permissions
Definition NBEdge.cpp:4696
Lane & getLaneStruct(int lane)
Definition NBEdge.h:1415
const Connection & getConnection(int fromLane, const NBEdge *to, int toLane) const
Returns the specified connection (unmodifiable) This method goes through "myConnections" and returns ...
Definition NBEdge.cpp:1235
const std::vector< NBSign > & getSigns() const
get Signs
Definition NBEdge.h:1442
void addLane(int index, bool recomputeShape, bool recomputeConnections, bool shiftIndices)
add lane
Definition NBEdge.cpp:3884
void markOffRamp(bool isOffRamp)
marks this edge has being an offRamp or leading to one (used for connection computation)
Definition NBEdge.h:1382
bool hasLaneSpecificSpeed() const
whether lanes differ in speed
Definition NBEdge.cpp:2371
void setAverageLengthWithOpposite(double val)
patch average lane length in regard to the opposite edge
Definition NBEdge.cpp:4252
void disallowVehicleClass(int lane, SUMOVehicleClass vclass)
set disallowed class for the given lane or for all lanes if -1 is given
Definition NBEdge.cpp:3991
double getShapeStartAngle() const
Returns the angle at the start of the edge.
Definition NBEdge.cpp:2330
static const int UNSPECIFIED_INTERNAL_LANE_INDEX
internal lane computation not yet done
Definition NBEdge.h:368
bool isBidi()
return whether this edge should be a bidi edge
Definition NBEdge.h:1410
void appendTurnaround(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike, bool checkPermissions)
Add a connection to the previously computed turnaround, if wished and a turning direction exists (myT...
Definition NBEdge.cpp:3436
static bool connections_sorter(const Connection &c1, const Connection &c2)
connections_sorter sort by fromLane, toEdge and toLane
Definition NBEdge.cpp:4267
std::string myType
The type of the edge.
Definition NBEdge.h:1719
const PositionVector & getGeometry() const
Returns the geometry of the edge.
Definition NBEdge.h:771
bool hasPermissions() const
whether at least one lane has restrictions
Definition NBEdge.cpp:2346
double myTotalAngle
Definition NBEdge.h:1734
std::vector< Connection > & getConnections()
Returns the connections.
Definition NBEdge.h:1034
LaneSpreadFunction getLaneSpreadFunction() const
Returns how this edge's lanes' lateral offset is computed.
Definition NBEdge.cpp:948
bool hasDefaultGeometryEndpoints() const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
Definition NBEdge.cpp:594
std::string myTurnSignTarget
node for which turnSign information applies
Definition NBEdge.h:1725
bool isBidiRail(bool ignoreSpread=false) const
whether this edge is part of a bidirectional railway
Definition NBEdge.cpp:729
static const bool UNSPECIFIED_CONNECTION_UNCONTROLLED
TLS-controlled despite its node controlled not specified.
Definition NBEdge.h:371
const EdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges for the given vClass.
Definition NBEdge.cpp:4611
std::vector< LinkDirection > decodeTurnSigns(int turnSigns)
decode bitset
Definition NBEdge.cpp:2587
void dismissVehicleClassInformation()
dimiss vehicle class information
Definition NBEdge.cpp:4258
bool computeEdge2Edges(bool noLeftMovers)
computes the edge (step1: computation of approached edges)
Definition NBEdge.cpp:2496
EdgeBuildingStep getStep() const
The building step of this edge.
Definition NBEdge.h:625
void setInsideTLS(bool inside)
Marks this edge being within an intersection.
Definition NBEdge.h:1127
LaneSpreadFunction myLaneSpreadFunction
The information about how to spread the lanes.
Definition NBEdge.h:1773
void moveConnectionToLeft(int lane)
Definition NBEdge.cpp:1594
void updateChangeRestrictions(SVCPermissions ignoring)
modify all existing restrictions on lane changing
Definition NBEdge.cpp:2147
void restoreBikelane(std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore an previously added BikeLane
Definition NBEdge.cpp:4443
Position getEndpointAtNode(const NBNode *node) const
Definition NBEdge.cpp:612
NBEdge * getStraightContinuation(SVCPermissions permissions) const
return the straightest follower edge for the given permissions or nullptr (never returns turn-arounds...
Definition NBEdge.cpp:4707
bool hasLoadedLength() const
Returns whether a length was set explicitly.
Definition NBEdge.h:602
void restoreSidewalk(std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore an previously added sidewalk
Definition NBEdge.cpp:4431
bool addEdge2EdgeConnection(NBEdge *dest, bool overrideRemoval=false, SVCPermissions permission=SVC_UNSPECIFIED)
Adds a connection to another edge.
Definition NBEdge.cpp:1032
bool addLane2LaneConnection(int fromLane, NBEdge *dest, int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, KeepClear keepClear=KEEPCLEAR_UNSPECIFIED, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, double friction=UNSPECIFIED_FRICTION, double length=myDefaultConnectionLength, const PositionVector &customShape=PositionVector::EMPTY, const bool uncontrolled=UNSPECIFIED_CONNECTION_UNCONTROLLED, SVCPermissions permissions=SVC_UNSPECIFIED, const bool indirectLeft=false, const std::string &edgeType="", SVCPermissions changeLeft=SVC_UNSPECIFIED, SVCPermissions changeRight=SVC_UNSPECIFIED, bool postProcess=false)
Adds a connection between the specified this edge's lane and an approached one.
Definition NBEdge.cpp:1067
void divideSelectedLanesOnEdges(const EdgeVector *outgoing, const std::vector< int > &availableLanes)
divide selected lanes on edges
Definition NBEdge.cpp:3156
int getNumericalID() const
Returns the index (numeric id) of the edge.
Definition NBEdge.h:1497
void setTurnSignTarget(const std::string &target)
Definition NBEdge.h:1544
void setDistance(double distance)
set kilometrage at start of edge (negative value implies couting down along the edge)
Definition NBEdge.h:1400
static double getTravelTimeStatic(const NBEdge *const edge, const NBVehicle *const, double)
Definition NBEdge.h:1482
bool setEdgeStopOffset(int lane, const StopOffset &offset, bool overwrite=false)
set lane and vehicle class specific stopOffset (negative lane implies set for all lanes)
Definition NBEdge.cpp:4117
const std::vector< NBEdge::Lane > & getLanes() const
Returns the lane definitions.
Definition NBEdge.h:720
bool hasLaneSpecificStopOffsets() const
whether lanes differ in stopOffsets
Definition NBEdge.cpp:2424
void setNodeBorder(const NBNode *node, const Position &p, const Position &p2, bool rectangularCut)
Set Node border.
Definition NBEdge.cpp:675
int getFirstNonPedestrianLaneIndex(int direction, bool exclusive=false) const
return the first lane with permissions other than SVC_PEDESTRIAN and 0
Definition NBEdge.cpp:4292
EdgeVector mySuccessors
Definition NBEdge.h:1827
void shiftToLanesToEdge(NBEdge *to, int laneOff)
modifify the toLane for all connections to the given edge
Definition NBEdge.cpp:4518
void checkGeometry(const double maxAngle, const double minRadius, bool fix, bool silent)
Check the angles of successive geometry segments.
Definition NBEdge.cpp:986
static double myDefaultConnectionLength
Definition NBEdge.h:1833
bool isNearEnough2BeJoined2(NBEdge *e, double threshold) const
Check if edge is near enought to be joined to another edge.
Definition NBEdge.cpp:3876
EdgeBuildingStep myStep
The building step.
Definition NBEdge.h:1716
void setLaneType(int lane, const std::string &type)
set lane specific type (negative lane implies set for all lanes)
Definition NBEdge.cpp:4033
bool computeLanes2Edges()
computes the edge, step2: computation of which lanes approach the edges)
Definition NBEdge.cpp:2552
EdgeBuildingStep
Current state of the edge within the building process.
Definition NBEdge.h:109
@ INIT_REJECT_CONNECTIONS
The edge has been loaded and connections shall not be added.
@ EDGE2EDGES
The relationships between edges are computed/loaded.
@ LANES2LANES_RECHECK
Lanes to lanes - relationships are computed; should be rechecked.
@ LANES2LANES_DONE
Lanes to lanes - relationships are computed; no recheck is necessary/wished.
@ LANES2EDGES
Lanes to edges - relationships are computed/loaded.
@ LANES2LANES_USER
Lanes to lanes - relationships are loaded; no recheck is necessary/wished.
@ INIT
The edge has been loaded, nothing is computed yet.
NBEdge * getStraightPredecessor(SVCPermissions permissions) const
return the straightest predecessor edge for the given permissions or nullptr (never returns turn-arou...
Definition NBEdge.cpp:4722
void remapConnections(const EdgeVector &incoming)
Remaps the connection in a way that allows the removal of it.
Definition NBEdge.cpp:1366
double getSpeed() const
Returns the speed allowed on this edge.
Definition NBEdge.h:609
~NBEdge()
Destructor.
Definition NBEdge.cpp:537
NBNode * myTo
Definition NBEdge.h:1722
double myEndAngle
Definition NBEdge.h:1733
const std::string & getID() const
Definition NBEdge.h:1515
int getFirstAllowedLaneIndex(int direction) const
return the first lane that permits at least 1 vClass or the last lane if search direction of there is...
Definition NBEdge.cpp:4335
bool allowsChangingRight(int lane, SUMOVehicleClass vclass) const
Returns whether the given vehicle class may change left from this lane.
Definition NBEdge.cpp:4378
double getDistance() const
get distance
Definition NBEdge.h:669
static const double UNSPECIFIED_LOADED_LENGTH
no length override given
Definition NBEdge.h:359
void setLaneWidth(int lane, double width)
set lane specific width (negative lane implies set for all lanes)
Definition NBEdge.cpp:4018
void resetLaneShapes()
reset lane shapes to what they would be before cutting with the junction shapes
Definition NBEdge.cpp:2141
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
Definition NBEdge.cpp:3578
bool bothLeftTurns(LinkDirection dir, const NBEdge *otherFrom, LinkDirection dir2) const
determine conflict between opposite left turns
Definition NBEdge.cpp:2032
void setAcceleration(int lane, bool accelRamp)
marks one lane as acceleration lane
Definition NBEdge.cpp:4179
const StopOffset & getEdgeStopOffset() const
Returns the stopOffset to the end of the edge.
Definition NBEdge.cpp:4085
NBNode * tryGetNodeAtPosition(double pos, double tolerance=5.0) const
Returns the node at the given edges length (using an epsilon)
Definition NBEdge.cpp:3529
void setLaneSpreadFunction(LaneSpreadFunction spread)
(Re)sets how the lanes lateral offset shall be computed
Definition NBEdge.cpp:942
void clearControllingTLInformation()
clears tlID for all connections
Definition NBEdge.cpp:3641
NBEdge & operator=(const NBEdge &s)=delete
invalidated assignment operator
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
Definition NBEdge.cpp:3516
void addStraightConnections(const EdgeVector *outgoing, const std::vector< int > &availableLanes, const std::vector< int > &priorities)
add some straight connections
Definition NBEdge.cpp:3261
bool hasLaneSpecificPermissions() const
whether lanes differ in allowed vehicle classes
Definition NBEdge.cpp:2357
bool needsLaneSpecificOutput() const
whether at least one lane has values differing from the edges values
Definition NBEdge.cpp:2479
void computeAngle()
computes the angle of this edge and stores it in myAngle
Definition NBEdge.cpp:2232
bool isBidiEdge(bool checkPotential=false) const
whether this edge is part of a bidirectional edge pair
Definition NBEdge.cpp:741
void setBidi(bool isBidi)
mark this edge as a bidi edge
Definition NBEdge.h:1405
static const double UNSPECIFIED_SIGNAL_OFFSET
unspecified signal offset
Definition NBEdge.h:362
void addSidewalk(double width)
add a pedestrian sidewalk of the given width and shift existing connctions
Definition NBEdge.cpp:4425
bool hasSignalisedConnectionTo(const NBEdge *const e) const
Check if edge has signalised connections.
Definition NBEdge.cpp:3850
const NBNode * getSignalNode() const
Returns the node that (possibly) represents a traffic signal controlling at the end of this edge.
Definition NBEdge.h:707
std::vector< Lane > myLanes
Lane information.
Definition NBEdge.h:1790
int getNumLanes() const
Returns the number of lanes.
Definition NBEdge.h:510
std::vector< Connection > getConnectionsFromLane(int lane, const NBEdge *to=nullptr, int toLane=-1) const
Returns connections from a given lane.
Definition NBEdge.cpp:1221
bool hasAccelLane() const
whether one of the lanes is an acceleration lane
Definition NBEdge.cpp:2437
bool myIsBidi
whether this edge is part of a non-rail bidi edge pair
Definition NBEdge.h:1821
static double firstIntersection(const PositionVector &v1, const PositionVector &v2, double width1, double width2, const std::string &error="", bool secondIntersection=false)
compute the first intersection point between the given lane geometries considering their rspective wi...
Definition NBEdge.cpp:1968
PositionVector myToBorder
Definition NBEdge.h:1814
void extendGeometryAtNode(const NBNode *node, double maxExtent)
linearly extend the geometry at the given node
Definition NBEdge.cpp:638
void setFriction(int lane, double friction)
set lane specific friction (negative lane implies set for all lanes)
Definition NBEdge.cpp:4163
static const double UNSPECIFIED_CONTPOS
unspecified internal junction position
Definition NBEdge.h:353
static const double ANGLE_LOOKAHEAD
the distance at which to take the default angle
Definition NBEdge.h:365
void reduceGeometry(const double minDist)
Removes points with a distance lesser than the given.
Definition NBEdge.cpp:964
static NBEdge DummyEdge
Dummy edge to use when a reference must be supplied in the no-arguments constructor (FOX technicality...
Definition NBEdge.h:338
bool joinLanes(SVCPermissions perms)
join adjacent lanes with the given permissions
Definition NBEdge.cpp:4676
void resetNodeBorder(const NBNode *node)
Definition NBEdge.cpp:718
void markAsInLane2LaneState()
mark edge as in lane to state lane
Definition NBEdge.cpp:3971
bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const
return true if certain connection must be controlled by TLS
Definition NBEdge.cpp:3567
void addRestrictedLane(double width, SUMOVehicleClass vclass)
add a lane of the given width, restricted to the given class and shift existing connections
Definition NBEdge.cpp:4459
void removeFromConnections(NBEdge *toEdge, int fromLane=-1, int toLane=-1, bool tryLater=false, const bool adaptToLaneRemoval=false, const bool keepPossibleTurns=false)
Removes the specified connection(s)
Definition NBEdge.cpp:1382
double myLength
The length of the edge.
Definition NBEdge.h:1728
NBEdge::Lane getFirstNonPedestrianLane(int direction) const
@brif get first non-pedestrian lane
Definition NBEdge.cpp:4400
void invalidateConnections(bool reallowSetting=false)
invalidate current connections of edge
Definition NBEdge.cpp:1463
const std::vector< int > prepareEdgePriorities(const EdgeVector *outgoing, const std::vector< int > &availableLanes)
recomputes the edge priorities and manipulates them for a distribution of lanes on edges which is mor...
Definition NBEdge.cpp:3343
int myIndex
the index of the edge in the list of all edges. Set by NBEdgeCont and requires re-set whenever the li...
Definition NBEdge.h:1824
double getTotalWidth() const
Returns the combined width of all lanes of this edge.
Definition NBEdge.cpp:4070
PositionVector cutAtIntersection(const PositionVector &old) const
cut shape at the intersection shapes
Definition NBEdge.cpp:774
Position geometryPositionAtOffset(double offset) const
return position taking into account loaded length
Definition NBEdge.cpp:4554
static const double UNSPECIFIED_VISIBILITY_DISTANCE
unspecified foe visibility for connections
Definition NBEdge.h:356
bool canMoveConnection(const Connection &con, int newFromLane) const
whether the connection can originate on newFromLane
Definition NBEdge.cpp:1585
double getInternalLaneWidth(const NBNode &node, const NBEdge::Connection &connection, const NBEdge::Lane &successor, bool isVia) const
Returns the width of the internal lane associated with the connection.
Definition NBEdge.cpp:4054
void allowVehicleClass(int lane, SUMOVehicleClass vclass)
set allowed class for the given lane or for all lanes if -1 is given
Definition NBEdge.cpp:3978
bool isConnectedTo(const NBEdge *e, const bool ignoreTurnaround=false) const
Returns the information whethe a connection to the given edge has been added (or computed)
Definition NBEdge.cpp:1265
void addSign(NBSign sign)
add Sign
Definition NBEdge.h:1447
double getMaxLaneOffset()
get max lane offset
Definition NBEdge.cpp:3561
void deleteLane(int index, bool recompute, bool shiftIndices)
delete lane
Definition NBEdge.cpp:3939
std::vector< NBSign > mySigns
the street signs along this edge
Definition NBEdge.h:1805
NBEdge * myPossibleTurnDestination
The edge that would be the turn destination if there was one.
Definition NBEdge.h:1761
const PositionVector & getNodeBorder(const NBNode *node) const
Definition NBEdge.cpp:707
int getNumLanesThatAllow(SVCPermissions permissions) const
get lane indices that allow the given permissions
Definition NBEdge.cpp:4361
const NBNode * mySignalNode
Definition NBEdge.h:1809
bool hasLaneSpecificWidth() const
whether lanes differ in width
Definition NBEdge.cpp:2391
void setNumericalID(int index)
sets the index of the edge in the list of all network edges
Definition NBEdge.h:1489
void moveConnectionToRight(int lane)
Definition NBEdge.cpp:1609
std::set< SVCPermissions > getPermissionVariants(int iStart, int iEnd) const
return all permission variants within the specified lane range [iStart, iEnd[
Definition NBEdge.cpp:4349
void reshiftPosition(double xoff, double yoff)
Applies an offset to the edge.
Definition NBEdge.cpp:542
void moveOutgoingConnectionsFrom(NBEdge *e, int laneOff)
move outgoing connection
Definition NBEdge.cpp:3543
std::string getLaneID(int lane) const
get lane ID
Definition NBEdge.cpp:3870
bool myIsOffRamp
whether this edge is an Off-Ramp or leads to one
Definition NBEdge.h:1818
static const double UNSPECIFIED_SPEED
unspecified lane speed
Definition NBEdge.h:347
Lane2LaneInfoType
Modes of setting connections between lanes.
Definition NBEdge.h:130
@ USER
The connection was given by the user.
@ VALIDATED
The connection was computed and validated.
@ COMPUTED
The connection was computed.
double getFriction() const
Returns the friction on this edge.
Definition NBEdge.h:616
static PositionVector startShapeAt(const PositionVector &laneShape, const NBNode *startNode, PositionVector nodeShape)
Definition NBEdge.cpp:876
std::string getSidewalkID()
get the lane id for the canonical sidewalk lane
Definition NBEdge.cpp:4409
std::vector< int > getConnectionLanes(NBEdge *currentOutgoing, bool withBikes=true) const
Returns the list of lanes that may be used to reach the given edge.
Definition NBEdge.cpp:1340
void computeLaneShapes()
compute lane shapes
Definition NBEdge.cpp:2168
double getStartAngle() const
Returns the angle at the start of the edge (relative to the node shape center) The angle is computed ...
Definition NBEdge.h:545
double 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:2105
int getSpecialLane(SVCPermissions permissions) const
return index of the first lane that allows the given permissions
Definition NBEdge.cpp:4325
bool setConnection(int lane, NBEdge *destEdge, int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false, KeepClear keepClear=KEEPCLEAR_UNSPECIFIED, double contPos=UNSPECIFIED_CONTPOS, double visibility=UNSPECIFIED_VISIBILITY_DISTANCE, double speed=UNSPECIFIED_SPEED, double friction=UNSPECIFIED_FRICTION, double length=myDefaultConnectionLength, const PositionVector &customShape=PositionVector::EMPTY, const bool uncontrolled=UNSPECIFIED_CONNECTION_UNCONTROLLED, SVCPermissions permissions=SVC_UNSPECIFIED, bool indirectLeft=false, const std::string &edgeType="", SVCPermissions changeLeft=SVC_UNSPECIFIED, SVCPermissions changeRight=SVC_UNSPECIFIED, bool postProcess=false)
Adds a connection to a certain lane of a certain edge.
Definition NBEdge.cpp:1120
bool hasLaneSpecificEndOffset() const
whether lanes differ in offset
Definition NBEdge.cpp:2413
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
Definition NBEdge.cpp:2051
double myDistance
The mileage/kilometrage at the start of this edge in a linear coordination system.
Definition NBEdge.h:1747
bool isOffRamp() const
Definition NBEdge.h:1386
const std::string & getTypeID() const
get ID of type
Definition NBEdge.h:1167
bool myAmMacroscopicConnector
Information whether this edge is a (macroscopic) connector.
Definition NBEdge.h:1799
EdgeVector getConnectedEdges() const
Returns the list of outgoing edges unsorted.
Definition NBEdge.cpp:1315
const ConstRouterEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges for the given vClass.
Definition NBEdge.cpp:4629
const std::string & getStreetName() const
Returns the street name of this edge.
Definition NBEdge.h:659
void setLaneShape(int lane, const PositionVector &shape)
sets a custom lane shape
Definition NBEdge.cpp:4187
double myLoadedLength
An optional length to use (-1 if not valid)
Definition NBEdge.h:1793
static void setDefaultConnectionLength(double length)
Definition NBEdge.h:380
void sortOutgoingConnectionsByAngle()
sorts the outgoing connections by their angle relative to their junction
Definition NBEdge.cpp:1354
bool applyTurnSigns()
apply loaded turn sign information
Definition NBEdge.cpp:2599
bool haveIntersection(const NBNode &n, const PositionVector &shape, const NBEdge *otherFrom, const NBEdge::Connection &otherCon, int numPoints, double width1, double width2, int shapeFlag=0) const
Definition NBEdge.cpp:2041
NBEdge(const NBEdge &s)=delete
invalidated copy constructor
void preferVehicleClass(int lane, SVCPermissions vclasses)
prefer certain vehicle classes for the given lane or for all lanes if -1 is given (ensures also permi...
Definition NBEdge.cpp:4004
const NBEdge * getBidiEdge() const
Definition NBEdge.h:1501
NBNode * getFromNode() const
Returns the origin node of the edge.
Definition NBEdge.h:529
double myStartAngle
The angles of the edge.
Definition NBEdge.h:1732
double getAngleAtNodeNormalized(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node and disregards edge direction.
Definition NBEdge.cpp:2088
NBEdge * getTurnDestination(bool possibleDestination=false) const
Definition NBEdge.cpp:3861
void shiftPositionAtNode(NBNode *node, NBEdge *opposite)
shift geometry at the given node to avoid overlap
Definition NBEdge.cpp:4529
double getAngleAtNode(const NBNode *const node) const
Returns the angle of the edge's geometry at the given node.
Definition NBEdge.cpp:2077
bool hasLaneSpecificType() const
whether lanes differ in type
Definition NBEdge.cpp:2402
PositionVector myFromBorder
intersection borders (because the node shape might be invalid)
Definition NBEdge.h:1813
double getSignalOffset() const
Returns the offset of a traffic signal from the end of this edge.
Definition NBEdge.cpp:4279
bool hasDefaultGeometry() const
Returns whether the geometry consists only of the node positions.
Definition NBEdge.cpp:588
void setPriority(int priority)
Sets the priority of the edge.
Definition NBEdge.h:522
double getTotalAngle() const
Returns the angle at the start of the edge.
Definition NBEdge.h:576
bool myAmInTLS
Information whether this is lies within a joined tls.
Definition NBEdge.h:1796
void setTurningDestination(NBEdge *e, bool onlyPossible=false)
Sets the turing destination at the given edge.
Definition NBEdge.cpp:2120
bool hasDefaultGeometryEndpointAtNode(const NBNode *node) const
Returns whether the geometry is terminated by the node positions This default may be violated by init...
Definition NBEdge.cpp:601
NBEdge * myTurnDestination
The turn destination edge (if a connection exists)
Definition NBEdge.h:1758
int getPriority() const
Returns the priority of the edge.
Definition NBEdge.h:517
void computeEdgeShape(double smoothElevationThreshold=-1)
Recomputeds the lane shapes to terminate at the node shape For every lane the intersection with the f...
Definition NBEdge.cpp:835
double assignInternalLaneLength(std::vector< Connection >::iterator i, int numLanes, double lengthSum, bool averageLength)
assign length to all lanes of an internal edge
Definition NBEdge.cpp:1928
static const double UNSPECIFIED_WIDTH
unspecified lane width
Definition NBEdge.h:341
bool hasRestrictedLane(SUMOVehicleClass vclass) const
returns whether any lane already allows the given vclass exclusively
Definition NBEdge.cpp:4448
void copyConnectionsFrom(NBEdge *src)
copy connections from antoher edge
Definition NBEdge.cpp:1578
double getEndAngle() const
Returns the angle at the end of the edge (relative to the node shape center) The angle is computed in...
Definition NBEdge.h:554
const StopOffset & getLaneStopOffset(int lane) const
Returns the stop offset to the specified lane's end.
Definition NBEdge.cpp:4091
void debugPrintConnections(bool outgoing=true, bool incoming=false) const
debugging helper to print all connections
Definition NBEdge.cpp:4652
Position mySignalPosition
the position of a traffic light signal on this edge
Definition NBEdge.h:1808
void replaceInConnections(NBEdge *which, NBEdge *by, int laneOff)
replace in current connections of edge
Definition NBEdge.cpp:1475
bool lanesWereAssigned() const
Check if lanes were assigned.
Definition NBEdge.cpp:3555
void restoreRestrictedLane(SUMOVehicleClass vclass, std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
restore a restricted lane
Definition NBEdge.cpp:4495
void declareConnectionsAsLoaded(EdgeBuildingStep step=EdgeBuildingStep::LANES2LANES_USER)
declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has ...
Definition NBEdge.h:1429
double getEndOffset() const
Returns the offset to the destination node.
Definition NBEdge.h:679
bool isRailDeadEnd() const
whether this edge is a railway edge that does not continue
Definition NBEdge.cpp:759
double myFriction
The current friction.
Definition NBEdge.h:1744
void setEndOffset(int lane, double offset)
set lane specific end-offset (negative lane implies set for all lanes)
Definition NBEdge.cpp:4101
static const double UNSPECIFIED_OFFSET
unspecified lane offset
Definition NBEdge.h:344
void sortOutgoingConnectionsByIndex()
sorts the outgoing connections by their from-lane-index and their to-lane-index
Definition NBEdge.cpp:1360
bool recheckLanes()
recheck whether all lanes within the edge are all right and optimises the connections once again
Definition NBEdge.cpp:2790
int myFromJunctionPriority
The priority normalised for the node the edge is outgoing of.
Definition NBEdge.h:1764
bool addLane2LaneConnections(int fromLane, NBEdge *dest, int toLane, int no, Lane2LaneInfoType type, bool invalidatePrevious=false, bool mayDefinitelyPass=false)
Builds no connections starting at the given lanes.
Definition NBEdge.cpp:1103
void setOrigID(const std::string origID, const bool append, const int laneIdx=-1)
set origID for all lanes or for a specific lane
Definition NBEdge.cpp:4586
PositionVector computeLaneShape(int lane, double offset) const
Computes the shape for the given lane.
Definition NBEdge.cpp:2220
bool allowsChangingLeft(int lane, SUMOVehicleClass vclass) const
Returns whether the given vehicle class may change left from this lane.
Definition NBEdge.cpp:4372
static int getLaneIndexFromLaneID(const std::string laneID)
Definition NBEdge.cpp:4671
bool hasConnectionTo(const NBEdge *destEdge, int destLane, int fromLane=-1) const
Retrieves info about a connection to a certain lane of a certain edge.
Definition NBEdge.cpp:1259
bool isMacroscopicConnector() const
Returns whether this edge was marked as a macroscopic connector.
Definition NBEdge.h:1122
void setAsMacroscopicConnector()
Definition NBEdge.h:1115
bool hasCustomLaneShape() const
whether one of the lanes has a custom shape
Definition NBEdge.cpp:2448
bool hasLaneParams() const
whether one of the lanes has parameters set
Definition NBEdge.cpp:2459
const PositionVector & getLaneShape(int i) const
Returns the shape of the nth lane.
Definition NBEdge.cpp:936
double getShapeEndAngle() const
Returns the angle at the end of the edge.
Definition NBEdge.cpp:2338
bool prohibitsChanging() const
whether one of the lanes prohibits lane changing
Definition NBEdge.cpp:2469
void setLoadedLength(double val)
set loaded length
Definition NBEdge.cpp:4247
const std::string & getTurnSignTarget() const
Definition NBEdge.h:1540
PositionVector myGeom
The geometry for the edge.
Definition NBEdge.h:1770
const PositionVector getInnerGeometry() const
Returns the geometry of the edge without the endpoints.
Definition NBEdge.cpp:582
void setSignalPosition(const Position &pos, const NBNode *signalNode)
sets the offset of a traffic signal from the end of this edge
Definition NBEdge.h:712
void decLaneNo(int by)
decrement lane
Definition NBEdge.cpp:3959
NBNode * myFrom
The source and the destination node.
Definition NBEdge.h:1722
void append(NBEdge *continuation)
append another edge
Definition NBEdge.cpp:3797
void setJunctionPriority(const NBNode *const node, int prio)
Sets the junction priority of the edge.
Definition NBEdge.cpp:2061
double getFinalLength() const
get length that will be assigned to the lanes in the final network
Definition NBEdge.cpp:4564
void shortenGeometryAtNode(const NBNode *node, double reduction)
linearly extend the geometry at the given node
Definition NBEdge.cpp:661
void setGeometry(const PositionVector &g, bool inner=false)
(Re)sets the edge's geometry
Definition NBEdge.cpp:617
int myPriority
The priority of the edge.
Definition NBEdge.h:1738
std::string myStreetName
The street name (or whatever arbitrary string you wish to attach)
Definition NBEdge.h:1802
EdgeVector getIncomingEdges() const
Returns the list of incoming edges unsorted.
Definition NBEdge.cpp:1327
int getFirstNonPedestrianNonBicycleLaneIndex(int direction, bool exclusive=false) const
return the first lane with permissions other than SVC_PEDESTRIAN, SVC_BICYCLE and 0
Definition NBEdge.cpp:4308
Container for nodes during the netbuilding process.
Definition NBNodeCont.h:57
Represents a single node (junction) during network building.
Definition NBNode.h:66
Superclass for NBEdge and NBEdge::Connection to initialize Router.
Definition NBEdge.h:62
virtual double getLength() const =0
virtual ~NBRouterEdge()
Definition NBEdge.h:64
static double getTravelTimeStatic(const NBRouterEdge *const edge, const NBVehicle *const, double)
Definition NBEdge.h:82
bool restricts(const NBVehicle *const) const
Definition NBEdge.h:77
virtual int getNumericalID() const =0
virtual bool isInternal() const
Definition NBEdge.h:71
bool prohibits(const NBVehicle *const) const
Definition NBEdge.h:74
virtual const ConstRouterEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const =0
virtual const std::string & getID() const =0
virtual const NBRouterEdge * getBidiEdge() const =0
virtual double getSpeed() const =0
A class representing a single street sign.
Definition NBSign.h:41
A vehicle as used by router.
Definition NBVehicle.h:42
Base class for objects which have an id.
Definition Named.h:54
const std::string & getID() const
Returns the id.
Definition Named.h:74
Static storage of an output device and its base (abstract) implementation.
An upper class for objects with additional parameters.
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
A list of positions.
double length() const
Returns the length.
static const PositionVector EMPTY
empty Vector
stop offset
A structure which describes a connection between edges or lanes.
Definition NBEdge.h:201
bool indirectLeft
Whether this connection is an indirect left turn.
Definition NBEdge.h:261
const std::string & getID() const
Definition NBEdge.h:311
int fromLane
The lane the connections starts at.
Definition NBEdge.h:210
std::string viaID
if Connection have a via, ID of it
Definition NBEdge.h:279
int toLane
The lane the connections yields in.
Definition NBEdge.h:216
std::vector< int > foeInternalLinks
FOE Internal links.
Definition NBEdge.h:288
SVCPermissions permissions
List of vehicle types that are allowed on this connection.
Definition NBEdge.h:252
const Connection * getBidiEdge() const
Definition NBEdge.h:324
int getNumericalID() const
Definition NBEdge.h:321
double speed
custom speed for connection
Definition NBEdge.h:240
NBEdge * toEdge
The edge the connections yields in.
Definition NBEdge.h:213
const ConstRouterEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Definition NBEdge.h:330
KeepClear keepClear
whether the junction must be kept clear when using this connection
Definition NBEdge.h:231
double getLength() const
Definition NBEdge.h:318
bool isInternal() const
Definition NBEdge.h:327
double getSpeed() const
Definition NBEdge.h:314
double customLength
custom length for connection
Definition NBEdge.h:246
std::string edgeType
optional type of Connection
Definition NBEdge.h:264
double vmax
maximum velocity
Definition NBEdge.h:273
bool uncontrolled
check if Connection is uncontrolled
Definition NBEdge.h:297
PositionVector customShape
custom shape for connection
Definition NBEdge.h:249
bool mayDefinitelyPass
Information about being definitely free to drive (on-ramps)
Definition NBEdge.h:228
SVCPermissions changeLeft
List of vehicle types that are allowed to change Left from this connections internal lane(s)
Definition NBEdge.h:255
SVCPermissions changeRight
List of vehicle types that are allowed to change right from this connections internal lane(s)
Definition NBEdge.h:258
PositionVector viaShape
shape of via
Definition NBEdge.h:282
std::string getDescription(const NBEdge *parent) const
get string describing this connection
Definition NBEdge.cpp:96
double contPos
custom position for internal junction on this connection
Definition NBEdge.h:234
std::string getInternalLaneID() const
get ID of internal lane
Definition NBEdge.cpp:90
int internalLaneIndex
The lane index of this internal lane within the internal edge.
Definition NBEdge.h:294
std::string tlID
The id of the traffic light that controls this connection.
Definition NBEdge.h:219
double visibility
custom foe visiblity for connection
Definition NBEdge.h:237
int tlLinkIndex2
The index of the internal junction within the controlling traffic light (optional)
Definition NBEdge.h:225
double length
computed length (average of all internal lane shape lengths that share an internal edge)
Definition NBEdge.h:306
PositionVector shape
shape of Connection
Definition NBEdge.h:270
std::string id
id of Connection
Definition NBEdge.h:267
std::vector< std::string > foeIncomingLanes
FOE Incomings lanes.
Definition NBEdge.h:291
bool haveVia
check if Connection have a Via
Definition NBEdge.h:276
int tlLinkIndex
The index of this connection within the controlling traffic light.
Definition NBEdge.h:222
double viaLength
the length of the via shape (maybe customized)
Definition NBEdge.h:285
static ConstRouterEdgePairVector myViaSuccessors
Definition NBEdge.h:310
An (internal) definition of a single lane of an edge.
Definition NBEdge.h:143
double width
This lane's width.
Definition NBEdge.h:176
StopOffset laneStopOffset
stopOffsets.second - The stop offset for vehicles stopping at the lane's end. Applies if vClass is in...
Definition NBEdge.h:173
int turnSigns
turning signs printed on the road, bitset of LinkDirection (imported from OSM)
Definition NBEdge.h:195
PositionVector customShape
A custom shape for this lane set by the user.
Definition NBEdge.h:189
double endOffset
This lane's offset to the intersection begin.
Definition NBEdge.h:169
std::string type
the type of this lane
Definition NBEdge.h:192
SVCPermissions preferred
List of vehicle types that are preferred on this lane.
Definition NBEdge.h:160
double speed
The speed allowed on this lane.
Definition NBEdge.h:151
std::string oppositeID
An opposite lane ID, if given.
Definition NBEdge.h:179
SVCPermissions changeRight
List of vehicle types that are allowed to change right from this lane.
Definition NBEdge.h:166
double friction
The friction on this lane.
Definition NBEdge.h:154
SVCPermissions changeLeft
List of vehicle types that are allowed to change Left from this lane.
Definition NBEdge.h:163
SVCPermissions permissions
List of vehicle types that are allowed on this lane.
Definition NBEdge.h:157
bool connectionsDone
Whether connection information for this lane is already completed.
Definition NBEdge.h:186
bool accelRamp
Whether this lane is an acceleration lane.
Definition NBEdge.h:182
PositionVector shape
The lane's shape.
Definition NBEdge.h:148