Eclipse SUMO - Simulation of Urban MObility
NBEdgeCont.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
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// ===========================================================================
60public:
65
68
77 void applyOptions(OptionsCont& oc);
78
80 void clear();
81
84
98 bool insert(NBEdge* edge, bool ignorePrunning = false);
99
108 NBEdge* retrieve(const std::string& id, bool retrieveExtracted = false) const;
109
120 NBEdge* retrievePossiblySplit(const std::string& id, bool downstream) const;
121
134 NBEdge* retrievePossiblySplit(const std::string& id, const std::string& hint, bool incoming) const;
135
146 NBEdge* retrievePossiblySplit(const std::string& id, double pos) const;
147
154 void erase(NBDistrictCont& dc, NBEdge* edge);
155
165 void extract(NBDistrictCont& dc, NBEdge* edge, bool remember = false);
166
170 std::map<std::string, NBEdge*>::const_iterator begin() const {
171 return myEdges.begin();
172 }
173
177 std::map<std::string, NBEdge*>::const_iterator end() const {
178 return myEdges.end();
179 }
181
184
188 struct Split {
190 std::vector<int> lanes;
198 NBNode* node = nullptr;
200 std::string idBefore;
202 std::string idAfter;
204 std::string nameID;
206 double offset = 0.;
209 };
210
211 void processSplits(NBEdge* e, std::vector<Split> splits,
213
214
228 bool splitAt(NBDistrictCont& dc, NBEdge* edge, NBNode* node);
229
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
281
282
285
289 int size() const {
290 return (int) myEdges.size();
291 }
292
297 std::vector<std::string> getAllNames() const;
298
302 const std::pair<NBEdge*, NBEdge*>* getSplit(const NBEdge* const origEdge) const {
303 const auto& split = myEdgesSplit.find(origEdge);
304 if (split == myEdgesSplit.end()) {
305 return nullptr;
306 }
307 return &split->second;
308 }
309
313 int getNumEdgeSplits() const {
314 return (int)myEdgesSplit.size();
315 }
317
320
326
327
337
338
343 void reduceGeometries(const double minDist);
344
345
352 void checkGeometries(const double maxAngle, const double minRadius, bool fix, bool fixRailways, bool silent = false);
354
355
356
359
368
369
378 void computeEdge2Edges(bool noLeftMovers);
379
380
388 void computeLanes2Edges();
389
390
398 void recheckLanes();
399
400
412 void appendTurnarounds(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike);
413
414
421 void appendTurnarounds(const std::set<std::string>& ids, bool noTLSControlled);
422
426
427
436 void computeEdgeShapes(double smoothElevationThreshold = -1);
437
438
447 void computeLaneShapes();
448
449
453
454
464
465
468 void guessOpposites();
469
470
475 void recheckLaneSpread();
476
478
480 NBEdge* getOppositeByID(const std::string& edgeID) const;
481
483 NBEdge* getByID(const std::string& edgeID) const;
484
489 int guessRoundabouts();
490
491
495 bool wasIgnored(std::string id) const {
496 return myIgnoredEdges.count(id) != 0;
497 }
498
500 void ignore(std::string id) {
501 myIgnoredEdges.insert(id);
502 }
503
506 bool wasRemoved(std::string id) const {
507 return myExtractedEdges.count(id) != 0;
508 }
509
512 void rename(NBEdge* edge, const std::string& newID);
513
514
515
518
533 void addPostProcessConnection(const std::string& from, int fromLane, const std::string& to, int toLane, bool mayDefinitelyPass,
534 KeepClear keepClear, double contPos, double visibility,
535 double speed, double friction, double length,
536 const PositionVector& customShape,
537 bool uncontrolled,
538 bool warnOnly,
539 SVCPermissions permissions = SVC_UNSPECIFIED,
540 bool indirectLeft = false,
541 const std::string& edgeType = "",
542 SVCPermissions changeLeft = SVC_UNSPECIFIED,
543 SVCPermissions changeRight = SVC_UNSPECIFIED);
544
545 bool hasPostProcessConnection(const std::string& from, const std::string& to = "");
546
547
552
554 void generateStreetSigns();
555
557 int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string& excludeOpt,
559
560
564 const std::set<EdgeSet> getRoundabouts() const;
565
567 return myGuessedRoundabouts.size() > 0;
568 }
569
571 void addRoundabout(const EdgeSet& roundabout);
572
574 void removeRoundabout(const NBNode* node);
576 void removeRoundaboutEdges(const EdgeSet& toRemove);
577
579 void markRoundabouts();
580
582 void patchRoundabouts(NBEdge* orig, NBEdge* part1, NBEdge* part2, std::set<EdgeSet>& roundabouts);
583
585 bool ignoreFilterMatch(NBEdge* edge);
586
588 int remapIDs(bool numericaIDs, bool reservedIDs, const std::string& prefix, NBPTStopCont& sc);
589
591 void checkOverlap(double threshold, double zThreshold) const;
592
594 void checkGrade(double threshold) const;
595
596
603 EdgeVector getGeneratedFrom(const std::string& id) const;
604
606 int joinLanes(SVCPermissions perms);
607
609 int joinTramEdges(NBDistrictCont& dc, NBPTStopCont& sc, NBPTLineCont& lc, double maxDist);
610
612 EdgeVector getAllEdges() const;
614
616 bool checkConsistency(const NBNodeCont& nc);
617
620
621private:
623 static double formFactor(const EdgeVector& loopEdges);
624
625 void removeRoundaboutEdges(const EdgeSet& toRemove, std::set<EdgeSet>& roundabouts);
626
627private:
630
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 {}
669 std::string from;
673 std::string to;
681 double contPos;
685 double speed;
687 double friction;
699 std::string edgeType;
706 };
707
709 std::map<std::string, std::vector<PostProcessConnection> > myConnections;
710
711
713 typedef std::map<std::string, NBEdge*> EdgeCont;
714
717
720
722 std::set<std::string> myIgnoredEdges;
723
725 std::map<const NBEdge*, std::pair<NBEdge*, NBEdge*> > myEdgesSplit;
726
729
732
735
737 std::set<std::string> myEdges2Keep;
738
740 std::set<std::string> myEdges2Remove;
741
744
747
749 std::set<std::string> myTypes2Keep;
750
752 std::set<std::string> myTypes2Remove;
753
756
760
762 std::set<EdgeSet> myRoundabouts;
764 std::set<EdgeSet> myGuessedRoundabouts;
765
770 public:
772 explicit split_sorter() { }
773
775 int operator()(const Split& e1, const Split& e2) const {
776 return e1.pos < e2.pos;
777 }
778 };
779
780
781private:
784
787
788};
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
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
const double INVALID_DOUBLE
Definition: StdDefs.h:60
A container for districts.
Sorts splits by their position (increasing)
Definition: NBEdgeCont.h:769
int operator()(const Split &e1, const Split &e2) const
Comparing operator.
Definition: NBEdgeCont.h:775
split_sorter()
Constructor.
Definition: NBEdgeCont.h:772
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
Definition: NBEdgeCont.cpp:703
void computeEdgeShapes(double smoothElevationThreshold=-1)
Computes the shapes of all edges stored in the container.
Definition: NBEdgeCont.cpp:934
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
Definition: NBEdgeCont.cpp:732
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:302
const std::set< EdgeSet > getRoundabouts() const
Returns the determined roundabouts.
void computeEdge2Edges(bool noLeftMovers)
Computes for each edge the approached edges.
Definition: NBEdgeCont.cpp:814
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:758
int size() const
Returns the number of edges.
Definition: NBEdgeCont.h:289
~NBEdgeCont()
Destructor.
Definition: NBEdgeCont.cpp:71
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
Definition: NBEdgeCont.cpp:806
NBEdgeCont(const NBEdgeCont &s)
invalidated copy constructor
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:762
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
Definition: NBEdgeCont.cpp:912
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.
Definition: NBEdgeCont.h:740
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
Definition: NBEdgeCont.h:722
std::map< std::string, NBEdge * >::const_iterator begin() const
Returns the pointer to the begin of the stored edges.
Definition: NBEdgeCont.h:170
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:731
void recheckPostProcessConnections()
Try to set any stored connections.
void checkGeometries(const double maxAngle, const double minRadius, bool fix, bool fixRailways, bool silent=false)
Definition: NBEdgeCont.cpp:784
void extract(NBDistrictCont &dc, NBEdge *edge, bool remember=false)
Removes the given edge from the container like erase but does not delete it.
Definition: NBEdgeCont.cpp:411
void processSplits(NBEdge *e, std::vector< Split > splits, NBNodeCont &nc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc)
Definition: NBEdgeCont.cpp:443
EdgeVector getAllEdges() const
return all edges
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
Definition: NBEdgeCont.cpp:404
NBEdgeCont & operator=(const NBEdgeCont &s)
invalidated assignment operator
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
Definition: NBEdgeCont.cpp:274
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
Definition: NBEdgeCont.h:749
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
Definition: NBEdgeCont.cpp:830
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
EdgeCont myExtractedEdges
The extracted nodes which are kept for reference.
Definition: NBEdgeCont.h:719
void reduceGeometries(const double minDist)
Definition: NBEdgeCont.cpp:776
void recheckLaneSpread()
Rechecks whether the lane spread is proper.
bool ignoreFilterMatch(NBEdge *edge)
Returns true if this edge matches one of the removal criteria.
Definition: NBEdgeCont.cpp:198
void removeRoundabout(const NBNode *node)
remove roundabout that contains the given node
std::map< std::string, NBEdge * >::const_iterator end() const
Returns the pointer to the end of the stored edges.
Definition: NBEdgeCont.h:177
void splitGeometry(NBDistrictCont &dc, NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
Definition: NBEdgeCont.cpp:749
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.
void computeLanes2Edges()
Computes for each edge which lanes approach the next edges.
Definition: NBEdgeCont.cpp:822
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
Definition: NBEdgeCont.cpp:310
RouterEdgeVector getAllRouterEdges() const
int getNumEdgeSplits() const
Returns the number of edge splits.
Definition: NBEdgeCont.h:313
void rename(NBEdge *edge, const std::string &newID)
Renames the edge. Throws exception if newID already exists.
Definition: NBEdgeCont.cpp:423
void ignore(std::string id)
mark the given edge id as ignored
Definition: NBEdgeCont.h:500
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="")
EdgeCont myEdges
The instance of the dictionary (id->edge)
Definition: NBEdgeCont.h:716
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
Definition: NBEdgeCont.h:737
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
Definition: NBEdgeCont.h:629
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition: NBEdgeCont.h:495
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.
Definition: NBEdgeCont.cpp:798
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
Definition: NBEdgeCont.h:764
bool hasGuessedRoundabouts() const
Definition: NBEdgeCont.h:566
void clear()
Deletes all edges.
Definition: NBEdgeCont.cpp:162
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:752
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
Definition: NBEdgeCont.cpp:77
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:755
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:746
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:506
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.
Definition: NBEdgeCont.cpp:896
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
Definition: NBEdgeCont.h:743
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
Definition: NBEdgeCont.cpp:958
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
Definition: NBEdgeCont.cpp:966
bool myRemoveEdgesAfterJoining
Whether edges shall be joined first, then removed.
Definition: NBEdgeCont.h:734
std::map< std::string, NBEdge * > EdgeCont
The type of the dictionary where an edge may be found by its id.
Definition: NBEdgeCont.h:713
std::map< const NBEdge *, std::pair< NBEdge *, NBEdge * > > myEdgesSplit
the number of splits of edges during the building
Definition: NBEdgeCont.h:725
std::map< std::string, std::vector< PostProcessConnection > > myConnections
The list of connections to recheck.
Definition: NBEdgeCont.h:709
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
Definition: NBEdgeCont.cpp:177
NBEdgeCont(NBTypeCont &tc)
Constructor.
Definition: NBEdgeCont.cpp:63
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
bool splitAt(NBDistrictCont &dc, NBEdge *edge, NBNode *node)
Splits the edge at the position nearest to the given node.
Definition: NBEdgeCont.cpp:588
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
Definition: NBEdgeCont.cpp:721
void checkGrade(double threshold) const
check whether edges are to steep
The representation of a single edge during network building.
Definition: NBEdge.h:92
Container for nodes during the netbuilding process.
Definition: NBNodeCont.h:58
Represents a single node (junction) during network building.
Definition: NBNode.h:66
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.
Definition: OutputDevice.h:61
A list of positions.
A structure representing a connection between two lanes.
Definition: NBEdgeCont.h:634
double customLength
custom length for connection
Definition: NBEdgeCont.h:689
bool warnOnly
whether a failure to set this connection is a warning or an error
Definition: NBEdgeCont.h:705
bool uncontrolled
whether this connection shall not be controlled by a traffic light
Definition: NBEdgeCont.h:693
SVCPermissions changeRight
custom lane changing permissions for connection
Definition: NBEdgeCont.h:703
double visibility
custom foe visiblity for connection
Definition: NBEdgeCont.h:683
int toLane
The number of the lane the connection ends at.
Definition: NBEdgeCont.h:675
PositionVector customShape
custom shape for connection
Definition: NBEdgeCont.h:691
KeepClear keepClear
Whether the connection may be passed without braking.
Definition: NBEdgeCont.h:679
double speed
custom speed for connection
Definition: NBEdgeCont.h:685
bool mayDefinitelyPass
Whether the connection may be passed without braking.
Definition: NBEdgeCont.h:677
SVCPermissions changeLeft
custom lane changing permissions for connection
Definition: NBEdgeCont.h:701
double contPos
custom position for internal junction on this connection
Definition: NBEdgeCont.h:681
std::string from
The id of the edge the connection starts at.
Definition: NBEdgeCont.h:669
double friction
custom friction for connection
Definition: NBEdgeCont.h:687
std::string edgeType
custom edge type
Definition: NBEdgeCont.h:699
SVCPermissions permissions
custom permissions for connection
Definition: NBEdgeCont.h:695
std::string to
The id of the edge the connection ends at.
Definition: NBEdgeCont.h:673
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:671
bool indirectLeft
whether this connection is an indirect left turn
Definition: NBEdgeCont.h:697
A structure which describes changes of lane number or speed along the road.
Definition: NBEdgeCont.h:188
int offsetFactor
direction in which to apply the offset (used by netgenerate for lefthand networks)
Definition: NBEdgeCont.h:208
double speed
The speed after this change.
Definition: NBEdgeCont.h:194
double offset
lateral offset to edge geometry
Definition: NBEdgeCont.h:206
double friction
The friction after this change.
Definition: NBEdgeCont.h:196
std::string nameID
the default node id
Definition: NBEdgeCont.h:204
std::string idBefore
The id for the edge before the split.
Definition: NBEdgeCont.h:200
double pos
The position of this change.
Definition: NBEdgeCont.h:192
std::vector< int > lanes
The lanes after this change.
Definition: NBEdgeCont.h:190
std::string idAfter
The id for the edge after the split.
Definition: NBEdgeCont.h:202
NBNode * node
The new node that is created for this split.
Definition: NBEdgeCont.h:198