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-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// 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
324
334
339 void reduceGeometries(const double minDist);
340
347 void checkGeometries(const double maxAngle, const double minRadius, bool fix, bool fixRailways, bool silent = false);
349
352
361
370 void computeEdge2Edges(bool noLeftMovers);
371
379 void computeLanes2Edges();
380
388 void recheckLanes();
389
401 void appendTurnarounds(bool noTLSControlled, bool noFringe, bool onlyDeadends, bool onlyTurnlane, bool noGeometryLike);
402
409 void appendTurnarounds(const std::set<std::string>& ids, bool noTLSControlled);
410
413
422 void computeEdgeShapes(double smoothElevationThreshold = -1);
423
432 void computeLaneShapes();
433
436
446
448 void guessOpposites();
449
454 void recheckLaneSpread();
455
457
459 NBEdge* getOppositeByID(const std::string& edgeID) const;
460
462 NBEdge* getByID(const std::string& edgeID) const;
463
468 int guessRoundabouts();
469
473 bool wasIgnored(std::string id) const {
474 return myIgnoredEdges.count(id) != 0;
475 }
476
478 void ignore(std::string id) {
479 myIgnoredEdges.insert(id);
480 }
481
483 bool wasRemoved(std::string id) const {
484 return myExtractedEdges.count(id) != 0;
485 }
486
488 void rename(NBEdge* edge, const std::string& newID);
489
492
507 void addPostProcessConnection(const std::string& from, int fromLane, const std::string& to, int toLane, bool mayDefinitelyPass,
508 KeepClear keepClear, double contPos, double visibility,
509 double speed, double friction, double length,
510 const PositionVector& customShape,
511 bool uncontrolled,
512 bool warnOnly,
513 SVCPermissions permissions = SVC_UNSPECIFIED,
514 bool indirectLeft = false,
515 const std::string& edgeType = "",
516 SVCPermissions changeLeft = SVC_UNSPECIFIED,
517 SVCPermissions changeRight = SVC_UNSPECIFIED);
518
520 bool hasPostProcessConnection(const std::string& from, const std::string& to = "");
521
525
527 void generateStreetSigns();
528
530 int guessSpecialLanes(SUMOVehicleClass svc, double width, double minSpeed, double maxSpeed, bool fromPermissions, const std::string& excludeOpt,
532
536 const std::set<EdgeSet> getRoundabouts() const;
537
540 return myGuessedRoundabouts.size() > 0;
541 }
542
544 void addRoundabout(const EdgeSet& roundabout);
545
547 void removeRoundabout(const NBNode* node);
549 void removeRoundaboutEdges(const EdgeSet& toRemove);
550
552 void markRoundabouts();
553
555 void patchRoundabouts(NBEdge* orig, NBEdge* part1, NBEdge* part2, std::set<EdgeSet>& roundabouts);
556
558 bool ignoreFilterMatch(NBEdge* edge);
559
561 int remapIDs(bool numericaIDs, bool reservedIDs, const std::string& prefix, NBPTStopCont& sc);
562
564 void checkOverlap(double threshold, double zThreshold) const;
565
567 void checkGrade(double threshold) const;
568
575 EdgeVector getGeneratedFrom(const std::string& id) const;
576
578 int joinLanes(SVCPermissions perms);
579
581 int joinTramEdges(NBDistrictCont& dc, NBPTStopCont& sc, NBPTLineCont& lc, double maxDist);
582
584 EdgeVector getAllEdges() const;
585
588
590 bool checkConsistency(const NBNodeCont& nc);
591
594
596 void addPrefix(const std::string& prefix);
597
600
602 void computeAngles();
603
604private:
606 static double formFactor(const EdgeVector& loopEdges);
607
609 void removeRoundaboutEdges(const EdgeSet& toRemove, std::set<EdgeSet>& roundabouts);
610
613
618
619 public:
627 PostProcessConnection(const std::string& from_, int fromLane_, const std::string& to_, int toLane_,
628 bool mayDefinitelyPass_, KeepClear keepClear_, double contPos_, double visibility_, double speed_,
629 double friction_, double length_,
630 const PositionVector& customShape_,
631 bool uncontrolled_,
632 bool warnOnly_,
633 SVCPermissions permissions_,
634 bool indirectLeft_,
635 const std::string& edgeType_,
636 SVCPermissions changeLeft_,
637 SVCPermissions changeRight_) :
638 from(from_), fromLane(fromLane_), to(to_), toLane(toLane_), mayDefinitelyPass(mayDefinitelyPass_), keepClear(keepClear_), contPos(contPos_),
639 visibility(visibility_),
640 speed(speed_),
641 friction(friction_),
642 customLength(length_),
643 customShape(customShape_),
644 uncontrolled(uncontrolled_),
645 permissions(permissions_),
646 indirectLeft(indirectLeft_),
647 edgeType(edgeType_),
648 changeLeft(changeLeft_),
649 changeRight(changeRight_),
650 warnOnly(warnOnly_)
651 {}
652
654 std::string from;
655
658
660 std::string to;
661
664
667
670
672 double contPos;
673
676
678 double speed;
679
681 double friction;
682
685
688
691
694
697
699 std::string edgeType;
700
703
706
709 };
710
712 bool operator()(const std::pair<NBEdge*, int>& a, const std::pair<NBEdge*, int>& b) const;
713 };
714
716 std::map<std::string, std::vector<PostProcessConnection> > myConnections;
717
719 typedef std::map<std::string, NBEdge*> EdgeCont;
720
723
726
728 std::set<NBEdge*> myEdgeCemetery;
729
731 std::set<std::string> myIgnoredEdges;
732
734 std::map<const NBEdge*, std::pair<NBEdge*, NBEdge*> > myEdgesSplit;
736 std::set<const NBEdge*> myWasSplit;
737
740
743
746
748 std::set<std::string> myEdges2Keep;
749
751 std::set<std::string> myEdges2Remove;
752
755
758
760 std::set<std::string> myTypes2Keep;
761
763 std::set<std::string> myTypes2Remove;
764
767
771
773 std::set<EdgeSet> myRoundabouts;
774
776 std::set<EdgeSet> myGuessedRoundabouts;
777
782 public:
784 explicit split_sorter() { }
785
787 int operator()(const Split& e1, const Split& e2) const {
788 return e1.pos < e2.pos;
789 }
790 };
791
793 NBEdgeCont(const NBEdgeCont& s) = delete;
794
796 NBEdgeCont& operator=(const NBEdgeCont& s) = delete;
797};
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
invalid double
Definition: StdDefs.h:64
A container for districts.
Sorts splits by their position (increasing)
Definition: NBEdgeCont.h:781
int operator()(const Split &e1, const Split &e2) const
Comparing operator.
Definition: NBEdgeCont.h:787
split_sorter()
Constructor.
Definition: NBEdgeCont.h:784
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:738
void computeEdgeShapes(double smoothElevationThreshold=-1)
Computes the shapes of all edges stored in the container.
Definition: NBEdgeCont.cpp:969
void removeUnwishedEdges(NBDistrictCont &dc)
Removes unwished edges (not in keep-edges)
Definition: NBEdgeCont.cpp:767
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.
Definition: NBEdgeCont.cpp:849
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:769
int size() const
Returns the number of edges.
Definition: NBEdgeCont.h:287
~NBEdgeCont()
Destructor.
Definition: NBEdgeCont.cpp:72
void sortOutgoingLanesConnections()
Sorts all lanes of all edges within the container by their direction.
Definition: NBEdgeCont.cpp:841
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:773
void appendRailwayTurnarounds(const NBPTStopCont &sc)
Appends turnarounds to all bidiRail edges with stops.
Definition: NBEdgeCont.cpp:947
std::set< std::string > myEdges2Remove
Set of ids of edges which shall explicitly be removed.
Definition: NBEdgeCont.h:751
std::set< std::string > myIgnoredEdges
The ids of ignored edges.
Definition: NBEdgeCont.h:731
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:742
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:819
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:416
void processSplits(NBEdge *e, std::vector< Split > splits, NBNodeCont &nc, NBDistrictCont &dc, NBTrafficLightLogicCont &tlc)
process splits
Definition: NBEdgeCont.cpp:456
EdgeVector getAllEdges() const
return all edges
void erase(NBDistrictCont &dc, NBEdge *edge)
Removes the given edge from the container (deleting it)
Definition: NBEdgeCont.cpp:409
NBEdge * retrieve(const std::string &id, bool retrieveExtracted=false) const
Returns the edge that has the given id.
Definition: NBEdgeCont.cpp:279
NBEdgeCont(const NBEdgeCont &s)=delete
invalidated copy constructor
std::set< std::string > myTypes2Keep
Set of edges types which shall be kept.
Definition: NBEdgeCont.h:760
NBEdgeCont & operator=(const NBEdgeCont &s)=delete
invalidated assignment operator
void recheckLanes()
Rechecks whether all lanes have a successor for each of the stored edges.
Definition: NBEdgeCont.cpp:865
NBEdge * getOppositeByID(const std::string &edgeID) const
Returns the edge with negated id if it exists.
EdgeCont myExtractedEdges
The extracted edges which are kept for reference.
Definition: NBEdgeCont.h:725
void reduceGeometries(const double minDist)
Definition: NBEdgeCont.cpp:811
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:203
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:178
void splitGeometry(NBDistrictCont &dc, NBNodeCont &nc)
Splits edges into multiple if they have a complex geometry.
Definition: NBEdgeCont.cpp:784
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:857
NBEdge * retrievePossiblySplit(const std::string &id, bool downstream) const
Tries to retrieve an edge, even if it is splitted.
Definition: NBEdgeCont.cpp:315
RouterEdgeVector getAllRouterEdges() const
return all router edges
std::set< const NBEdge * > myWasSplit
the edges that were created as result of splitting
Definition: NBEdgeCont.h:736
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.
Definition: NBEdgeCont.cpp:436
void ignore(std::string id)
mark the given edge id as ignored
Definition: NBEdgeCont.h:478
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:722
std::set< std::string > myEdges2Keep
Set of ids of edges which shall explicitly be kept.
Definition: NBEdgeCont.h:748
NBTypeCont & myTypeCont
The network builder; used to obtain type information.
Definition: NBEdgeCont.h:612
bool wasIgnored(std::string id) const
Returns whether the edge with the id was ignored during parsing.
Definition: NBEdgeCont.h:473
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:833
std::set< EdgeSet > myGuessedRoundabouts
Edges marked as belonging to a roundabout after guessing.
Definition: NBEdgeCont.h:776
bool hasGuessedRoundabouts() const
check if there is guessed roundabouts
Definition: NBEdgeCont.h:539
void computeAngles()
compute all edge angles
void clear()
Deletes all edges.
Definition: NBEdgeCont.cpp:163
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:763
void applyOptions(OptionsCont &oc)
Initialises the storage by applying given options.
Definition: NBEdgeCont.cpp:78
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:766
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:757
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:483
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:931
SVCPermissions myVehicleClasses2Keep
Set of vehicle types which must be allowed on edges in order to keep them.
Definition: NBEdgeCont.h:754
void computeLaneShapes()
Computes the shapes of all lanes of all edges stored in the container.
Definition: NBEdgeCont.cpp:993
void joinSameNodeConnectingEdges(NBDistrictCont &dc, NBTrafficLightLogicCont &tlc, EdgeVector edges)
Joins the given edges because they connect the same nodes.
bool myRemoveEdgesAfterJoining
Whether edges shall be joined first, then removed.
Definition: NBEdgeCont.h:745
std::map< std::string, NBEdge * > EdgeCont
The type of the dictionary where an edge may be found by its id.
Definition: NBEdgeCont.h:719
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:734
std::map< std::string, std::vector< PostProcessConnection > > myConnections
The list of connections to recheck.
Definition: NBEdgeCont.h:716
bool insert(NBEdge *edge, bool ignorePrunning=false)
Adds an edge to the dictionary.
Definition: NBEdgeCont.cpp:182
NBEdgeCont(NBTypeCont &tc)
Constructor.
Definition: NBEdgeCont.cpp:64
std::set< NBEdge * > myEdgeCemetery
The edges which got extracted twice but may still be referenced somewhere TODO smart_ptr?
Definition: NBEdgeCont.h:728
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:602
std::vector< std::string > getAllNames() const
Returns all ids of known edges.
Definition: NBEdgeCont.cpp:756
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:57
Represents a single node (junction) during network building.
Definition: NBNode.h:66
Container for public transport stops during the net building process.
Definition: NBPTStopCont.h:44
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.
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:617
double customLength
custom length for connection
Definition: NBEdgeCont.h:684
bool warnOnly
whether a failure to set this connection is a warning or an error
Definition: NBEdgeCont.h:708
bool uncontrolled
whether this connection shall not be controlled by a traffic light
Definition: NBEdgeCont.h:690
SVCPermissions changeRight
custom lane changing permissions for connection
Definition: NBEdgeCont.h:705
double visibility
custom foe visiblity for connection
Definition: NBEdgeCont.h:675
int toLane
The number of the lane the connection ends at.
Definition: NBEdgeCont.h:663
PositionVector customShape
custom shape for connection
Definition: NBEdgeCont.h:687
KeepClear keepClear
Whether the connection may be passed without braking.
Definition: NBEdgeCont.h:669
double speed
custom speed for connection
Definition: NBEdgeCont.h:678
bool mayDefinitelyPass
Whether the connection may be passed without braking.
Definition: NBEdgeCont.h:666
SVCPermissions changeLeft
custom lane changing permissions for connection
Definition: NBEdgeCont.h:702
double contPos
custom position for internal junction on this connection
Definition: NBEdgeCont.h:672
std::string from
The id of the edge the connection starts at.
Definition: NBEdgeCont.h:654
double friction
custom friction for connection
Definition: NBEdgeCont.h:681
std::string edgeType
custom edge type
Definition: NBEdgeCont.h:699
SVCPermissions permissions
custom permissions for connection
Definition: NBEdgeCont.h:693
std::string to
The id of the edge the connection ends at.
Definition: NBEdgeCont.h:660
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:627
int fromLane
The number of the lane the connection starts at.
Definition: NBEdgeCont.h:657
bool indirectLeft
whether this connection is an indirect left turn
Definition: NBEdgeCont.h:696
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