The representation of a single edge during network building. More...

#include <NBEdge.h>

Inheritance diagram for NBEdge:

Collaboration diagram for NBEdge:

Data Structures
struct	Connection
	A structure which describes a connection between edges or lanes. More...

class	connections_conflict_finder

class	connections_finder

class	connections_fromlane_finder

class	connections_relative_edgelane_sorter
	Class to sort edges by their angle. More...

class	connections_toedge_finder

class	connections_toedgelane_finder

struct	Lane
	An (internal) definition of a single lane of an edge. More...

class	MainDirections
	Holds (- relative to the edge it is build from -!!!) the list of main directions a vehicle that drives on this street may take on the junction the edge ends in The back direction is not regarded. More...

class	ToEdgeConnectionsAdder
	A class that being a bresenham-callback assigns the incoming lanes to the edges. More...

Public Types
enum class	EdgeBuildingStep { INIT_REJECT_CONNECTIONS , INIT , EDGE2EDGES , LANES2EDGES , LANES2LANES_RECHECK , LANES2LANES_DONE , LANES2LANES_USER }
	Current state of the edge within the building process. More...

enum	JunctionPriority { MINOR_ROAD = 0 , PRIORITY_ROAD = 1 , ROUNDABOUT = 1000 }
	junction priority values set by setJunctionPriority More...

enum class	Lane2LaneInfoType { COMPUTED , USER , VALIDATED }
	Modes of setting connections between lanes. More...

typedef std::map< std::string, std::string >	Map
	parameters map

Public Member Functions
void	addBikeLane (double width)
	add a bicycle lane of the given width and shift existing connctions

void	addLane (int index, bool recomputeShape, bool recomputeConnections, bool shiftIndices)
	add lane

void	addRestrictedLane (double width, SUMOVehicleClass vclass)
	add a lane of the given width, restricted to the given class and shift existing connections

void	addSidewalk (double width)
	add a pedestrian sidewalk of the given width and shift existing connctions

void	addSign (NBSign sign)
	add Sign

void	addTo (const StoringVisitor &cont) const
	Adds this object to the given container.

void	allowVehicleClass (int lane, SUMOVehicleClass vclass)
	set allowed class for the given lane or for all lanes if -1 is given

void	append (NBEdge *continuation)
	append another edge

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 (myTurnDestination!=0)

double	buildInnerEdges (const NBNode &n, int noInternalNoSplits, int &linkIndex, int &splitIndex)

void	clearControllingTLInformation ()
	clears tlID for all connections

void	clearParameter ()
	Clears the parameter map.

bool	computeEdge2Edges (bool noLeftMovers)
	computes the edge (step1: computation of approached edges)

bool	computeLanes2Edges ()
	computes the edge, step2: computation of which lanes approach the edges)

PositionVector	cutAtIntersection (const PositionVector &old) const
	cut shape at the intersection shapes

void	debugPrintConnections (bool outgoing=true, bool incoming=false) const
	debugging helper to print all connections

void	decLaneNo (int by)
	decrement lane

void	declareConnectionsAsLoaded (EdgeBuildingStep step=EdgeBuildingStep::LANES2LANES_USER)
	declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has no connections intentionally.

void	deleteLane (int index, bool recompute, bool shiftIndices)
	delete lane

void	disallowVehicleClass (int lane, SUMOVehicleClass vclass)
	set disallowed class for the given lane or for all lanes if -1 is given

void	dismissVehicleClassInformation ()
	dimiss vehicle class information

bool	expandableBy (NBEdge *possContinuation, std::string &reason) const
	Check if Node is expandable.

double	getAngleAtNode (const NBNode *const node) const
	Returns the angle of the edge's geometry at the given node.

double	getAngleAtNodeNormalized (const NBNode *const node) const
	Returns the angle of the edge's geometry at the given node and disregards edge direction.

double	getAngleAtNodeToCenter (const NBNode *const node) const
	Returns the angle of from the node shape center to where the edge meets the node shape.

PositionVector	getCCWBoundaryLine (const NBNode &n) const
	get the outer boundary of this edge when going counter-clock-wise around the given node

PositionVector	getCWBoundaryLine (const NBNode &n) const
	get the outer boundary of this edge when going clock-wise around the given node

double	getDouble (const std::string &key, const double defaultValue) const
	Returns the value for a given key converted to a double.

std::vector< double >	getDoubles (const std::string &key, std::vector< double > defaultValue=std::vector< double >()) const
	Returns the value for a given key converted to a list of doubles.

int	getJunctionPriority (const NBNode *const node) const
	Returns the junction priority (normalised for the node currently build)

double	getLaneFriction (int lane) const
	get lane friction of specified lane

std::string	getLaneID (int lane) const
	get lane ID

double	getLaneSpeed (int lane) const
	get lane speed

Lane &	getLaneStruct (int lane)

const Lane &	getLaneStruct (int lane) const

double	getMaxLaneOffset ()
	get max lane offset

const PositionVector &	getNodeBorder (const NBNode *node) const

virtual const std::string	getParameter (const std::string &key, const std::string defaultValue="") const
	Returns the value for a given key.

const Parameterised::Map &	getParametersMap () const
	Returns the inner key/value map.

std::string	getParametersStr (const std::string kvsep="=", const std::string sep="\|") const
	Returns the inner key/value map in string format "key1=value1\|key2=value2\|...\|keyN=valueN".

SVCPermissions	getPermissions (int lane=-1) const
	get the union of allowed classes over all lanes or for a specific lane

const std::vector< NBSign > &	getSigns () const
	get Signs

NBEdge *	getTurnDestination (bool possibleDestination=false) const

const std::string &	getTypeID () const
	get ID of type

bool	hasAccelLane () const
	whether one of the lanes is an acceleration lane

bool	hasCustomLaneShape () const
	whether one of the lanes has a custom shape

bool	hasLaneParams () const
	whether one of the lanes has parameters set

bool	hasLaneSpecificEndOffset () const
	whether lanes differ in offset

bool	hasLaneSpecificFriction () const
	whether lanes differ in friction

bool	hasLaneSpecificPermissions () const
	whether lanes differ in allowed vehicle classes

bool	hasLaneSpecificSpeed () const
	whether lanes differ in speed

bool	hasLaneSpecificStopOffsets () const
	whether lanes differ in stopOffsets

bool	hasLaneSpecificType () const
	whether lanes differ in type

bool	hasLaneSpecificWidth () const
	whether lanes differ in width

bool	hasParameter (const std::string &key) const
	Returns whether the parameter is set.

bool	hasPermissions () const
	whether at least one lane has restrictions

bool	hasSignalisedConnectionTo (const NBEdge *const e) const
	Check if edge has signalised connections.

void	incLaneNo (int by)
	increment lane

bool	isBidi ()
	return whether this edge should be a bidi edge

bool	isBidiEdge (bool checkPotential=false) const
	whether this edge is part of a bidirectional edge pair

bool	isBidiRail (bool ignoreSpread=false) const
	whether this edge is part of a bidirectional railway

virtual bool	isInternal () const

bool	isNearEnough2BeJoined2 (NBEdge *e, double threshold) const
	Check if edge is near enought to be joined to another edge.

bool	isOffRamp () const

bool	isRailDeadEnd () const
	whether this edge is a railway edge that does not continue

bool	isTurningDirectionAt (const NBEdge *const edge) const
	Returns whether the given edge is the opposite direction to this edge.

bool	lanesWereAssigned () const
	Check if lanes were assigned.

void	markAsInLane2LaneState ()
	mark edge as in lane to state lane

void	markOffRamp (bool isOffRamp)
	marks this edge has being an offRamp or leading to one (used for connection computation)

bool	mayBeTLSControlled (int fromLane, NBEdge *toEdge, int toLane) const
	return true if certain connection must be controlled by TLS

void	mergeParameters (const Parameterised::Map &mapArg, const std::string separator=" ", bool uniqueValues=true)
	Adds or appends all given parameters from the map.

void	moveOutgoingConnectionsFrom (NBEdge *e, int laneOff)
	move outgoing connection

	NBEdge (const std::string &id, NBNode from, NBNode to, const NBEdge *tpl, const PositionVector &geom=PositionVector(), int numLanes=-1)
	Constructor.

	NBEdge (const std::string &id, NBNode from, NBNode to, std::string type, double speed, double friction, int nolanes, int priority, double width, double endOffset, LaneSpreadFunction spread, const std::string &streetName="")
	Constructor.

	NBEdge (const std::string &id, NBNode from, NBNode to, std::string type, double speed, double friction, int nolanes, int priority, double width, double endOffset, PositionVector geom, LaneSpreadFunction spread, const std::string &streetName="", const std::string &origID="", bool tryIgnoreNodePositions=false)
	Constructor.

bool	needsLaneSpecificOutput () const
	whether at least one lane has values differing from the edges values

void	preferVehicleClass (int lane, SVCPermissions vclasses)
	prefer certain vehicle classes for the given lane or for all lanes if -1 is given (ensures also permissions)

bool	prohibits (const NBVehicle *const) const

bool	prohibitsChanging () const
	whether one of the lanes prohibits lane changing

bool	recheckLanes ()
	recheck whether all lanes within the edge are all right and optimises the connections once again

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.

void	reinitNodes (NBNode from, NBNode to)
	Resets nodes but keeps all other values the same (used when joining)

void	resetNodeBorder (const NBNode *node)

