Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
NBEdgeCont.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-2024 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// Storage for edges, including some functionality operating on multiple edges
21/****************************************************************************/
22#pragma once
23#include <config.h>
24
25#include <map>
26#include <iostream>
27#include <string>
28#include <vector>
29#include <set>
30#include "NBCont.h"
35
36
37// ===========================================================================
38// class declarations
39// ===========================================================================
40class OptionsCont;
41class OutputDevice;
42class NBNodeCont;
43class NBTypeCont;
44class NBEdge;
45class NBNode;
46class NBDistrictCont;
48class NBPTStopCont;
49class NBPTLineCont;
50
51
52// ===========================================================================
53// class definitions
54// ===========================================================================
60
61public:
66
69
78 void applyOptions(OptionsCont& oc);
79
81 void clear();
82
85
99 bool insert(NBEdge* edge, bool ignorePrunning = false);
100
109 NBEdge* retrieve(const std::string& id, bool retrieveExtracted = false) const;
110
121 NBEdge* retrievePossiblySplit(const std::string& id, bool downstream) const;
122
135 NBEdge* retrievePossiblySplit(const std::string& id, const std::string& hint, bool incoming) const;
136
147 NBEdge* retrievePossiblySplit(const std::string& id, double pos) const;
148
155 void erase(NBDistrictCont& dc, NBEdge* edge);
156
166 void extract(NBDistrictCont& dc, NBEdge* edge, bool remember = false);
167
171 std::map<std::string, NBEdge*>::const_iterator begin() const {
172 return myEdges.begin();
173 }
174
178 std::map<std::string, NBEdge*>::const_iterator end() const {
179 return myEdges.end();
180 }
182
185
189 struct Split {
191 std::vector<int> lanes;
199 NBNode* node = nullptr;
201 std::string idBefore;
203 std::string idAfter;
205 std::string nameID;
207 double offset = 0.;
210 };
211
213 void processSplits(NBEdge* e, std::vector<Split> splits,
215
229 bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node);
230
255 bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node,
256 const std::string& firstEdgeName, const std::string& secondEdgeName,
257 int noLanesFirstEdge, int noLanesSecondEdge,
258 const double speed = -1., const double friction = 1., const int changedLeft = 0);
259
275 bool splitAt(NBDistrictCont& dc, NBEdge* edge, double edgepos, NBNode* node,
276 const std::string& firstEdgeName, const std::string& secondEdgeName,
277 int noLanesFirstEdge, int noLanesSecondEdge,
278 const double speed = -1., const double friction = 1., const int changedLeft = 0);
280
283
287 int size() const {
288 return (int) myEdges.size();
289 }
290
295 std::vector<std::string> getAllNames() const;
296
300 const std::pair<NBEdge*, NBEdge*>* getSplit(const NBEdge* const origEdge) const {
301 const auto& split = myEdgesSplit.find(origEdge);
302 if (split == myEdgesSplit.end()) {
303 return nullptr;
304 }
305 return &split->second;
306 }
307
311 int getNumEdgeSplits() const {
312 return (int)myEdgesSplit.size();
313 }
315
318
325
335
340 void reduceGeometries(const double minDist);
341
348 void checkGeometries(const double maxAngle, bool fixAngle, const double minRadius, bool fix, bool fixRailways, bool silent = false);
350
353
362
371 void computeEdge2Edges(bool noLeftMovers);
372
380 void computeLanes2Edges();
381
389 void recheckLanes();
390
402 void appendTurnarounds(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike);
403
410 void appendTurnarounds(const std::set<std::string>& ids, bool noTLSControlled);
411
414
423 void computeEdgeShapes(double smoothElevationThreshold = -1);
424
433 void computeLaneShapes();
434
437
447
449 void guessOpposites();
450
455 void recheckLaneSpread();
456
458
460 NBEdge* getOppositeByID(const std::string& edgeID) const;
461
463 NBEdge* getByID(const std::string& edgeID) const;
464
468 int guessRoundabouts();
469
473 int extractRoundabouts();
474
475 // brief ensure myRoundabouts only holds valid edges
476 void cleanupRoundabouts();
477
481 bool wasIgnored(std::string id) const {
482 return myIgnoredEdges.count(id) != 0;
483 }
484
486 void ignore(std::string id) {
487 myIgnoredEdges.insert(id);
488 }
489
491 bool wasRemoved(std::string id) const {
492 return myExtractedEdges.count(id) != 0;
493 }
494
496 void rename(NBEdge* edge, const std::string& newID);
497
500
515 void addPostProcessConnection(const std::string& from, int fromLane, const std::string& to, int toLane, bool mayDefinitelyPass,
516 KeepClear keepClear, double contPos, double visibility,
517 double speed, double friction, double length,
518 const PositionVector& customShape,
519 bool uncontrolled,
520 bool warnOnly,
521 SVCPermissions permissions = SVC_UNSPECIFIED,
522 bool indirectLeft = false,
523 const std::string& edgeType = "",
524 SVCPermissions changeLeft = SVC_UNSPECIFIED,
525 SVCPermissions changeRight = SVC_UNSPECIFIED);
526
528 bool hasPostProcessConnection(const std::string& from, const std::string& to = "");
529
533
535 void generateStreetSigns();
536
538 int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string& excludeOpt,
540
544 const std::set<EdgeSet> getRoundabouts() const;
545
548 return myGuessedRoundabouts.size() > 0;
549 }
550
552 void addRoundabout(const EdgeSet& roundabout);
553
555 void removeRoundabout(const NBNode* node);
557 void removeRoundaboutEdges(const EdgeSet& toRemove);
558
560 void markRoundabouts();
561
563 void patchRoundabouts(NBEdge* orig, NBEdge* part1, NBEdge* part2, std::set<EdgeSet>& roundabouts);
564
566 bool ignoreFilterMatch(NBEdge* edge);
567
569 int remapIDs(bool numericaIDs, bool reservedIDs, const std::string& prefix, NBPTStopCont& sc);
570
572 void checkOverlap(double threshold, double zThreshold) const;
573
575 void checkGrade(double threshold) const;
576
583 EdgeVector getGeneratedFrom(const std::string& id) const;
584
586 int joinLanes(SVCPermissions perms);
587
589 int joinTramEdges(NBDistrictCont& dc, NBPTStopCont& sc, NBPTLineCont& lc, double maxDist);
590
592 EdgeVector getAllEdges() const;
593
596
598 bool checkConsistency(const NBNodeCont& nc);
599
602
604 void addPrefix(const std::string& prefix);
605
608
610 void computeAngles();
611
613 std::set<std::string> getUsedTypes() const;
614
618 int removeLanesByWidth(NBDistrictCont& dc, const double minWidth);
619
620private:
622 static double formFactor(const EdgeVector& loopEdges);
623
625 void removeRoundaboutEdges(const EdgeSet& toRemove, std::set<EdgeSet>& roundabouts);
626
629
634
635 public:
643 PostProcessConnection(const std::string& from_, int fromLane_, const std::string& to_, int toLane_,
644 bool mayDefinitelyPass_, KeepClear keepClear_, double contPos_, double visibility_, double speed_,
645 double friction_, double length_,
646 const PositionVector& customShape_,
647 bool uncontrolled_,
648 bool warnOnly_,
649 SVCPermissions permissions_,
650 bool indirectLeft_,
651 const std::string& edgeType_,
652 SVCPermissions changeLeft_,
653 SVCPermissions changeRight_) :
654 from(from_), fromLane(fromLane_), to(to_), toLane(toLane_), mayDefinitelyPass(mayDefinitelyPass_), keepClear(keepClear_), contPos(contPos_),
655 visibility(visibility_),
656 speed(speed_),
657 friction(friction_),
658 customLength(length_),
659 customShape(customShape_),
660 uncontrolled(uncontrolled_),
661 permissions(permissions_),
662 indirectLeft(indirectLeft_),
663 edgeType(edgeType_),
664 changeLeft(changeLeft_),
665 changeRight(changeRight_),
666 warnOnly(warnOnly_)
667 {}
668
670 std::string from;
671
674
676 std::string to;
677
680
683
686
688 double contPos;
689
692
694 double speed;
695
697 double friction;
698
701
704
707
710
713
715 std::string edgeType;
716
719
722
725 };
726
728 bool operator()(const std::pair<NBEdge*, int>& a, const std::pair<NBEdge*, int>& b) const;
729 };
730
732 std::map<std::string, std::vector<PostProcessConnection> > myConnections;
733
735 typedef std::map<std::string, NBEdge*> EdgeCont;
736
739
742
744 std::set<NBEdge*> myEdgeCemetery;
745
747 std::set<std::string> myIgnoredEdges;
748
750 std::map<const NBEdge*, std::pair<NBEdge*, NBEdge*> > myEdgesSplit;
752 std::set<const NBEdge*> myWasSplit;
753
756
759
762
764 std::set<std::string> myEdges2Keep;
765
767 std::set<std::string> myEdges2Remove;
768
771
774
776 std::set<std::string> myTypes2Keep;
777
779 std::set<std::string> myTypes2Remove;
780
783
787
789 std::set<EdgeSet> myRoundabouts;
790
792 std::set<EdgeSet> myGuessedRoundabouts;
793
798 public:
800 explicit split_sorter() { }
801
803 int operator()(const Split& e1, const Split& e2) const {
804 return e1.pos < e2.pos;
805 }
806 };
807
809 NBEdgeCont(const NBEdgeCont& s) = delete;
810
812 NBEdgeCont& operator=(const NBEdgeCont& s) = delete;
813};
std::vector< std::string > & split(const std::string &s, char delim, std::vector< std::string > &elems)
std::set< NBEdge * > EdgeSet
container for unique edges
Definition NBCont.h:50
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition NBCont.h:42
KeepClear
keepClear status of connections
Definition NBCont.h:58
std::vector< NBRouterEdge * > RouterEdgeVector
Definition NBCont.h:43
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
const double INVALID_DOUBLE
invalid double
Definition StdDefs.h:64
A container for districts.
Sorts splits by their position (increasing)
Definition NBEdgeCont.h:797
int operator()(const Split &e1, const Split &e2) const
Comparing operator.
Definition NBEdgeCont.h:803
split_sorter()
Constructor.
Definition NBEdgeCont.h:800
Storage for edges, including some functionality operating on multiple edges.
Definition NBEdgeCont.h:59
void patchRoundabouts(NBEdge *orig, NBEdge *part1, NBEdge *part2, std::set< EdgeSet > &roundabouts)
fix roundabout information after splitting an edge
void computeEdgeShapes(double smoothElevationThreshold=-1)
Computes the shapes of all edges stored in the container.
NBEdge * getByID(const std::string &edgeID) const
Returns the edge with id if it exists.
const std::pair< NBEdge *, NBEdge * > * getSplit(const NBEdge *const origEdge) const
Returns the edge split if the edge has been split, nullptr otherwise.
Definition NBEdgeCont.h:300
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
int guessRoundabouts()
Determines which edges belong to roundabouts and increases their priority.
bool myNeedGeoTransformedPruningBoundary
whether a geo transform has been applied to the pruning boundary
Definition NBEdgeCont.h:785
int size() const
Returns the number of edges.
Definition NBEdgeCont.h:287
~NBEdgeCont()
Destructor.
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
void addRoundabout(const EdgeSet &roundabout)
add user specified roundabout
std::set< EdgeSet > myRoundabouts
Edges marked as belonging to a roundabout by the user (each EdgeVector is a roundabout)
Definition NBEdgeCont.h:789
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.
Definition NBEdgeCont.h:767
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
Definition NBEdgeCont.h:747
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition NBEdgeCont.h:171
void updateAllChangeRestrictions(SVCPermissions ignoring)
modify all restrictions on lane changing for edges and connections
double myEdgesMinSpeed
The minimum speed an edge may have in order to be kept (default: -1)
Definition NBEdgeCont.h:758
void recheckPostProcessConnections()
Try to set any stored connections.
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
void processSplits(NBEdge *e, std::vector< Split > splits, NBNodeCont &nc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc)
process splits
EdgeVector getAllEdges() const
return all edges
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
NBEdgeCont(const NBEdgeCont &s)=delete
invalidated copy constructor
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
Definition NBEdgeCont.h:776
NBEdgeCont & operator=(const NBEdgeCont &s)=delete
invalidated assignment operator
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
void checkGeometries(const double maxAngle, bool fixAngle, const double minRadius, bool fix, bool fixRailways, bool silent=false)
EdgeCont myExtractedEdges
The extracted edges which are kept for reference.
Definition NBEdgeCont.h:741
void reduceGeometries(const double minDist)
void recheckLaneSpread()
Rechecks whether the lane spread is proper.
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
void removeRoundabout(const NBNode *node)
remove roundabout that contains the given node
void cleanupRoundabouts()
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition NBEdgeCont.h:178
void splitGeometry(NBDistrictCont &dc, NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
void addPostProcessConnection(const std::string &from, int fromLane, const std::string &to, int toLane, bool mayDefinitelyPass, KeepClear keepClear, double contPos, double visibility, double speed, double friction, double length, const PositionVector &customShape, bool uncontrolled, bool warnOnly, SVCPermissions permissions=SVC_UNSPECIFIED, bool indirectLeft=false, const std::string &edgeType="", SVCPermissions changeLeft=SVC_UNSPECIFIED, SVCPermissions changeRight=SVC_UNSPECIFIED)
Adds a connection which could not be set during loading.
std::set< std::string > getUsedTypes() const
return all edge types in used
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
int extractRoundabouts()
Determines which edges have been marked as roundabouts and stores them internally.
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
RouterEdgeVector getAllRouterEdges() const
return all router edges
std::set< const NBEdge * > myWasSplit
the edges that were created as result of splitting
Definition NBEdgeCont.h:752
int getNumEdgeSplits() const
Returns the number of edge splits.
Definition NBEdgeCont.h:311
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
void ignore(std::string id)
mark the given edge id as ignored
Definition NBEdgeCont.h:486
int joinTramEdges(NBDistrictCont &dc, NBPTStopCont &sc, NBPTLineCont &lc, double maxDist)
join tram edges into adjacent lanes
bool hasPostProcessConnection(const std::string &from, const std::string &to="")
add post process connections
EdgeCont myEdges
The instance of the dictionary (id->edge)
Definition NBEdgeCont.h:738
int removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
Definition NBEdgeCont.h:764
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
Definition NBEdgeCont.h:628
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition NBEdgeCont.h:481
void generateStreetSigns()
assigns street signs to edges based on toNode types
void clearControllingTLInformation() const
Clears information about controlling traffic lights for all connenections of all edges.
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
Definition NBEdgeCont.h:792
bool hasGuessedRoundabouts() const
check if there is guessed roundabouts
Definition NBEdgeCont.h:547
void computeAngles()
compute all edge angles
void clear()
Deletes all edges.
void guessOpposites()
Sets opposite lane information for geometrically close edges.
void markRoundabouts()
mark edge priorities and prohibit turn-arounds for all roundabout edges
std::set< std::string > myTypes2Remove
Set of edges types which shall be removed.
Definition NBEdgeCont.h:779
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
void removeRoundaboutEdges(const EdgeSet &toRemove)
remove edges from all stored roundabouts
PositionVector myPruningBoundary
Boundary within which an edge must be located in order to be kept.
Definition NBEdgeCont.h:782
int joinLanes(SVCPermissions perms)
join adjacent lanes with the given permissions
void checkOverlap(double threshold, double zThreshold) const
check whether edges overlap
SVCPermissions myVehicleClasses2Remove
Set of vehicle types which need not be supported (edges which allow ONLY these are removed)
Definition NBEdgeCont.h:773
int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string &excludeOpt, NBTrafficLightLogicCont &tlc)
add sidwalks to edges within the given limits or permissions and return the number of edges affected
bool wasRemoved(std::string id) const
Returns whether the edge with the id was deleted explicitly.
Definition NBEdgeCont.h:491
EdgeVector getGeneratedFrom(const std::string &id) const
Returns the edges which have been built by splitting the edge of the given id.
void appendTurnarounds(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike)
Appends turnarounds to all edges stored in the container.
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
Definition NBEdgeCont.h:770
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
std::map< std::string, NBEdge * > EdgeCont
The type of the dictionary where an edge may be found by its id.
Definition NBEdgeCont.h:735
void addPrefix(const std::string &prefix)
add prefix to all edges
void fixSplitCustomLength()
adapt custom lengths of split edges to account for intersection size
std::map< const NBEdge *, std::pair< NBEdge *, NBEdge * > > myEdgesSplit
the number of splits of edges during the building
Definition NBEdgeCont.h:750
std::map< std::string, std::vector< PostProcessConnection > > myConnections
The list of connections to recheck.
Definition NBEdgeCont.h:732
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
std::set< NBEdge * > myEdgeCemetery
The edges which got extracted twice but may still be referenced somewhere TODO smart_ptr?
Definition NBEdgeCont.h:744
int remapIDs(bool numericaIDs, bool reservedIDs, const std::string &prefix, NBPTStopCont &sc)
remap node IDs accoring to options –numerical-ids and –reserved-ids
bool checkConsistency(const NBNodeCont &nc)
ensure that all edges have valid nodes
static double formFactor(const EdgeVector &loopEdges)
compute the form factor for a loop of edges
int removeLanesByWidth(NBDistrictCont &dc, const double minWidth)
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
int removeEdgesBySpeed(NBDistrictCont &dc)
return number of edges removed
void checkGrade(double threshold) const
check whether edges are to steep
int removeEdgesByPermissions(NBDistrictCont &dc)
bool myRemoveEdgesAfterLoading
Whether edges shall be joined and patched first, then removed.
Definition NBEdgeCont.h:761
The representation of a single edge during network building.
Definition NBEdge.h:92
Container for nodes during the netbuilding process.
Definition NBNodeCont.h:57
Represents a single node (junction) during network building.
Definition NBNode.h:66
Container for public transport stops during the net building process.
A container for traffic light definitions and built programs.
A storage for available edgeTypes of edges.
Definition NBTypeCont.h:52
A storage for options typed value containers)
Definition OptionsCont.h:89
Static storage of an output device and its base (abstract) implementation.
A list of positions.
bool operator()(const std::pair< NBEdge *, int > &a, const std::pair< NBEdge *, int > &b) const
A structure representing a connection between two lanes.
Definition NBEdgeCont.h:633
double customLength
custom length for connection
Definition NBEdgeCont.h:700
bool warnOnly
whether a failure to set this connection is a warning or an error
Definition NBEdgeCont.h:724
bool uncontrolled
whether this connection shall not be controlled by a traffic light
Definition NBEdgeCont.h:706
SVCPermissions changeRight
custom lane changing permissions for connection
Definition NBEdgeCont.h:721
double visibility
custom foe visiblity for connection
Definition NBEdgeCont.h:691
int toLane
The number of the lane the connection ends at.
Definition NBEdgeCont.h:679
PositionVector customShape
custom shape for connection
Definition NBEdgeCont.h:703
KeepClear keepClear
Whether the connection may be passed without braking.
Definition NBEdgeCont.h:685
double speed
custom speed for connection
Definition NBEdgeCont.h:694
bool mayDefinitelyPass
Whether the connection may be passed without braking.
Definition NBEdgeCont.h:682
SVCPermissions changeLeft
custom lane changing permissions for connection
Definition NBEdgeCont.h:718
double contPos
custom position for internal junction on this connection
Definition NBEdgeCont.h:688
std::string from
The id of the edge the connection starts at.
Definition NBEdgeCont.h:670
double friction
custom friction for connection
Definition NBEdgeCont.h:697
std::string edgeType
custom edge type
Definition NBEdgeCont.h:715
SVCPermissions permissions
custom permissions for connection
Definition NBEdgeCont.h:709
std::string to
The id of the edge the connection ends at.
Definition NBEdgeCont.h:676
PostProcessConnection(const std::string &from_, int fromLane_, const std::string &to_, int toLane_, bool mayDefinitelyPass_, KeepClear keepClear_, double contPos_, double visibility_, double speed_, double friction_, double length_, const PositionVector &customShape_, bool uncontrolled_, bool warnOnly_, SVCPermissions permissions_, bool indirectLeft_, const std::string &edgeType_, SVCPermissions changeLeft_, SVCPermissions changeRight_)
Constructor.
Definition NBEdgeCont.h:643
int fromLane
The number of the lane the connection starts at.
Definition NBEdgeCont.h:673
bool indirectLeft
whether this connection is an indirect left turn
Definition NBEdgeCont.h:712
A structure which describes changes of lane number or speed along the road.
Definition NBEdgeCont.h:189
int offsetFactor
direction in which to apply the offset (used by netgenerate for lefthand networks)
Definition NBEdgeCont.h:209
double speed
The speed after this change.
Definition NBEdgeCont.h:195
double offset
lateral offset to edge geometry
Definition NBEdgeCont.h:207
double friction
The friction after this change.
Definition NBEdgeCont.h:197
std::string nameID
the default node id
Definition NBEdgeCont.h:205
std::string idBefore
The id for the edge before the split.
Definition NBEdgeCont.h:201
double pos
The position of this change.
Definition NBEdgeCont.h:193
std::vector< int > lanes
The lanes after this change.
Definition NBEdgeCont.h:191
std::string idAfter
The id for the edge after the split.
Definition NBEdgeCont.h:203
NBNode * node
The new node that is created for this split.
Definition NBEdgeCont.h:199