void	restoreBikelane (std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
	restore an previously added BikeLane

void	restoreSidewalk (std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
	restore an previously added sidewalk

bool	restricts (const NBVehicle *const) const

void	setAcceleration (int lane, bool accelRamp)
	marks one lane as acceleration lane

void	setAverageLengthWithOpposite (double val)
	patch average lane length in regard to the opposite edge

void	setBidi (bool isBidi)
	mark this edge as a bidi edge

bool	setControllingTLInformation (const NBConnection &c, const std::string &tlID)
	Returns if the link could be set as to be controlled.

void	setDistance (double distance)
	set kilometrage at start of edge (negative value implies couting down along the edge)

bool	setEdgeStopOffset (int lane, const StopOffset &offset, bool overwrite=false)
	set lane and vehicle class specific stopOffset (negative lane implies set for all lanes)

void	setEndOffset (int lane, double offset)
	set lane specific end-offset (negative lane implies set for all lanes)

void	setFriction (int lane, double friction)
	set lane specific friction (negative lane implies set for all lanes)

virtual void	setID (const std::string &newID)
	resets the id

void	setJunctionPriority (const NBNode *const node, int prio)
	Sets the junction priority of the edge.

void	setLaneShape (int lane, const PositionVector &shape)
	sets a custom lane shape

void	setLaneType (int lane, const std::string &type)
	set lane specific type (negative lane implies set for all lanes)

void	setLaneWidth (int lane, double width)
	set lane specific width (negative lane implies set for all lanes)

void	setLoadedLength (double val)
	set loaded length

void	setNodeBorder (const NBNode *node, const Position &p, const Position &p2, bool rectangularCut)
	Set Node border.

void	setOrigID (const std::string origID, const bool append, const int laneIdx=-1)
	set origID for all lanes or for a specific lane

virtual void	setParameter (const std::string &key, const std::string &value)
	Sets a parameter.

void	setParameters (const Parameterised &params)
	set the inner key/value map in map<string, string> format

void	setParametersStr (const std::string &paramsString, const std::string kvsep="=", const std::string sep="\|")
	set the inner key/value map in string format "key1=value1\|key2=value2\|...\|keyN=valueN"

void	setPermissions (SVCPermissions permissions, int lane=-1)
	set allowed/disallowed classes for the given lane or for all lanes if -1 is given

void	setPermittedChanging (int lane, SVCPermissions changeLeft, SVCPermissions changeRight)
	set allowed classes for changing to the left and right from the given lane

void	setPreferredVehicleClass (SVCPermissions permissions, int lane=-1)
	set preferred Vehicle Class

void	setSpeed (int lane, double speed)
	set lane specific speed (negative lane implies set for all lanes)

void	setTurningDestination (NBEdge *e, bool onlyPossible=false)
	Sets the turing destination at the given edge.

NBNode *	tryGetNodeAtPosition (double pos, double tolerance=5.0) const
	Returns the node at the given edges length (using an epsilon)

void	unsetParameter (const std::string &key)
	Removes a parameter.

void	updateParameters (const Parameterised::Map &mapArg)
	Adds or updates all given parameters from the map.

void	writeParams (OutputDevice &device) const
	write Params in the given outputdevice

	~NBEdge ()
	Destructor.

Applying offset
void	reshiftPosition (double xoff, double yoff)
	Applies an offset to the edge.

void	mirrorX ()
	mirror coordinates along the x-axis

Atomar getter methods
int	getNumLanes () const
	Returns the number of lanes.

int	getPriority () const
	Returns the priority of the edge.

void	setPriority (int priority)
	Sets the priority of the edge.

NBNode *	getFromNode () const
	Returns the origin node of the edge.

NBNode *	getToNode () const
	Returns the destination node of the edge.

double	getStartAngle () const
	Returns the angle at the start of the edge (relative to the node shape center) The angle is computed in computeAngle()

double	getEndAngle () const
	Returns the angle at the end of the edge (relative to the node shape center) The angle is computed in computeAngle()

double	getShapeStartAngle () const
	Returns the angle at the start of the edge.

double	getShapeEndAngle () const
	Returns the angle at the end of the edge.

double	getTotalAngle () const
	Returns the angle at the start of the edge.

double	getLength () const
	Returns the computed length of the edge.

double	getLoadedLength () const
	Returns the length was set explicitly or the computed length if it wasn't set.

double	getFinalLength () const
	get length that will be assigned to the lanes in the final network

bool	hasLoadedLength () const
	Returns whether a length was set explicitly.

double	getSpeed () const
	Returns the speed allowed on this edge.

double	getFriction () const
	Returns the friction on this edge.

EdgeBuildingStep	getStep () const
	The building step of this edge.

double	getLaneWidth () const
	Returns the default width of lanes of this edge.

double	getLaneWidth (int lane) const
	Returns the width of the lane of this edge.

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.

double	getTotalWidth () const
	Returns the combined width of all lanes of this edge.

const std::string &	getStreetName () const
	Returns the street name of this edge.

void	setStreetName (const std::string &name)
	sets the street name of this edge

double	getDistance () const
	get distance

double	getDistancAt (double pos) const
	get distance at the given offset

double	getEndOffset () const
	Returns the offset to the destination node.

double	getEndOffset (int lane) const
	Returns the offset to the destination node a the specified lane.

const StopOffset &	getEdgeStopOffset () const
	Returns the stopOffset to the end of the edge.

const StopOffset &	getLaneStopOffset (int lane) const
	Returns the stop offset to the specified lane's end.

double	getSignalOffset () const
	Returns the offset of a traffic signal from the end of this edge.

const Position &	getSignalPosition () const
	Returns the position of a traffic signal on this edge.

const NBNode *	getSignalNode () const
	Returns the node that (possibly) represents a traffic signal controlling at the end of this edge.

void	setSignalPosition (const Position &pos, const NBNode *signalNode)
	sets the offset of a traffic signal from the end of this edge

const std::vector< NBEdge::Lane > &	getLanes () const
	Returns the lane definitions.

int	getFirstNonPedestrianLaneIndex (int direction, bool exclusive=false) const
	return the first lane with permissions other than SVC_PEDESTRIAN and 0

int	getFirstNonPedestrianNonBicycleLaneIndex (int direction, bool exclusive=false) const
	return the first lane with permissions other than SVC_PEDESTRIAN, SVC_BICYCLE and 0

int	getSpecialLane (SVCPermissions permissions) const
	return index of the first lane that allows the given permissions

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 no such lane

NBEdge::Lane	getFirstNonPedestrianLane (int direction) const
	@brif get first non-pedestrian lane

std::set< SVCPermissions >	getPermissionVariants (int iStart, int iEnd) const
	return all permission variants within the specified lane range [iStart, iEnd[

int	getNumLanesThatAllow (SVCPermissions permissions, bool allPermissions=true) const

bool	allowsChangingLeft (int lane, SUMOVehicleClass vclass) const
	Returns whether the given vehicle class may change left from this lane.

bool	allowsChangingRight (int lane, SUMOVehicleClass vclass) const
	Returns whether the given vehicle class may change left from this lane.

double	getCrossingAngle (NBNode *node)
	return the angle for computing pedestrian crossings at the given node

std::string	getSidewalkID ()
	get the lane id for the canonical sidewalk lane

Edge geometry access and computation
const PositionVector &	getGeometry () const
	Returns the geometry of the edge.

const PositionVector	getInnerGeometry () const
	Returns the geometry of the edge without the endpoints.

bool	hasDefaultGeometry () const
	Returns whether the geometry consists only of the node positions.

bool	hasDefaultGeometryEndpoints () const
	Returns whether the geometry is terminated by the node positions This default may be violated by initializing with tryIgnoreNodePositions=true' or with setGeometry() non-default endpoints are useful to control the generated node shape.

bool	hasDefaultGeometryEndpointAtNode (const NBNode *node) const
	Returns whether the geometry is terminated by the node positions This default may be violated by initializing with tryIgnoreNodePositions=true' or with setGeometry() non-default endpoints are useful to control the generated node shape.

Position	getEndpointAtNode (const NBNode *node) const

void	resetEndpointAtNode (const NBNode *node)

void	setGeometry (const PositionVector &g, bool inner=false)
	(Re)sets the edge's geometry

void	addGeometryPoint (int index, const Position &p)
	Adds a further geometry point.

void	extendGeometryAtNode (const NBNode *node, double maxExtent)
	linearly extend the geometry at the given node

void	shortenGeometryAtNode (const NBNode *node, double reduction)
	linearly extend the geometry at the given node

void	shiftPositionAtNode (NBNode node, NBEdge opposite)
	shift geometry at the given node to avoid overlap

Position	geometryPositionAtOffset (double offset) const
	return position taking into account loaded length

void	computeEdgeShape (double smoothElevationThreshold=-1)
	Recomputeds the lane shapes to terminate at the node shape For every lane the intersection with the fromNode and toNode is calculated and the lane shorted accordingly. The edge length is then set to the average of all lane lengths (which may differ). This average length is used as the lane length when writing the network.

const PositionVector &	getLaneShape (int i) const
	Returns the shape of the nth lane.

void	setLaneSpreadFunction (LaneSpreadFunction spread)
	(Re)sets how the lanes lateral offset shall be computed

LaneSpreadFunction	getLaneSpreadFunction () const
	Returns how this edge's lanes' lateral offset is computed.

void	reduceGeometry (const double minDist)
	Removes points with a distance lesser than the given.

void	checkGeometry (const double maxAngle, bool fixAngle, const double minRadius, bool fix, bool silent)
	Check the angles of successive geometry segments.

Setting/getting special types
Marks this edge as a macroscopic connector
void	setAsMacroscopicConnector ()

bool	isMacroscopicConnector () const
	Returns whether this edge was marked as a macroscopic connector.

void	setInsideTLS (bool inside)
	Marks this edge being within an intersection.

bool	isInsideTLS () const
	Returns whether this edge was marked as being within an intersection.

Static Public Member Functions
static bool	areAttributesValid (const std::string &value, bool report=false, const std::string kvsep="=", const std::string sep="\|")
	check if given string can be parsed to an attributes map "key1=value1\|key2=value2\|...\|keyN=valueN" (used in generic datas)

static bool	areParametersValid (const std::string &value, bool report=false, const std::string kvsep="=", const std::string sep="\|")
	check if given string can be parsed to a parameters map "key1=value1\|key2=value2\|...\|keyN=valueN"

static bool	connections_sorter (const Connection &c1, const Connection &c2)
	connections_sorter sort by fromLane, toEdge and toLane

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 widths

template<class T >
static std::string	getIDSecure (const T *obj, const std::string &fallBack="NULL")
	get an identifier for Named-like object which may be Null

static double	getTravelTimeStatic (const NBRouterEdge const edge, const NBVehicle const, double)

static void	setDefaultConnectionLength (double length)

static PositionVector	startShapeAt (const PositionVector &laneShape, const NBNode *startNode, PositionVector nodeShape)

Static Public Attributes
static const double	ANGLE_LOOKAHEAD = 10.0
	the distance at which to take the default angle

static NBEdge	DummyEdge
	Dummy edge to use when a reference must be supplied in the no-arguments constructor (FOX technicality)

static const int	TURN_SIGN_SHIFT_BICYCLE = 24

static const int	TURN_SIGN_SHIFT_BUS = 8
	shift values for decoding turn signs

static const int	TURN_SIGN_SHIFT_TAXI = 16

static const bool	UNSPECIFIED_CONNECTION_UNCONTROLLED = false
	TLS-controlled despite its node controlled not specified.

static const double	UNSPECIFIED_CONTPOS = -1
	unspecified internal junction position

static const double	UNSPECIFIED_FRICTION = 1.
	unspecified lane friction

static const int	UNSPECIFIED_INTERNAL_LANE_INDEX = -1
	internal lane computation not yet done

static const double	UNSPECIFIED_LOADED_LENGTH = -1
	no length override given

static const double	UNSPECIFIED_OFFSET = 0
	unspecified lane offset

static const double	UNSPECIFIED_SIGNAL_OFFSET = -1
	unspecified signal offset

static const double	UNSPECIFIED_SPEED = -1
	unspecified lane speed

static const double	UNSPECIFIED_VISIBILITY_DISTANCE = -1
	unspecified foe visibility for connections

static const double	UNSPECIFIED_WIDTH = -1
	unspecified lane width

Protected Attributes
std::string	myID
	The name of the object.

Private Member Functions
bool	applyTurnSigns ()
	apply loaded turn sign information

double	assignInternalLaneLength (std::vector< Connection >::iterator i, int numLanes, double lengthSum, bool averageLength)
	assign length to all lanes of an internal edge

bool	bothLeftTurns (LinkDirection dir, const NBEdge *otherFrom, LinkDirection dir2) const
	determine conflict between opposite left turns

void	computeAngle ()
	computes the angle of this edge and stores it in myAngle

bool	hasRestrictedLane (SUMOVehicleClass vclass) const
	returns whether any lane already allows the given vclass exclusively

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

	NBEdge ()
	constructor for dummy edge

	NBEdge (const NBEdge &s)=delete
	invalidated copy constructor

NBEdge &	operator= (const NBEdge &s)=delete
	invalidated assignment operator

void	removeInvalidConnections ()

void	restoreRestrictedLane (SUMOVehicleClass vclass, std::vector< NBEdge::Lane > oldLanes, PositionVector oldGeometry, std::vector< NBEdge::Connection > oldConnections)
	restore a restricted lane

Static Private Member Functions
static std::vector< LinkDirection >	decodeTurnSigns (int turnSigns, int shift=0)
	decode bitset

static bool	isParameterValid (const std::string &value, const std::string &kvsep, const std::string &sep)
	check if given string can be parsed to a parameter of type "key=value"

static void	updateTurnPermissions (SVCPermissions &perm, LinkDirection dir, SVCPermissions spec, std::vector< LinkDirection > dirs)

Private Attributes
bool	myAmInTLS
	Information whether this is lies within a joined tls.

bool	myAmMacroscopicConnector
	Information whether this edge is a (macroscopic) connector.

std::vector< Connection >	myConnections
	List of connections to following edges.

std::vector< Connection >	myConnectionsToDelete
	List of connections marked for delayed removal.

double	myDistance
	The mileage/kilometrage at the start of this edge in a linear coordination system.

StopOffset	myEdgeStopOffset
	A vClass specific stop offset - assumed of length 0 (unspecified) or 1. For the latter case the int is a bit set specifying the vClasses, the offset applies to (see SUMOVehicleClass.h), and the double is the stopping offset in meters from the lane end.

double	myEndOffset
	This edges's offset to the intersection begin (will be applied to all lanes)

double	myFriction
	The current friction.

NBNode *	myFrom
	The source and the destination node.

int	myFromJunctionPriority
	The priority normalised for the node the edge is outgoing of.

PositionVector	myGeom
	The geometry for the edge.

int	myIndex
	the index of the edge in the list of all edges. Set by NBEdgeCont and requires re-set whenever the list of edges changes

bool	myIsBidi
	whether this edge is part of a non-rail bidi edge pair

bool	myIsOffRamp
	whether this edge is an Off-Ramp or leads to one

std::vector< Lane >	myLanes
	Lane information.

LaneSpreadFunction	myLaneSpreadFunction
	The information about how to spread the lanes.

double	myLaneWidth
	This width of this edge's lanes.

double	myLength
	The length of the edge.

double	myLoadedLength
	An optional length to use (-1 if not valid)

Parameterised::Map	myMap
	The key->value map.

NBEdge *	myPossibleTurnDestination
	The edge that would be the turn destination if there was one.

int	myPriority
	The priority of the edge.

const NBNode *	mySignalNode

Position	mySignalPosition
	the position of a traffic light signal on this edge

std::vector< NBSign >	mySigns
	the street signs along this edge

double	mySpeed
	The maximal speed.

EdgeBuildingStep	myStep
	The building step.

std::string	myStreetName
	The street name (or whatever arbitrary string you wish to attach)

EdgeVector	mySuccessors

NBNode *	myTo

int	myToJunctionPriority
	The priority normalised for the node the edge is incoming in.

NBEdge *	myTurnDestination
	The turn destination edge (if a connection exists)

std::string	myTurnSignTarget
	node for which turnSign information applies

std::string	myType
	The type of the edge.

ConstRouterEdgePairVector	myViaSuccessors


double	myStartAngle
	The angles of the edge.

double	myEndAngle

double	myTotalAngle


PositionVector	myFromBorder
	intersection borders (because the node shape might be invalid)

PositionVector	myToBorder

Static Private Attributes
static double	myDefaultConnectionLength = NBEdge::UNSPECIFIED_LOADED_LENGTH

Friends
class	GNEEdge

class	GNEJunction

class	GNELane

class	NBEdgeCont

functions for router usage
static double	getTravelTimeStatic (const NBEdge const edge, const NBVehicle const, double)

static int	getLaneIndexFromLaneID (const std::string laneID)

static EdgeVector	filterByPermissions (const EdgeVector &edges, SVCPermissions permissions)
	return only those edges that permit at least one of the give permissions

void	setNumericalID (int index)
	sets the index of the edge in the list of all network edges

int	getNumericalID () const
	Returns the index (numeric id) of the edge.

const NBEdge *	getBidiEdge () const

const EdgeVector &	getSuccessors (SUMOVehicleClass vClass=SVC_IGNORING) const
	Returns the following edges for the given vClass.

const ConstRouterEdgePairVector &	getViaSuccessors (SUMOVehicleClass vClass=SVC_IGNORING, bool ignoreTransientPermissions=false) const
	Returns the following edges for the given vClass.

const std::string &	getID () const

bool	joinLanes (SVCPermissions perms)
	join adjacent lanes with the given permissions

void	resetLaneShapes ()
	reset lane shapes to what they would be before cutting with the junction shapes

void	updateChangeRestrictions (SVCPermissions ignoring)
	modify all existing restrictions on lane changing

NBEdge *	getStraightContinuation (SVCPermissions permissions) const
	return the straightest follower edge for the given permissions or nullptr (never returns turn-arounds)

NBEdge *	getStraightPredecessor (SVCPermissions permissions) const
	return the straightest predecessor edge for the given permissions or nullptr (never returns turn-arounds)

NBEdge *	guessOpposite (bool reguess=false)
	set oppositeID and return opposite edge if found

const std::string &	getTurnSignTarget () const

void	setTurnSignTarget (const std::string &target)

PositionVector	computeLaneShape (int lane, double offset) const
	Computes the shape for the given lane.

void	computeLaneShapes ()
	compute lane shapes

void	init (int noLanes, bool tryIgnoreNodePositions, const std::string &origID)
	Initialization routines common to all constructors.

void	divideOnEdges (const EdgeVector *outgoing)
	divides the lanes on the outgoing edges

void	divideSelectedLanesOnEdges (const EdgeVector *outgoing, const std::vector< int > &availableLanes)
	divide selected lanes on edges

void	addStraightConnections (const EdgeVector *outgoing, const std::vector< int > &availableLanes, const std::vector< int > &priorities)
	add some straight connections

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 more like in real-life

Setting and getting connections
bool	addEdge2EdgeConnection (NBEdge *dest, bool overrideRemoval=false, SVCPermissions permission=SVC_UNSPECIFIED)
	Adds a connection to another edge.

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.

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.

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.

std::vector< Connection >	getConnectionsFromLane (int lane, const NBEdge *to=nullptr, int toLane=-1) const
	Returns connections from a given lane.

const Connection &	getConnection (int fromLane, const NBEdge *to, int toLane) const
	Returns the specified connection (unmodifiable) This method goes through "myConnections" and returns the specified one.

Connection &	getConnectionRef (int fromLane, const NBEdge *to, int toLane)
	Returns reference to the specified connection This method goes through "myConnections" and returns the specified one.

bool	hasConnectionTo (const NBEdge *destEdge, int destLane, int fromLane=-1) const
	Retrieves info about a connection to a certain lane of a certain edge.

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)

const std::vector< Connection > &	getConnections () const
	Returns the connections.

std::vector< Connection > &	getConnections ()
	Returns the connections.

const EdgeVector *	getConnectedSorted ()
	Returns the list of outgoing edges without the turnaround sorted in clockwise direction.

EdgeVector	getConnectedEdges () const
	Returns the list of outgoing edges unsorted.

EdgeVector	getIncomingEdges () const
	Returns the list of incoming edges unsorted.

std::vector< int >	getConnectionLanes (NBEdge *currentOutgoing, bool withBikes=true) const
	Returns the list of lanes that may be used to reach the given edge.

void	sortOutgoingConnectionsByAngle ()
	sorts the outgoing connections by their angle relative to their junction

void	sortOutgoingConnectionsByIndex ()
	sorts the outgoing connections by their from-lane-index and their to-lane-index

void	remapConnections (const EdgeVector &incoming)
	Remaps the connection in a way that allows the removal of it.

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)

bool	removeFromConnections (const NBEdge::Connection &connectionToRemove)
	remove an existent connection of edge

void	invalidateConnections (bool reallowSetting=false)
	invalidate current connections of edge

void	replaceInConnections (NBEdge which, NBEdge by, int laneOff)
	replace in current connections of edge

void	replaceInConnections (NBEdge *which, const std::vector< NBEdge::Connection > &origConns)
	replace in current connections of edge

void	copyConnectionsFrom (NBEdge *src)
	copy connections from antoher edge

void	shiftToLanesToEdge (NBEdge *to, int laneOff)
	modifify the toLane for all connections to the given edge

void	moveConnectionToLeft (int lane)

void	moveConnectionToRight (int lane)

bool	canMoveConnection (const Connection &con, int newFromLane) const
	whether the connection can originate on newFromLane

Detailed Description

The representation of a single edge during network building.

Definition at line 92 of file NBEdge.h.

Member Typedef Documentation

◆ Map

typedef std::map<std::string, std::string> Parameterised::Map

inherited

parameters map

Definition at line 45 of file Parameterised.h.

Member Enumeration Documentation

◆ EdgeBuildingStep

enum class NBEdge::EdgeBuildingStep

strong

Current state of the edge within the building process.

As the network is build in a cascaded way, considering loaded information, a counter holding the current step is needed. This is done by using this enumeration.

Enumerator
INIT_REJECT_CONNECTIONS	The edge has been loaded and connections shall not be added.
INIT	The edge has been loaded, nothing is computed yet.
EDGE2EDGES	The relationships between edges are computed/loaded.
LANES2EDGES	Lanes to edges - relationships 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.
LANES2LANES_USER	Lanes to lanes - relationships are loaded; no recheck is necessary/wished.

Definition at line 109 of file NBEdge.h.

◆ JunctionPriority

enum NBEdge::JunctionPriority

junction priority values set by setJunctionPriority

Enumerator
MINOR_ROAD
PRIORITY_ROAD
ROUNDABOUT

Definition at line 384 of file NBEdge.h.

◆ Lane2LaneInfoType

enum class NBEdge::Lane2LaneInfoType

strong

Modes of setting connections between lanes.

Enumerator
COMPUTED	The connection was computed.
USER	The connection was given by the user.
VALIDATED	The connection was computed and validated.

Definition at line 130 of file NBEdge.h.

Constructor & Destructor Documentation

◆ NBEdge() [1/5]

NBEdge::NBEdge	(	const std::string &	id,
		NBNode *	from,
		NBNode *	to,
		std::string	type,
		double	speed,
		double	friction,
		int	nolanes,
		int	priority,
		double	width,
		double	endOffset,
		LaneSpreadFunction	spread,
		const std::string &	streetName = `""`
	)

Constructor.

Use this if no edge geometry is given.

Parameters

[in]	id	The id of the edge
[in]	from	The node the edge starts at
[in]	to	The node the edge ends at
[in]	type	The type of the edge (my be =="")
[in]	speed	The maximum velocity allowed on this edge
[in]	friction	The current friction coefficient on this edge
[in]	nolanes	The number of lanes this edge has
[in]	priority	This edge's priority
[in]	width	This edge's lane width
[in]	endOffset	Additional offset to the destination node
[in]	spread	How the lateral offset of the lanes shall be computed
[in]	streetName	The street name (need not be unique)

See also: init; LaneSpreadFunction

Definition at line 256 of file NBEdge.cpp.

References init().

◆ NBEdge() [2/5]

NBEdge::NBEdge	(	const std::string &	id,
		NBNode *	from,
		NBNode *	to,
		std::string	type,
		double	speed,
		double	friction,
		int	nolanes,
		int	priority,
		double	width,
		double	endOffset,
		PositionVector	geom,
		LaneSpreadFunction	spread,
		const std::string &	streetName = `""`,
		const std::string &	origID = `""`,
		bool	tryIgnoreNodePositions = `false`
	)

Constructor.

Use this if the edge's geometry is given.

Parameters

[in]	id	The id of the edge
[in]	from	The node the edge starts at
[in]	to	The node the edge ends at
[in]	type	The type of the edge (may be =="")
[in]	speed	The maximum velocity allowed on this edge
[in]	friction	The current friction coefficient on this edge
[in]	nolanes	The number of lanes this edge has
[in]	priority	This edge's priority
[in]	width	This edge's lane width
[in]	endOffset	Additional offset to the destination node
[in]	geom	The edge's geomatry
[in]	spread	How the lateral offset of the lanes shall be computed
[in]	streetName	The street name (need not be unique)
[in]	origID	The original ID in the source network (need not be unique)
[in]	spread	How the lateral offset of the lanes shall be computed
[in]	tryIgnoreNodePositions	Does not add node geometries if geom.size()>=2

See also: init

Definition at line 284 of file NBEdge.cpp.

References init().

◆ NBEdge() [3/5]

NBEdge::NBEdge	(	const std::string &	id,
		NBNode *	from,
		NBNode *	to,
		const NBEdge *	tpl,
		const PositionVector &	geom = `PositionVector()`,
		int	numLanes = `-1`
	)

Constructor.

Use this to copy attributes from another edge

Parameters

[in]	id	The id of the edge
[in]	from	The node the edge starts at
[in]	to	The node the edge ends at
[in]	tpl	The template edge to copy attributes from
[in]	geom	The geometry to use (may be empty)
[in]	numLanes	The number of lanes of the new edge (copy from tpl by default)

Definition at line 316 of file NBEdge.cpp.

References getFromNode(), getGeometry(), getLaneFriction(), getLaneSpeed(), getNumLanes(), Parameterised::getParametersMap(), getPermissions(), getToNode(), init(), MIN2(), myGeom, myLanes, myLoadedLength, myTo, PositionVector::reverse(), setEdgeStopOffset(), setEndOffset(), setFriction(), setLaneType(), setLaneWidth(), setPermissions(), setSpeed(), and Parameterised::updateParameters().

◆ ~NBEdge()

NBEdge::~NBEdge ( )

Destructor.

Definition at line 545 of file NBEdge.cpp.

◆ NBEdge() [4/5]

NBEdge::NBEdge ( const NBEdge & s )

privatedelete

invalidated copy constructor

◆ NBEdge() [5/5]

NBEdge::NBEdge ( )

private

constructor for dummy edge

Definition at line 363 of file NBEdge.cpp.

Member Function Documentation

◆ addBikeLane()

void NBEdge::addBikeLane ( double width )

add a bicycle lane of the given width and shift existing connctions

Definition at line 4584 of file NBEdge.cpp.

References addRestrictedLane(), and SVC_BICYCLE.

Referenced by NIImporter_OpenStreetMap::insertEdge(), and NIXMLEdgesHandler::myEndElement().

Here is the caller graph for this function:

◆ addEdge2EdgeConnection()

bool NBEdge::addEdge2EdgeConnection	(	NBEdge *	dest,
		bool	overrideRemoval = `false`,
		SVCPermissions	permission = `SVC_UNSPECIFIED`
	)

Adds a connection to another edge.

If the given edge does not start at the node this edge ends on, false is returned.

All other cases return true. Though, a connection may not been added if this edge is in step "INIT_REJECT_CONNECTIONS". Also, this method assures that a connection to an edge is set only once, no multiple connections to next edge are stored.

After a first connection to an edge was set, the process step is set to "EDGE2EDGES".

Note: Passing 0 implicitly removes all existing connections

Parameters

[in] dest The connection's destination edge

Returns: Whether the connection was valid

Definition at line 1097 of file NBEdge.cpp.

References EDGE2EDGES, INIT_REJECT_CONNECTIONS, invalidateConnections(), myConnections, myConnectionsToDelete, myFrom, myStep, and myTo.

Referenced by addLane2LaneConnection(), NIImporter_OpenStreetMap::RelationHandler::applyRestriction(), NBEdgeCont::joinSameNodeConnectingEdges(), NIImporter_VISUM::parse_Turns(), NIXMLConnectionsHandler::parseConnection(), and remapConnections().

Here is the caller graph for this function:

◆ addGeometryPoint()

void NBEdge::addGeometryPoint	(	int	index,
		const Position &	p
	)

Adds a further geometry point.

Some importer do not know an edge's geometry when it is initialised. This method allows to insert further geometry points after the edge has been built.

Parameters

[in]	index	The position at which the point shall be added
[in]	p	The point to add

Definition at line 1004 of file NBEdge.cpp.

References myGeom.

Referenced by NIImporter_VISUM::parse_EdgePolys().

Here is the caller graph for this function:

◆ addLane()

void NBEdge::addLane	(	int	index,
		bool	recomputeShape,
		bool	recomputeConnections,
		bool	shiftIndices
	)

add lane

Definition at line 4030 of file NBEdge.cpp.

References computeLaneShapes(), NBNode::getIncomingEdges(), Parameterised::getParametersMap(), invalidateConnections(), myConnections, myFrom, myLanes, myTo, and NBNode::shiftTLConnectionLaneIndex().

Referenced by GNEEdge::addLane(), and incLaneNo().

Here is the caller graph for this function:

◆ addLane2LaneConnection()

bool NBEdge::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.

If the given edge does not start at the node this edge ends on, false is returned.

All other cases return true. Though, a connection may not been added if this edge is in step "INIT_REJECT_CONNECTIONS". Before the lane-to-lane connection is set, a connection between edges is established using "addEdge2EdgeConnection". Then, "setConnection" is called for inserting the lane-to-lane connection.

Parameters

[in]	fromLane	The connection's starting lane (of this edge)
[in]	dest	The connection's destination edge
[in]	toLane	The connection's destination lane
[in]	type	The connections's type
[in]	mayUseSameDestination	Whether this connection may be set though connecting an already connected lane
[in]	mayDefinitelyPass	Whether this connection is definitely undistrubed (special case for on-ramps)

Returns: Whether the connection was added / exists

See also: addEdge2EdgeConnection; setConnection

Todo:: Check difference between "setConnection" and "addLane2LaneConnection"

Definition at line 1132 of file NBEdge.cpp.

References addEdge2EdgeConnection(), INIT_REJECT_CONNECTIONS, myFrom, myStep, myTo, and setConnection().

Referenced by NIImporter_SUMO::_loadNetwork(), addLane2LaneConnections(), NIVissimConnection::buildEdgeConnections(), NIImporter_OpenDrive::loadNetwork(), moveOutgoingConnectionsFrom(), NIImporter_VISUM::parse_LanesConnections(), NIXMLConnectionsHandler::parseLaneBound(), NBEdgeCont::processSplits(), NBEdgeCont::recheckPostProcessConnections(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), and NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ addLane2LaneConnections()

bool NBEdge::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.

If "invalidatePrevious" is true, a call to "invalidateConnections(true)" is done. This method loops through the given connections to set, calling "addLane2LaneConnection" for each.

Parameters

[in]	fromLane	The first of the connections' starting lanes (of this edge)
[in]	dest	The connections' destination edge
[in]	toLane	The first of the connections' destination lanes
[in]	no	The number of connections to set
[in]	type	The connections' type
[in]	invalidatePrevious	Whether previously set connection shall be deleted
[in]	mayDefinitelyPass	Whether these connections are definitely undistrubed (special case for on-ramps)

Returns: Whether the connections were added / existed

See also: addLane2LaneConnection; invalidateConnections

Definition at line 1168 of file NBEdge.cpp.

References addLane2LaneConnection(), and invalidateConnections().

Referenced by NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), and NBNode::computeLanes2Lanes().

Here is the caller graph for this function:

◆ addRestrictedLane()

void NBEdge::addRestrictedLane	(	double	width,
		SUMOVehicleClass	vclass
	)

add a lane of the given width, restricted to the given class and shift existing connections

Definition at line 4606 of file NBEdge.cpp.

References CENTER, computeLaneShapes(), disallowVehicleClass(), NBEdge::Connection::fromLane, getID(), NBNode::getIncomingEdges(), Parameterised::getParameter(), hasRestrictedLane(), PositionVector::move2side(), myConnections, myFrom, myGeom, myLanes, myLaneSpreadFunction, myTo, NBNode::shiftTLConnectionLaneIndex(), SUMO_PARAM_ORIGID, SVC_PEDESTRIAN, TL, toString(), and WRITE_WARNINGF.

Referenced by addBikeLane(), addSidewalk(), and NBEdgeCont::guessSpecialLanes().

Here is the caller graph for this function:

◆ addSidewalk()

void NBEdge::addSidewalk ( double width )

add a pedestrian sidewalk of the given width and shift existing connctions

Definition at line 4572 of file NBEdge.cpp.

References addRestrictedLane(), and SVC_PEDESTRIAN.

Referenced by NIImporter_OpenStreetMap::insertEdge(), and NIXMLEdgesHandler::myEndElement().

Here is the caller graph for this function:

◆ addSign()

void NBEdge::addSign ( NBSign sign )

inline

add Sign

Definition at line 1460 of file NBEdge.h.

References mySigns.

Referenced by NBEdgeCont::generateStreetSigns().

Here is the caller graph for this function:

◆ addStraightConnections()

void NBEdge::addStraightConnections	(	const EdgeVector *	outgoing,
		const std::vector< int > &	availableLanes,
		const std::vector< int > &	priorities
	)

private

add some straight connections

Definition at line 3409 of file NBEdge.cpp.

References DEBUGCOND, NBNode::getDirection(), getID(), getNumLanes(), getPermissions(), MIN2(), myConnections, myLanes, myTo, STRAIGHT, and SVC_PEDESTRIAN.

Referenced by divideSelectedLanesOnEdges().

Here is the caller graph for this function:

◆ addTo()

void Named::addTo ( const StoringVisitor & cont ) const

inlineinherited

Adds this object to the given container.

Parameters

[in,filled] cont The container to add this item to

Definition at line 118 of file Named.h.

References Named::StoringVisitor::add().

◆ allowsChangingLeft()

bool NBEdge::allowsChangingLeft	(	int	lane,
		SUMOVehicleClass	vclass
	)		const

Returns whether the given vehicle class may change left from this lane.

Definition at line 4519 of file NBEdge.cpp.

References getNumLanes(), myLanes, and SVC_UNSPECIFIED.

Referenced by GNELane::drawMarkingsAndBoundings().

Here is the caller graph for this function:

◆ allowsChangingRight()

bool NBEdge::allowsChangingRight	(	int	lane,
		SUMOVehicleClass	vclass
	)		const

Returns whether the given vehicle class may change left from this lane.

Definition at line 4525 of file NBEdge.cpp.

References getNumLanes(), myLanes, and SVC_UNSPECIFIED.

Referenced by GNELane::drawMarkingsAndBoundings().

Here is the caller graph for this function:

◆ allowVehicleClass()

void NBEdge::allowVehicleClass	(	int	lane,
		SUMOVehicleClass	vclass
	)

set allowed class for the given lane or for all lanes if -1 is given

Definition at line 4124 of file NBEdge.cpp.

References allowVehicleClass(), and myLanes.

Referenced by NINavTeqHelper::addCommonVehicleClasses(), NINavTeqHelper::addVehicleClasses(), NINavTeqHelper::addVehicleClassesV6(), and allowVehicleClass().

Here is the caller graph for this function:

◆ append()

void NBEdge::append ( NBEdge * continuation )

append another edge

Definition at line 3945 of file NBEdge.cpp.

References PositionVector::append(), computeAngle(), OptionsCont::getBool(), getFinalLength(), getID(), getLength(), OptionsCont::getOptions(), Parameterised::getParametersMap(), Parameterised::hasParameter(), Position::INVALID, Parameterised::mergeParameters(), myConnections, myConnectionsToDelete, myGeom, myLanes, myLength, myLoadedLength, myPossibleTurnDestination, mySignalPosition, myStep, myStreetName, myTo, myToBorder, myTurnDestination, myTurnSignTarget, and SUMO_PARAM_ORIGID.

Referenced by NBNodeCont::removeUnwishedNodes(), and setOrigID().

Here is the caller graph for this function:

◆ appendTurnaround()

void NBEdge::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 (myTurnDestination!=0)

Parameters

[in]	noTLSControlled	Whether the turnaround shall not be connected if the edge is controlled by a tls
[in]	noFringe	Whether the turnaround shall not be connected if the junction is at the (outer) fringe
[in]	onlyDeadends	Whether the turnaround shall only be built at deadends
[in]	onlyTurnlane	Whether the turnaround shall only be built when there is an exclusive (left) turn lane
[in]	noGeometryLike	Whether the turnaround shall be built at geometry-like nodes

Definition at line 3584 of file NBEdge.cpp.

References NBNode::BACKWARD, filterByPermissions(), NBNode::geometryLike(), getAngleAtNode(), getConnectionsFromLane(), NBNode::getDirection(), getFirstAllowedLaneIndex(), NBNode::getFringeType(), getIncomingEdges(), NBNode::getIncomingEdges(), NBNode::getOutgoingEdges(), getPermissions(), NBNode::getType(), isBidiRail(), isRailDeadEnd(), isRailway(), NBNode::isTLControlled(), KEEPCLEAR_UNSPECIFIED, LEFT, myConnections, myTo, myTurnDestination, NBHelpers::normRelAngle(), OUTER, PARTLEFT, RAIL_CROSSING, setConnection(), SUMO_const_haltingSpeed, SVC_BICYCLE, SVC_DELIVERY, SVC_PASSENGER, SVC_PEDESTRIAN, UNSPECIFIED_CONTPOS, UNSPECIFIED_VISIBILITY_DISTANCE, and VALIDATED.

◆ applyTurnSigns()

bool NBEdge::applyTurnSigns ( )

private

apply loaded turn sign information

Definition at line 2689 of file NBEdge.cpp.

References decodeTurnSigns(), PositionVector::EMPTY, NBNode::getDirection(), getID(), getNumLanes(), getNumLanesThatAllow(), getPermissions(), KEEPCLEAR_UNSPECIFIED, myConnections, myDefaultConnectionLength, myLanes, myTo, NODIR, setConnection(), sortOutgoingConnectionsByAngle(), sortOutgoingConnectionsByIndex(), STRAIGHT, SVC_BICYCLE, SVC_BUS, SVC_DELIVERY, SVC_PASSENGER, SVC_TAXI, SVC_UNSPECIFIED, SVCAll, TL, toString(), TURN_SIGN_SHIFT_BICYCLE, TURN_SIGN_SHIFT_BUS, TURN_SIGN_SHIFT_TAXI, UNSPECIFIED_CONNECTION_UNCONTROLLED, UNSPECIFIED_CONTPOS, UNSPECIFIED_FRICTION, UNSPECIFIED_SPEED, UNSPECIFIED_VISIBILITY_DISTANCE, updateTurnPermissions(), VALIDATED, and WRITE_WARNINGF.

Referenced by recheckLanes().

Here is the caller graph for this function:

◆ areAttributesValid()

bool Parameterised::areAttributesValid	(	const std::string &	value,
		bool	report = `false`,
		const std::string	kvsep = `"="`,
		const std::string	sep = `"\|"`
	)

staticinherited

check if given string can be parsed to an attributes map "key1=value1|key2=value2|...|keyN=valueN" (used in generic datas)

Definition at line 219 of file Parameterised.cpp.

References StringTokenizer::getVector(), Parameterised::isParameterValid(), TL, and WRITE_WARNINGF.

Referenced by GNEFrameAttributeModules::GenericDataAttributes::areAttributesValid(), GNEEdgeData::isValid(), GNEEdgeRelData::isValid(), and GNETAZRelData::isValid().

Here is the caller graph for this function:

◆ areParametersValid()

bool Parameterised::areParametersValid	(	const std::string &	value,
		bool	report = `false`,
		const std::string	kvsep = `"="`,
		const std::string	sep = `"\|"`
	)

staticinherited

check if given string can be parsed to a parameters map "key1=value1|key2=value2|...|keyN=valueN"

Definition at line 200 of file Parameterised.cpp.

References StringTokenizer::getVector(), Parameterised::isParameterValid(), TL, and WRITE_WARNINGF.

Referenced by GNEDetector::isDetectorValid(), GNEAccess::isValid(), GNEBusStop::isValid(), GNECalibrator::isValid(), GNECalibratorFlow::isValid(), GNEChargingStation::isValid(), GNEContainerStop::isValid(), GNEMultiEntryExitDetector::isValid(), GNEOverheadWire::isValid(), GNEParkingArea::isValid(), GNEParkingSpace::isValid(), GNERerouter::isValid(), GNERouteProbe::isValid(), GNETAZ::isValid(), GNETAZSourceSink::isValid(), GNETractionSubstation::isValid(), GNEVaporizer::isValid(), GNEVariableSpeedSign::isValid(), GNEContainer::isValid(), GNEPerson::isValid(), GNERoute::isValid(), GNEStop::isValid(), GNEVehicle::isValid(), GNEVType::isValid(), GNEConnection::isValid(), GNECrossing::isValid(), GNEEdge::isValid(), GNEEdgeType::isValid(), GNEJunction::isValid(), GNELane::isValid(), GNELaneType::isValid(), GNEPOI::isValid(), GNEPoly::isValid(), GNETLSEditorFrame::TLSAttributes::isValidParameters(), and GNEFrameAttributeModules::GenericDataAttributes::onCmdSetParameters().

Here is the caller graph for this function:

◆ assignInternalLaneLength()

double NBEdge::assignInternalLaneLength	(	std::vector< Connection >::iterator	i,
		int	numLanes,
		double	lengthSum,
		bool	averageLength
	)

private

assign length to all lanes of an internal edge

Definition at line 2009 of file NBEdge.cpp.

References NBEdge::Connection::customLength, gPrecision, NBEdge::Connection::haveVia, NBEdge::Connection::indirectLeft, NBEdge::Connection::length, PositionVector::length(), MAX2(), NBOwnTLDef::MIN_SPEED_CROSSING_TIME, myConnections, NBEdge::Connection::shape, UNSPECIFIED_LOADED_LENGTH, NBEdge::Connection::viaLength, NBEdge::Connection::viaShape, and NBEdge::Connection::vmax.

Referenced by buildInnerEdges().

Here is the caller graph for this function:

◆ bothLeftTurns()

bool NBEdge::bothLeftTurns	(	LinkDirection	dir,
		const NBEdge *	otherFrom,
		LinkDirection	dir2
	)		const

private

determine conflict between opposite left turns

Definition at line 2113 of file NBEdge.cpp.

References LEFT, and PARTLEFT.

Referenced by buildInnerEdges().

Here is the caller graph for this function:

◆ buildInnerEdges()

double NBEdge::buildInnerEdges	(	const NBNode &	n,
		int	noInternalNoSplits,
		int &	linkIndex,
		int &	splitIndex
	)

Definition at line 1693 of file NBEdge.cpp.

◆ canMoveConnection()

bool NBEdge::canMoveConnection	(	const Connection &	con,
		int	newFromLane
	)		const

private

whether the connection can originate on newFromLane

Definition at line 1650 of file NBEdge.cpp.

References getPermissions(), SVC_PEDESTRIAN, NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by moveConnectionToLeft(), and moveConnectionToRight().

Here is the caller graph for this function:

◆ checkGeometry()

void NBEdge::checkGeometry	(	const double	maxAngle,
		bool	fixAngle,
		const double	minRadius,
		bool	fix,
		bool	silent
	)

Check the angles of successive geometry segments.

Parameters

[in]	maxAngle	The maximum angle allowed
[in]	minRadius	The minimum turning radius allowed at the start and end
[in]	fix	Whether to prune geometry points to avoid sharp turns at start and end

Definition at line 1036 of file NBEdge.cpp.

References PositionVector::angleAt2D(), GeomHelper::angleDiff(), checkGeometry(), DEG2RAD, getBidiEdge(), getID(), M_PI, myGeom, RAD2DEG, PositionVector::reverse(), TL, toString(), WRITE_MESSAGEF, and WRITE_WARNINGF.

Referenced by checkGeometry().

Here is the caller graph for this function:

◆ clearControllingTLInformation()

void NBEdge::clearControllingTLInformation ( )

clears tlID for all connections

Definition at line 3789 of file NBEdge.cpp.

References myConnections.

◆ clearParameter()

void Parameterised::clearParameter ( )

inherited

Clears the parameter map.

Definition at line 139 of file Parameterised.cpp.

References Parameterised::myMap.

Referenced by NLHandler::beginEdgeParsing(), and GNESingleParametersDialog::onCmdAccept().

Here is the caller graph for this function:

◆ computeAngle()

void NBEdge::computeAngle ( )

private

computes the angle of this edge and stores it in myAngle

Definition at line 2311 of file NBEdge.cpp.

References ANGLE_LOOKAHEAD, Position::angleTo2D(), PositionVector::around(), DEBUGCOND, PositionVector::distance2D(), getAngleAtNode(), PositionVector::getCentroid(), getID(), getLaneWidth(), getNumLanes(), getPermissions(), NBNode::getPosition(), NBNode::getShape(), GeomHelper::legacyDegree(), PositionVector::length(), PositionVector::length2D(), MIN2(), PositionVector::move2side(), myEndAngle, myFrom, myGeom, myLanes, myLaneSpreadFunction, myStartAngle, myTo, myTotalAngle, NBHelpers::normRelAngle(), PositionVector::positionAtOffset2D(), RIGHT, and SVC_PEDESTRIAN.

Referenced by append(), computeEdgeShape(), init(), mirrorX(), reinitNodes(), reshiftPosition(), and setGeometry().

Here is the caller graph for this function:

◆ computeEdge2Edges()

bool NBEdge::computeEdge2Edges ( bool noLeftMovers )

computes the edge (step1: computation of approached edges)

Definition at line 2575 of file NBEdge.cpp.

References NBNode::computeSmoothShape(), DEBUGCOND, DEG2RAD, EDGE2EDGES, getAngleAtNode(), getID(), NBNode::getOutgoingEdges(), getPermissions(), getTurnDestination(), NBNode::isLeftMover(), isRailway(), PositionVector::length2D(), myConnections, myConnectionsToDelete, myLanes, myStep, myTo, myTurnDestination, NBHelpers::normRelAngle(), SVC_PEDESTRIAN, and SVC_TRAM.

◆ computeEdgeShape()

void NBEdge::computeEdgeShape ( double smoothElevationThreshold = -1 )

Recomputeds the lane shapes to terminate at the node shape For every lane the intersection with the fromNode and toNode is calculated and the lane shorted accordingly. The edge length is then set to the average of all lane lengths (which may differ). This average length is used as the lane length when writing the network.

Note: All lanes of an edge in a sumo net must have the same nominal length but may differ in actual geomtric length.; Depends on previous call to NBNodeCont::computeNodeShapes

Definition at line 885 of file NBEdge.cpp.

References computeAngle(), computeLaneShapes(), cutAtIntersection(), NBNode::geometryLike(), NBNode::getPosition(), PositionVector::hasElevation(), PositionVector::length2D(), MIN2(), myFrom, myGeom, myLanes, myLength, myTo, PositionVector::reverse(), PositionVector::smoothedZFront(), and Position::z().

Referenced by reshiftPosition().

Here is the caller graph for this function:

◆ computeLanes2Edges()

bool NBEdge::computeLanes2Edges ( )

computes the edge, step2: computation of which lanes approach the edges)

Definition at line 2631 of file NBEdge.cpp.

References DEBUGCOND, divideOnEdges(), EDGE2EDGES, getConnectedSorted(), getID(), LANES2EDGES, myConnections, myConnectionsToDelete, and myStep.

◆ computeLaneShape()

PositionVector NBEdge::computeLaneShape	(	int	lane,
		double	offset
	)		const

private

Computes the shape for the given lane.

Definition at line 2299 of file NBEdge.cpp.

References getLaneID(), PositionVector::move2side(), myGeom, TL, and WRITE_WARNINGF.

Referenced by computeLaneShapes().

Here is the caller graph for this function:

◆ computeLaneShapes()

void NBEdge::computeLaneShapes ( )

private

compute lane shapes

Definition at line 2247 of file NBEdge.cpp.

References CENTER, computeLaneShape(), getInnerGeometry(), getLaneID(), getLaneWidth(), NBNode::getOutgoingEdges(), getTotalWidth(), myFrom, myGeom, myLanes, myLaneSpreadFunction, myTo, PositionVector::reverse(), ROADCENTER, SUMO_const_laneWidth, TL, UNSPECIFIED_WIDTH, and WRITE_WARNINGF.

Referenced by addLane(), addRestrictedLane(), computeEdgeShape(), deleteLane(), init(), resetLaneShapes(), reshiftPosition(), restoreRestrictedLane(), setGeometry(), and shortenGeometryAtNode().

Here is the caller graph for this function:

◆ connections_sorter()

bool NBEdge::connections_sorter	(	const Connection &	c1,
		const Connection &	c2
	)

static

connections_sorter sort by fromLane, toEdge and toLane

Definition at line 4413 of file NBEdge.cpp.

References NBEdge::Connection::fromLane, NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by sortOutgoingConnectionsByIndex().

Here is the caller graph for this function:

◆ copyConnectionsFrom()

void NBEdge::copyConnectionsFrom ( NBEdge * src )

copy connections from antoher edge

Definition at line 1643 of file NBEdge.cpp.

References myConnections, and myStep.

Referenced by NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ cutAtIntersection()

PositionVector NBEdge::cutAtIntersection ( const PositionVector & old ) const

cut shape at the intersection shapes

Definition at line 794 of file NBEdge.cpp.

References GeomHelper::angleDiff(), PositionVector::beginEndAngle(), DEBUGCOND, DEG2RAD, getID(), PositionVector::getSubpart(), PositionVector::length(), myFrom, myFromBorder, myTo, myToBorder, PositionVector::reverse(), and startShapeAt().

Referenced by computeEdgeShape(), and getFinalLength().

Here is the caller graph for this function:

◆ debugPrintConnections()

void NBEdge::debugPrintConnections	(	bool	outgoing = `true`,
		bool	incoming = `false`
	)		const

debugging helper to print all connections

Definition at line 4802 of file NBEdge.cpp.

References getID(), NBNode::getIncomingEdges(), myConnections, and myFrom.

◆ decLaneNo()

void NBEdge::decLaneNo ( int by )

decrement lane

Definition at line 4105 of file NBEdge.cpp.

References deleteLane(), LANES2LANES_USER, myLanes, and myStep.

Referenced by NBEdgeCont::processSplits().

Here is the caller graph for this function:

◆ declareConnectionsAsLoaded()

void NBEdge::declareConnectionsAsLoaded ( EdgeBuildingStep step = EdgeBuildingStep::LANES2LANES_USER )

inline

declares connections as fully loaded. This is needed to avoid recomputing connections if an edge has no connections intentionally.

Definition at line 1442 of file NBEdge.h.

References myStep.

Referenced by NIImporter_SUMO::_loadNetwork(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), and GNEEdge::setAttribute().

Here is the caller graph for this function:

◆ decodeTurnSigns()

std::vector< LinkDirection > NBEdge::decodeTurnSigns	(	int	turnSigns,
		int	shift = `0`
	)

staticprivate

decode bitset

Definition at line 2666 of file NBEdge.cpp.

Referenced by applyTurnSigns().

Here is the caller graph for this function:

◆ deleteLane()

void NBEdge::deleteLane	(	int	index,
		bool	recompute,
		bool	shiftIndices
	)

delete lane

Definition at line 4085 of file NBEdge.cpp.

References computeLaneShapes(), NBNode::getIncomingEdges(), invalidateConnections(), myFrom, myLanes, and removeFromConnections().

Referenced by decLaneNo(), NIXMLEdgesHandler::deleteEdge(), joinLanes(), GNEEdge::removeLane(), and NBEdgeCont::removeLanesByWidth().

Here is the caller graph for this function:

◆ disallowVehicleClass()

void NBEdge::disallowVehicleClass	(	int	lane,
		SUMOVehicleClass	vclass
	)

set disallowed class for the given lane or for all lanes if -1 is given

Definition at line 4137 of file NBEdge.cpp.

References disallowVehicleClass(), and myLanes.

Referenced by NINavTeqHelper::addCommonVehicleClasses(), addRestrictedLane(), NINavTeqHelper::addVehicleClasses(), NINavTeqHelper::addVehicleClassesV6(), disallowVehicleClass(), and NIImporter_DlrNavteq::EdgesHandler::report().

Here is the caller graph for this function:

◆ dismissVehicleClassInformation()

void NBEdge::dismissVehicleClassInformation ( )

dimiss vehicle class information

Definition at line 4404 of file NBEdge.cpp.

References myLanes, and SVCAll.

Referenced by NBEdgeCont::insert().

Here is the caller graph for this function:

◆ divideOnEdges()

void NBEdge::divideOnEdges ( const EdgeVector * outgoing )

private

divides the lanes on the outgoing edges

Definition at line 3214 of file NBEdge.cpp.

References DEBUGCOND, divideSelectedLanesOnEdges(), getID(), getNumLanes(), getPermissions(), isForbidden(), myConnections, myLanes, myTurnDestination, sortOutgoingConnectionsByIndex(), SVC_BICYCLE, SVC_BUS, SVC_PASSENGER, SVC_PEDESTRIAN, SVC_UNSPECIFIED, and toString().

Referenced by computeLanes2Edges().

Here is the caller graph for this function:

◆ divideSelectedLanesOnEdges()

void NBEdge::divideSelectedLanesOnEdges	(	const EdgeVector *	outgoing,
		const std::vector< int > &	availableLanes
	)

private

divide selected lanes on edges

Definition at line 3304 of file NBEdge.cpp.

References addStraightConnections(), Bresenham::compute(), DEBUGCOND, NBEdge::ToEdgeConnectionsAdder::getBuiltConnections(), getConnectionsFromLane(), getID(), getPermissions(), myConnections, myLanes, prepareEdgePriorities(), SVC_PEDESTRIAN, and toString().

Referenced by divideOnEdges().

Here is the caller graph for this function:

◆ expandableBy()

bool NBEdge::expandableBy	(	NBEdge *	possContinuation,
		std::string &	reason
	)		const

Check if Node is expandable.

Definition at line 3833 of file NBEdge.cpp.

References EDGE2EDGES, NBNode::FORWARD, getConnectedEdges(), getConnectionLanes(), getFirstNonPedestrianLaneIndex(), OptionsCont::getFloat(), getLength(), getLoadedLength(), OptionsCont::getOptions(), getPriority(), getStreetName(), INIT, INIT_REJECT_CONNECTIONS, isBidiRail(), LANES2EDGES, LANES2LANES_DONE, LANES2LANES_RECHECK, LANES2LANES_USER, MAX2(), myConnections, myFrom, myGeom, myLanes, myLaneSpreadFunction, myLength, mySpeed, myStep, myStreetName, myTo, and toString().

◆ extendGeometryAtNode()

void NBEdge::extendGeometryAtNode	(	const NBNode *	node,
		double	maxExtent
	)

linearly extend the geometry at the given node

Definition at line 658 of file NBEdge.cpp.

References PositionVector::extrapolate(), NBNode::getPosition(), PositionVector::getSubpart2D(), GeomHelper::INVALID_OFFSET, PositionVector::length2D(), MAX2(), MIN2(), myFrom, myGeom, myTo, and PositionVector::nearest_offset_to_point2D().

◆ filterByPermissions()

EdgeVector NBEdge::filterByPermissions	(	const EdgeVector &	edges,
		SVCPermissions	permissions
	)

static

return only those edges that permit at least one of the give permissions

Definition at line 4846 of file NBEdge.cpp.

Referenced by appendTurnaround(), getStraightContinuation(), getStraightPredecessor(), and NBNodeCont::pruneLongEdges().

Here is the caller graph for this function:

◆ firstIntersection()

double NBEdge::firstIntersection	(	const PositionVector &	v1,
		const PositionVector &	v2,
		double	width1,
		double	width2,
		const std::string &	error = `""`,
		bool	secondIntersection = `false`
	)

static

compute the first intersection point between the given lane geometries considering their rspective widths

Definition at line 2049 of file NBEdge.cpp.

References PositionVector::intersectsAtLengths2D(), PositionVector::length(), MIN2(), PositionVector::move2side(), and WRITE_WARNING.

Referenced by buildInnerEdges(), haveIntersection(), and NBRequest::oppositeLeftTurnConflict().

Here is the caller graph for this function:

◆ geometryPositionAtOffset()

Position NBEdge::geometryPositionAtOffset ( double offset ) const

return position taking into account loaded length

Definition at line 4704 of file NBEdge.cpp.

References myGeom, myLength, myLoadedLength, and PositionVector::positionAtOffset().

Referenced by NIXMLPTHandler::addPTStop().

Here is the caller graph for this function:

◆ getAngleAtNode()

double NBEdge::getAngleAtNode ( const NBNode *const node ) const

Returns the angle of the edge's geometry at the given node.

The angle is in degrees between -180 and 180.

Parameters

[in] node The node for which the edge's angle shall be returned

Returns: This edge's angle at the given node

Definition at line 2158 of file NBEdge.cpp.

References PositionVector::angleAt2D(), GeomHelper::legacyDegree(), myFrom, myGeom, and myTo.

Referenced by appendTurnaround(), computeAngle(), computeEdge2Edges(), NBNode::computeLanes2Lanes(), NBNodeCont::feasibleCluster(), NBRampsComputer::fulfillsRampConstraints(), NBNode::geometryLike(), getCrossingAngle(), NBNode::getDirection(), NBEdgeCont::guessRoundabouts(), NBNode::isLeftMover(), NBRailwayTopologyAnalyzer::isStraight(), NBNode::isStraighter(), NBRequest::laneConflict(), NBEdgePriorityComputer::markBestParallel(), NBEdgePriorityComputer::setPriorityJunctionPriorities(), and NBRailwayGeometryHelper::straigthenCorrdidor().

Here is the caller graph for this function:

◆ getAngleAtNodeNormalized()

double NBEdge::getAngleAtNodeNormalized ( const NBNode *const node ) const

Returns the angle of the edge's geometry at the given node and disregards edge direction.

Parameters

[in] node The node for which the edge's angle shall be returned

Returns: This edge's angle at the given node (normalized to point towards the node)

Definition at line 2168 of file NBEdge.cpp.

References PositionVector::angleAt2D(), GeomHelper::legacyDegree(), myFrom, myGeom, and myTo.

Referenced by NBNodesEdgesSorter::edge_by_junction_angle_sorter::operator()().

Here is the caller graph for this function:

◆ getAngleAtNodeToCenter()

double NBEdge::getAngleAtNodeToCenter ( const NBNode *const node ) const

Returns the angle of from the node shape center to where the edge meets the node shape.

The angle is signed, disregards direction, and starts at 12 o'clock (north->south), proceeds positive clockwise.

Parameters

[in] node The node for which the edge's angle shall be returned

Returns: This edge's angle at the given node shape

Definition at line 2184 of file NBEdge.cpp.

References myEndAngle, myFrom, myStartAngle, and myTo.

Referenced by NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()().

Here is the caller graph for this function:

◆ getBidiEdge()

const NBEdge * NBEdge::getBidiEdge ( ) const

inlinevirtual

Implements NBRouterEdge.

Definition at line 1514 of file NBEdge.h.

References isBidiEdge(), isBidiRail(), and myPossibleTurnDestination.

Referenced by NIXMLEdgesHandler::addEdge(), NBRequest::bidiConflict(), checkGeometry(), NBTrafficLightDefinition::collectAllLinks(), GNEEdge::drawEdgeName(), GNEEdge::getAttribute(), NBPTLineCont::getCost(), NBNode::isExplicitRailNoBidi(), NBEdgeCont::recheckLanes(), GNEEdge::setAttribute(), shiftPositionAtNode(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getCCWBoundaryLine()

PositionVector NBEdge::getCCWBoundaryLine ( const NBNode & n ) const

get the outer boundary of this edge when going counter-clock-wise around the given node

Definition at line 3815 of file NBEdge.cpp.

References NBNode::BACKWARD, NBNode::FORWARD, getFirstAllowedLaneIndex(), getLaneWidth(), PositionVector::move2side(), myFrom, myLanes, and PositionVector::reverse().

Referenced by NBEdgeCont::checkOverlap().

Here is the caller graph for this function:

◆ getConnectedEdges()

EdgeVector NBEdge::getConnectedEdges ( ) const

Returns the list of outgoing edges unsorted.

Returns: Connected edges

Definition at line 1380 of file NBEdge.cpp.

References myConnections.

Referenced by NIVissimDisturbance::addToNode(), expandableBy(), NBTrafficLightDefinition::forbids(), NBContHelper::same_connection_edge_sorter::getMinMaxRelAngles(), remapConnections(), and NBNode::removeSelfLoops().

Here is the caller graph for this function:

◆ getConnectedSorted()

const EdgeVector * NBEdge::getConnectedSorted ( )

Returns the list of outgoing edges without the turnaround sorted in clockwise direction.

Returns: Connected edges, sorted clockwise

Definition at line 1343 of file NBEdge.cpp.

References NBNode::getOutgoingEdges(), myConnections, myConnectionsToDelete, myTo, and myTurnDestination.

Referenced by computeLanes2Edges().

Here is the caller graph for this function:

◆ getConnection()

const NBEdge::Connection & NBEdge::getConnection	(	int	fromLane,
		const NBEdge *	to,
		int	toLane
	)		const

Returns the specified connection (unmodifiable) This method goes through "myConnections" and returns the specified one.

See also: NBEdge::Connection

Definition at line 1300 of file NBEdge.cpp.

References getID(), myConnections, and toString().

Referenced by NBRequest::getFoesString(), NBRequest::getResponseString(), NBNode::mergeConflictYields(), and NBRequest::mustBrake().

Here is the caller graph for this function:

◆ getConnectionLanes()

std::vector< int > NBEdge::getConnectionLanes	(	NBEdge *	currentOutgoing,
		bool	withBikes = `true`
	)		const

Returns the list of lanes that may be used to reach the given edge.

Returns: Lanes approaching the given edge

Definition at line 1405 of file NBEdge.cpp.

References getPermissions(), myConnections, myTurnDestination, and SVC_BICYCLE.

Referenced by NBNode::ApproachingDivider::execute(), and expandableBy().

Here is the caller graph for this function:

◆ getConnectionRef()

NBEdge::Connection & NBEdge::getConnectionRef	(	int	fromLane,
		const NBEdge *	to,
		int	toLane
	)

Returns reference to the specified connection This method goes through "myConnections" and returns the specified one.

See also: NBEdge::Connection

Definition at line 1312 of file NBEdge.cpp.

References getID(), myConnections, and toString().

Referenced by NIImporter_SUMO::_loadNetwork(), GNEConnection::getNBEdgeConnection(), and recheckLanes().

Here is the caller graph for this function:

◆ getConnections() [1/2]

std::vector< Connection > & NBEdge::getConnections ( )

inline

Returns the connections.

Returns: This edge's connections to following edges

Definition at line 1048 of file NBEdge.h.

References myConnections.

◆ getConnections() [2/2]

const std::vector< Connection > & NBEdge::getConnections ( ) const

inline

Returns the connections.

Returns: This edge's connections to following edges

Definition at line 1041 of file NBEdge.h.

References myConnections.

Referenced by NIXMLTrafficLightsHandler::addTlConnection(), NBEdgeCont::checkGrade(), NBRequest::checkLaneFoesByCooperation(), NBTrafficLightDefinition::collectReachable(), NBEdgeCont::fixSplitCustomLength(), NWWriter_SUMO::getInternalBidi(), NWWriter_SUMO::getOppositeInternalID(), NBNode::hasConflict(), NBOwnTLDef::hasStraightConnection(), NBNodeCont::joinNodeCluster(), NIImporter_OpenDrive::loadNetwork(), NBRequest::mustBrake(), NBEdgeCont::recheckPostProcessConnections(), GNEEdge::remakeGNEConnections(), GNEJunction::removeConnectionsFrom(), GNEJunction::replaceIncomingConnections(), GNENet::replaceIncomingEdge(), GNENet::replaceJunctionByGeometry(), NWWriter_DlrNavteq::writeConnectedLanes(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_OpenDrive::writeNetwork(), NWWriter_SUMO::writeNetwork(), and NWWriter_XML::writeTrafficLights().

Here is the caller graph for this function:

◆ getConnectionsFromLane()

std::vector< NBEdge::Connection > NBEdge::getConnectionsFromLane	(	int	lane,
		const NBEdge *	to = `nullptr`,
		int	toLane = `-1`
	)		const

Returns connections from a given lane.

This method goes through "myConnections" and copies those which are starting at the given lane.

Parameters

[in]	lane	The lane which connections shall be returned
[in]	to	The target Edge (ignore nullptr)
[in]	toLane	The target lane (ignore if > 0)

Returns: The connections from the given lane

See also: NBEdge::Connection

Definition at line 1286 of file NBEdge.cpp.

References myConnections.

Referenced by NIVissimTL::NIVissimTLSignal::addTo(), appendTurnaround(), GNEConnectorFrame::buildConnection(), NBTrafficLightDefinition::collectAllLinks(), NBLoadedTLDef::collectLinks(), NBRequest::computeCrossingResponse(), NBRequest::computeLaneResponse(), NBOwnTLDef::computeUnblockedWeightedStreamNumber(), GNEPathManager::connectedLanes(), divideSelectedLanesOnEdges(), GNELane::drawLane2LaneConnections(), GNELane::drawLinkNo(), GNELane::drawTLSLinkNo(), GNEConnection::existNBEdgeConnection(), NBPTLineCont::fixPermissions(), NWWriter_SUMO::getInternalBidi(), GNEConnectorFrame::initTargets(), moveOutgoingConnectionsFrom(), NIXMLConnectionsHandler::parseLaneBound(), and recheckLanes().

Here is the caller graph for this function:

◆ getCrossingAngle()

double NBEdge::getCrossingAngle ( NBNode * node )

return the angle for computing pedestrian crossings at the given node

Definition at line 4531 of file NBEdge.cpp.

References gDebugFlag1, getAngleAtNode(), getFromNode(), and getID().

Referenced by NBNode::checkCrossing().

Here is the caller graph for this function:

◆ getCWBoundaryLine()

PositionVector NBEdge::getCWBoundaryLine ( const NBNode & n ) const

get the outer boundary of this edge when going clock-wise around the given node

Definition at line 3797 of file NBEdge.cpp.

References NBNode::BACKWARD, NBNode::FORWARD, getFirstAllowedLaneIndex(), getLaneWidth(), PositionVector::move2side(), myFrom, myLanes, and PositionVector::reverse().

◆ getDistancAt()

double NBEdge::getDistancAt ( double pos ) const

get distance at the given offset

Definition at line 4916 of file NBEdge.cpp.

References myDistance.

Referenced by GNELane::getPopUpMenu().

Here is the caller graph for this function:

◆ getDistance()

double NBEdge::getDistance ( ) const

inline

get distance

Definition at line 679 of file NBEdge.h.

References myDistance.

Referenced by NIXMLEdgesHandler::addEdge(), GNEEdge::getAttribute(), GNELane::getColorValue(), GNELane::getPopUpMenu(), NBEdgeCont::splitAt(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getDouble()

double Parameterised::getDouble	(	const std::string &	key,
		const double	defaultValue
	)		const

inherited

Returns the value for a given key converted to a double.

Parameters

[in]	key	The key to ask for
[in]	defaultValue	The default value to return if no value is stored under the key

Returns: The value stored under the key

Definition at line 100 of file Parameterised.cpp.

References Parameterised::myMap, TL, StringUtils::toDouble(), WRITE_WARNING, and WRITE_WARNINGF.

Here is the caller graph for this function:

◆ getDoubles()

std::vector< double > Parameterised::getDoubles	(	const std::string &	key,
		std::vector< double >	defaultValue = `std::vector<double>()`
	)		const

inherited

Returns the value for a given key converted to a list of doubles.

Parameters

[in]	key	The key to ask for
[in]	defaultValue	The default value to return if no value is stored under the key

Returns: The value stored under the key

Definition at line 118 of file Parameterised.cpp.

References StringTokenizer::getVector(), Parameterised::myMap, TL, StringUtils::toDouble(), WRITE_WARNING, and WRITE_WARNINGF.

Referenced by EnergyParams::EnergyParams().

Here is the caller graph for this function:

◆ getEdgeStopOffset()

const StopOffset & NBEdge::getEdgeStopOffset ( ) const

Returns the stopOffset to the end of the edge.

Returns: The offset to the end of the edge

Definition at line 4231 of file NBEdge.cpp.

References myEdgeStopOffset.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::myEndElement(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getEndAngle()

double NBEdge::getEndAngle ( ) const

inline

Returns the angle at the end of the edge (relative to the node shape center) The angle is computed in computeAngle()

Returns: This edge's end angle

Definition at line 564 of file NBEdge.h.

References myEndAngle.

Referenced by NBContHelper::relative_incoming_edge_sorter::operator()(), and NBNode::rightTurnConflict().

Here is the caller graph for this function:

◆ getEndOffset() [1/2]

double NBEdge::getEndOffset ( ) const

inline

Returns the offset to the destination node.

Returns: The offset to the destination node

Definition at line 689 of file NBEdge.h.

References myEndOffset.

Referenced by NIImporter_SUMO::_loadNetwork(), buildInnerEdges(), NBNode::computeInternalLaneShape(), GNEEdge::getAttribute(), getEndOffset(), getFinalLength(), NBEdgeCont::recheckLanes(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getEndOffset() [2/2]

double NBEdge::getEndOffset ( int lane ) const

Returns the offset to the destination node a the specified lane.

Returns: The offset to the destination node

Definition at line 4225 of file NBEdge.cpp.

References getEndOffset(), myLanes, and UNSPECIFIED_OFFSET.

◆ getEndpointAtNode()

Position NBEdge::getEndpointAtNode ( const NBNode * node ) const

Definition at line 620 of file NBEdge.cpp.

References myFrom, and myGeom.

Referenced by NBNodeShapeComputer::isDivided().

Here is the caller graph for this function:

◆ getFinalLength()

double NBEdge::getFinalLength ( ) const

get length that will be assigned to the lanes in the final network

Definition at line 4714 of file NBEdge.cpp.

References cutAtIntersection(), getEndOffset(), getFromNode(), getLoadedLength(), OptionsCont::getOptions(), getToNode(), hasLoadedLength(), isBidiRail(), PositionVector::length(), MAX2(), myGeom, myLanes, myPossibleTurnDestination, PositionVector::push_back_noDoublePos(), and PositionVector::push_front_noDoublePos().

Here is the caller graph for this function:

◆ getFirstAllowedLaneIndex()

int NBEdge::getFirstAllowedLaneIndex ( int direction ) const

return the first lane that permits at least 1 vClass or the last lane if search direction of there is no such lane

Parameters

[in] direction The direction in which the lanes shall be checked

Definition at line 4481 of file NBEdge.cpp.

References NBNode::BACKWARD, NBNode::FORWARD, and myLanes.

Referenced by appendTurnaround(), getCCWBoundaryLine(), and getCWBoundaryLine().

Here is the caller graph for this function:

◆ getFirstNonPedestrianLane()

NBEdge::Lane NBEdge::getFirstNonPedestrianLane ( int direction ) const

@brif get first non-pedestrian lane

Definition at line 4547 of file NBEdge.cpp.

References getFirstNonPedestrianLaneIndex(), getID(), myLanes, and TLF.

◆ getFirstNonPedestrianLaneIndex()

int NBEdge::getFirstNonPedestrianLaneIndex	(	int	direction,
		bool	exclusive = `false`
	)		const

return the first lane with permissions other than SVC_PEDESTRIAN and 0

Parameters

[in]	direction	The direction in which the lanes shall be checked
[in]	exclusive	Whether lanes that allow pedestrians along with other classes shall be counted as non-pedestrian

Definition at line 4438 of file NBEdge.cpp.

References NBNode::BACKWARD, NBNode::FORWARD, myLanes, and SVC_PEDESTRIAN.

Referenced by NBNode::addedLanesRight(), NBTrafficLightDefinition::collectEdges(), NBNode::computeLanes2Lanes(), expandableBy(), getFirstNonPedestrianLane(), and NBNode::getReduction().

Here is the caller graph for this function:

◆ getFirstNonPedestrianNonBicycleLaneIndex()

int NBEdge::getFirstNonPedestrianNonBicycleLaneIndex	(	int	direction,
		bool	exclusive = `false`
	)		const

return the first lane with permissions other than SVC_PEDESTRIAN, SVC_BICYCLE and 0

Parameters

[in]	direction	The direction in which the lanes shall be checked
[in]	exclusive	Whether lanes that allow pedestrians along with other classes shall be counted as non-pedestrian

Definition at line 4454 of file NBEdge.cpp.

References NBNode::BACKWARD, NBNode::FORWARD, myLanes, SVC_BICYCLE, SVC_PEDESTRIAN, and SVCAll.

Referenced by NBNode::addedLanesRight(), NBNode::computeLanes2Lanes(), and NBNode::getReduction().

Here is the caller graph for this function:

◆ getFriction()

double NBEdge::getFriction ( ) const

inline

Returns the friction on this edge.

Returns: The friction on this edge

Definition at line 626 of file NBEdge.h.

References myFriction.

Referenced by GNEEdge::getAttribute(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getFromNode()

NBNode * NBEdge::getFromNode ( ) const

inline

Returns the origin node of the edge.

Returns: The node this edge starts at

Definition at line 539 of file NBEdge.h.

References myFrom.

Referenced by NIImporter_SUMO::_loadNetwork(), NBRailwayTopologyAnalyzer::addBidiEdge(), NBRailwayTopologyAnalyzer::addBidiEdgesBetweenSwitches(), NBRailwayTopologyAnalyzer::addBidiEdgesForBufferStops(), NBLoadedSUMOTLDef::addConnection(), NIXMLConnectionsHandler::addCrossing(), NIXMLEdgesHandler::addLane(), NIXMLEdgesHandler::addSplit(), NIVissimDisturbance::addToNode(), NBLoadedTLDef::addToSignalGroup(), NIXMLConnectionsHandler::addWalkingArea(), NBNode::alreadyConnectedPaths(), NBRampsComputer::buildOffRamp(), NBNode::buildWalkingAreas(), NBEdgeCont::checkConsistency(), NBNode::checkCrossing(), NBEdgeCont::checkOverlap(), NBRampsComputer::computeRamps(), NIVissimDistrictConnection::dict_BuildDistricts(), NBRailwayTopologyAnalyzer::extendBidiEdges(), NBEdgeCont::extractRoundabouts(), NBNodeCont::feasibleCluster(), NBRampsComputer::fulfillsRampConstraints(), GNEEdge::getAttribute(), getCrossingAngle(), NBNode::getDirection(), NBContHelper::edge_opposite_direction_sorter::getEdgeAngleAt(), getFinalLength(), NWWriter_DlrNavteq::getGraphLength(), NIImporter_VISUM::getNamedEdgeContinuating(), NBPTStopCont::getReverseEdge(), GNEEdge::GNEEdge(), NBRailwaySignalGuesser::guessByStops(), NBNode::guessCrossings(), guessOpposite(), NBEdgeCont::guessRoundabouts(), NBEdgeCont::guessSpecialLanes(), NBOwnTLDef::hasCrossing(), NBEdgeCont::insert(), GNENetHelper::AttributeCarriers::insertEdge(), isBidiEdge(), NBRailwayTopologyAnalyzer::isStraight(), GNELane::isValid(), NBNodeCont::joinJunctions(), NBEdgeCont::joinSameNodeConnectingEdges(), NBEdgeCont::joinTramEdges(), NBRequest::laneConflict(), NBEdge(), NBNodeShapeComputer::needsLargeTurn(), NBContHelper::relative_outgoing_edge_sorter::operator()(), NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()(), NBNode::edge_by_direction_sorter::operator()(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_stopPoints(), NBRampsComputer::patchRampGeometry(), NBEdgeCont::processSplits(), NBNodeCont::pruneSlipLaneNodes(), NBEdgeCont::recheckLanes(), NBEdgeCont::recheckPostProcessConnections(), NIImporter_OpenStreetMap::reconstructLayerElevation(), NBNodeCont::reduceToCircle(), NBNodeCont::removeComponents(), NBNodeCont::removeIsolatedRoads(), NBNodeCont::removeRailComponents(), NBEdgeCont::removeUnwishedEdges(), NIImporter_OpenDrive::retrieveSignalEdges(), NIXMLEdgesHandler::setNodes(), GNEEdge::smoothShape(), GNEEdge::straightenElevation(), NBRailwayGeometryHelper::straigthenCorrdidor(), NBRailwayTopologyAnalyzer::updateTurns(), NWWriter_SUMO::writeEdge(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_DlrNavteq::writeLinksUnsplitted(), and NWWriter_OpenDrive::writeNetwork().

◆ getGeometry()

const PositionVector & NBEdge::getGeometry ( ) const

inline

Returns the geometry of the edge.

Returns: The edge's geometry

Definition at line 783 of file NBEdge.h.

References myGeom.

Referenced by NBRailwayTopologyAnalyzer::addBidiEdge(), NIXMLEdgesHandler::addEdge(), GNENet::addReversedEdge(), NIXMLEdgesHandler::addSplit(), NBPTStopCont::assignEdgeForFloatingStops(), NBNodeShapeComputer::badIntersection(), NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), GNEContour::calculateContourEdgeGeometryPoints(), GNEEdge::calculateEdgeContour(), GNEViewNetHelper::MoveMultipleElementModul::calculateEdgeSelection(), NBEdgeCont::checkOverlap(), GNEEdge::clickedOverShapeEnd(), GNEEdge::clickedOverShapeStart(), NBPTStopCont::computeCrossProductEdgePosition(), GNEEdge::drawEdgeGeometryPoints(), GNEEdge::drawEdgeShape(), GNEEdge::drawEndGeometryPoint(), GNEEdge::drawStartGeometryPoint(), GNEEdge::editEndpoint(), NBNode::geometryLike(), GNEEdge::getAttribute(), NBNode::getDirection(), NBContHelper::edge_opposite_direction_sorter::getEdgeAngleAt(), NBTurningDirectionsComputer::getFarAngleAtNode(), NWWriter_DlrNavteq::getGraphLength(), GNEEdge::getMoveOperation(), GNEEdge::getSplitPos(), GNEEdge::hasCustomEndPoints(), NBEdgeCont::ignoreFilterMatch(), isBidiEdge(), isBidiRail(), isNearEnough2BeJoined2(), GNEEdge::isValid(), NBEdgeCont::joinTramEdges(), NIImporter_ArcView::load(), NWWriter_OpenDrive::mapmatchRoadObjects(), NBRampsComputer::moveRampRight(), NBEdge(), GNEViewNet::onCmdSetCustomGeometryPoint(), NBContHelper::relative_outgoing_edge_sorter::operator()(), NBContHelper::relative_incoming_edge_sorter::operator()(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_stopPoints(), NBRampsComputer::patchRampGeometry(), GNEEdge::processMoveBothJunctionSelected(), GNEEdge::processNoneJunctionSelected(), NBEdgeCont::processSplits(), NIImporter_OpenStreetMap::reconstructLayerElevation(), GNEEdge::removeGeometryPoint(), NBPTStop::replaceEdge(), GNENet::replaceJunctionByGeometry(), GNEEdge::setAttribute(), GNEEdge::setShapeEndPos(), GNEEdge::setShapeStartPos(), shiftPositionAtNode(), GNEEdge::smooth(), GNEEdge::smoothElevation(), NBEdgeCont::splitAt(), NBEdgeCont::splitAt(), GNENet::splitEdge(), NBEdgeCont::splitGeometry(), GNEEdge::straightenElevation(), NGNet::toNB(), GNEEdge::updateCenteringBoundary(), GNEEdge::updateJunctionPosition(), NWWriter_SUMO::writeEdge(), NWWriter_XML::writeEdgesAndConnections(), and NWWriter_DlrNavteq::writeNodesUnsplitted().

◆ getID()

const std::string & NBEdge::getID ( ) const

inlinevirtual

Implements NBRouterEdge.

Definition at line 1528 of file NBEdge.h.

References Named::getID().

Referenced by NIImporter_SUMO::_loadNetwork(), NBRailwayTopologyAnalyzer::addBidiEdge(), NBRailwayTopologyAnalyzer::addBidiEdgesForStops(), NBLoadedSUMOTLDef::addConnection(), NBNode::addedLanesRight(), addRestrictedLane(), NBDistrict::addSink(), NBDistrict::addSource(), NIXMLEdgesHandler::addSplit(), addStraightConnections(), NIXMLTrafficLightsHandler::addTlConnection(), NIVissimDisturbance::addToNode(), NBRailwayTopologyAnalyzer::allBroken(), append(), NBEdgeCont::appendRailwayTurnarounds(), applyTurnSigns(), NIImporter_OpenStreetMap::applyTurnSigns(), NBPTStopCont::assignAndCreatNewPTStopAsNeeded(), NBPTStopCont::assignPTStopToEdgeOfClosestPlatform(), NIVissimConnection::buildEdgeConnections(), buildInnerEdges(), NIVissimEdge::buildNBEdge(), NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), NBNode::buildWalkingAreas(), NBEdgeCont::checkConsistency(), checkGeometry(), NBEdgeCont::checkGrade(), NBEdgeCont::checkOverlap(), NBTrafficLightDefinition::collectAllLinks(), NBLoadedSUMOTLDef::collectEdges(), NBTrafficLightDefinition::collectEdges(), computeAngle(), NBPTStopCont::computeCrossProductEdgePosition(), computeEdge2Edges(), NBNode::computeInternalLaneShape(), computeLanes2Edges(), NBOwnTLDef::computeUnblockedWeightedStreamNumber(), cutAtIntersection(), debugPrintConnections(), NIXMLConnectionsHandler::delConnection(), divideOnEdges(), divideSelectedLanesOnEdges(), NBNode::ApproachingDivider::execute(), NBRailwayTopologyAnalyzer::extendBidiEdges(), NBRailwayTopologyAnalyzer::extendDirectionPriority(), NBEdgeCont::extract(), NBNodeCont::feasibleCluster(), NBPTStop::findLaneAndComputeBusStopExtent(), NBPTLineCont::findWay(), NBTrafficLightDefinition::forbids(), NBRampsComputer::fulfillsRampConstraints(), NBPTStopCont::generateBidiStops(), NBRailwayTopologyAnalyzer::getBrokenRailNodes(), getConnection(), getConnectionRef(), getCrossingAngle(), getFirstNonPedestrianLane(), NIImporter_VISUM::getNamedEdgeContinuating(), NBNode::getPossiblySplittedIncoming(), NBNode::getPossiblySplittedOutgoing(), NIImporter_VISUM::getReversedContinuating(), NBPTStopCont::getReverseStop(), NBPTLine::getRouteEnd(), NBPTLine::getRouteStart(), NBPTLine::getStopEdges(), NBNode::guessCrossings(), NBEdgeCont::guessRoundabouts(), NBEdgeCont::guessSpecialLanes(), NBNodeCont::guessTLs(), NBEdgeCont::ignoreFilterMatch(), init(), NBEdgeCont::insert(), NIImporter_VISUM::isSplitEdge(), GNELane::isValid(), NBNodeCont::joinNodeCluster(), NBEdgeCont::joinTramEdges(), NIImporter_ArcView::load(), NIImporter_OpenDrive::loadNetwork(), NBEdge::MainDirections::MainDirections(), NWWriter_OpenDrive::mapmatchRoadObjects(), GNEJunction::markAsModified(), NBRampsComputer::mayNeedOffRamp(), NBRampsComputer::mayNeedOnRamp(), moveConnectionToLeft(), moveConnectionToRight(), NBRampsComputer::moveRampRight(), NIXMLEdgesHandler::myStartElement(), NBConnection::NBConnection(), NBRequest::NBRequest(), NBTurningDirectionsComputer::combination_by_angle_sorter::operator()(), NBOwnTLDef::edge_by_incoming_priority_sorter::operator()(), NBContHelper::relative_outgoing_edge_sorter::operator()(), NBContHelper::relative_incoming_edge_sorter::operator()(), NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()(), NBContHelper::same_connection_edge_sorter::operator()(), NBRequest::oppositeLeftTurnConflict(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_LanesConnections(), NIImporter_VISUM::parse_stopPoints(), NIImporter_VISUM::parse_TurnsToSignalGroups(), NIXMLConnectionsHandler::parseConnection(), NIXMLConnectionsHandler::parseDeprecatedLaneDefinition(), NIXMLConnectionsHandler::parseLaneBound(), prepareEdgePriorities(), GNECreateEdgeFrame::processClick(), NBEdgeCont::processSplits(), NWWriter_SUMO::prohibitionConnection(), NBTrafficLightDefinition::railSignalUncontrolled(), recheckLanes(), NBEdgeCont::recheckLanes(), NBEdgeCont::recheckPostProcessConnections(), NBNode::recheckVClassConnections(), NBLoadedTLDef::SignalGroup::remapIncoming(), NBLoadedTLDef::SignalGroup::remapOutgoing(), GNEJunction::removeConnectionsFrom(), removeFromConnections(), NBNodeCont::removeIsolatedRoads(), NBNode::removeSelfLoops(), NBEdgeCont::removeUnwishedEdges(), NBNodeCont::removeUnwishedNodes(), NBEdgeCont::rename(), NBConnection::replaceFrom(), NBConnection::replaceFrom(), replaceInConnections(), NBConnection::replaceTo(), NBConnection::replaceTo(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), restoreRestrictedLane(), GNEEdge::retrieveGNEConnection(), NIXMLTrafficLightsHandler::retrieveLaneIndex(), NBPTLineCont::reviseStops(), GNEEdge::setAttribute(), NBRequest::setBlocking(), setControllingTLInformation(), setEdgeStopOffset(), GNEJunction::setMoveShape(), setNodeBorder(), NBEdgePriorityComputer::setPriorityJunctionPriorities(), shiftPositionAtNode(), NBEdgeCont::splitAt(), NBEdgeCont::splitAt(), NBEdgeCont::splitGeometry(), GNENetHelper::AttributeCarriers::updateEdgeID(), NBParking::write(), NBSign::writeAsPOI(), NWWriter_DlrNavteq::writeConnectedLanes(), NWWriter_SUMO::writeConnection(), NWWriter_SUMO::writeEdge(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_DlrNavteq::writeLinksUnsplitted(), NWWriter_OpenDrive::writeNetwork(), NWWriter_DlrNavteq::writeNodesUnsplitted(), NWWriter_OpenDrive::writeNormalEdge(), NWWriter_DlrNavteq::writeProhibitedManoeuvres(), NWWriter_OpenDrive::writeRoadObjectPOI(), NWWriter_OpenDrive::writeRoadObjectPoly(), NWWriter_OpenDrive::writeRoadObjects(), NWWriter_SUMO::writeRoundabout(), and NWWriter_DlrNavteq::writeTrafficSignals().

◆ getIDSecure()

template<class T >

static std::string Named::getIDSecure	(	const T *	obj,
		const std::string &	fallBack = `"NULL"`
	)

inlinestaticinherited

get an identifier for Named-like object which may be Null

Definition at line 67 of file Named.h.

Referenced by MSLCM_LC2013::_wantsChange(), MSLCM_SL2015::_wantsChangeSublane(), MSDriveWay::addSidings(), MSLaneChanger::avoidDeadlock(), MSDriveWay::canUseSiding(), MSLaneChanger::changeOpposite(), MSLaneChanger::checkChangeOpposite(), MSDriveWay::checkFlanks(), MSVehicle::checkReversal(), MSVehicle::checkRewindLinkLanes(), AStarRouter< E, V >::compute(), DijkstraRouter< E, V >::compute(), NBOwnTLDef::computeLogicAndConts(), MSDriveWay::conflictLaneOccupied(), NBPTLineCont::constructRoute(), MSLaneChanger::continueChange(), MSLane::detectCollisions(), MSVehicle::enterLaneAtLaneChange(), MSVehicle::executeMove(), NBRailwayTopologyAnalyzer::extendDirectionPriority(), NBPTLineCont::findWay(), MSDriveWay::foeDriveWayOccupied(), MSCFModel_CACC::followSpeed(), MSCFModel_W99::followSpeed(), MSStopOut::generateOutputForUnfinished(), MSVehicle::getBackPositionOnLane(), NBOwnTLDef::getBestCombination(), NBOwnTLDef::getBestPair(), MSVehicle::getCenterOnEdge(), MSLaneChanger::getColumnleader(), NBEdge::Connection::getDescription(), MSLane::getFollowersOnConsecutive(), GUIVehicle::getLaneID(), LIBSUMO_NAMESPACE::Person::getLaneID(), MSVehicle::getLatOffset(), MSLane::getLeaderOnConsecutive(), MSLaneChanger::getOncomingOppositeVehicle(), MSLaneChanger::getRealLeader(), GUIVehicle::getShadowLaneID(), GUIVehicle::getTargetLaneID(), MSDevice_SSM::getVehiclesOnJunction(), NBEdgeCont::guessRoundabouts(), MSDriveWay::hasLinkConflict(), MSCFModel_IDM::insertionFollowSpeed(), MSLane::isInsertionSuccess(), MESegment::isOpen(), joinNamedToString(), joinNamedToString(), joinNamedToStringSorting(), MSPModel_Striping::PState::moveToNextLane(), LIBSUMO_NAMESPACE::Person::moveToXY(), LIBSUMO_NAMESPACE::Vehicle::moveToXY(), MSPModel_Striping::PState::moveToXY(), libsumo::Helper::moveToXYMap(), libsumo::Helper::moveToXYMap_matchingRoutePosition(), MSDevice_Bluelight::notifyEnter(), MSDevice_Bluelight::notifyLeave(), MSDriveWay::notifyLeave(), MSDriveWay::notifyLeaveBack(), MSVehicle::Influencer::postProcessRemoteControl(), MSVehicle::processNextStop(), MSBaseVehicle::replaceRoute(), MSStoppingPlaceRerouter::reroute(), MSBaseVehicle::reroute(), MSLaneChanger::resolveDeadlock(), MSLCM_LC2013::slowDownForBlocked(), MSLCM_SL2015::slowDownForBlocked(), MSLaneChangerSublane::startChangeSublane(), MSLeaderInfo::toString(), MSLeaderDistanceInfo::toString(), MSCriticalFollowerDistanceInfo::toString(), toString(), toString(), toString(), MSTriggeredRerouter::triggerRouting(), MSVehicle::updateBestLanes(), MSLCHelper::updateBlockerLength(), MSAbstractLaneChangeModel::updateShadowLane(), MSPModel_Striping::PState::walk(), and MSLaneChanger::yieldToDeadlockOncoming().

◆ getIncomingEdges()

EdgeVector NBEdge::getIncomingEdges ( ) const

Returns the list of incoming edges unsorted.

Returns: Connected predecessor edges

Definition at line 1392 of file NBEdge.cpp.

References NBNode::getIncomingEdges(), and myFrom.

Referenced by appendTurnaround(), NBTrafficLightDefinition::collectEdges(), NBEdgeCont::fixSplitCustomLength(), NBNode::removeSelfLoops(), NBRailwayGeometryHelper::straigthenCorrdidor(), and NWWriter_OpenDrive::writeNetwork().

Here is the caller graph for this function:

◆ getInnerGeometry()

const PositionVector NBEdge::getInnerGeometry ( ) const

Returns the geometry of the edge without the endpoints.

Definition at line 590 of file NBEdge.cpp.

References PositionVector::getSubpartByIndex(), and myGeom.

Referenced by GNENet::addReversedEdge(), GNELane::buildEdgeOperations(), GNEEdge::clickedOverGeometryPoint(), computeLaneShapes(), GNEEdge::drawEndGeometryPoint(), GNEEdge::drawStartGeometryPoint(), GNEEdge::getAttribute(), GNEEdge::getAttributePositionVector(), GNEViewNet::onCmdSplitEdgeBidi(), GNENet::replaceJunctionByGeometry(), and GNENet::reverseEdge().

Here is the caller graph for this function:

◆ getInternalLaneWidth()

double NBEdge::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.

Parameters

[in]	node	The node for which this edge is an incoming one
[in]	connection	The connection from this edge to the successor lane
[in]	successor	The outgoing lane of the connection
[in]	isVia	Whether it is computing the Via stage

Returns: The width of the internal lane

Todo:: validity checks

Definition at line 4200 of file NBEdge.cpp.

References NBEdge::Connection::fromLane, getLaneWidth(), getNumLanes(), getPermissions(), isBikepath(), NBNode::isConstantWidthTransition(), myLanes, NBEdge::Connection::toEdge, UNSPECIFIED_WIDTH, and NBEdge::Lane::width.

◆ getJunctionPriority()

int NBEdge::getJunctionPriority ( const NBNode *const node ) const

Returns the junction priority (normalised for the node currently build)

If the given node is neither the edge's start nor the edge's ending node, the behaviour is undefined.

Parameters

[in] node The node for which the edge's priority shall be returned

Returns: The edge's priority at the given node

Todo:: Maybe the edge priority whould be stored in the node

Definition at line 2132 of file NBEdge.cpp.

References myFrom, myFromJunctionPriority, and myToJunctionPriority.

Referenced by buildInnerEdges(), NBOwnTLDef::computeUnblockedWeightedStreamNumber(), NBNode::ApproachingDivider::execute(), NBEdgeCont::extractRoundabouts(), NBEdgeCont::generateStreetSigns(), NBNode::getDirection(), NWWriter_DlrNavteq::getFormOfWay(), NBOwnTLDef::getToPrio(), NBEdge::MainDirections::MainDirections(), NBNode::needsCont(), NBOwnTLDef::edge_by_incoming_priority_sorter::operator()(), NBRequest::setBlocking(), and NWWriter_SUMO::writeConnection().

Here is the caller graph for this function:

◆ getLaneFriction()

double NBEdge::getLaneFriction ( int lane ) const

get lane friction of specified lane

Definition at line 2214 of file NBEdge.cpp.

References myLanes.

Referenced by NBEdge().

Here is the caller graph for this function:

◆ getLaneID()

std::string NBEdge::getLaneID ( int lane ) const

get lane ID

Definition at line 4016 of file NBEdge.cpp.

References Named::myID, and toString().

Referenced by buildInnerEdges(), NWWriter_OpenDrive::checkLaneGeometries(), NBEdgeCont::computeEdgeShapes(), computeLaneShape(), computeLaneShapes(), NIXMLConnectionsHandler::delConnection(), NBPTStop::findLaneAndComputeBusStopExtent(), NWWriter_SUMO::getOppositeInternalID(), getSidewalkID(), guessOpposite(), GNELane::isValid(), NIXMLConnectionsHandler::parseLaneBound(), recheckLanes(), NBEdgeCont::recheckLanes(), GNEChange_Connection::redo(), NBEdgeCont::rename(), GNENet::replaceIncomingEdge(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), setConnection(), GNEEdge::setEdgeID(), setEdgeStopOffset(), GNELane::setIndex(), GNEChange_Connection::undo(), NBParking::write(), NWWriter_SUMO::writeEdge(), and NWWriter_OpenDrive::writeInternalEdge().

Here is the caller graph for this function:

◆ getLaneIndexFromLaneID()

int NBEdge::getLaneIndexFromLaneID ( const std::string laneID )

static

Definition at line 4821 of file NBEdge.cpp.

References StringUtils::toInt().

Referenced by NIXMLPTHandler::addPTStop().

Here is the caller graph for this function:

◆ getLanes()

const std::vector< NBEdge::Lane > & NBEdge::getLanes ( ) const

inline

Returns the lane definitions.

Returns: The stored lane definitions

Definition at line 730 of file NBEdge.h.

References myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), NWWriter_OpenDrive::addPedestrianConnection(), buildInnerEdges(), NBNode::buildWalkingAreas(), NBNode::checkCrossing(), NBEdgeCont::computeEdgeShapes(), GNEEdge::drawEndGeometryPoint(), GNEEdge::drawStartGeometryPoint(), NBPTStop::findLaneAndComputeBusStopExtent(), GNEConnection::getAttribute(), GNEEdge::getLaneByAllowedVClass(), GNEEdge::getLaneByDisallowedVClass(), NIXMLShapeHandler::getLanePos(), NWWriter_SUMO::getOppositeInternalID(), NBNode::guessCrossings(), NIImporter_OpenStreetMap::insertEdge(), NIXMLEdgesHandler::myEndElement(), NBEdgeCont::recheckLanes(), NBEdgeCont::removeLanesByWidth(), NBEdgeCont::rename(), GNEConnection::updateGeometry(), NBSign::writeAsPOI(), NWWriter_SUMO::writeEdge(), NWWriter_XML::writeEdgesAndConnections(), and NWWriter_OpenDrive::writeNormalEdge().

Here is the caller graph for this function:

◆ getLaneShape()

const PositionVector & NBEdge::getLaneShape ( int i ) const

Returns the shape of the nth lane.

Returns: The shape of the lane given by its index (counter from right)

Definition at line 986 of file NBEdge.cpp.

References myLanes.

Referenced by NBRequest::bidiConflict(), buildInnerEdges(), NBNode::buildWalkingAreas(), NBEdgeCont::checkGrade(), NWWriter_OpenDrive::checkLaneGeometries(), NBNode::computeInternalLaneShape(), NBPTStop::findLaneAndComputeBusStopExtent(), NBPTLineCont::findWay(), NWWriter_OpenDrive::getInnerLaneBorder(), GNELane::getLaneShape(), NBEdgeCont::guessRoundabouts(), NBEdgeCont::joinTramEdges(), NWWriter_OpenDrive::mapmatchRoadObjects(), NBRampsComputer::patchRampGeometry(), and GNELane2laneConnection::updateLane2laneConnection().

Here is the caller graph for this function:

◆ getLaneSpeed()

double NBEdge::getLaneSpeed ( int lane ) const

get lane speed

Definition at line 2208 of file NBEdge.cpp.

References myLanes.

Referenced by NBNetBuilder::compute(), GNELane::getAttribute(), GNELane::getColorValue(), GNELane::getSpeed(), and NBEdge().

Here is the caller graph for this function:

◆ getLaneSpreadFunction()

LaneSpreadFunction NBEdge::getLaneSpreadFunction ( ) const

Returns how this edge's lanes' lateral offset is computed.

Returns: The type of lateral offset that is applied on this edge

See also: LaneSpreadFunction

Definition at line 998 of file NBEdge.cpp.

References myLaneSpreadFunction.

Referenced by NBRailwayTopologyAnalyzer::addBidiEdge(), NBRailwayTopologyAnalyzer::addBidiEdgesBetweenSwitches(), NBRailwayTopologyAnalyzer::addBidiEdgesForStops(), NIXMLEdgesHandler::addEdge(), NBNodeShapeComputer::badIntersection(), GNEEdge::getAttribute(), isBidiEdge(), isBidiRail(), NBRampsComputer::moveRampRight(), NBRampsComputer::patchRampGeometry(), NBEdgeCont::processSplits(), NWWriter_SUMO::writeEdge(), NWWriter_XML::writeEdgesAndConnections(), and NWWriter_DlrNavteq::writeNodesUnsplitted().

Here is the caller graph for this function:

◆ getLaneStopOffset()

const StopOffset & NBEdge::getLaneStopOffset ( int lane ) const

Returns the stop offset to the specified lane's end.

Returns: The stop offset to the specified lane's end

Definition at line 4237 of file NBEdge.cpp.

References myEdgeStopOffset, and myLanes.

Referenced by NIXMLEdgesHandler::myStartElement().

Here is the caller graph for this function:

◆ getLaneStruct() [1/2]

Lane & NBEdge::getLaneStruct ( int lane )

inline

Definition at line 1428 of file NBEdge.h.

References myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addLane(), NIImporter_OpenStreetMap::applyTurnSigns(), GNELane::buildLaneOperations(), GNEPathManager::PathCalculator::busStopConnected(), GNEPathManager::PathCalculator::calculateReachability(), NBNode::computeInternalLaneShape(), GNEPathManager::PathCalculator::consecutiveEdgesConnected(), GNENet::deleteLane(), GNEEdge::drawEdgeName(), GNELane::drawLaneStopOffset(), GNELane::drawStartEndGeometryPoints(), GNENet::duplicateLane(), GNELane::getACParametersMap(), GNELane::getAttribute(), GNELane::getAttributePositionVector(), GNELane::getColorValue(), GNELane::getLaneShape(), GNELane::isAttributeComputed(), GNELane::isAttributeEnabled(), NIImporter_OpenDrive::loadNetwork(), NIXMLEdgesHandler::myStartElement(), NBEdgeCont::recheckLanes(), NBEdgeCont::rename(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), GNELane::setAttribute(), GNELane::setMoveShape(), GNEEdge::setNumLanes(), NBEdgeCont::splitAt(), GNELane::DrawingConstants::update(), and NWWriter_OpenDrive::writeNormalEdge().

Here is the caller graph for this function:

◆ getLaneStruct() [2/2]

const Lane & NBEdge::getLaneStruct ( int lane ) const

inline

Definition at line 1435 of file NBEdge.h.

References myLanes.

◆ getLaneWidth() [1/2]

double NBEdge::getLaneWidth ( ) const

inline

Returns the default width of lanes of this edge.

Returns: The width of lanes of this edge

Definition at line 642 of file NBEdge.h.

References myLaneWidth.

Referenced by NIImporter_SUMO::_loadNetwork(), buildInnerEdges(), GNEAdditional::calculatePerpendicularLine(), NBNode::checkCrossing(), computeAngle(), NBNode::computeInternalLaneShape(), computeLaneShapes(), NBNode::displaceShapeAtWidthChange(), GNELane::drawArrows(), GNELane::drawLinkNo(), GNELane::drawTLSLinkNo(), GNEEdge::getAttribute(), getCCWBoundaryLine(), getCWBoundaryLine(), NBNodeShapeComputer::getExtraWidth(), NWWriter_OpenDrive::getInnerLaneBorder(), getInternalLaneWidth(), getLaneWidth(), NWWriter_OpenDrive::getOuterLaneBorder(), NWWriter_OpenDrive::getRoadSideOffset(), getTotalWidth(), guessOpposite(), GNEEdge::isAttributeComputed(), joinLanes(), NBRampsComputer::moveRampRight(), NBRequest::oppositeLeftTurnConflict(), NBRampsComputer::patchRampGeometry(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_OpenDrive::writeInternalEdge(), NWWriter_OpenDrive::writeNormalEdge(), and NWWriter_OpenDrive::writeSignals().

Here is the caller graph for this function:

◆ getLaneWidth() [2/2]

double NBEdge::getLaneWidth ( int lane ) const

Returns the width of the lane of this edge.

Returns: The width of the lane of this edge

Definition at line 4193 of file NBEdge.cpp.

References getLaneWidth(), myLanes, SUMO_const_laneWidth, and UNSPECIFIED_WIDTH.

◆ getLength()

double NBEdge::getLength ( ) const

inlinevirtual

Returns the computed length of the edge.

Returns: The edge's computed length

Implements NBRouterEdge.

Definition at line 593 of file NBEdge.h.

References myLength.

Referenced by append(), GNEPathManager::PathCalculator::calculateReachability(), NBEdgeCont::computeEdgeShapes(), expandableBy(), NBEdgeCont::generateStreetSigns(), GNELane::getColorValue(), NIXMLShapeHandler::getLanePos(), getTravelTimeStatic(), NBEdgeCont::guessRoundabouts(), NBRampsComputer::mayNeedOnRamp(), NIXMLEdgesHandler::myStartElement(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_stopPoints(), NBNodeCont::pruneSlipLaneNodes(), NBEdgeCont::recheckLanes(), and NBEdgeCont::retrievePossiblySplit().

Here is the caller graph for this function:

◆ getLoadedLength()

double NBEdge::getLoadedLength ( ) const

inline

Returns the length was set explicitly or the computed length if it wasn't set.

Todo:: consolidate use of myLength and myLoaded length

Returns: The edge's specified length

Definition at line 602 of file NBEdge.h.

References myLength, and myLoadedLength.

Referenced by NIXMLEdgesHandler::addEdge(), NIXMLEdgesHandler::addSplit(), NBRampsComputer::buildOffRamp(), expandableBy(), NBNodeCont::feasibleCluster(), NBEdgeCont::fixSplitCustomLength(), GNELane::getColorValue(), getFinalLength(), GNELane::getLaneParametricLength(), NBRailwaySignalGuesser::guessByStops(), NBEdgeCont::guessRoundabouts(), NBNode::isLongEnough(), GNEEdge::isValid(), NBNodeCont::joinSimilarEdges(), NBEdgeCont::processSplits(), NBNodeCont::pruneLongEdges(), NBEdgeCont::recheckLanes(), GNENet::replaceJunctionByGeometry(), NBEdgeCont::splitAt(), GNENet::splitEdge(), NBRailwayGeometryHelper::straigthenCorrdidor(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getMaxLaneOffset()

double NBEdge::getMaxLaneOffset ( )

get max lane offset

Definition at line 3709 of file NBEdge.cpp.

References myLanes, and SUMO_const_laneWidth.

◆ getNodeBorder()

const PositionVector & NBEdge::getNodeBorder ( const NBNode * node ) const

Definition at line 727 of file NBEdge.cpp.

References myFrom, myFromBorder, myTo, and myToBorder.

Referenced by NBNode::computeInternalLaneShape().

Here is the caller graph for this function:

◆ getNumericalID()

int NBEdge::getNumericalID ( ) const

inlinevirtual

Returns the index (numeric id) of the edge.

Note: This is only used in the context of routing

Returns: This edge's numerical id

Implements NBRouterEdge.

Definition at line 1510 of file NBEdge.h.

References myIndex.

Referenced by NBContHelper::edge_similar_direction_sorter::operator()(), and NBNodesEdgesSorter::edge_by_junction_angle_sorter::operator()().

Here is the caller graph for this function:

◆ getNumLanes()

int NBEdge::getNumLanes ( ) const

inline

Returns the number of lanes.

Returns: This edge's number of lanes

Definition at line 520 of file NBEdge.h.

References myLanes.

Referenced by NBLoadedTLDef::SignalGroup::addConnection(), NIXMLEdgesHandler::addEdge(), NIXMLEdgesHandler::addLane(), GNEEdge::addLane(), NIXMLPTHandler::addPTStop(), NIXMLEdgesHandler::addSplit(), addStraightConnections(), NIVissimTL::NIVissimTLSignal::addTo(), allowsChangingLeft(), allowsChangingRight(), NBEdgeCont::appendRailwayTurnarounds(), NIImporter_OpenStreetMap::applyChangeProhibition(), NIImporter_OpenStreetMap::applyLaneUse(), applyTurnSigns(), NIImporter_OpenStreetMap::applyTurnSigns(), NBNode::ApproachingDivider::ApproachingDivider(), NIVissimConnection::buildEdgeConnections(), NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), NBNode::checkCrossing(), NBEdgeCont::checkGrade(), NWWriter_OpenDrive::checkLaneGeometries(), NBTrafficLightDefinition::collectAllLinks(), NBLoadedTLDef::collectLinks(), NBNetBuilder::compute(), computeAngle(), NBRequest::computeCrossingResponse(), NBEdgeCont::computeEdgeShapes(), NBNode::computeInternalLaneShape(), NBNode::computeLanes2Lanes(), NBOwnTLDef::computeUnblockedWeightedStreamNumber(), GNENet::createRoundabout(), GNENet::deleteLane(), NBNode::displaceShapeAtWidthChange(), divideOnEdges(), GNELane::drawMarkingsAndBoundings(), NBRampsComputer::fulfillsRampConstraints(), GNEEdge::getAttribute(), GNELane::getColorValue(), NWWriter_OpenDrive::getInnerLaneBorder(), NWWriter_SUMO::getInternalBidi(), getInternalLaneWidth(), getPermissionVariants(), NWWriter_DlrNavteq::getRoadClass(), NWWriter_OpenDrive::getRoadSideOffset(), NBEdgePriorityComputer::getScore(), getSignalOffset(), guessOpposite(), NBRampsComputer::hasWrongMode(), NBNode::isSimpleContinuation(), GNELane::isValid(), joinLanes(), NBEdge::MainDirections::MainDirections(), moveOutgoingConnectionsFrom(), NIXMLEdgesHandler::myStartElement(), NBEdge(), NBContHelper::edge_by_priority_sorter::operator()(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_LanesConnections(), NBRampsComputer::patchRampGeometry(), NBEdgeCont::processSplits(), recheckLanes(), NBEdgeCont::recheckLanes(), NIVissimExtendedEdgePoint::recheckLanes(), NBNode::recheckVClassConnections(), removeInvalidConnections(), NBEdgeCont::removeLanesByWidth(), NBEdgeCont::rename(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), NIXMLTrafficLightsHandler::retrieveLaneIndex(), NBEdgePriorityComputer::samePriority(), GNELane::setAttribute(), setConnection(), NBLoadedSUMOTLDef::setTLControllingInformation(), NBEdgeCont::splitAt(), NBEdgeCont::splitGeometry(), GNEConnection::updateGeometry(), GNELane2laneConnection::updateLane2laneConnection(), NBParking::write(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_OpenDrive::writeInternalEdge(), NWWriter_DlrNavteq::writeLinksUnsplitted(), NWWriter_OpenDrive::writeNormalEdge(), and NWWriter_OpenDrive::writeSignals().

◆ getNumLanesThatAllow()

int NBEdge::getNumLanesThatAllow	(	SVCPermissions	permissions,
		bool	allPermissions = `true`
	)		const

Definition at line 4507 of file NBEdge.cpp.

References myLanes.

Referenced by applyTurnSigns(), NBNode::getDirection(), and NBNode::isStraighter().

Here is the caller graph for this function:

◆ getParameter()

const std::string Parameterised::getParameter	(	const std::string &	key,
		const std::string	defaultValue = `""`
	)		const

virtualinherited

Returns the value for a given key.

Parameters

[in]	key	The key to ask for
[in]	defaultValue	The default value to return if no value is stored under the key

Returns: The value stored under the key

Reimplemented in MSActuatedTrafficLightLogic, MSSimpleTrafficLightLogic, and NEMALogic.

Definition at line 90 of file Parameterised.cpp.

References Parameterised::myMap.

◆ getParametersMap()

const Parameterised::Map & Parameterised::getParametersMap ( ) const

inherited

Returns the inner key/value map.

Definition at line 145 of file Parameterised.cpp.

References Parameterised::myMap.

◆ getParametersStr()

std::string Parameterised::getParametersStr	(	const std::string	kvsep = `"="`,
		const std::string	sep = `"\|"`
	)		const

inherited

Returns the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN".

Definition at line 151 of file Parameterised.cpp.

References Parameterised::myMap.

Here is the caller graph for this function:

◆ getPermissions()

SVCPermissions NBEdge::getPermissions ( int lane = -1 ) const

get the union of allowed classes over all lanes or for a specific lane

Definition at line 4378 of file NBEdge.cpp.

References getPermissions(), and myLanes.

Referenced by NBRailwayTopologyAnalyzer::addBidiEdgesForStops(), NWWriter_OpenDrive::addPedestrianConnection(), NIXMLPTHandler::addPTStop(), GNENet::addRestrictedLane(), addStraightConnections(), NBRailwayTopologyAnalyzer::Track::addSuccessor(), GNELane::allowPedestrians(), NBNode::alreadyConnectedPaths(), appendTurnaround(), NIImporter_OpenStreetMap::applyLaneUse(), applyTurnSigns(), NBNode::ApproachingDivider::ApproachingDivider(), NBPTStopCont::assignEdgeForFloatingStops(), NBRequest::bidiConflict(), GNEConnectorFrame::buildConnection(), buildInnerEdges(), canMoveConnection(), NBRequest::checkLaneFoesByClass(), NBTrafficLightDefinition::collectAllLinks(), computeAngle(), computeEdge2Edges(), NBOwnTLDef::computeLogicAndConts(), NBOwnTLDef::computeUnblockedWeightedStreamNumber(), NBNode::displaceShapeAtWidthChange(), divideOnEdges(), divideSelectedLanesOnEdges(), GNELane::drawAsWaterway(), NBNode::ApproachingDivider::execute(), NBRailwayTopologyAnalyzer::extendDirectionPriority(), NBNodeCont::feasibleCluster(), NBPTStopCont::findAccessEdgesForRailStops(), NBPTLineCont::fixPermissions(), GNEEdge::getAttribute(), GNELane::getAttribute(), GNELane::getColorValue(), getConnectionLanes(), NBNode::getDirection(), NBNodeShapeComputer::getExtraWidth(), NWWriter_DlrNavteq::getFormOfWay(), getInternalLaneWidth(), GNEConnectorFrame::getLaneStatus(), NBNode::getLinkState(), getPermissions(), getPermissionVariants(), NWWriter_OpenDrive::getRoadSideOffset(), getSuccessors(), getViaSuccessors(), NBRailwaySignalGuesser::guessByStops(), NBEdgeCont::guessRoundabouts(), NBEdgeCont::guessSpecialLanes(), NBNodeCont::guessTLs(), NBRampsComputer::hasWrongMode(), NBEdgeCont::ignoreFilterMatch(), NIImporter_OpenStreetMap::insertEdge(), isBidiRail(), NBNode::isExplicitRailNoBidi(), isRailDeadEnd(), GNELane::isRestricted(), joinLanes(), NBNodeCont::joinNodeCluster(), NBNodeCont::joinSimilarEdges(), NBEdgeCont::joinTramEdges(), NBEdge::MainDirections::MainDirections(), NBEdgePriorityComputer::markBestParallel(), NBRequest::mergeConflict(), NBEdge(), NBNodeShapeComputer::needsLargeTurn(), NBTurningDirectionsComputer::combination_by_angle_sorter::operator()(), NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()(), recheckLanes(), NBNode::recheckVClassConnections(), NBNodeCont::removeComponents(), NBEdgeCont::removeEdgesByPermissions(), removeInvalidConnections(), NBPTStop::replaceEdge(), GNENet::restrictLane(), shiftPositionAtNode(), GNERerouterSymbol::updateGeometry(), NBParking::write(), NWWriter_DlrNavteq::writeConnectedLanes(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_OpenDrive::writeInternalEdge(), NWWriter_DlrNavteq::writeLinksUnsplitted(), NWWriter_OpenDrive::writeNormalEdge(), and NWWriter_DlrNavteq::writeProhibitedManoeuvres().

◆ getPermissionVariants()

std::set< SVCPermissions > NBEdge::getPermissionVariants	(	int	iStart,
		int	iEnd
	)		const

return all permission variants within the specified lane range [iStart, iEnd[

Definition at line 4495 of file NBEdge.cpp.

References getNumLanes(), getPermissions(), and toString().

Referenced by NBNode::computeLanes2Lanes().

Here is the caller graph for this function:

◆ getPriority()

int NBEdge::getPriority ( ) const

inline

Returns the priority of the edge.

Returns: This edge's priority

Definition at line 527 of file NBEdge.h.

References myPriority.

Referenced by NIXMLEdgesHandler::addEdge(), GNENet::createRoundabout(), expandableBy(), NBRailwayTopologyAnalyzer::extendDirectionPriority(), GNEEdge::getAttribute(), GNELane::getColorValue(), NBEdgePriorityComputer::getScore(), NBEdgePriorityComputer::hasDifferentPriorities(), NBEdge::MainDirections::MainDirections(), NBContHelper::edge_by_priority_sorter::operator()(), NBContHelper::edge_opposite_direction_sorter::operator()(), NBEdgePriorityComputer::samePriority(), NBEdgePriorityComputer::setPriorityJunctionPriorities(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getShapeEndAngle()

double NBEdge::getShapeEndAngle ( ) const

Returns the angle at the end of the edge.

Note: only using edge shape; The angle is computed in computeAngle()

Returns: This edge's end angle

Definition at line 2417 of file NBEdge.cpp.

References ANGLE_LOOKAHEAD, Position::angleTo2D(), GeomHelper::legacyDegree(), PositionVector::length2D(), MIN2(), myGeom, and PositionVector::positionAtOffset2D().

Referenced by NBContHelper::edge_similar_direction_sorter::operator()().

Here is the caller graph for this function:

◆ getShapeStartAngle()

double NBEdge::getShapeStartAngle ( ) const

Returns the angle at the start of the edge.

Note: only using edge shape

Returns: This edge's start angle

Definition at line 2409 of file NBEdge.cpp.

References ANGLE_LOOKAHEAD, GeomHelper::legacyDegree(), PositionVector::length2D(), MIN2(), myGeom, and PositionVector::positionAtOffset2D().

Referenced by NBContHelper::edge_similar_direction_sorter::operator()().

Here is the caller graph for this function:

◆ getSidewalkID()

std::string NBEdge::getSidewalkID ( )

get the lane id for the canonical sidewalk lane

Definition at line 4556 of file NBEdge.cpp.

References getLaneID(), myLanes, and SVC_PEDESTRIAN.

Referenced by NBNode::buildWalkingAreas().

Here is the caller graph for this function:

◆ getSignalNode()

const NBNode * NBEdge::getSignalNode ( ) const

inline

Returns the node that (possibly) represents a traffic signal controlling at the end of this edge.

Definition at line 717 of file NBEdge.h.

References mySignalNode.

Referenced by NBNodeCont::guessTLs().

Here is the caller graph for this function:

◆ getSignalOffset()

double NBEdge::getSignalOffset ( ) const

Returns the offset of a traffic signal from the end of this edge.

Definition at line 4425 of file NBEdge.cpp.

References Position::distanceTo2D(), getNumLanes(), Position::INVALID, myLanes, myLaneSpreadFunction, mySignalPosition, RIGHT, and UNSPECIFIED_SIGNAL_OFFSET.

Referenced by NBNodeCont::guessTLs().

Here is the caller graph for this function:

◆ getSignalPosition()

const Position & NBEdge::getSignalPosition ( ) const

inline

Returns the position of a traffic signal on this edge.

Definition at line 712 of file NBEdge.h.

References mySignalPosition.

Referenced by NBNodeCont::guessTLs().

Here is the caller graph for this function:

◆ getSigns()

const std::vector< NBSign > & NBEdge::getSigns ( ) const

inline

get Signs

Definition at line 1455 of file NBEdge.h.

References mySigns.

Referenced by NWWriter_XML::writeStreetSigns().

Here is the caller graph for this function:

◆ getSpecialLane()

int NBEdge::getSpecialLane ( SVCPermissions permissions ) const

return index of the first lane that allows the given permissions

Definition at line 4471 of file NBEdge.cpp.

References myLanes.

Referenced by NBNode::computeLanes2Lanes(), and NBNode::recheckVClassConnections().

Here is the caller graph for this function:

◆ getSpeed()

double NBEdge::getSpeed ( ) const

inlinevirtual

Returns the speed allowed on this edge.

Returns: The maximum speed allowed on this edge

Implements NBRouterEdge.

Definition at line 619 of file NBEdge.h.

References mySpeed.

Referenced by NIXMLEdgesHandler::addSplit(), GNEPathManager::PathCalculator::calculateReachability(), NBNode::checkCrossing(), NBRampsComputer::fulfillsRampConstraints(), GNEEdge::getAttribute(), NWWriter_DlrNavteq::getRoadClass(), NBEdgePriorityComputer::getScore(), getTravelTimeStatic(), NBEdgeCont::guessSpecialLanes(), hasLaneSpecificSpeed(), NBEdgeCont::ignoreFilterMatch(), NBNodeCont::joinSimilarEdges(), NBContHelper::edge_by_priority_sorter::operator()(), NBEdgeCont::removeEdgesBySpeed(), NBEdgePriorityComputer::samePriority(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_DlrNavteq::writeLinksUnsplitted(), and NWWriter_OpenDrive::writeNormalEdge().

Here is the caller graph for this function:

◆ getStartAngle()

double NBEdge::getStartAngle ( ) const

inline

Returns the angle at the start of the edge (relative to the node shape center) The angle is computed in computeAngle()

Returns: This edge's start angle

Definition at line 555 of file NBEdge.h.

References myStartAngle.

Referenced by NBContHelper::relative_outgoing_edge_sorter::operator()(), and NBNode::rightTurnConflict().

Here is the caller graph for this function:

◆ getStep()

EdgeBuildingStep NBEdge::getStep ( ) const

inline

The building step of this edge.

Returns: The current building step for this edge

Todo:: Recheck usage!

See also: EdgeBuildingStep

Definition at line 635 of file NBEdge.h.

References myStep.

Referenced by NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), NBNode::computeLanes2Lanes(), NIXMLConnectionsHandler::delConnection(), NBNode::ApproachingDivider::execute(), NBNode::isExplicitRailNoBidi(), NBNodeCont::joinNodeCluster(), NIXMLConnectionsHandler::parseLaneBound(), replaceInConnections(), and GNENet::restrictLane().

Here is the caller graph for this function:

◆ getStraightContinuation()

NBEdge * NBEdge::getStraightContinuation ( SVCPermissions permissions ) const

return the straightest follower edge for the given permissions or nullptr (never returns turn-arounds)

Note: : this method is called before connections are built and simply goes by node graph topology

Definition at line 4857 of file NBEdge.cpp.

References filterByPermissions(), NBNode::getOutgoingEdges(), isTurningDirectionAt(), and myTo.

Referenced by NBRailwayTopologyAnalyzer::extendDirectionPriority(), and NBNodeCont::pruneLongEdges().

Here is the caller graph for this function:

◆ getStraightPredecessor()

NBEdge * NBEdge::getStraightPredecessor ( SVCPermissions permissions ) const

return the straightest predecessor edge for the given permissions or nullptr (never returns turn-arounds)

Note: : this method is called before connections are built and simply goes by node graph topology

Definition at line 4872 of file NBEdge.cpp.

References filterByPermissions(), NBNode::getIncomingEdges(), isTurningDirectionAt(), and myFrom.

Referenced by NBRailwayTopologyAnalyzer::extendDirectionPriority().

Here is the caller graph for this function:

◆ getStreetName()

const std::string & NBEdge::getStreetName ( ) const

inline

Returns the street name of this edge.

Definition at line 669 of file NBEdge.h.

References myStreetName.

Referenced by NIXMLEdgesHandler::addEdge(), GNEEdge::drawEdgeName(), expandableBy(), GNEEdge::getAttribute(), GNEEdge::getOptionalName(), NBEdgeCont::joinSameNodeConnectingEdges(), NWWriter_SUMO::writeEdge(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_DlrNavteq::writeLinksUnsplitted(), and NWWriter_OpenDrive::writeNormalEdge().

Here is the caller graph for this function:

◆ getSuccessors()

const EdgeVector & NBEdge::getSuccessors ( SUMOVehicleClass vClass = SVC_IGNORING ) const

Returns the following edges for the given vClass.

Definition at line 4761 of file NBEdge.cpp.

References getPermissions(), myConnections, mySuccessors, and SVC_IGNORING.

Referenced by recheckLanes(), and replaceInConnections().

Here is the caller graph for this function:

◆ getToNode()

NBNode * NBEdge::getToNode ( ) const

inline

Returns the destination node of the edge.

Returns: The node this edge ends at

Definition at line 546 of file NBEdge.h.

References myTo.

Referenced by NIImporter_SUMO::_loadNetwork(), NBRailwayTopologyAnalyzer::addBidiEdge(), NBRailwayTopologyAnalyzer::addBidiEdgesBetweenSwitches(), NBRailwayTopologyAnalyzer::addBidiEdgesForBufferStops(), NBLoadedSUMOTLDef::addConnection(), NIXMLConnectionsHandler::addCrossing(), NBNode::addedLanesRight(), NIXMLEdgesHandler::addLane(), NIXMLConnectionsHandler::addProhibition(), NIXMLEdgesHandler::addSplit(), NIXMLTrafficLightsHandler::addTlConnection(), NIVissimDisturbance::addToNode(), NBLoadedTLDef::addToSignalGroup(), NIXMLConnectionsHandler::addWalkingArea(), NBNode::alreadyConnectedPaths(), NIImporter_OpenStreetMap::RelationHandler::applyRestriction(), NBNodeShapeComputer::badIntersection(), NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), GNEConnection::changeTLIndex(), NBEdgeCont::checkConsistency(), NBNode::checkCrossing(), NBEdgeCont::checkOverlap(), NBTrafficLightDefinition::collectAllLinks(), NBLoadedTLDef::collectNodes(), NBOwnTLDef::computeLogicAndConts(), NBRampsComputer::computeRamps(), NBOwnTLDef::computeUnblockedWeightedStreamNumber(), NIVissimDistrictConnection::dict_BuildDistricts(), GNELane::drawLane2LaneConnections(), GNELane::drawLinkNo(), NBNode::ApproachingDivider::execute(), NBRailwayTopologyAnalyzer::extendBidiEdges(), NBRailwayTopologyAnalyzer::extendBidiEdges(), NBEdgeCont::extractRoundabouts(), NBNodeCont::feasibleCluster(), NBRampsComputer::fulfillsRampConstraints(), NBEdgeCont::generateStreetSigns(), GNEEdge::getAttribute(), NBNode::getDirection(), NBTurningDirectionsComputer::getFarAngleAtNode(), getFinalLength(), NWWriter_DlrNavteq::getFormOfWay(), NWWriter_DlrNavteq::getGraphLength(), NIImporter_VISUM::getNamedEdgeContinuating(), NBNode::getOppositeIncoming(), NWWriter_SUMO::getOppositeInternalID(), NBPTStopCont::getReverseEdge(), NIImporter_OpenDrive::getTLSSecure(), NBOwnTLDef::getToPrio(), GNEEdge::GNEEdge(), NBRailwaySignalGuesser::guessByStops(), guessOpposite(), NBEdgeCont::guessRoundabouts(), NBEdgeCont::guessSpecialLanes(), NBNodeCont::guessTLs(), NBOwnTLDef::hasStraightConnection(), NBEdgeCont::insert(), GNENetHelper::AttributeCarriers::insertEdge(), GNEConnection::isAttributeEnabled(), isBidiEdge(), NBNode::isLongEnough(), NBRailwayTopologyAnalyzer::isStraight(), GNEConnection::isValid(), GNELane::isValid(), NBNodeCont::joinJunctions(), NBNodeCont::joinNodeCluster(), NBEdgeCont::joinSameNodeConnectingEdges(), NBEdgeCont::joinTramEdges(), NBRequest::laneConflict(), NBRampsComputer::mayNeedOnRamp(), NBEdge(), NBNodeShapeComputer::needsLargeTurn(), NBOwnTLDef::edge_by_incoming_priority_sorter::operator()(), NBContHelper::relative_incoming_edge_sorter::operator()(), NBContHelper::edge_by_angle_to_nodeShapeCentroid_sorter::operator()(), NBContHelper::edge_with_destination_finder::operator()(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_LanesConnections(), NIImporter_VISUM::parse_stopPoints(), NIXMLConnectionsHandler::parseConnection(), NIXMLConnectionsHandler::parseLaneBound(), NBOwnTLDef::patchNEMAStateForCrossings(), NBRampsComputer::patchRampGeometry(), NBEdgeCont::processSplits(), NBNodeCont::pruneLongEdges(), NBNodeCont::pruneSlipLaneNodes(), NBTrafficLightDefinition::railSignalUncontrolled(), NBEdgeCont::recheckLanes(), NBEdgeCont::recheckPostProcessConnections(), NIImporter_OpenStreetMap::reconstructLayerElevation(), NBNodeCont::reduceToCircle(), NBNodeCont::removeComponents(), NBNode::removeEdge(), NBNodeCont::removeIsolatedRoads(), NBNodeCont::removeRailComponents(), NBEdgeCont::removeUnwishedEdges(), NBNodeCont::removeUnwishedNodes(), GNENet::replaceJunctionByGeometry(), NIImporter_DlrNavteq::TrafficlightsHandler::report(), NIImporter_OpenDrive::retrieveSignalEdges(), NBNode::rightTurnConflict(), GNEConnection::setAttribute(), NIXMLEdgesHandler::setNodes(), NIVissimConflictArea::setPriorityRegulation(), GNEEdge::smoothShape(), GNEEdge::straightenElevation(), NBRailwayGeometryHelper::straigthenCorrdidor(), NBNodesEdgesSorter::swapWhenReversed(), GNELane2laneConnection::updateLane2laneConnection(), GNEConnection::updateLinkState(), NBRailwayTopologyAnalyzer::updateTurns(), NWWriter_SUMO::writeConnection(), NWWriter_SUMO::writeEdge(), NWWriter_XML::writeEdgesAndConnections(), NWWriter_OpenDrive::writeInternalEdge(), NWWriter_DlrNavteq::writeLinksUnsplitted(), NWWriter_OpenDrive::writeNetwork(), NWWriter_SUMO::writeRoundabout(), and NWWriter_OpenDrive::writeSignals().

◆ getTotalAngle()

double NBEdge::getTotalAngle ( ) const

inline

Returns the angle at the start of the edge.

Note: The angle is computed in computeAngle()

Returns: This edge's angle

Definition at line 586 of file NBEdge.h.

References myTotalAngle.

Referenced by NBContHelper::same_connection_edge_sorter::getMinMaxRelAngles().

Here is the caller graph for this function:

◆ getTotalWidth()

double NBEdge::getTotalWidth ( ) const

Returns the combined width of all lanes of this edge.

Definition at line 4216 of file NBEdge.cpp.

References getLaneWidth(), and myLanes.

Referenced by GNENet::addReversedEdge(), NBNodeShapeComputer::badIntersection(), NBEdgeCont::checkOverlap(), computeLaneShapes(), NBNodeShapeComputer::divisionWidth(), NBNodeShapeComputer::isDivided(), NBNode::isSimpleContinuation(), setNodeBorder(), shiftPositionAtNode(), and NWWriter_DlrNavteq::writeNodesUnsplitted().

Here is the caller graph for this function:

◆ getTravelTimeStatic() [1/2]

static double NBEdge::getTravelTimeStatic	(	const NBEdge *const	edge,
		const NBVehicle * const	,
		double
	)

inlinestatic

Definition at line 1495 of file NBEdge.h.

References getLength(), and getSpeed().

Referenced by NBRailwayTopologyAnalyzer::getTravelTimeStatic().

Here is the caller graph for this function:

◆ getTravelTimeStatic() [2/2]

static double NBRouterEdge::getTravelTimeStatic	(	const NBRouterEdge *const	edge,
		const NBVehicle * const	,
		double
	)

inlinestaticinherited

Definition at line 82 of file NBEdge.h.

References NBRouterEdge::getLength(), and NBRouterEdge::getSpeed().

Referenced by NBPTLineCont::fixBidiStops(), GNEPathManager::PathCalculator::PathCalculator(), and GNEPathManager::PathCalculator::updatePathCalculator().

Here is the caller graph for this function:

◆ getTurnDestination()

NBEdge * NBEdge::getTurnDestination ( bool possibleDestination = false ) const

Definition at line 4007 of file NBEdge.cpp.

References myPossibleTurnDestination, and myTurnDestination.

Referenced by NBEdgeCont::appendRailwayTurnarounds(), NBNode::avoidOverlap(), buildInnerEdges(), NBNode::checkIsRemovableReporting(), computeEdge2Edges(), NBNode::computeInternalLaneShape(), NBNode::computeLanes2Lanes(), NBOwnTLDef::computeUnblockedWeightedStreamNumber(), NBRailwayTopologyAnalyzer::extendBidiEdges(), NBRailwayTopologyAnalyzer::extendBidiEdges(), NBPTStopCont::generateBidiStops(), NBRailwayTopologyAnalyzer::getBrokenRailNodes(), NBNode::getEdgesToJoin(), NWWriter_SUMO::getInternalBidi(), NBEdgeCont::guessRoundabouts(), isRailDeadEnd(), NBEdgeCont::recheckLanes(), GNEEdge::removeConnection(), GNEJunction::removeConnectionsFrom(), GNEEdge::setAttribute(), GNELane2laneConnection::updateLane2laneConnection(), and NWWriter_SUMO::writeEdge().

Here is the caller graph for this function:

◆ getTurnSignTarget()

const std::string & NBEdge::getTurnSignTarget ( ) const

inline

Definition at line 1553 of file NBEdge.h.

References myTurnSignTarget.

◆ getTypeID()

const std::string & NBEdge::getTypeID ( ) const

inline

get ID of type

Definition at line 1181 of file NBEdge.h.

References myType.

Referenced by NIXMLEdgesHandler::addEdge(), GNEEdge::getAttribute(), NWWriter_DlrNavteq::getBrunnelType(), NWWriter_DlrNavteq::getFormOfWay(), NWWriter_DlrNavteq::getRoadClass(), NBEdgeCont::ignoreFilterMatch(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ getViaSuccessors()

const ConstRouterEdgePairVector & NBEdge::getViaSuccessors	(	SUMOVehicleClass	vClass = `SVC_IGNORING`,
		bool	ignoreTransientPermissions = `false`
	)		const

virtual

Returns the following edges for the given vClass.

Implements NBRouterEdge.

Definition at line 4779 of file NBEdge.cpp.

References getPermissions(), myConnections, myViaSuccessors, and SVC_PEDESTRIAN.

◆ guessOpposite()

NBEdge * NBEdge::guessOpposite ( bool reguess = false )

set oppositeID and return opposite edge if found

Definition at line 4888 of file NBEdge.cpp.

References PositionVector::distances(), getFromNode(), getLaneID(), getLaneWidth(), getNumLanes(), NBNode::getOutgoingEdges(), getToNode(), VectorHelper< T >::maxValue(), myLanes, NBEdge::Lane::oppositeID, and NBEdge::Lane::shape.

Referenced by NBEdgeCont::guessOpposites().

Here is the caller graph for this function:

◆ hasAccelLane()

bool NBEdge::hasAccelLane ( ) const

whether one of the lanes is an acceleration lane

Definition at line 2516 of file NBEdge.cpp.

References myLanes.

Referenced by needsLaneSpecificOutput().

Here is the caller graph for this function:

◆ hasConnectionTo()

bool NBEdge::hasConnectionTo	(	const NBEdge *	destEdge,
		int	destLane,
		int	fromLane = `-1`
	)		const

Retrieves info about a connection to a certain lane of a certain edge.

Turnaround edge is ignored!

Parameters

[in]	destEdge	The connection's destination edge
[in]	destLane	The connection's destination lane
[in]	fromLane	If a value >= 0 is given, only return true if a connection from the given lane exists

Returns: whether a connection to the specified lane exists

Definition at line 1324 of file NBEdge.cpp.

References myConnections.

Referenced by NBNode::buildWalkingAreas(), NIXMLConnectionsHandler::delConnection(), GNEConnectorFrame::getLaneStatus(), recheckLanes(), NBLoadedSUMOTLDef::reconstructLogic(), removeInvalidConnections(), and setConnection().

Here is the caller graph for this function:

◆ hasCustomLaneShape()

bool NBEdge::hasCustomLaneShape ( ) const

whether one of the lanes has a custom shape

Definition at line 2527 of file NBEdge.cpp.

References myLanes.

Referenced by needsLaneSpecificOutput().

Here is the caller graph for this function:

◆ hasDefaultGeometry()

bool NBEdge::hasDefaultGeometry ( ) const

Returns whether the geometry consists only of the node positions.

Definition at line 596 of file NBEdge.cpp.

References hasDefaultGeometryEndpoints(), and myGeom.

Referenced by NIXMLEdgesHandler::addEdge(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasDefaultGeometryEndpointAtNode()

bool NBEdge::hasDefaultGeometryEndpointAtNode ( const NBNode * node ) const

Returns whether the geometry is terminated by the node positions This default may be violated by initializing with tryIgnoreNodePositions=true' or with setGeometry() non-default endpoints are useful to control the generated node shape.

Definition at line 609 of file NBEdge.cpp.

References NBNode::getPosition(), myFrom, myGeom, and myTo.

Referenced by NBNodeShapeComputer::badIntersection(), NBRampsComputer::patchRampGeometry(), and GNENet::replaceJunctionByGeometry().

Here is the caller graph for this function:

◆ hasDefaultGeometryEndpoints()

bool NBEdge::hasDefaultGeometryEndpoints ( ) const

Returns whether the geometry is terminated by the node positions This default may be violated by initializing with tryIgnoreNodePositions=true' or with setGeometry() non-default endpoints are useful to control the generated node shape.

Definition at line 602 of file NBEdge.cpp.

References PositionVector::almostSame(), NBNode::getPosition(), myFrom, myGeom, and myTo.

Referenced by hasDefaultGeometry(), and NBRampsComputer::patchRampGeometry().

Here is the caller graph for this function:

◆ hasLaneParams()

bool NBEdge::hasLaneParams ( ) const

whether one of the lanes has parameters set

Definition at line 2538 of file NBEdge.cpp.

References myLanes.

Referenced by needsLaneSpecificOutput().

Here is the caller graph for this function:

◆ hasLaneSpecificEndOffset()

bool NBEdge::hasLaneSpecificEndOffset ( ) const

whether lanes differ in offset

Definition at line 2492 of file NBEdge.cpp.

References myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), GNEEdge::getAttribute(), needsLaneSpecificOutput(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasLaneSpecificFriction()

bool NBEdge::hasLaneSpecificFriction ( ) const

whether lanes differ in friction

Definition at line 2460 of file NBEdge.cpp.

References myLanes.

Referenced by GNEEdge::getAttribute(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasLaneSpecificPermissions()

bool NBEdge::hasLaneSpecificPermissions ( ) const

whether lanes differ in allowed vehicle classes

Definition at line 2436 of file NBEdge.cpp.

References myLanes.

Referenced by GNEEdge::getAttribute(), needsLaneSpecificOutput(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasLaneSpecificSpeed()

bool NBEdge::hasLaneSpecificSpeed ( ) const

whether lanes differ in speed

Definition at line 2450 of file NBEdge.cpp.

References getSpeed(), and myLanes.

Referenced by GNEEdge::getAttribute(), needsLaneSpecificOutput(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasLaneSpecificStopOffsets()

bool NBEdge::hasLaneSpecificStopOffsets ( ) const

whether lanes differ in stopOffsets

Definition at line 2503 of file NBEdge.cpp.

References StopOffset::isDefined(), myEdgeStopOffset, and myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), needsLaneSpecificOutput(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasLaneSpecificType()

bool NBEdge::hasLaneSpecificType ( ) const

whether lanes differ in type

Definition at line 2481 of file NBEdge.cpp.

References myLanes.

Referenced by needsLaneSpecificOutput().

Here is the caller graph for this function:

◆ hasLaneSpecificWidth()

bool NBEdge::hasLaneSpecificWidth ( ) const

whether lanes differ in width

Definition at line 2470 of file NBEdge.cpp.

References myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), GNEEdge::getAttribute(), GNEEdge::isAttributeComputed(), needsLaneSpecificOutput(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasLoadedLength()

bool NBEdge::hasLoadedLength ( ) const

inline

Returns whether a length was set explicitly.

Returns: Wether the edge's length was specified

Definition at line 612 of file NBEdge.h.

References myLoadedLength.

Referenced by NIXMLEdgesHandler::addEdge(), NIXMLEdgesHandler::addSplit(), NBEdgeCont::fixSplitCustomLength(), getFinalLength(), GNEEdge::isAttributeComputed(), GNENet::replaceJunctionByGeometry(), NBEdgeCont::splitAt(), GNENet::splitEdge(), NWWriter_SUMO::writeEdge(), and NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ hasParameter()

bool Parameterised::hasParameter ( const std::string & key ) const

inherited

Returns whether the parameter is set.

Parameters

[in] key The key to ask for

Returns: Whether the key is known

Definition at line 84 of file Parameterised.cpp.

References Parameterised::myMap.

Referenced by MSStageWalking::activateEntryReminders(), append(), MSVehicleType::build(), GUIInductLoop::buildDetectorGUIRepresentation(), MSDevice_ElecHybrid::buildVehicleDevices(), MSDevice_Example::buildVehicleDevices(), GUINet::createTLWrapper(), EnergyParams::EnergyParams(), MSDevice_SSM::filterByConflictType(), NWWriter_DlrNavteq::getBrunnelType(), GNEEdgeData::getColorValue(), GNEEdgeRelData::getColorValue(), GNETAZRelData::getColorValue(), GNELane::getColorValue(), GUILane::getColorValue(), MSDevice_SSM::getDetectionRange(), MSDevice_SSM::getExtraTime(), MSDevice_SSM::getMDRAC_PRT(), MSDevice_SSM::getMeasuresAndThresholds(), MSDevice_SSM::getOutputFilename(), LIBSUMO_NAMESPACE::Simulation::getParameter(), MSStoppingPlaceRerouter::getWeight(), MSStageDriving::init(), SUMOVTypeParameter::initRailVisualizationParameters(), MSEdge::insertVehicle(), NIImporter_OpenStreetMap::load(), NWWriter_OpenDrive::mapmatchRoadObjects(), Parameterised::mergeParameters(), MSActuatedTrafficLightLogic::MSActuatedTrafficLightLogic(), MSSimpleTrafficLightLogic::MSSimpleTrafficLightLogic(), GNEVType::overwriteVType(), NWWriter_OpenDrive::parseTrafficSign(), NBTrafficLightDefinition::railSignalUncontrolled(), MSDevice_Battery::readParameterValue(), MSDevice_SSM::requestsTrajectories(), NBTrafficLightLogicCont::setOpenDriveSignalParameters(), MSVehicle::slowDownForSchedule(), MSDevice_SSM::useGeoCoords(), MSTLLogicControl::WAUTSwitchProcedure_Stretch::WAUTSwitchProcedure_Stretch(), MSDevice_SSM::writeLanesPositions(), MSDevice_SSM::writePositions(), NWWriter_OpenDrive::writeRoadObjectPoly(), NWWriter_OpenDrive::writeRoadObjects(), and NWWriter_OpenDrive::writeSignals().

Here is the caller graph for this function:

◆ hasPermissions()

bool NBEdge::hasPermissions ( ) const

whether at least one lane has restrictions

Definition at line 2425 of file NBEdge.cpp.

References myLanes, and SVCAll.

◆ hasRestrictedLane()

bool NBEdge::hasRestrictedLane ( SUMOVehicleClass vclass ) const

private

returns whether any lane already allows the given vclass exclusively

Definition at line 4595 of file NBEdge.cpp.

References myLanes.

Referenced by addRestrictedLane(), and NBEdgeCont::guessSpecialLanes().

Here is the caller graph for this function:

◆ hasSignalisedConnectionTo()

bool NBEdge::hasSignalisedConnectionTo ( const NBEdge *const e ) const

Check if edge has signalised connections.

Definition at line 3996 of file NBEdge.cpp.

References myConnections.

Referenced by buildInnerEdges(), and NBRequest::forbids().

Here is the caller graph for this function:

◆ haveIntersection()

bool NBEdge::haveIntersection	(	const NBNode &	n,
		const PositionVector &	shape,
		const NBEdge *	otherFrom,
		const NBEdge::Connection &	otherCon,
		int	numPoints,
		double	width1,
		double	width2,
		int	shapeFlag = `0`
	)		const

private

Definition at line 2122 of file NBEdge.cpp.

References NBNode::computeInternalLaneShape(), firstIntersection(), and PositionVector::length().

Referenced by buildInnerEdges().

Here is the caller graph for this function:

◆ incLaneNo()

void NBEdge::incLaneNo ( int by )

increment lane

Definition at line 4074 of file NBEdge.cpp.

References addLane(), LANES2LANES_USER, myLanes, and myStep.

Referenced by NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), NIImporter_VISUM::parse_Lanes(), and NBEdgeCont::processSplits().

Here is the caller graph for this function:

◆ init()

void NBEdge::init	(	int	noLanes,
		bool	tryIgnoreNodePositions,
		const std::string &	origID
	)

private

Initialization routines common to all constructors.

Checks whether the number of lanes>0, whether the junction's from- and to-nodes are given (!=0) and whether they are distict. Throws a ProcessError if any of these checks fails.

Adds the nodes positions to geometry if it shall not be ignored or if the geometry is empty.

Computes the angle and length, and adds this edge to its node as outgoing/incoming. Builds lane informations.

Parameters

[in]	noLanes	The number of lanes this edge has
[in]	tryIgnoreNodePositions	Does not add node geometries if geom.size()>=2
[in]	origID	The original ID this edge had

Definition at line 463 of file NBEdge.cpp.

References PositionVector::add(), NBNode::addIncomingEdge(), NBNode::addOutgoingEdge(), computeAngle(), computeLaneShapes(), DEBUGCOND, getID(), Named::getID(), NBNode::getIncomingEdges(), NBNode::getPosition(), SUMOXMLDefinitions::isValidNetID(), PositionVector::length(), myConnections, myConnectionsToDelete, myFrom, myGeom, Named::myID, myLanes, myLength, myTo, PositionVector::push_back_noDoublePos(), PositionVector::push_front_noDoublePos(), PositionVector::removeDoublePoints(), removeFromConnections(), PositionVector::reverse(), TL, TLF, and WRITE_WARNINGF.

Referenced by NBEdge(), NBEdge(), NBEdge(), and reinit().

Here is the caller graph for this function:

◆ invalidateConnections()

void NBEdge::invalidateConnections ( bool reallowSetting = false )

invalidate current connections of edge

Definition at line 1528 of file NBEdge.cpp.

References INIT, INIT_REJECT_CONNECTIONS, myConnections, myStep, and myTurnDestination.

Referenced by addEdge2EdgeConnection(), addLane(), addLane2LaneConnections(), NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), deleteLane(), NBEdgeCont::guessSpecialLanes(), NBEdgeCont::joinTramEdges(), NBRailwayTopologyAnalyzer::makeAllBidi(), NBEdgeCont::processSplits(), and GNEEdge::setAttribute().

Here is the caller graph for this function:

◆ isBidi()

bool NBEdge::isBidi ( )

inline

return whether this edge should be a bidi edge

Definition at line 1423 of file NBEdge.h.

References myIsBidi.

Referenced by setBidi(), and NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ isBidiEdge()

bool NBEdge::isBidiEdge ( bool checkPotential = false ) const

whether this edge is part of a bidirectional edge pair

Definition at line 761 of file NBEdge.cpp.

References CENTER, getFromNode(), getGeometry(), getLaneSpreadFunction(), getToNode(), myIsBidi, myLanes, myLaneSpreadFunction, myPossibleTurnDestination, and PositionVector::reverse().

Referenced by getBidiEdge(), GNEEdge::isAttributeEnabled(), GNEEdge::isValid(), NBNode::mustBrake(), and GNELane::DrawingConstants::update().

Here is the caller graph for this function:

◆ isBidiRail()

bool NBEdge::isBidiRail ( bool ignoreSpread = false ) const

whether this edge is part of a bidirectional railway

Definition at line 749 of file NBEdge.cpp.

References CENTER, getGeometry(), getLaneSpreadFunction(), getPermissions(), isRailway(), myLaneSpreadFunction, myPossibleTurnDestination, and PositionVector::reverse().

Referenced by NBRailwayTopologyAnalyzer::addBidiEdge(), NBRailwayTopologyAnalyzer::addBidiEdgesForStops(), NBEdgeCont::appendRailwayTurnarounds(), appendTurnaround(), buildInnerEdges(), NBNode::computeInternalLaneShape(), expandableBy(), NBRailwayTopologyAnalyzer::extendBidiEdges(), NBPTStopCont::generateBidiStops(), getBidiEdge(), getFinalLength(), NBEdgeCont::recheckLanes(), GNELane::DrawingConstants::update(), and NWWriter_SUMO::writeEdge().

Here is the caller graph for this function:

◆ isConnectedTo()

bool NBEdge::isConnectedTo	(	const NBEdge *	e,
		const bool	ignoreTurnaround = `false`
	)		const

Returns the information whethe a connection to the given edge has been added (or computed)

Parameters

[in]	e	The destination edge
[in]	ignoreTurnaround	flag to ignore or not Turnaround

Returns: Whether a connection to the specified edge exists

Definition at line 1330 of file NBEdge.cpp.

References myConnections, and myTurnDestination.

Referenced by NBNode::addedLanesRight(), NIImporter_OpenStreetMap::RelationHandler::applyRestriction(), NBNode::computeLanes2Lanes(), NIXMLConnectionsHandler::delConnection(), NBEdgeCont::joinTramEdges(), NBRequest::setBlocking(), and NWWriter_DlrNavteq::writeProhibitedManoeuvres().

Here is the caller graph for this function:

◆ isInsideTLS()

bool NBEdge::isInsideTLS ( ) const

inline

Returns whether this edge was marked as being within an intersection.

Returns: Whether this edge was marked as being within an intersection

Definition at line 1148 of file NBEdge.h.

References myAmInTLS.

Referenced by NBNode::getLinkState().

Here is the caller graph for this function:

◆ isInternal()

virtual bool NBRouterEdge::isInternal ( ) const

inlinevirtualinherited

Reimplemented in NBEdge::Connection.

Definition at line 71 of file NBEdge.h.

◆ isMacroscopicConnector()

bool NBEdge::isMacroscopicConnector ( ) const

inline

Returns whether this edge was marked as a macroscopic connector.

Returns: Whether this edge was marked as a macroscopic connector

Definition at line 1136 of file NBEdge.h.

References myAmMacroscopicConnector.

Referenced by NBRampsComputer::fulfillsRampConstraints(), GNELane::getColorValue(), and NWWriter_SUMO::writeEdge().

Here is the caller graph for this function:

◆ isNearEnough2BeJoined2()

bool NBEdge::isNearEnough2BeJoined2	(	NBEdge *	e,
		double	threshold
	)		const

Check if edge is near enought to be joined to another edge.

Definition at line 4022 of file NBEdge.cpp.

References PositionVector::distances(), getGeometry(), VectorHelper< T >::maxValue(), and myGeom.

Referenced by NBNodeCont::joinSimilarEdges().

Here is the caller graph for this function:

◆ isOffRamp()

bool NBEdge::isOffRamp ( ) const

inline

Definition at line 1399 of file NBEdge.h.

References myIsOffRamp.

Referenced by NBNode::addedLanesRight(), and markOffRamp().

Here is the caller graph for this function:

◆ isParameterValid()

bool Parameterised::isParameterValid	(	const std::string &	value,
		const std::string &	kvsep,
		const std::string &	sep
	)

staticprivateinherited

check if given string can be parsed to a parameter of type "key=value"

Definition at line 254 of file Parameterised.cpp.

References StringTokenizer::getVector(), and SUMOXMLDefinitions::isValidParameterKey().

Referenced by Parameterised::areAttributesValid(), and Parameterised::areParametersValid().

Here is the caller graph for this function:

◆ isRailDeadEnd()

bool NBEdge::isRailDeadEnd ( ) const

whether this edge is a railway edge that does not continue

Definition at line 779 of file NBEdge.cpp.

References NBNode::getOutgoingEdges(), getPermissions(), getTurnDestination(), isRailway(), and myTo.

Referenced by appendTurnaround().

Here is the caller graph for this function:

◆ isTurningDirectionAt()

bool NBEdge::isTurningDirectionAt ( const NBEdge *const edge ) const

Returns whether the given edge is the opposite direction to this edge.

Parameters

[in] edge The edge which may be the turnaround direction

Returns: Whether the given edge is this edge's turnaround direction (regardless of whether a connection exists)

Definition at line 3664 of file NBEdge.cpp.

References myPossibleTurnDestination, and myTurnDestination.

Referenced by NBRampsComputer::buildOffRamp(), NBRampsComputer::buildOnRamp(), GNEJunction::checkMissingConnections(), NBNode::computeLanes2Lanes(), NBNode::crossesFringe(), NBRampsComputer::fulfillsRampConstraints(), NBNode::geometryLike(), NBNode::getDirection(), NBNode::getNextCompatibleOutgoing(), getStraightContinuation(), getStraightPredecessor(), NBLoadedSUMOTLDef::initNeedsContRelation(), NBNode::isLeftMover(), NBRequest::laneConflict(), NBContHelper::opposite_finder::operator()(), recheckLanes(), removeInvalidConnections(), NBNode::rightTurnConflict(), NBRequest::setBlocking(), GNEEdge::smoothShape(), NBRailwayGeometryHelper::straigthenCorrdidor(), NBNodesEdgesSorter::swapWhenReversed(), NBNode::tlsContConflict(), NBNode::turnFoes(), and NWWriter_OpenDrive::writeInternalEdge().

Here is the caller graph for this function:

◆ joinLanes()

bool NBEdge::joinLanes ( SVCPermissions perms )

join adjacent lanes with the given permissions

Definition at line 4826 of file NBEdge.cpp.

References deleteLane(), getLaneWidth(), getNumLanes(), getPermissions(), myLanes, setLaneType(), and setLaneWidth().

◆ lanesWereAssigned()

bool NBEdge::lanesWereAssigned ( ) const

Check if lanes were assigned.

Definition at line 3703 of file NBEdge.cpp.

References LANES2LANES_DONE, LANES2LANES_USER, and myStep.

Referenced by NIVissimTL::NIVissimTLSignal::addTo().

Here is the caller graph for this function:

◆ markAsInLane2LaneState()

void NBEdge::markAsInLane2LaneState ( )

mark edge as in lane to state lane

Definition at line 4117 of file NBEdge.cpp.

References NBNode::getOutgoingEdges(), LANES2LANES_DONE, myStep, and myTo.

◆ markOffRamp()

void NBEdge::markOffRamp ( bool isOffRamp )

inline

marks this edge has being an offRamp or leading to one (used for connection computation)

Definition at line 1395 of file NBEdge.h.

References isOffRamp(), and myIsOffRamp.

Referenced by NBRampsComputer::buildOffRamp().

Here is the caller graph for this function:

◆ mayBeTLSControlled()

bool NBEdge::mayBeTLSControlled	(	int	fromLane,
		NBEdge *	toEdge,
		int	toLane
	)		const

return true if certain connection must be controlled by TLS

Definition at line 3715 of file NBEdge.cpp.

References myConnections.

Referenced by NBTrafficLightDefinition::collectAllLinks(), NBLoadedTLDef::collectLinks(), NBTrafficLightDefinition::collectReachable(), NBLoadedSUMOTLDef::reconstructLogic(), and setControllingTLInformation().

Here is the caller graph for this function:

◆ mergeParameters()

void Parameterised::mergeParameters	(	const Parameterised::Map &	mapArg,
		const std::string	separator = `" "`,
		bool	uniqueValues = `true`
	)

inherited

Adds or appends all given parameters from the map.

Parameters

[in] mapArg The keys/values to insert

Definition at line 65 of file Parameterised.cpp.

References Parameterised::getParameter(), Parameterised::hasParameter(), and Parameterised::setParameter().

Referenced by append().

Here is the caller graph for this function:

◆ mirrorX()

void NBEdge::mirrorX ( )

mirror coordinates along the x-axis

Definition at line 570 of file NBEdge.cpp.

References computeAngle(), Position::INVALID, PositionVector::mirrorX(), myConnections, myGeom, myLanes, mySignalPosition, Position::sety(), and Position::y().

Referenced by GNEEdge::setGeometry().

Here is the caller graph for this function:

◆ moveConnectionToLeft()

void NBEdge::moveConnectionToLeft ( int lane )

private

@briefmoves a connection one place to the left;

Note: Attention! no checking for field validity

Definition at line 1659 of file NBEdge.cpp.

References canMoveConnection(), getID(), myConnections, setConnection(), NBEdge::Connection::toEdge, NBEdge::Connection::toLane, and VALIDATED.

Referenced by recheckLanes().

Here is the caller graph for this function:

◆ moveConnectionToRight()

void NBEdge::moveConnectionToRight ( int lane )

private

@briefmoves a connection one place to the right; @noteAttention! no checking for field validity

Definition at line 1677 of file NBEdge.cpp.

References canMoveConnection(), getID(), myConnections, setConnection(), NBEdge::Connection::toEdge, NBEdge::Connection::toLane, and VALIDATED.

Referenced by recheckLanes().

Here is the caller graph for this function:

◆ moveOutgoingConnectionsFrom()

void NBEdge::moveOutgoingConnectionsFrom	(	NBEdge *	e,
		int	laneOff
	)

move outgoing connection

Definition at line 3691 of file NBEdge.cpp.

References addLane2LaneConnection(), COMPUTED, getConnectionsFromLane(), and getNumLanes().

Referenced by NBEdgeCont::joinSameNodeConnectingEdges().

Here is the caller graph for this function:

◆ needsLaneSpecificOutput()

bool NBEdge::needsLaneSpecificOutput ( ) const

whether at least one lane has values differing from the edges values

Definition at line 2558 of file NBEdge.cpp.

References hasAccelLane(), hasCustomLaneShape(), hasLaneParams(), hasLaneSpecificEndOffset(), hasLaneSpecificPermissions(), hasLaneSpecificSpeed(), hasLaneSpecificStopOffsets(), hasLaneSpecificType(), hasLaneSpecificWidth(), myLanes, and prohibitsChanging().

Referenced by NWWriter_XML::writeEdgesAndConnections().

Here is the caller graph for this function:

◆ operator=()

NBEdge & NBEdge::operator= ( const NBEdge & s )

privatedelete

invalidated assignment operator

◆ preferVehicleClass()

void NBEdge::preferVehicleClass	(	int	lane,
		SVCPermissions	vclasses
	)

prefer certain vehicle classes for the given lane or for all lanes if -1 is given (ensures also permissions)

Definition at line 4150 of file NBEdge.cpp.

References myLanes, and preferVehicleClass().

Referenced by NIImporter_OpenStreetMap::applyLaneUse(), and preferVehicleClass().

Here is the caller graph for this function:

◆ prepareEdgePriorities()

const std::vector< int > NBEdge::prepareEdgePriorities	(	const EdgeVector *	outgoing,
		const std::vector< int > &	availableLanes
	)

private

recomputes the edge priorities and manipulates them for a distribution of lanes on edges which is more like in real-life

Definition at line 3491 of file NBEdge.cpp.

References DEBUGCOND, NBEdge::MainDirections::empty(), NBEdge::MainDirections::FORWARD, getID(), NBEdge::MainDirections::getStraightest(), NBNode::getType(), NBEdge::MainDirections::includes(), NBNode::isTrafficLight(), NBEdge::MainDirections::LEFTMOST, myLanes, myTo, NBEdge::MainDirections::RIGHTMOST, and toString().

Referenced by divideSelectedLanesOnEdges().

Here is the caller graph for this function:

◆ prohibits()

bool NBRouterEdge::prohibits ( const NBVehicle * const ) const

inlineinherited

Definition at line 74 of file NBEdge.h.

◆ prohibitsChanging()

bool NBEdge::prohibitsChanging ( ) const

whether one of the lanes prohibits lane changing

Definition at line 2548 of file NBEdge.cpp.

References myLanes, and SVCAll.

Referenced by needsLaneSpecificOutput().

Here is the caller graph for this function:

◆ recheckLanes()

bool NBEdge::recheckLanes ( )

recheck whether all lanes within the edge are all right and optimises the connections once again

Definition at line 2911 of file NBEdge.cpp.

References NBEdge::Lane::accelRamp, applyTurnSigns(), NBEdge::Lane::changeLeft, NBEdge::Lane::changeRight, COMPUTED, DEBUGCOND, NBEdge::Connection::fromLane, getConnectionRef(), getConnectionsFromLane(), getID(), Named::getID(), NBNode::getIncomingEdges(), getLaneID(), getNumLanes(), NBNode::getOutgoingEdges(), getPermissions(), getSuccessors(), hasConnectionTo(), isForbidden(), isTurningDirectionAt(), LANES2LANES_DONE, LANES2LANES_USER, moveConnectionToLeft(), moveConnectionToRight(), myConnections, myConnectionsToDelete, myFrom, myLanes, myStep, myTo, myTurnSignTarget, removeFromConnections(), removeInvalidConnections(), setConnection(), sortOutgoingConnectionsByAngle(), sortOutgoingConnectionsByIndex(), SVC_BICYCLE, SVC_IGNORING, SVC_PASSENGER, SVC_PEDESTRIAN, SVC_UNSPECIFIED, SVCAll, TL, NBEdge::Connection::toEdge, NBEdge::Connection::toLane, WRITE_WARNING, and WRITE_WARNINGF.

Referenced by NBEdgeCont::recheckLanes().

Here is the caller graph for this function:

◆ reduceGeometry()

void NBEdge::reduceGeometry ( const double minDist )

Removes points with a distance lesser than the given.

Parameters

[in] minDist The minimum distance between two position to keep the second

Definition at line 1014 of file NBEdge.cpp.

References Named::getID(), myFrom, myGeom, myLanes, myTo, PositionVector::removeDoublePoints(), and PositionVector::reverse().

◆ reinit()

void NBEdge::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.

Parameters

[in]	from	The node the edge starts at
[in]	to	The node the edge ends at
[in]	type	The type of the edge (may be =="")
[in]	speed	The maximum velocity allowed on this edge
[in]	nolanes	The number of lanes this edge has
[in]	priority	This edge's priority
[in]	geom	The edge's geomatry
[in]	width	This edge's lane width
[in]	endOffset	Additional offset to the destination node
[in]	streetName	The street name (need not be unique)
[in]	spread	How the lateral offset of the lanes shall be computed
[in]	tryIgnoreNodePositions	Does not add node geometries if geom.size()>=2

Definition at line 386 of file NBEdge.cpp.

References StringUtils::convertUmlaute(), init(), MIN2(), myFrom, myGeom, myLanes, myLaneSpreadFunction, myLoadedLength, myPriority, myStreetName, myTo, myType, NBNode::removeEdge(), setEndOffset(), setFriction(), setLaneWidth(), setSpeed(), SUMO_PARAM_ORIGID, UNSPECIFIED_FRICTION, UNSPECIFIED_LOADED_LENGTH, UNSPECIFIED_OFFSET, UNSPECIFIED_SPEED, and UNSPECIFIED_WIDTH.

Referenced by NIXMLEdgesHandler::addEdge().

Here is the caller graph for this function:

◆ reinitNodes()

void NBEdge::reinitNodes	(	NBNode *	from,
		NBNode *	to
	)

Resets nodes but keeps all other values the same (used when joining)

Parameters

[in]	from	The node the edge starts at
[in]	to	The node the edge ends at

Definition at line 437 of file NBEdge.cpp.

References NBNode::addIncomingEdge(), NBNode::addOutgoingEdge(), computeAngle(), myFrom, Named::myID, myTo, NBNode::removeEdge(), and TLF.

Referenced by GNENet::changeEdgeEndpoints().

Here is the caller graph for this function:

◆ remapConnections()

void NBEdge::remapConnections ( const EdgeVector & incoming )

Remaps the connection in a way that allows the removal of it.

This edge (which is a self loop edge, in fact) connections are spread over the valid incoming edges

Todo:: recheck!

Definition at line 1431 of file NBEdge.cpp.

References addEdge2EdgeConnection(), EDGE2EDGES, getConnectedEdges(), myStep, and removeFromConnections().

Referenced by NBNode::removeSelfLoops().

Here is the caller graph for this function:

◆ removeFromConnections() [1/2]

bool NBEdge::removeFromConnections ( const NBEdge::Connection & connectionToRemove )

remove an existent connection of edge

Definition at line 1513 of file NBEdge.cpp.

References NBEdge::Connection::fromLane, myConnections, NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

◆ removeFromConnections() [2/2]

void NBEdge::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)

Parameters

[in]	toEdge	The destination edge
[in]	fromLane	The lane from which connections shall be removed; -1 means remove all
[in]	toLane	The lane to which connections shall be removed; -1 means remove all
[in]	tryLater	If the connection does not exist, try again during recheckLanes()
[in]	adaptToLaneRemoval	we are in the process of removing a complete lane, adapt all connections accordingly

Definition at line 1447 of file NBEdge.cpp.

References DEBUGCOND, NBEdge::Connection::fromLane, NBNode::getControllingTLS(), NBConnection::getFromLane(), getID(), NBConnection::getTo(), NBConnection::getToLane(), NBNode::isTLControlled(), myConnections, myConnectionsToDelete, myPossibleTurnDestination, myTo, myTurnDestination, NBConnection::shiftLaneIndex(), NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by NIImporter_OpenStreetMap::RelationHandler::applyRestriction(), NIXMLConnectionsHandler::delConnection(), deleteLane(), init(), NIXMLConnectionsHandler::parseLaneBound(), recheckLanes(), NBEdgeCont::recheckPostProcessConnections(), remapConnections(), GNEEdge::removeConnection(), replaceInConnections(), and NIImporter_DlrNavteq::ProhibitionHandler::report().

Here is the caller graph for this function:

◆ removeInvalidConnections()

void NBEdge::removeInvalidConnections ( )

private

Definition at line 3152 of file NBEdge.cpp.

References NBEdge::Connection::fromLane, NBEdge::Connection::getDescription(), getNumLanes(), getPermissions(), hasConnectionTo(), isRailway(), isTurningDirectionAt(), myConnections, SVC_PEDESTRIAN, NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by recheckLanes().

Here is the caller graph for this function:

◆ replaceInConnections() [1/2]

void NBEdge::replaceInConnections	(	NBEdge *	which,
		const std::vector< NBEdge::Connection > &	origConns
	)

replace in current connections of edge

Definition at line 1555 of file NBEdge.cpp.

References COMPUTED, DEBUGCOND, EDGE2EDGES, getID(), getStep(), getSuccessors(), joinToString(), MAX2(), MIN2(), myConnections, removeFromConnections(), replaceInConnections(), setConnection(), and toString().

◆ replaceInConnections() [2/2]

void NBEdge::replaceInConnections	(	NBEdge *	which,
		NBEdge *	by,
		int	laneOff
	)

replace in current connections of edge

Definition at line 1540 of file NBEdge.cpp.

References myConnections, and myTurnDestination.

Referenced by replaceInConnections(), and NBNode::replaceOutgoing().

Here is the caller graph for this function:

◆ resetEndpointAtNode()

void NBEdge::resetEndpointAtNode ( const NBNode * node )

Definition at line 625 of file NBEdge.cpp.

References NBNode::getPosition(), myFrom, myGeom, and myTo.

◆ resetLaneShapes()

void NBEdge::resetLaneShapes ( )

reset lane shapes to what they would be before cutting with the junction shapes

Definition at line 2220 of file NBEdge.cpp.

References computeLaneShapes().

Referenced by NBRampsComputer::patchRampGeometry().

Here is the caller graph for this function:

◆ resetNodeBorder()

void NBEdge::resetNodeBorder ( const NBNode * node )

Definition at line 738 of file NBEdge.cpp.

References myFrom, myFromBorder, myTo, and myToBorder.

Referenced by GNENet::replaceJunctionByGeometry().

Here is the caller graph for this function:

◆ reshiftPosition()

void NBEdge::reshiftPosition	(	double	xoff,
		double	yoff
	)

Applies an offset to the edge.

Parameters

[in]	xoff	The x-offset to apply
[in]	yoff	The y-offset to apply

Definition at line 550 of file NBEdge.cpp.

References Position::add(), PositionVector::add(), computeAngle(), computeEdgeShape(), computeLaneShapes(), Position::INVALID, myConnections, myFromBorder, myGeom, myLanes, mySignalPosition, and myToBorder.

◆ restoreBikelane()

void NBEdge::restoreBikelane	(	std::vector< NBEdge::Lane >	oldLanes,
		PositionVector	oldGeometry,
		std::vector< NBEdge::Connection >	oldConnections
	)

restore an previously added BikeLane

Definition at line 4590 of file NBEdge.cpp.

References restoreRestrictedLane(), and SVC_BICYCLE.

◆ restoreRestrictedLane()

void NBEdge::restoreRestrictedLane	(	SUMOVehicleClass	vclass,
		std::vector< NBEdge::Lane >	oldLanes,
		PositionVector	oldGeometry,
		std::vector< NBEdge::Connection >	oldConnections
	)

private

restore a restricted lane

Definition at line 4645 of file NBEdge.cpp.

References computeLaneShapes(), getID(), NBNode::getIncomingEdges(), myConnections, myFrom, myGeom, myLanes, myTo, NBNode::shiftTLConnectionLaneIndex(), TL, toString(), and WRITE_WARNINGF.

Referenced by restoreBikelane(), and restoreSidewalk().

Here is the caller graph for this function:

◆ restoreSidewalk()

void NBEdge::restoreSidewalk	(	std::vector< NBEdge::Lane >	oldLanes,
		PositionVector	oldGeometry,
		std::vector< NBEdge::Connection >	oldConnections
	)

restore an previously added sidewalk

Definition at line 4578 of file NBEdge.cpp.

References restoreRestrictedLane(), and SVC_PEDESTRIAN.

◆ restricts()

bool NBRouterEdge::restricts ( const NBVehicle * const ) const

inlineinherited

Definition at line 77 of file NBEdge.h.

◆ setAcceleration()

void NBEdge::setAcceleration	(	int	lane,
		bool	accelRamp
	)

marks one lane as acceleration lane

Definition at line 4325 of file NBEdge.cpp.

References myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addLane(), NBRampsComputer::buildOnRamp(), and GNELane::setAttribute().

Here is the caller graph for this function:

◆ setAsMacroscopicConnector()

void NBEdge::setAsMacroscopicConnector ( )

inline

Definition at line 1129 of file NBEdge.h.

References myAmMacroscopicConnector.

Referenced by NIImporter_VISUM::parse_Connectors_legacy().

Here is the caller graph for this function:

◆ setAverageLengthWithOpposite()

void NBEdge::setAverageLengthWithOpposite ( double val )

patch average lane length in regard to the opposite edge

Definition at line 4398 of file NBEdge.cpp.

References myLength.

Referenced by NBEdgeCont::computeEdgeShapes().

Here is the caller graph for this function:

◆ setBidi()

void NBEdge::setBidi ( bool isBidi )

inline

mark this edge as a bidi edge

Definition at line 1418 of file NBEdge.h.

References isBidi(), and myIsBidi.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addEdge(), and GNEEdge::setAttribute().

Here is the caller graph for this function:

◆ setConnection()

bool NBEdge::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.

Parameters

[in]	lane	The connection's starting lane (of this edge)
[in]	destEdge	The connection's destination edge
[in]	destLane	The connection's destination lane
[in]	type	The connections's type
[in]	mayUseSameDestination	Whether this connection may be set though connecting an already connected lane
[in]	mayDefinitelyPass	Whether this connection is definitely undistrubed (special case for on-ramps)

Todo:: Check difference between "setConnection" and "addLane2LaneConnection"

Definition at line 1185 of file NBEdge.cpp.

References COMPUTED, getLaneID(), getNumLanes(), hasConnectionTo(), INIT_REJECT_CONNECTIONS, LANES2LANES_DONE, LANES2LANES_RECHECK, LANES2LANES_USER, myConnections, myConnectionsToDelete, myLanes, myStep, SVC_UNSPECIFIED, TL, USER, and WRITE_WARNINGF.

Referenced by GNEEdge::addConnection(), addLane2LaneConnection(), NBEdgeCont::appendRailwayTurnarounds(), appendTurnaround(), applyTurnSigns(), NBNode::computeLanes2Lanes(), NBNode::ApproachingDivider::execute(), moveConnectionToLeft(), moveConnectionToRight(), recheckLanes(), and replaceInConnections().

Here is the caller graph for this function:

◆ setControllingTLInformation()

bool NBEdge::setControllingTLInformation	(	const NBConnection &	c,
		const std::string &	tlID
	)

Returns if the link could be set as to be controlled.

Definition at line 3726 of file NBEdge.cpp.

References NBConnection::getFromLane(), getID(), NBConnection::getTLIndex(), NBConnection::getTLIndex2(), NBConnection::getTo(), NBConnection::getToLane(), mayBeTLSControlled(), myConnections, myLanes, TL, NBEdge::Connection::tlID, NBEdge::Connection::tlLinkIndex, NBEdge::Connection::tlLinkIndex2, and WRITE_WARNINGF.

Referenced by NBLoadedSUMOTLDef::addConnection(), NBLoadedSUMOTLDef::setTLControllingInformation(), NBLoadedTLDef::setTLControllingInformation(), and NBOwnTLDef::setTLControllingInformation().

Here is the caller graph for this function:

◆ setDefaultConnectionLength()

static void NBEdge::setDefaultConnectionLength ( double length )

inlinestatic

Definition at line 390 of file NBEdge.h.

References myDefaultConnectionLength.

Referenced by NBNetBuilder::applyOptions().

Here is the caller graph for this function:

◆ setDistance()

void NBEdge::setDistance ( double distance )

inline

set kilometrage at start of edge (negative value implies couting down along the edge)

Definition at line 1413 of file NBEdge.h.

References myDistance.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addEdge(), NIImporter_OpenStreetMap::insertEdge(), GNEEdge::setAttribute(), and NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ setEdgeStopOffset()

bool NBEdge::setEdgeStopOffset	(	int	lane,
		const StopOffset &	offset,
		bool	overwrite = `false`
	)

set lane and vehicle class specific stopOffset (negative lane implies set for all lanes)

Returns: Whether given stop offset was applied.

Definition at line 4263 of file NBEdge.cpp.

References getID(), getLaneID(), StopOffset::getOffset(), StopOffset::isDefined(), myEdgeStopOffset, myLanes, TL, toString(), and WRITE_WARNINGF.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::myEndElement(), NIXMLEdgesHandler::myStartElement(), and NBEdge().

Here is the caller graph for this function:

◆ setEndOffset()

void NBEdge::setEndOffset	(	int	lane,
		double	offset
	)

set lane specific end-offset (negative lane implies set for all lanes)

Definition at line 4247 of file NBEdge.cpp.

References myEndOffset, myLanes, and setEndOffset().

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addLane(), GNEEdge::addLane(), NBEdgeCont::joinSameNodeConnectingEdges(), NBEdge(), reinit(), GNEEdge::setAttribute(), GNELane::setAttribute(), and setEndOffset().

Here is the caller graph for this function:

◆ setFriction()

void NBEdge::setFriction	(	int	lane,
		double	friction
	)

set lane specific friction (negative lane implies set for all lanes)

Definition at line 4309 of file NBEdge.cpp.

References myFriction, myLanes, and setFriction().

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addEdge(), NIXMLEdgesHandler::addLane(), GNEEdge::addLane(), NBEdge(), reinit(), GNEEdge::setAttribute(), GNELane::setAttribute(), setFriction(), and NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ setGeometry()

void NBEdge::setGeometry	(	const PositionVector &	g,
		bool	inner = `false`
	)

(Re)sets the edge's geometry

Replaces the edge's prior geometry by the given. Then, computes the geometries of all lanes using computeLaneShapes. Definitely not the best way to have it accessable from outside...

Parameters

[in]	g	The edge's new geometry
[in]	inner	whether g should be interpreted as inner points

Todo:: Recheck usage, disallow access

See also: computeLaneShapes

Definition at line 637 of file NBEdge.cpp.

References PositionVector::add(), computeAngle(), computeLaneShapes(), Named::getID(), PositionVector::length(), myFrom, myGeom, Named::myID, myLength, myTo, TL, and WRITE_WARNINGF.

Referenced by NBRampsComputer::moveRampRight(), NBRampsComputer::patchRampGeometry(), NBEdgeCont::processSplits(), NIImporter_OpenStreetMap::reconstructLayerElevation(), GNEEdge::setGeometry(), and NGNet::toNB().

Here is the caller graph for this function:

◆ setID()

virtual void Named::setID ( const std::string & newID )

inlinevirtualinherited

resets the id

Parameters

[in] newID The new id of this object

Reimplemented in MSBaseVehicle, MSTransportable, and NBLoadedSUMOTLDef.

Definition at line 82 of file Named.h.

References Named::myID.

Referenced by Distribution_Parameterized::parse(), NBLoadedSUMOTLDef::reconstructLogic(), NBEdgeCont::rename(), NBNodeCont::rename(), GNEJunction::setAttribute(), NBLoadedSUMOTLDef::setID(), and IntermodalNetwork< E, L, N, V >::splitEdge().

Here is the caller graph for this function:

◆ setInsideTLS()

void NBEdge::setInsideTLS ( bool inside )

inline

Marks this edge being within an intersection.

Definition at line 1141 of file NBEdge.h.

References myAmInTLS.

Referenced by NBLoadedSUMOTLDef::collectEdges(), and NBTrafficLightDefinition::collectEdges().

Here is the caller graph for this function:

◆ setJunctionPriority()

void NBEdge::setJunctionPriority	(	const NBNode *const	node,
		int	prio
	)

Sets the junction priority of the edge.

Parameters

[in]	node	The node for which the edge's priority is given
[in]	prio	The edge's new priority at this node

Todo:: Maybe the edge priority whould be stored in the node

Definition at line 2142 of file NBEdge.cpp.

References myFrom, myFromJunctionPriority, myToJunctionPriority, Parameterised::setParameter(), and toString().

Referenced by NBEdgePriorityComputer::extractAndMarkFirst(), NIImporter_OpenStreetMap::insertEdge(), and NBEdgePriorityComputer::setPriorityJunctionPriorities().

Here is the caller graph for this function:

◆ setLaneShape()

void NBEdge::setLaneShape	(	int	lane,
		const PositionVector &	shape
	)

sets a custom lane shape

Definition at line 4333 of file NBEdge.cpp.

References myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addLane(), and GNELane::setAttribute().

Here is the caller graph for this function:

◆ setLaneSpreadFunction()

void NBEdge::setLaneSpreadFunction ( LaneSpreadFunction spread )

(Re)sets how the lanes lateral offset shall be computed

Parameters

[in] spread The type of lateral offset to apply

See also: LaneSpreadFunction

Definition at line 992 of file NBEdge.cpp.

References myLaneSpreadFunction.

Referenced by NBRailwayTopologyAnalyzer::addBidiEdgesForBufferStops(), NIImporter_VISUM::parse_Edges(), NBEdgeCont::recheckLaneSpread(), and GNEEdge::setAttribute().

Here is the caller graph for this function:

◆ setLaneType()

void NBEdge::setLaneType	(	int	lane,
		const std::string &	type
	)

set lane specific type (negative lane implies set for all lanes)

Definition at line 4179 of file NBEdge.cpp.

References myLanes, and setLaneType().

Referenced by NIXMLEdgesHandler::addLane(), joinLanes(), NBEdge(), and setLaneType().

Here is the caller graph for this function:

◆ setLaneWidth()

void NBEdge::setLaneWidth	(	int	lane,
		double	width
	)

set lane specific width (negative lane implies set for all lanes)

Definition at line 4164 of file NBEdge.cpp.

References myLanes, myLaneWidth, and setLaneWidth().

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addEdge(), NIXMLEdgesHandler::addLane(), GNEEdge::addLane(), NIVissimEdge::buildNBEdge(), NIImporter_OpenStreetMap::insertEdge(), joinLanes(), NBEdgeCont::joinSameNodeConnectingEdges(), NBEdge(), reinit(), GNEEdge::setAttribute(), GNELane::setAttribute(), and setLaneWidth().

Here is the caller graph for this function:

◆ setLoadedLength()

void NBEdge::setLoadedLength ( double val )

set loaded length

Definition at line 4393 of file NBEdge.cpp.

References myLoadedLength.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addEdge(), NBEdgeCont::fixSplitCustomLength(), NIImporter_MATSim::EdgesHandler::insertEdge(), NIImporter_ArcView::load(), NBEdgeCont::recheckLanes(), NIImporter_DlrNavteq::EdgesHandler::report(), GNEEdge::setAttribute(), and NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ setNodeBorder()

void NBEdge::setNodeBorder	(	const NBNode *	node,
		const Position &	p,
		const Position &	p2,
		bool	rectangularCut
	)

Set Node border.

Definition at line 695 of file NBEdge.cpp.

References DEBUGCOND, PositionVector::extrapolate2D(), gDebugFlag1, getID(), Named::getID(), PositionVector::getOrthogonal(), getTotalWidth(), myFrom, myFromBorder, myGeom, myTo, and myToBorder.

◆ setNumericalID()

void NBEdge::setNumericalID ( int index )

inline

sets the index of the edge in the list of all network edges

Definition at line 1502 of file NBEdge.h.

References myIndex.

◆ setOrigID()

void NBEdge::setOrigID	(	const std::string	origID,
		const bool	append,
		const int	laneIdx = `-1`
	)

set origID for all lanes or for a specific lane

Definition at line 4736 of file NBEdge.cpp.

References append(), Parameterised::getParameter(), StringTokenizer::getVector(), myLanes, setOrigID(), SUMO_PARAM_ORIGID, and toString().

Referenced by NBEdgeCont::joinTramEdges(), setOrigID(), and NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ setParameter()

void Parameterised::setParameter	(	const std::string &	key,
		const std::string &	value
	)

virtualinherited

Sets a parameter.

Parameters

[in]	key	The parameter's name
[in]	value	The parameter's value

Reimplemented in MSRailCrossing, MSActuatedTrafficLightLogic, MSRailSignal, MSSimpleTrafficLightLogic, and NEMALogic.

Definition at line 45 of file Parameterised.cpp.

References Parameterised::myMap.

Referenced by NBRailwayTopologyAnalyzer::addBidiEdge(), NLHandler::addDistrict(), RONetHandler::addParam(), ShapeHandler::addPOI(), NBOwnTLDef::buildNemaPhases(), MSParkingArea::enter(), NIImporter_MATSim::EdgesHandler::insertEdge(), NIImporter_OpenStreetMap::insertEdge(), NIImporter_OpenStreetMap::insertNodeChecking(), MSLane::isInsertionSuccess(), NBNodeCont::joinNodeCluster(), NBEdge::Lane::Lane(), NWWriter_OpenDrive::mapmatchRoadObjects(), Parameterised::mergeParameters(), MSStateHandler::myStartElement(), NIXMLConnectionsHandler::myStartElement(), NIXMLNodesHandler::myStartElement(), NIXMLTrafficLightsHandler::myStartElement(), ShapeHandler::myStartElement(), MSDevice_Bluelight::notifyMove(), GNESingleParametersDialog::onCmdAccept(), NBRailwayTopologyAnalyzer::reverseEdges(), GNEVType::setAttribute(), setJunctionPriority(), NIImporter_OpenDrive::setLaneAttributes(), MSRailCrossing::setParameter(), MSActuatedTrafficLightLogic::setParameter(), MSRailSignal::setParameter(), MSSimpleTrafficLightLogic::setParameter(), NEMALogic::setParameter(), LIBSUMO_NAMESPACE::Simulation::setParameter(), Parameterised::setParametersStr(), LIBSUMO_NAMESPACE::Vehicle::setStopParameter(), LIBSUMO_NAMESPACE::TrafficLight::swapParameters(), Parameterised::updateParameters(), NWWriter_OpenDrive::writeNetwork(), and NIImporter_OpenDrive::writeRoadObjects().

Here is the caller graph for this function:

◆ setParameters()

void Parameterised::setParameters ( const Parameterised & params )

inherited

set the inner key/value map in map<string, string> format

Definition at line 167 of file Parameterised.cpp.

References Parameterised::getParametersMap(), and Parameterised::myMap.

Referenced by MSStageDriving::clone(), MSStageTranship::clone(), MSStageTrip::clone(), MSStageWaiting::clone(), MSStageWalking::clone(), and MSStageTrip::reroute().

Here is the caller graph for this function:

◆ setParametersStr()

void Parameterised::setParametersStr	(	const std::string &	paramsString,
		const std::string	kvsep = `"="`,
		const std::string	sep = `"\|"`
	)

inherited

set the inner key/value map in string format "key1=value1|key2=value2|...|keyN=valueN"

Parameters

[in]	paramsString	A serialized key-value map
[in]	kvsep	The separater between key and value
[in]	sep	The separater between map entries

Definition at line 173 of file Parameterised.cpp.

References StringTokenizer::getVector(), Parameterised::myMap, and Parameterised::setParameter().

Here is the caller graph for this function:

◆ setPermissions()

void NBEdge::setPermissions	(	SVCPermissions	permissions,
		int	lane = `-1`
	)

set allowed/disallowed classes for the given lane or for all lanes if -1 is given

Definition at line 4341 of file NBEdge.cpp.

References myLanes, and setPermissions().

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addEdge(), NIXMLEdgesHandler::addLane(), GNEEdge::addLane(), NINavTeqHelper::addVehicleClasses(), NINavTeqHelper::addVehicleClassesV6(), NIImporter_OpenStreetMap::applyLaneUse(), NGEdge::buildNBEdge(), NBPTLineCont::fixPermissions(), NIImporter_MATSim::EdgesHandler::insertEdge(), NIImporter_OpenStreetMap::insertEdge(), NBEdgeCont::joinSameNodeConnectingEdges(), NBEdgeCont::joinTramEdges(), NIImporter_ArcView::load(), NBEdge(), NIImporter_VISUM::parse_Edges(), NIImporter_DlrNavteq::EdgesHandler::report(), GNELane::setAttribute(), and setPermissions().

Here is the caller graph for this function:

◆ setPermittedChanging()

void NBEdge::setPermittedChanging	(	int	lane,
		SVCPermissions	changeLeft,
		SVCPermissions	changeRight
	)

set allowed classes for changing to the left and right from the given lane

Definition at line 4369 of file NBEdge.cpp.

References myLanes.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addLane(), NIImporter_OpenStreetMap::applyChangeProhibition(), and GNELane::setAttribute().

Here is the caller graph for this function:

◆ setPreferredVehicleClass()

void NBEdge::setPreferredVehicleClass	(	SVCPermissions	permissions,
		int	lane = `-1`
	)

set preferred Vehicle Class

Definition at line 4355 of file NBEdge.cpp.

References myLanes, and setPreferredVehicleClass().

Referenced by NIXMLEdgesHandler::addLane(), GNEEdge::addLane(), and setPreferredVehicleClass().

Here is the caller graph for this function:

◆ setPriority()

void NBEdge::setPriority ( int priority )

inline

Sets the priority of the edge.

Definition at line 532 of file NBEdge.h.

References myPriority.

Referenced by NBRailwayTopologyAnalyzer::extendDirectionPriority().

Here is the caller graph for this function:

◆ setSignalPosition()

void NBEdge::setSignalPosition	(	const Position &	pos,
		const NBNode *	signalNode
	)

inline

sets the offset of a traffic signal from the end of this edge

Definition at line 722 of file NBEdge.h.

References mySignalNode, and mySignalPosition.

◆ setSpeed()

void NBEdge::setSpeed	(	int	lane,
		double	speed
	)

set lane specific speed (negative lane implies set for all lanes)

Definition at line 4293 of file NBEdge.cpp.

References myLanes, mySpeed, and setSpeed().

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLEdgesHandler::addEdge(), NIXMLEdgesHandler::addLane(), GNEEdge::addLane(), NIVissimEdge::buildNBEdge(), NBNetBuilder::compute(), NBEdge(), NBEdgeCont::processSplits(), reinit(), GNEEdge::setAttribute(), GNELane::setAttribute(), setSpeed(), and NBEdgeCont::splitAt().

Here is the caller graph for this function:

◆ setStreetName()

void NBEdge::setStreetName ( const std::string & name )

inline

sets the street name of this edge

Definition at line 674 of file NBEdge.h.

References myStreetName.

Referenced by GNEEdge::setAttribute().

Here is the caller graph for this function:

◆ setTurningDestination()

void NBEdge::setTurningDestination	(	NBEdge *	e,
		bool	onlyPossible = `false`
	)

Sets the turing destination at the given edge.

Parameters

[in]	e	The turn destination
[in]	onlyPossible	If true, only sets myPossibleTurnDestination

Definition at line 2199 of file NBEdge.cpp.

References myPossibleTurnDestination, and myTurnDestination.

◆ setTurnSignTarget()

void NBEdge::setTurnSignTarget ( const std::string & target )

inline

Definition at line 1557 of file NBEdge.h.

References myTurnSignTarget.

Referenced by NIImporter_OpenStreetMap::insertEdge().

Here is the caller graph for this function:

◆ shiftPositionAtNode()

void NBEdge::shiftPositionAtNode	(	NBNode *	node,
		NBEdge *	opposite
	)

shift geometry at the given node to avoid overlap

Definition at line 4679 of file NBEdge.cpp.

References CENTER, PositionVector::distance2D(), getBidiEdge(), getGeometry(), getID(), Named::getID(), getPermissions(), NBNode::getPosition(), getTotalWidth(), isRailway(), MIN2(), PositionVector::move2side(), myGeom, myLaneSpreadFunction, myTo, TL, and WRITE_WARNINGF.

Referenced by NBNode::avoidOverlap().

Here is the caller graph for this function:

◆ shiftToLanesToEdge()

void NBEdge::shiftToLanesToEdge	(	NBEdge *	to,
		int	laneOff
	)

modifify the toLane for all connections to the given edge

XXX could we repurpose the function replaceInConnections ?

Definition at line 4668 of file NBEdge.cpp.

References myConnections.

◆ shortenGeometryAtNode()

void NBEdge::shortenGeometryAtNode	(	const NBNode *	node,
		double	reduction
	)

linearly extend the geometry at the given node

Definition at line 681 of file NBEdge.cpp.

References computeLaneShapes(), PositionVector::getSubpart2D(), PositionVector::length2D(), MIN2(), myFrom, and myGeom.

◆ sortOutgoingConnectionsByAngle()

void NBEdge::sortOutgoingConnectionsByAngle ( )

sorts the outgoing connections by their angle relative to their junction

Definition at line 1419 of file NBEdge.cpp.

References myConnections.

Referenced by applyTurnSigns(), and recheckLanes().

Here is the caller graph for this function:

◆ sortOutgoingConnectionsByIndex()

void NBEdge::sortOutgoingConnectionsByIndex ( )

sorts the outgoing connections by their from-lane-index and their to-lane-index

Definition at line 1425 of file NBEdge.cpp.

References connections_sorter(), and myConnections.

Referenced by applyTurnSigns(), divideOnEdges(), and recheckLanes().

Here is the caller graph for this function:

◆ startShapeAt()

PositionVector NBEdge::startShapeAt	(	const PositionVector &	laneShape,
		const NBNode *	startNode,
		PositionVector	nodeShape
	)

static

returns a modified version of laneShape which starts at the outside of startNode. laneShape may be shorted or extended

Note: see [wiki:Developer/Network_Building_Process]

Definition at line 926 of file NBEdge.cpp.

References PositionVector::closePolygon(), PositionVector::extrapolate2D(), NBNode::geometryLike(), NBNode::getPosition(), NBNode::getShape(), PositionVector::getSubpart2D(), PositionVector::getSubpartByIndex(), PositionVector::intersects(), PositionVector::intersectsAtLengths2D(), PositionVector::length2D(), VectorHelper< T >::maxValue(), MIN2(), PositionVector::positionAtOffset2D(), PositionVector::push_front_noDoublePos(), Position::setz(), and Position::z().

Referenced by NBNode::computeInternalLaneShape(), and cutAtIntersection().

Here is the caller graph for this function:

◆ tryGetNodeAtPosition()

NBNode * NBEdge::tryGetNodeAtPosition	(	double	pos,
		double	tolerance = `5.0`
	)		const

Returns the node at the given edges length (using an epsilon)

Note: When no node is existing at the given position, 0 is returned The epsilon is a static member of NBEdge, should be setable via program options

Definition at line 3677 of file NBEdge.cpp.

References myFrom, myLength, and myTo.

◆ unsetParameter()

void Parameterised::unsetParameter ( const std::string & key )

inherited

Removes a parameter.

Parameters

[in] key The parameter's name

Definition at line 51 of file Parameterised.cpp.

References Parameterised::myMap.

Referenced by NIImporter_OpenStreetMap::insertEdge(), MSLane::isInsertionSuccess(), NIImporter_OpenStreetMap::load(), GNEVType::setAttribute(), and LIBSUMO_NAMESPACE::TrafficLight::swapParameters().

Here is the caller graph for this function:

◆ updateChangeRestrictions()

void NBEdge::updateChangeRestrictions ( SVCPermissions ignoring )

modify all existing restrictions on lane changing

Definition at line 2226 of file NBEdge.cpp.

References myConnections, myLanes, SVC_UNSPECIFIED, and SVCAll.

◆ updateParameters()

void Parameterised::updateParameters ( const Parameterised::Map & mapArg )

inherited

Adds or updates all given parameters from the map.

Parameters

[in] mapArg The keys/values to insert

Definition at line 57 of file Parameterised.cpp.

References Parameterised::setParameter().

Referenced by NIImporter_SUMO::_loadNetwork(), NBNode::addCrossing(), PCLoaderOSM::addPOI(), PCLoaderOSM::addPolygon(), NLHandler::closeEdge(), NLJunctionControlBuilder::closeJunction(), NLJunctionControlBuilder::closeTrafficLightLogic(), NBTrafficLightDefinition::compute(), NLDetectorBuilder::endE3Detector(), NIImporter_OpenStreetMap::insertEdge(), NIImporter_OpenStreetMap::insertNodeChecking(), NBEdge(), NBLoadedSUMOTLDef::NBLoadedSUMOTLDef(), NBTrafficLightLogic::NBTrafficLightLogic(), and LIBSUMO_NAMESPACE::TrafficLight::swapConstraints().

Here is the caller graph for this function:

◆ updateTurnPermissions()

void NBEdge::updateTurnPermissions	(	SVCPermissions &	perm,
		LinkDirection	dir,
		SVCPermissions	spec,
		std::vector< LinkDirection >	dirs
	)

staticprivate

Definition at line 2678 of file NBEdge.cpp.

Referenced by applyTurnSigns().

Here is the caller graph for this function:

◆ writeParams()

void Parameterised::writeParams ( OutputDevice & device ) const

inherited

write Params in the given outputdevice

Definition at line 188 of file Parameterised.cpp.

References OutputDevice::closeTag(), StringUtils::escapeXML(), Parameterised::myMap, OutputDevice::openTag(), SUMO_ATTR_KEY, SUMO_ATTR_VALUE, SUMO_TAG_PARAM, and OutputDevice::writeAttr().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ GNEEdge

friend class GNEEdge

friend

Definition at line 97 of file NBEdge.h.

◆ GNEJunction

friend class GNEJunction

friend

Definition at line 98 of file NBEdge.h.

◆ GNELane

friend class GNELane

friend

used for visualization (netedit)

Definition at line 96 of file NBEdge.h.

◆ NBEdgeCont

friend class NBEdgeCont

friend

Definition at line 93 of file NBEdge.h.

Field Documentation

◆ ANGLE_LOOKAHEAD

const double NBEdge::ANGLE_LOOKAHEAD = 10.0

static

the distance at which to take the default angle

Definition at line 370 of file NBEdge.h.

Referenced by computeAngle(), getShapeEndAngle(), getShapeStartAngle(), NBContHelper::relative_outgoing_edge_sorter::operator()(), and NBContHelper::relative_incoming_edge_sorter::operator()().

◆ DummyEdge

NBEdge NBEdge::DummyEdge

static

Dummy edge to use when a reference must be supplied in the no-arguments constructor (FOX technicality)

Definition at line 343 of file NBEdge.h.

◆ myAmInTLS

bool NBEdge::myAmInTLS

private

Information whether this is lies within a joined tls.

Definition at line 1814 of file NBEdge.h.

Referenced by isInsideTLS(), and setInsideTLS().

◆ myAmMacroscopicConnector

bool NBEdge::myAmMacroscopicConnector

private

Information whether this edge is a (macroscopic) connector.

Definition at line 1817 of file NBEdge.h.

Referenced by isMacroscopicConnector(), and setAsMacroscopicConnector().

◆ myConnections

std::vector<Connection> NBEdge::myConnections

private

List of connections to following edges.

See also: Connection

Definition at line 1770 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), addLane(), addRestrictedLane(), addStraightConnections(), append(), appendTurnaround(), applyTurnSigns(), assignInternalLaneLength(), buildInnerEdges(), clearControllingTLInformation(), computeEdge2Edges(), computeLanes2Edges(), copyConnectionsFrom(), debugPrintConnections(), divideOnEdges(), divideSelectedLanesOnEdges(), GNELane::drawArrows(), NBEdge::ToEdgeConnectionsAdder::execute(), expandableBy(), getConnectedEdges(), getConnectedSorted(), getConnection(), getConnectionLanes(), getConnectionRef(), getConnections(), getConnections(), getConnectionsFromLane(), getSuccessors(), getViaSuccessors(), hasConnectionTo(), hasSignalisedConnectionTo(), init(), invalidateConnections(), isConnectedTo(), mayBeTLSControlled(), mirrorX(), moveConnectionToLeft(), moveConnectionToRight(), recheckLanes(), removeFromConnections(), removeFromConnections(), removeInvalidConnections(), replaceInConnections(), replaceInConnections(), reshiftPosition(), restoreRestrictedLane(), setConnection(), setControllingTLInformation(), shiftToLanesToEdge(), sortOutgoingConnectionsByAngle(), sortOutgoingConnectionsByIndex(), and updateChangeRestrictions().

◆ myConnectionsToDelete

std::vector<Connection> NBEdge::myConnectionsToDelete

private

List of connections marked for delayed removal.

Definition at line 1773 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), append(), computeEdge2Edges(), computeLanes2Edges(), getConnectedSorted(), init(), recheckLanes(), removeFromConnections(), and setConnection().

◆ myDefaultConnectionLength

double NBEdge::myDefaultConnectionLength = NBEdge::UNSPECIFIED_LOADED_LENGTH

staticprivate

Definition at line 1851 of file NBEdge.h.

Referenced by applyTurnSigns(), and setDefaultConnectionLength().

◆ myDistance

double NBEdge::myDistance

private

The mileage/kilometrage at the start of this edge in a linear coordination system.

Definition at line 1765 of file NBEdge.h.

Referenced by getDistancAt(), getDistance(), and setDistance().

◆ myEdgeStopOffset

StopOffset NBEdge::myEdgeStopOffset

private

A vClass specific stop offset - assumed of length 0 (unspecified) or 1. For the latter case the int is a bit set specifying the vClasses, the offset applies to (see SUMOVehicleClass.h), and the double is the stopping offset in meters from the lane end.

Definition at line 1800 of file NBEdge.h.

Referenced by GNEEdge::drawLaneStopOffset(), GNEEdge::getAttribute(), getEdgeStopOffset(), getLaneStopOffset(), hasLaneSpecificStopOffsets(), GNEEdge::isAttributeEnabled(), GNEEdge::setAttribute(), and setEdgeStopOffset().

◆ myEndAngle

double NBEdge::myEndAngle

private

Definition at line 1751 of file NBEdge.h.

Referenced by computeAngle(), getAngleAtNodeToCenter(), and getEndAngle().

◆ myEndOffset

double NBEdge::myEndOffset

private

This edges's offset to the intersection begin (will be applied to all lanes)

Definition at line 1794 of file NBEdge.h.

Referenced by getEndOffset(), and setEndOffset().

◆ myFriction

double NBEdge::myFriction

private

The current friction.

Definition at line 1762 of file NBEdge.h.

Referenced by getFriction(), and setFriction().

◆ myFrom

NBNode* NBEdge::myFrom

private

The source and the destination node.

Definition at line 1740 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), addLane(), addLane2LaneConnection(), addRestrictedLane(), buildInnerEdges(), computeAngle(), computeEdgeShape(), computeLaneShapes(), cutAtIntersection(), debugPrintConnections(), deleteLane(), expandableBy(), extendGeometryAtNode(), NBEdgeCont::extract(), getAngleAtNode(), getAngleAtNodeNormalized(), getAngleAtNodeToCenter(), getCCWBoundaryLine(), getCWBoundaryLine(), getEndpointAtNode(), getFromNode(), getIncomingEdges(), getJunctionPriority(), getNodeBorder(), getStraightPredecessor(), hasDefaultGeometryEndpointAtNode(), hasDefaultGeometryEndpoints(), init(), recheckLanes(), reduceGeometry(), reinit(), reinitNodes(), resetEndpointAtNode(), resetNodeBorder(), restoreRestrictedLane(), setGeometry(), setJunctionPriority(), setNodeBorder(), shortenGeometryAtNode(), NBEdgeCont::splitAt(), NBEdgeCont::splitAt(), and tryGetNodeAtPosition().

◆ myFromBorder

PositionVector NBEdge::myFromBorder

private

intersection borders (because the node shape might be invalid)

Definition at line 1831 of file NBEdge.h.

Referenced by cutAtIntersection(), getNodeBorder(), resetNodeBorder(), reshiftPosition(), and setNodeBorder().

◆ myFromJunctionPriority

int NBEdge::myFromJunctionPriority

private

The priority normalised for the node the edge is outgoing of.

Definition at line 1782 of file NBEdge.h.

Referenced by getJunctionPriority(), and setJunctionPriority().

◆ myGeom

PositionVector NBEdge::myGeom

private

◆ myID

std::string Named::myID

protectedinherited

The name of the object.

Definition at line 125 of file Named.h.

Referenced by MSDriveWay::addBidiFoes(), MSE2Collector::addDetectorToLanes(), MSDriveWay::addFoes(), MSDriveWay::addParallelFoes(), MSDriveWay::addReversalFoes(), MSDriveWay::addSwitchFoes(), RODFDetector::buildDestinationDistribution(), MSDriveWay::buildDriveWay(), NGEdge::buildNBEdge(), NGNode::buildNBNode(), MSSOTLTrafficLightLogic::checkPhases(), NBNode::computeNodeShape(), NEMALogic::constructTimingAndPhaseDefs(), MSE2Collector::detectorUpdate(), GNEPOI::getAttribute(), GNEPoly::getAttribute(), MSLane::getCanonicalPredecessorLane(), MSLane::getCanonicalSuccessorLane(), Named::getID(), getLaneID(), NEMALogic::getPhaseObj(), ROEdge::getStoredEffort(), GNEPOI::getSumoBaseObject(), MSLane::getSurroundingVehicles(), ROEdge::getTravelTime(), init(), MSSOTLTrafficLightLogic::init(), MSDelayBasedTrafficLightLogic::init(), NEMALogic::init(), MSLane::isInsertionSuccess(), NBNode::NBNode(), NBNode::NBNode(), MSE2Collector::notifyEnter(), MSE2Collector::notifyLeave(), MSE2Collector::notifyMove(), MSMeanData::openInterval(), NEMALogic::parseControllerType(), RORouteDef::preComputeCurrentRoute(), reinitNodes(), GNEPOI::setAttribute(), GNEPoly::setAttribute(), setGeometry(), Named::setID(), MSSOTLTrafficLightLogic::setToATargetPhase(), Distribution_Parameterized::toStr(), MSChargingStation::writeAggregatedChargingStationOutput(), MSDriveWay::writeBlocks(), MSDriveWay::writeBlockVehicles(), MSChargingStation::writeChargingStationOutput(), RODFDetector::writeEmitterDefinition(), MSOverheadWire::writeOverheadWireSegmentOutput(), RODFDetector::writeSingleSpeedTrigger(), MSTractionSubstation::writeTractionSubstationOutput(), MEInductLoop::writeXMLOutput(), and MSE3Collector::writeXMLOutput().

◆ myIndex

int NBEdge::myIndex

private

the index of the edge in the list of all edges. Set by NBEdgeCont and requires re-set whenever the list of edges changes

Definition at line 1842 of file NBEdge.h.

Referenced by getNumericalID(), and setNumericalID().

◆ myIsBidi

bool NBEdge::myIsBidi

private

whether this edge is part of a non-rail bidi edge pair

Definition at line 1839 of file NBEdge.h.

Referenced by isBidi(), isBidiEdge(), and setBidi().

◆ myIsOffRamp

bool NBEdge::myIsOffRamp

private

whether this edge is an Off-Ramp or leads to one

Definition at line 1836 of file NBEdge.h.

Referenced by isOffRamp(), and markOffRamp().

◆ myLanes

std::vector<Lane> NBEdge::myLanes

private

Lane information.

See also: Lane

Definition at line 1808 of file NBEdge.h.

Referenced by addLane(), addRestrictedLane(), addStraightConnections(), allowsChangingLeft(), allowsChangingRight(), allowVehicleClass(), append(), applyTurnSigns(), buildInnerEdges(), computeAngle(), computeEdge2Edges(), computeEdgeShape(), computeLaneShapes(), decLaneNo(), deleteLane(), disallowVehicleClass(), dismissVehicleClassInformation(), divideOnEdges(), divideSelectedLanesOnEdges(), expandableBy(), getCCWBoundaryLine(), getCWBoundaryLine(), getEndOffset(), getFinalLength(), getFirstAllowedLaneIndex(), getFirstNonPedestrianLane(), getFirstNonPedestrianLaneIndex(), getFirstNonPedestrianNonBicycleLaneIndex(), getInternalLaneWidth(), getLaneFriction(), getLanes(), getLaneShape(), getLaneSpeed(), getLaneStopOffset(), getLaneStruct(), getLaneStruct(), getLaneWidth(), getMaxLaneOffset(), getNumLanes(), getNumLanesThatAllow(), getPermissions(), getSidewalkID(), getSignalOffset(), getSpecialLane(), getTotalWidth(), guessOpposite(), hasAccelLane(), hasCustomLaneShape(), hasLaneParams(), hasLaneSpecificEndOffset(), hasLaneSpecificFriction(), hasLaneSpecificPermissions(), hasLaneSpecificSpeed(), hasLaneSpecificStopOffsets(), hasLaneSpecificType(), hasLaneSpecificWidth(), hasPermissions(), hasRestrictedLane(), incLaneNo(), init(), isBidiEdge(), joinLanes(), NBEdge::MainDirections::MainDirections(), mirrorX(), NBEdge(), needsLaneSpecificOutput(), preferVehicleClass(), prepareEdgePriorities(), prohibitsChanging(), recheckLanes(), reduceGeometry(), reinit(), reshiftPosition(), restoreRestrictedLane(), setAcceleration(), setConnection(), setControllingTLInformation(), setEdgeStopOffset(), setEndOffset(), setFriction(), setLaneShape(), setLaneType(), setLaneWidth(), setOrigID(), setPermissions(), setPermittedChanging(), setPreferredVehicleClass(), setSpeed(), NBEdgeCont::splitAt(), and updateChangeRestrictions().

◆ myLaneSpreadFunction

LaneSpreadFunction NBEdge::myLaneSpreadFunction

private

The information about how to spread the lanes.

Definition at line 1791 of file NBEdge.h.

Referenced by addRestrictedLane(), computeAngle(), computeLaneShapes(), expandableBy(), getLaneSpreadFunction(), getSignalOffset(), isBidiEdge(), isBidiRail(), NBEdgeCont::joinSameNodeConnectingEdges(), reinit(), setLaneSpreadFunction(), and shiftPositionAtNode().

◆ myLaneWidth

double NBEdge::myLaneWidth

private

This width of this edge's lanes.

Definition at line 1803 of file NBEdge.h.

Referenced by getLaneWidth(), and setLaneWidth().

◆ myLength

double NBEdge::myLength

private

The length of the edge.

Definition at line 1746 of file NBEdge.h.

Referenced by append(), computeEdgeShape(), expandableBy(), geometryPositionAtOffset(), getLength(), getLoadedLength(), init(), setAverageLengthWithOpposite(), setGeometry(), and tryGetNodeAtPosition().

◆ myLoadedLength

double NBEdge::myLoadedLength

private

An optional length to use (-1 if not valid)

Definition at line 1811 of file NBEdge.h.

Referenced by append(), geometryPositionAtOffset(), getLoadedLength(), hasLoadedLength(), NBEdge(), reinit(), and setLoadedLength().

◆ myMap

Parameterised::Map Parameterised::myMap

privateinherited

The key->value map.

Definition at line 139 of file Parameterised.h.

Referenced by Parameterised::clearParameter(), Parameterised::getDouble(), Parameterised::getDoubles(), Parameterised::getParameter(), Parameterised::getParametersMap(), Parameterised::getParametersStr(), Parameterised::hasParameter(), Parameterised::setParameter(), Parameterised::setParameters(), Parameterised::setParametersStr(), Parameterised::unsetParameter(), and Parameterised::writeParams().

◆ myPossibleTurnDestination

NBEdge* NBEdge::myPossibleTurnDestination

private

The edge that would be the turn destination if there was one.

Definition at line 1779 of file NBEdge.h.

Referenced by append(), getBidiEdge(), getFinalLength(), getTurnDestination(), isBidiEdge(), isBidiRail(), isTurningDirectionAt(), removeFromConnections(), and setTurningDestination().

◆ myPriority

int NBEdge::myPriority

private

The priority of the edge.

Definition at line 1756 of file NBEdge.h.

Referenced by getPriority(), reinit(), GNEEdge::setAttribute(), and setPriority().

◆ mySignalNode

const NBNode* NBEdge::mySignalNode

private

Definition at line 1827 of file NBEdge.h.

Referenced by getSignalNode(), and setSignalPosition().

◆ mySignalPosition

Position NBEdge::mySignalPosition

private

the position of a traffic light signal on this edge

Definition at line 1826 of file NBEdge.h.

Referenced by append(), getSignalOffset(), getSignalPosition(), mirrorX(), reshiftPosition(), and setSignalPosition().

◆ mySigns

std::vector<NBSign> NBEdge::mySigns

private

the street signs along this edge

Definition at line 1823 of file NBEdge.h.

Referenced by addSign(), and getSigns().

◆ mySpeed

double NBEdge::mySpeed

private

The maximal speed.

Definition at line 1759 of file NBEdge.h.

Referenced by expandableBy(), getSpeed(), and setSpeed().

◆ myStartAngle

double NBEdge::myStartAngle

private

The angles of the edge.

Definition at line 1750 of file NBEdge.h.

Referenced by computeAngle(), getAngleAtNodeToCenter(), and getStartAngle().

◆ myStep

EdgeBuildingStep NBEdge::myStep

private

The building step.

See also: EdgeBuildingStep

Definition at line 1734 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), addLane2LaneConnection(), append(), computeEdge2Edges(), computeLanes2Edges(), copyConnectionsFrom(), decLaneNo(), declareConnectionsAsLoaded(), expandableBy(), getStep(), incLaneNo(), invalidateConnections(), lanesWereAssigned(), markAsInLane2LaneState(), recheckLanes(), remapConnections(), and setConnection().

◆ myStreetName

std::string NBEdge::myStreetName

private

The street name (or whatever arbitrary string you wish to attach)

Definition at line 1820 of file NBEdge.h.

Referenced by append(), expandableBy(), getStreetName(), reinit(), and setStreetName().

◆ mySuccessors

EdgeVector NBEdge::mySuccessors

mutableprivate

Definition at line 1845 of file NBEdge.h.

Referenced by getSuccessors().

◆ myTo

NBNode * NBEdge::myTo

private

Definition at line 1740 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), addLane(), addLane2LaneConnection(), addRestrictedLane(), addStraightConnections(), append(), appendTurnaround(), applyTurnSigns(), buildInnerEdges(), computeAngle(), computeEdge2Edges(), computeEdgeShape(), computeLaneShapes(), cutAtIntersection(), GNELane::drawArrows(), expandableBy(), extendGeometryAtNode(), NBEdgeCont::extract(), getAngleAtNode(), getAngleAtNodeNormalized(), getAngleAtNodeToCenter(), getConnectedSorted(), getNodeBorder(), getStraightContinuation(), getToNode(), hasDefaultGeometryEndpointAtNode(), hasDefaultGeometryEndpoints(), init(), isRailDeadEnd(), markAsInLane2LaneState(), NBEdge(), prepareEdgePriorities(), recheckLanes(), reduceGeometry(), reinit(), reinitNodes(), removeFromConnections(), resetEndpointAtNode(), resetNodeBorder(), restoreRestrictedLane(), setGeometry(), setNodeBorder(), shiftPositionAtNode(), NBEdgeCont::splitAt(), NBEdgeCont::splitAt(), and tryGetNodeAtPosition().

◆ myToBorder

PositionVector NBEdge::myToBorder

private

Definition at line 1832 of file NBEdge.h.

Referenced by append(), cutAtIntersection(), getNodeBorder(), resetNodeBorder(), reshiftPosition(), and setNodeBorder().

◆ myToJunctionPriority

int NBEdge::myToJunctionPriority

private

The priority normalised for the node the edge is incoming in.

Definition at line 1785 of file NBEdge.h.

Referenced by getJunctionPriority(), and setJunctionPriority().

◆ myTotalAngle

double NBEdge::myTotalAngle

private

Definition at line 1752 of file NBEdge.h.

Referenced by computeAngle(), and getTotalAngle().

◆ myTurnDestination

NBEdge* NBEdge::myTurnDestination

private

The turn destination edge (if a connection exists)

Definition at line 1776 of file NBEdge.h.

Referenced by append(), appendTurnaround(), computeEdge2Edges(), divideOnEdges(), getConnectedSorted(), getConnectionLanes(), getTurnDestination(), invalidateConnections(), isConnectedTo(), isTurningDirectionAt(), removeFromConnections(), replaceInConnections(), and setTurningDestination().

◆ myTurnSignTarget

std::string NBEdge::myTurnSignTarget

private

node for which turnSign information applies

Definition at line 1743 of file NBEdge.h.

Referenced by append(), getTurnSignTarget(), recheckLanes(), and setTurnSignTarget().

◆ myType

std::string NBEdge::myType

private

The type of the edge.

Definition at line 1737 of file NBEdge.h.

Referenced by getTypeID(), reinit(), and GNEEdge::setAttribute().

◆ myViaSuccessors

ConstRouterEdgePairVector NBEdge::myViaSuccessors

mutableprivate

Definition at line 1848 of file NBEdge.h.

Referenced by getViaSuccessors().

◆ TURN_SIGN_SHIFT_BICYCLE

const int NBEdge::TURN_SIGN_SHIFT_BICYCLE = 24

static

Definition at line 381 of file NBEdge.h.

Referenced by applyTurnSigns(), and NIImporter_OpenStreetMap::EdgesHandler::myStartElement().

◆ TURN_SIGN_SHIFT_BUS

const int NBEdge::TURN_SIGN_SHIFT_BUS = 8

static

shift values for decoding turn signs

Definition at line 379 of file NBEdge.h.

Referenced by applyTurnSigns(), and NIImporter_OpenStreetMap::EdgesHandler::myStartElement().

◆ TURN_SIGN_SHIFT_TAXI

const int NBEdge::TURN_SIGN_SHIFT_TAXI = 16

static

Definition at line 380 of file NBEdge.h.

Referenced by applyTurnSigns(), and NIImporter_OpenStreetMap::EdgesHandler::myStartElement().

◆ UNSPECIFIED_CONNECTION_UNCONTROLLED

const bool NBEdge::UNSPECIFIED_CONNECTION_UNCONTROLLED = false

static

TLS-controlled despite its node controlled not specified.

Definition at line 376 of file NBEdge.h.

Referenced by NIImporter_SUMO::addConnection(), and applyTurnSigns().

◆ UNSPECIFIED_CONTPOS

const double NBEdge::UNSPECIFIED_CONTPOS = -1

static

unspecified internal junction position

Definition at line 358 of file NBEdge.h.

Referenced by NIImporter_SUMO::addConnection(), NBEdgeCont::appendRailwayTurnarounds(), appendTurnaround(), applyTurnSigns(), buildInnerEdges(), GNEAttributeCarrier::fillNetworkElements(), NBFrame::fillOptions(), NIImporter_OpenDrive::loadNetwork(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), and NWWriter_SUMO::writeConnection().

◆ UNSPECIFIED_FRICTION

const double NBEdge::UNSPECIFIED_FRICTION = 1.

static

unspecified lane friction

Definition at line 355 of file NBEdge.h.

Referenced by NIImporter_SUMO::_loadNetwork(), NIImporter_SUMO::addConnection(), NIXMLEdgesHandler::addEdge(), NIImporter_SUMO::addLane(), applyTurnSigns(), buildInnerEdges(), NIVissimEdge::buildNBEdge(), NGEdge::buildNBEdge(), GNENet::createEdge(), NIVissimDistrictConnection::dict_BuildDistricts(), NBFrame::fillOptions(), NIImporter_MATSim::EdgesHandler::insertEdge(), NIImporter_OpenStreetMap::insertEdge(), NBTypeCont::insertEdgeType(), NBTypeCont::insertLaneType(), NBEdgeCont::joinSameNodeConnectingEdges(), NIImporter_ArcView::load(), NIImporter_OpenDrive::loadNetwork(), NIImporter_ITSUMO::Handler::myEndElement(), NBTypeCont::EdgeTypeDefinition::needsLaneType(), NIImporter_VISUM::parse_Connectors_legacy(), NIImporter_VISUM::parse_Edges(), reinit(), NIImporter_DlrNavteq::EdgesHandler::report(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), NWWriter_XML::writeEdgesAndConnections(), NBTypeCont::writeEdgeTypes(), NWWriter_SUMO::writeInternalEdges(), and NWWriter_SUMO::writeLane().

◆ UNSPECIFIED_INTERNAL_LANE_INDEX

const int NBEdge::UNSPECIFIED_INTERNAL_LANE_INDEX = -1

static

internal lane computation not yet done

Definition at line 373 of file NBEdge.h.

◆ UNSPECIFIED_LOADED_LENGTH

const double NBEdge::UNSPECIFIED_LOADED_LENGTH = -1

static

no length override given

Definition at line 364 of file NBEdge.h.

Referenced by NIImporter_SUMO::addConnection(), NIImporter_SUMO::addEdge(), NIXMLEdgesHandler::addEdge(), assignInternalLaneLength(), buildInnerEdges(), GNEAttributeCarrier::fillNetworkElements(), NBFrame::fillOptions(), GNEEdge::isValid(), NIImporter_OpenDrive::loadNetwork(), reinit(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), GNEEdge::setAttribute(), and NWWriter_SUMO::writeConnection().

◆ UNSPECIFIED_OFFSET

const double NBEdge::UNSPECIFIED_OFFSET = 0

static

◆ UNSPECIFIED_SIGNAL_OFFSET

const double NBEdge::UNSPECIFIED_SIGNAL_OFFSET = -1

static

unspecified signal offset

Definition at line 367 of file NBEdge.h.

Referenced by getSignalOffset(), and NBNodeCont::guessTLs().

◆ UNSPECIFIED_SPEED

const double NBEdge::UNSPECIFIED_SPEED = -1

static

unspecified lane speed

Definition at line 352 of file NBEdge.h.

Referenced by NIImporter_SUMO::addConnection(), NIXMLEdgesHandler::addEdge(), applyTurnSigns(), buildInnerEdges(), GNEAttributeCarrier::fillNetworkElements(), GNEConnection::getAttribute(), GNEConnection::isAttributeComputed(), GNEConnection::isValid(), NIImporter_OpenDrive::loadNetwork(), NBTypeCont::EdgeTypeDefinition::needsLaneType(), reinit(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), GNEConnection::setAttribute(), NWWriter_SUMO::writeConnection(), and NBTypeCont::writeEdgeTypes().

◆ UNSPECIFIED_VISIBILITY_DISTANCE

const double NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE = -1

static

unspecified foe visibility for connections

Definition at line 361 of file NBEdge.h.

Referenced by NIImporter_SUMO::addConnection(), NBEdgeCont::appendRailwayTurnarounds(), appendTurnaround(), applyTurnSigns(), NBFrame::checkOptions(), GNEAttributeCarrier::fillNetworkElements(), NIImporter_OpenDrive::loadNetwork(), NIImporter_DlrNavteq::ConnectedLanesHandler::report(), NWWriter_SUMO::writeConnection(), and NWWriter_SUMO::writeInternalConnection().

◆ UNSPECIFIED_WIDTH

const double NBEdge::UNSPECIFIED_WIDTH = -1

static

unspecified lane width

Definition at line 346 of file NBEdge.h.

Referenced by NIImporter_SUMO::_loadNetwork(), NIXMLConnectionsHandler::addCrossing(), NIXMLEdgesHandler::addEdge(), NIImporter_SUMO::addLane(), NIXMLConnectionsHandler::addWalkingArea(), NBNode::buildCrossings(), NIVissimEdge::buildNBEdge(), NBNode::buildWalkingAreas(), NBNode::checkCrossing(), computeLaneShapes(), NBNodeShapeComputer::computeNodeShapeDefault(), GNENet::createEdge(), NIVissimDistrictConnection::dict_BuildDistricts(), NIVissimEdge::dictionary(), NBFrame::fillOptions(), GNEEdge::getAttribute(), GNELane::getAttribute(), getInternalLaneWidth(), getLaneWidth(), NIImporter_MATSim::EdgesHandler::insertEdge(), NIImporter_OpenStreetMap::insertEdge(), GNEEdge::isAttributeComputed(), GNELane::isAttributeComputed(), GNEEdge::isValid(), GNELane::isValid(), NBEdgeCont::joinSameNodeConnectingEdges(), NIImporter_OpenDrive::loadNetwork(), NBRampsComputer::moveRampRight(), NIImporter_ITSUMO::Handler::myEndElement(), NIXMLEdgesHandler::myEndElement(), NBTypeCont::EdgeTypeDefinition::needsLaneType(), NIVissimSingleTypeParser_Streckendefinition::parse(), NIImporter_VISUM::parse_Connectors_legacy(), NIImporter_VISUM::parse_Edges(), NIImporter_VISUM::parse_Types(), reinit(), NBEdgeCont::removeLanesByWidth(), NIImporter_DlrNavteq::EdgesHandler::report(), GNEEdge::setAttribute(), GNELane::setAttribute(), NIImporter_OpenDrive::setLaneAttributes(), NIImporter_OpenStreetMap::usableType(), NWWriter_XML::writeEdgesAndConnections(), NBTypeCont::writeEdgeTypes(), and NWWriter_SUMO::writeLane().

The documentation for this class was generated from the following files:

Data Structures

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

functions for router usage

Setting and getting connections

Detailed Description

Member Typedef Documentation

◆ Map

Member Enumeration Documentation

◆ EdgeBuildingStep

◆ JunctionPriority

◆ Lane2LaneInfoType

Constructor & Destructor Documentation

◆ NBEdge() [1/5]

◆ NBEdge() [2/5]

◆ NBEdge() [3/5]

◆ ~NBEdge()

◆ NBEdge() [4/5]

◆ NBEdge() [5/5]

Member Function Documentation

◆ addBikeLane()

◆ addEdge2EdgeConnection()

◆ addGeometryPoint()

◆ addLane()

◆ addLane2LaneConnection()

◆ addLane2LaneConnections()

◆ addRestrictedLane()

◆ addSidewalk()

◆ addSign()

◆ addStraightConnections()

◆ addTo()

◆ allowsChangingLeft()

◆ allowsChangingRight()

◆ allowVehicleClass()

◆ append()

◆ appendTurnaround()

◆ applyTurnSigns()

◆ areAttributesValid()

◆ areParametersValid()

◆ assignInternalLaneLength()

◆ bothLeftTurns()

◆ buildInnerEdges()

◆ canMoveConnection()

◆ checkGeometry()

◆ clearControllingTLInformation()

◆ clearParameter()

◆ computeAngle()

◆ computeEdge2Edges()

◆ computeEdgeShape()

◆ computeLanes2Edges()

◆ computeLaneShape()

◆ computeLaneShapes()

◆ connections_sorter()

◆ copyConnectionsFrom()

◆ cutAtIntersection()

◆ debugPrintConnections()

◆ decLaneNo()

◆ declareConnectionsAsLoaded()

◆ decodeTurnSigns()

◆ deleteLane()

◆ disallowVehicleClass()

◆ dismissVehicleClassInformation()

◆ divideOnEdges()

◆ divideSelectedLanesOnEdges()

◆ expandableBy()

◆ extendGeometryAtNode()

◆ filterByPermissions()

◆ firstIntersection()

◆ geometryPositionAtOffset()

◆ getAngleAtNode()

◆ getAngleAtNodeNormalized()

◆ getAngleAtNodeToCenter()