NBEdge Class Reference

#include <NBEdge.h>

---

Detailed Description

The representation of a single edge during network building.

Definition at line 62 of file NBEdge.h.

Public Types
enum	EdgeBuildingStep {   INIT_REJECT_CONNECTIONS, INIT, EDGE2EDGES, LANES2EDGES,   LANES2LANES_RECHECK, LANES2LANES_DONE, LANES2LANES_USER }
	Current state of the edge within the building process. More...
enum	Lane2LaneInfoType { L2L_COMPUTED, L2L_USER, L2L_VALIDATED }
	Modes of setting connections between lanes. More...
enum	LaneSpreadFunction { LANESPREAD_RIGHT, LANESPREAD_CENTER }
	Information how the edge's lateral offset shall be computed. More...
Public Member Functions
void	addCrossingPointsAsIncomingWithGivenOutgoing (NBEdge *o, Position2DVector &into)
void	allowVehicleClass (int lane, SUMOVehicleClass vclass)
void	append (NBEdge *continuation)
void	appendTurnaround (bool noTLSControlled) throw ()
	Add a connection to the previously computed turnaround, if wished.
bool	computeEdge2Edges ()
	computes the edge (step1: computation of approached edges)
bool	computeLanes2Edges ()
	computes the edge, step2: computation of which lanes approach the edges)
void	computeTurningDirections ()
	computes which edge shall be the turn-around one, if any
void	copyConnectionsFrom (NBEdge *src)
void	decLaneNo (unsigned int by, int dir=0)
void	disableConnection4TLS (int fromLane, NBEdge *toEdge, int toLane)
void	disallowVehicleClass (int lane, SUMOVehicleClass vclass)
void	dismissVehicleClassInformation ()
bool	expandableBy (NBEdge *possContinuation) const
std::vector< SUMOVehicleClass >	getAllowedVehicleClasses () const
SUMOReal	getAngle (const NBNode &atNode) const
Position2DVector	getCCWBoundaryLine (const NBNode &n, SUMOReal offset) const
std::vector< NBEdge * >	getConnectedEdges () const throw ()
const std::vector< NBEdge * > *	getConnectedSorted ()
std::vector< int >	getConnectionLanes (NBEdge *currentOutgoing) const
	returns the list of lanes that may be used to reach the given edge
std::vector< Connection > &	getConnections ()
const std::vector< Connection > &	getConnections () const
Position2DVector	getCWBoundaryLine (const NBNode &n, SUMOReal offset) const
int	getJunctionPriority (const NBNode *const node) const
	Returns the junction priority (normalised for the node currently build).
std::string	getLaneID (unsigned int lane)
SUMOReal	getLaneSpeed (unsigned int lane) const
int	getMaxConnectedLane (NBEdge *of) const
SUMOReal	getMaxLaneOffset ()
Position2D	getMaxLaneOffsetPositionAt (NBNode *node, SUMOReal width) const
int	getMinConnectedLane (NBEdge *of) const
Position2D	getMinLaneOffsetPositionAt (NBNode *node, SUMOReal width) const
SUMOReal	getNormedAngle (const NBNode &atNode) const
SUMOReal	getNormedAngle () const
NBEdge *	getTurnDestination () const
const std::string &	getTypeID () const throw ()
bool	hasRestrictions () const
bool	hasSignalisedConnectionTo (const NBEdge *const e) const throw ()
void	incLaneNo (unsigned int by)
void	invalidateConnections (bool reallowSetting=false)
bool	isConnectedTo (NBEdge *e)
	Returns the information whethe a connection to the given edge has been added (or computed).
bool	isNearEnough2BeJoined2 (NBEdge *e)
bool	isTurningDirectionAt (const NBNode *n, const NBEdge *const edge) const throw ()
	Returns whether the given edge is the opposite direction to this edge.
bool	lanesWereAssigned () const
void	markAsInLane2LaneState ()
bool	mayBeTLSControlled (int fromLane, NBEdge *toEdge, int toLane) const throw ()
void	moveOutgoingConnectionsFrom (NBEdge *e, unsigned int laneOff)
	NBEdge (const std::string &id, NBNode *from, NBNode *to, std::string type, SUMOReal speed, unsigned int nolanes, int priority, Position2DVector geom, LaneSpreadFunction spread=LANESPREAD_RIGHT, bool tryIgnoreNodePositions=false) throw (ProcessError)
	Constructor.
	NBEdge (const std::string &id, NBNode *from, NBNode *to, std::string type, SUMOReal speed, unsigned int nolanes, int priority, LaneSpreadFunction spread=LANESPREAD_RIGHT) throw (ProcessError)
	Constructor.
void	preferVehicleClass (int lane, SUMOVehicleClass vclass)
bool	recheckLanes ()
void	reinit (NBNode *from, NBNode *to, std::string type, SUMOReal speed, unsigned int nolanes, int priority, Position2DVector geom, LaneSpreadFunction spread=LANESPREAD_RIGHT) throw (ProcessError)
	Resets initial values.
void	remapConnections (const EdgeVector &incoming)
	Remaps the connection in a way tha allows the removal of it This edges (which is a "dummy" edge, in fact) connections are spread over the incoming non-dummy edges.
void	removeFromConnections (NBEdge *which, int lane=-1)
void	replaceInConnections (NBEdge *which, NBEdge *by, unsigned int laneOff)
bool	setControllingTLInformation (int fromLane, NBEdge *toEdge, int toLane, const std::string &tlID, unsigned int tlPos)
	Returns if the link could be set as to be controlled.
void	setJunctionPriority (const NBNode *const node, int prio)
	Sets the junction priority of the edge.
void	setLaneSpeed (unsigned int lane, SUMOReal speed)
void	setLeftHanded () throw ()
	Marks this edge to be left-handed.
void	setLoadedLength (SUMOReal val)
void	setTurningDestination (NBEdge *e)
void	setVehicleClasses (const std::vector< SUMOVehicleClass > &allowed, const std::vector< SUMOVehicleClass > &disallowed, int lane=-1)
void	sortOutgoingLanesConnections ()
	sorts the connections of outgoing lanes (!!! Kaskade beschreiben)
NBNode *	tryGetNodeAtPosition (SUMOReal pos, SUMOReal tolerance=5.0) const
	Returns the node at the given edges length (using an epsilon) 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.
SUMOReal	width () const
void	writeLanesPlain (OutputDevice &into)
void	writeXMLStep1 (OutputDevice &into)
void	writeXMLStep2 (OutputDevice &into, bool includeInternal)
	~NBEdge () throw ()
	Destructor.
Setting and getting connections
bool	addEdge2EdgeConnection (NBEdge *dest) throw ()
	Adds a connection to another edge.
bool	addLane2LaneConnection (unsigned int fromLane, NBEdge *dest, unsigned int toLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false) throw ()
	Adds a connection between the specified this edge's lane and an approached one.
bool	addLane2LaneConnections (unsigned int fromLane, NBEdge *dest, unsigned int toLane, unsigned int no, Lane2LaneInfoType type, bool invalidatePrevious=false, bool mayDefinitelyPass=false) throw ()
	Builds no connections starting at the given lanes.
std::vector< Connection >	getConnectionsFromLane (unsigned int lane) const throw ()
	Returns connections from a given lane.
bool	hasConnectionTo (NBEdge *destEdge, unsigned int destLane) const throw ()
	Retrieves info about a connection to a certain lane of a certain edge.
void	setConnection (unsigned int lane, NBEdge *destEdge, unsigned int destLane, Lane2LaneInfoType type, bool mayUseSameDestination=false, bool mayDefinitelyPass=false) throw ()
	Adds a connection to a certain lane of a certain edge.
Edge geometry access and computation
void	addGeometryPoint (int index, const Position2D &p) throw ()
	Adds a further geometry point.
void	computeEdgeShape () throw ()
	Computes the shape of the edge (regarding the nodes' shapes.
const Position2DVector &	getGeometry () const throw ()
	Returns the geometry of the edge.
const Position2DVector &	getLaneShape (unsigned int i) const throw ()
	Returns the shape of the nth lane.
LaneSpreadFunction	getLaneSpreadFunction () const throw ()
	Returns how this edge's lanes' lateral offset is computed.
void	reshiftPosition (SUMOReal xoff, SUMOReal yoff) throw ()
	Applies an offset to the edge.
void	setGeometry (const Position2DVector &g) throw ()
	(Re)sets the edge's geometry
void	setLaneSpreadFunction (LaneSpreadFunction spread) throw ()
	(Re)sets how the lanes lateral offset shall be computed
Atomar getter methods
SUMOReal	getAngle () const throw ()
	Returns the angle of the edge.
NBNode *const	getFromNode () const throw ()
	Returns the origin node of the edge.
const std::string &	getID () const throw ()
	Returns the id of the edge.
SUMOReal	getLength () const throw ()
	Returns the computed length of the edge.
unsigned int	getNoLanes () const throw ()
	Returns the number of lanes.
int	getPriority () const throw ()
	Returns the priority of the edge.
SUMOReal	getSpeed () const throw ()
	Returns the speed allowed on this edge.
EdgeBuildingStep	getStep () const throw ()
	The building step of this edge.
NBNode *const	getToNode () const throw ()
	Returns the destination node of the edge.
Setting/getting special types
bool	isInnerEdge () const throw ()
	Returns whether this edge was marked as being within an intersection.
bool	isMacroscopicConnector () throw ()
	Returns whether this edge was marked as a macroscopic connector.
void	setAsMacroscopicConnector () throw ()
	Marks this edge as a macroscopic connector.
void	setIsInnerEdge () throw ()
	Marks this edge being within an intersection.
Protected Member Functions
bool	acceptBeingTurning (NBEdge *e)
Private Member Functions
Position2DVector	computeLaneShape (unsigned int lane) throw (InvalidArgument)
	Computes the shape for the given lane.
void	computeLaneShapes () throw ()
unsigned int	computePrioritySum (std::vector< unsigned int > *priorities)
void	divideOnEdges (const std::vector< NBEdge * > *outgoing)
void	init (unsigned int noLanes, bool tryIgnoreNodePositions) throw (ProcessError)
	Initialization routines common to all constructors.
std::pair< SUMOReal, SUMOReal >	laneOffset (const Position2D &from, const Position2D &to, SUMOReal lanewidth, unsigned int lane) throw (InvalidArgument)
	Computes the offset from the edge shape on the current segment.
void	moveConnectionToLeft (unsigned int lane)
void	moveConnectionToRight (unsigned int lane)
	NBEdge (const NBEdge &s)
	invalidated copy constructor
NBEdge &	operator= (const NBEdge &s)
	invalidated assignment operator
std::vector< unsigned int > *	preparePriorities (const std::vector< NBEdge * > *outgoing)
bool	splitGeometry (NBEdgeCont &ec, NBNodeCont &nc)
void	writeLane (OutputDevice &into, NBEdge::Lane &lane, unsigned int index) const
void	writeSingleSucceeding (OutputDevice &into, const NBEdge::Connection &c, bool includeInternal)
void	writeSucceeding (OutputDevice &into, unsigned int lane, bool includeInternal)
Private Attributes
bool	myAmInnerEdge
	Information whether this is a junction-inner edge.
bool	myAmLeftHand
	Whether this edge is a left-hand edge.
bool	myAmMacroscopicConnector
	Information whether this edge is a (macroscopic) connector.
SUMOReal	myAngle
	The angle of the edge.
std::vector< Connection >	myConnections
	List of connections to following edges.
NBNode *	myFrom
	The source and the destination node.
int	myFromJunctionPriority
	The priority normalised for the node the edge is outgoing of.
Position2DVector	myGeom
	The geometry for the edge.
std::string	myID
	The id of the edge.
std::vector< Lane >	myLanes
	Lane information.
LaneSpreadFunction	myLaneSpreadFunction
	The information about how to spread the lanes.
SUMOReal	myLength
	The length of the edge.
SUMOReal	myLoadedLength
	An optional length to use (-1 if not valid).
int	myPriority
	The priority of the edge.
SUMOReal	mySpeed
	The maximal speed.
EdgeBuildingStep	myStep
	The building step.
std::vector < TLSDisabledConnection >	myTLSDisabledConnections
NBNode *	myTo
int	myToJunctionPriority
	The priority normalised for the node the edge is incoming in.
NBEdge *	myTurnDestination
	The turn destination edge.
std::string	myType
	The type of the edge.
Temporary variables for turning edge computation
NBEdge *	myAmTurningOf
	Was assigned as a turning edge of this one.
SUMOReal	myAmTurningWithAngle
	Was assigned as a turn with this angle.
Friends
class	NBEdgeCont
class	NBEdgeSuccessorBuilder
Data Structures
struct	Connection
	A structure which describes a connection between edges or lanes. More...
class	connections_finder
class	connections_fromlane_finder
class	connections_relative_edgelane_sorter
class	connections_sorter
class	connections_toedge_finder
class	connections_toedgelane_finder
struct	Lane
	An (internal) definition of a single lane of an edge. More...
class	MainDirections
class	tls_disable_finder
struct	TLSDisabledConnection
class	ToEdgeConnectionsAdder

---

Member Enumeration Documentation

enum NBEdge::EdgeBuildingStep

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 recheked.
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 86 of file NBEdge.h.

                          {
        INIT_REJECT_CONNECTIONS,
        INIT,
        EDGE2EDGES,
        LANES2EDGES,
        LANES2LANES_RECHECK,
        LANES2LANES_DONE,
        LANES2LANES_USER
    };

enum NBEdge::Lane2LaneInfoType

Modes of setting connections between lanes.

Enumerator:

L2L_COMPUTED	The connection was computed.
L2L_USER	The connection was given by the user.
L2L_VALIDATED	The connection was computed and validated.

Definition at line 107 of file NBEdge.h.

                           {
        L2L_COMPUTED,
        L2L_USER,
        L2L_VALIDATED
    };

enum NBEdge::LaneSpreadFunction

Information how the edge's lateral offset shall be computed.

In dependence to this value, lanes will be spread to the right side or to both sides from the given edge geometry (Also used when node positions are used as edge geometry).

Enumerator:

LANESPREAD_RIGHT	The lanes will be spread to right.
LANESPREAD_CENTER	The lanes will be spread to both sides.

Definition at line 71 of file NBEdge.h.

                            {
        LANESPREAD_RIGHT,
        LANESPREAD_CENTER
    };

---

Constructor & Destructor Documentation

NBEdge::NBEdge	(	const std::string &	id,
		NBNode *	from,
		NBNode *	to,
		std::string	type,
		SUMOReal	speed,
		unsigned int	nolanes,
		int	priority,
		LaneSpreadFunction	spread = LANESPREAD_RIGHT
	)			throw (ProcessError)

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]	nolanes	The number of lanes this edge has
[in]	priority	This edge's priority
[in]	spread	How the lateral offset of the lanes shall be computed

See also:

init

LaneSpreadFunction

Definition at line 153 of file NBEdge.cpp.

References init().

Referenced by splitGeometry().

                                                                            :
        myStep(INIT), myID(StringUtils::convertUmlaute(id)),
        myType(StringUtils::convertUmlaute(type)),
        myFrom(from), myTo(to), myAngle(0),
        myPriority(priority), mySpeed(speed),
        myTurnDestination(0),
        myFromJunctionPriority(-1), myToJunctionPriority(-1),
        myLaneSpreadFunction(spread),
        myLoadedLength(-1), myAmLeftHand(false), myAmTurningWithAngle(0), myAmTurningOf(0),
        myAmInnerEdge(false), myAmMacroscopicConnector(false) {
    init(nolanes, false);
}

NBEdge::NBEdge	(	const std::string &	id,
		NBNode *	from,
		NBNode *	to,
		std::string	type,
		SUMOReal	speed,
		unsigned int	nolanes,
		int	priority,
		Position2DVector	geom,
		LaneSpreadFunction	spread = LANESPREAD_RIGHT,
		bool	tryIgnoreNodePositions = false
	)			throw (ProcessError)

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 (my 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]	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

LaneSpreadFunction

Definition at line 169 of file NBEdge.cpp.

References init().

                                                                                           :
        myStep(INIT), myID(StringUtils::convertUmlaute(id)),
        myType(StringUtils::convertUmlaute(type)),
        myFrom(from), myTo(to), myAngle(0),
        myPriority(priority), mySpeed(speed),
        myTurnDestination(0),
        myFromJunctionPriority(-1), myToJunctionPriority(-1),
        myGeom(geom), myLaneSpreadFunction(spread),
        myLoadedLength(-1), myAmLeftHand(false), myAmTurningWithAngle(0), myAmTurningOf(0),
        myAmInnerEdge(false), myAmMacroscopicConnector(false) {
    init(nolanes, tryIgnoreNodePositions);
}

NBEdge::~NBEdge

(

)

throw ()

Destructor.

Definition at line 261 of file NBEdge.cpp.

{}

NBEdge::NBEdge

(

const NBEdge &

s

)

[private]

invalidated copy constructor

---

Member Function Documentation

bool NBEdge::acceptBeingTurning

(

NBEdge *

e

)

[protected]

Definition at line 576 of file NBEdge.cpp.

References computeTurningDirections(), getAngle(), myAmTurningOf, myAmTurningWithAngle, NBHelpers::relAngle(), and SUMOReal.

Referenced by setTurningDestination().

                                    {
    if (e==myAmTurningOf) {
        return true;
    }
    SUMOReal angle = fabs(NBHelpers::relAngle(getAngle(), e->getAngle()));
    if (myAmTurningWithAngle>angle) {
        return false;
    }
    if (myAmTurningWithAngle==angle) {
        return false; // !!! ok, this happens only within a cell-network (backgrnd), we have to take a further look sometime
    }
    NBEdge *previous = myAmTurningOf;
    myAmTurningWithAngle = angle;
    myAmTurningOf = e;
    if (previous!=0) {
        previous->computeTurningDirections();
    }
    return true;
}

void NBEdge::addCrossingPointsAsIncomingWithGivenOutgoing	(	NBEdge *	o,
		Position2DVector &	into
	)

bool NBEdge::addEdge2EdgeConnection

(

NBEdge *

dest

)

throw ()

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".

Parameters:

[in]

dest

The connection's destination edge

Returns:

Whether the connection was valid

Definition at line 374 of file NBEdge.cpp.

References EDGE2EDGES, INIT_REJECT_CONNECTIONS, myConnections, myStep, and myTo.

Referenced by addLane2LaneConnection(), NBEdgeCont::joinSameNodeConnectingEdges(), NIXMLConnectionsHandler::myStartElement(), and remapConnections().

                                                   {
    if (myStep==INIT_REJECT_CONNECTIONS) {
        return true;
    }
    // check whether the node was merged and now a connection between
    //  not matching edges is tried to be added
    //  This happens f.e. within the ptv VISSIM-example "Beijing"
    if (dest!=0 && myTo!=dest->myFrom) {
        return false;
    }
    if (find_if(myConnections.begin(), myConnections.end(), connections_toedge_finder(dest))==myConnections.end()) {
        myConnections.push_back(Connection(-1, dest, -1));
    }
    if (myStep<EDGE2EDGES) {
        myStep = EDGE2EDGES;
    }
    return true;
}

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

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 358 of file NBEdge.cpp.

References Position2DVector::insertAt(), and myGeom.

Referenced by NIImporter_VISUM::parse_EdgePolys().

                                                               {
    myGeom.insertAt(index, p);
}

bool NBEdge::addLane2LaneConnection	(	unsigned int	fromLane,
		NBEdge *	dest,
		unsigned int	toLane,
		Lane2LaneInfoType	type,
		bool	mayUseSameDestination = false,
		bool	mayDefinitelyPass = false
	)			throw ()

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 395 of file NBEdge.cpp.

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

Referenced by addLane2LaneConnections(), NIVissimConnection::buildEdgeConnections(), NIImporter_SUMO::loadNetwork(), moveOutgoingConnectionsFrom(), NIXMLEdgesHandler::myEndElement(), NIImporter_VISUM::parse_LanesConnections(), NIXMLConnectionsHandler::parseLaneBound(), and NBEdgeCont::splitAt().

                                                               {
    if (myStep==INIT_REJECT_CONNECTIONS) {
        return true;
    }
    // check whether the node was merged and now a connection between
    //  not matching edges is tried to be added
    //  This happens f.e. within the ptv VISSIM-example "Beijing"
    if (myTo!=dest->myFrom) {
        return false;
    }
    if (!addEdge2EdgeConnection(dest)) {
        return false;
    }
    setConnection(from, dest, toLane, type, mayUseSameDestination, mayDefinitelyPass);
    return true;
}

bool NBEdge::addLane2LaneConnections	(	unsigned int	fromLane,
		NBEdge *	dest,
		unsigned int	toLane,
		unsigned int	no,
		Lane2LaneInfoType	type,
		bool	invalidatePrevious = false,
		bool	mayDefinitelyPass = false
	)			throw ()

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 417 of file NBEdge.cpp.

References addLane2LaneConnection(), and invalidateConnections().

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

                                                                {
    if (invalidatePrevious) {
        invalidateConnections(true);
    }
    bool ok = true;
    for (unsigned int i=0; i<no&&ok; i++) {
        ok &= addLane2LaneConnection(fromLane+i, dest, toLane+i, type, false, mayDefinitelyPass);
    }
    return ok;
}

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

Definition at line 1853 of file NBEdge.cpp.

References myLanes.

Referenced by NIXMLEdgesHandler::myStartElement(), and setVehicleClasses().

                                                           {
    if (lane<0) {
        // if all lanes are meant...
        for (unsigned int i=0; i<myLanes.size(); i++) {
            // ... do it for each lane
            allowVehicleClass((int) i, vclass);
        }
        return;
    }
    assert(lane<(int) myLanes.size());
    // add it only if not already done
    if (find(myLanes[lane].allowed.begin(), myLanes[lane].allowed.end(), vclass)==myLanes[lane].allowed.end()) {
        myLanes[lane].allowed.push_back(vclass);
    }
}

void NBEdge::append

(

NBEdge *

continuation

)

Definition at line 1674 of file NBEdge.cpp.

References Position2DVector::appendWithCrossingPoint(), myConnections, myGeom, myLanes, myLength, myStep, myTo, and myTurnDestination.

Referenced by NBNodeCont::removeUnwishedNodes().

                        {
    // append geometry
    myGeom.appendWithCrossingPoint(e->myGeom);
    for (unsigned int i=0; i<myLanes.size(); i++) {
        myLanes[i].shape.appendWithCrossingPoint(e->myLanes[i].shape);
    }
    // recompute length
    myLength += e->myLength;
    // copy the connections and the building step if given
    myStep = e->myStep;
    myConnections = e->myConnections;
    myTurnDestination = e->myTurnDestination;
    // set the node
    myTo = e->myTo;
}

void NBEdge::appendTurnaround

(

bool

noTLSControlled

)

throw ()

Add a connection to the previously computed turnaround, if wished.

If a turning direction exists (myTurnDestination!=0) and either the edge is not controlled by a tls or noTLSControlled is false, a connection to the edge stored in myTurnDestination is added (from the leftmost lane of this edge to the leftmost lane of myTurnDestination).

Parameters:

[in]

noTLSControlled

Whether the turnaround shall not be connected if this edge is controlled by a tls

Definition at line 1279 of file NBEdge.cpp.

References getNoLanes(), NBNode::isTLControlled(), L2L_VALIDATED, myLanes, myTo, myTurnDestination, and setConnection().

                                                     {
    // do nothing if no turnaround is known
    if (myTurnDestination==0) {
        return;
    }
    // do nothing if the destination node is controlled by a tls and no turnarounds
    //  shall be appended for such junctions
    if (noTLSControlled&&myTo->isTLControlled()) {
        return;
    }
    setConnection((unsigned int)(myLanes.size()-1), myTurnDestination, myTurnDestination->getNoLanes()-1, L2L_VALIDATED);
}

bool NBEdge::computeEdge2Edges

(

)

computes the edge (step1: computation of approached edges)

Definition at line 961 of file NBEdge.cpp.

References EDGE2EDGES, NBNode::getOutgoingEdges(), myConnections, myStep, and myTo.

                          {
    // return if this relationship has been build in previous steps or
    //  during the import
    if (myStep>=EDGE2EDGES) {
        return true;
    }
    if (myConnections.size()==0) {
        const EdgeVector &o = myTo->getOutgoingEdges();
        for (EdgeVector::const_iterator i=o.begin(); i!=o.end(); ++i) {
            myConnections.push_back(Connection(-1, *i, -1));
        }
    }
    myStep = EDGE2EDGES;
    return true;
}

void NBEdge::computeEdgeShape

(

)

throw ()

Computes the shape of the edge (regarding the nodes' shapes.

Because an edge's shape should start/end at the boundaries of the nodes the edge starts/ends at, we have to recompute the edge's shape after we know the ones of the nodes. This is done within this method.

Todo:

Describe what is done here

Definition at line 273 of file NBEdge.cpp.

References Line2D::atan2DegreeAngle(), Position2DVector::eraseAt(), Line2D::extrapolateBy(), GeomHelper::getMinAngleDiff(), Line2D::getPositionAtDistance(), NBNode::getShape(), Position2DVector::getSubpart(), Position2DVector::intersects(), Line2D::intersectsAtLengths(), Position2DVector::intersectsAtLengths(), Position2DVector::length(), VectorHelper< T >::maxValue(), VectorHelper< T >::minValue(), myFrom, myLanes, myLength, myTo, Line2D::p1(), Line2D::p2(), Position2DVector::push_back(), Position2DVector::push_front(), Position2DVector::reverse(), Position2DVector::size(), and SUMOReal.

                                 {
    unsigned int i;
    for (i=0; i<myLanes.size(); i++) {
        Position2DVector &shape = myLanes[i].shape;
        // get lane begin and end
        Line2D lb = Line2D(shape[0], shape[1]);
        Line2D le = Line2D(shape[-1], shape[-2]);
        lb.extrapolateBy(100.0);
        le.extrapolateBy(100.0);
        //
        Position2DVector old = shape;
        Position2D nb, ne;
        // lane begin
        if (myFrom->getShape().intersects(shape)) {
            // get the intersection position with the junction
            DoubleVector pbv = shape.intersectsAtLengths(myFrom->getShape());
            if (pbv.size()>0) {
                SUMOReal pb = VectorHelper<SUMOReal>::maxValue(pbv);
                if (pb>=0&&pb<=shape.length()) {
                    shape = shape.getSubpart(pb, shape.length());
                }
            }
        } else if (myFrom->getShape().intersects(lb.p1(), lb.p2())) {
            DoubleVector pbv = lb.intersectsAtLengths(myFrom->getShape());
            if (pbv.size()>0) {
                SUMOReal pb = VectorHelper<SUMOReal>::maxValue(pbv);
                if (pb>=0) {
                    shape.eraseAt(0);
                    shape.push_front(lb.getPositionAtDistance(pb));
                }
            }
        }
        // lane end
        if (myTo->getShape().intersects(shape)) {
            // get the intersection position with the junction
            DoubleVector pev = shape.intersectsAtLengths(myTo->getShape());
            if (pev.size()>0) {
                SUMOReal pe = VectorHelper<SUMOReal>::minValue(pev);
                if (pe>=0&&pe<=shape.length()) {
                    shape = shape.getSubpart(0, pe);
                }
            }
        } else if (myTo->getShape().intersects(le.p1(), le.p2())) {
            DoubleVector pev = le.intersectsAtLengths(myTo->getShape());
            if (pev.size()>0) {
                SUMOReal pe = VectorHelper<SUMOReal>::maxValue(pev);
                if (pe>=0) {
                    shape.eraseAt((int) shape.size()-1);
                    shape.push_back(le.getPositionAtDistance(pe));
                }
            }
        }
        if (((int) shape.length())==0) {
            shape = old;
        } else {
            Line2D lc(shape[0], shape[-1]);
            Line2D lo(old[0], old[-1]);
            if (135<GeomHelper::getMinAngleDiff(lc.atan2DegreeAngle(), lo.atan2DegreeAngle())) {
                shape = shape.reverse();
            }
        }
    }
    // recompute edge's length
    SUMOReal length = 0;
    for (i=0; i<myLanes.size(); i++) {
        assert(myLanes[i].shape.length()>0);
        length += myLanes[i].shape.length();
    }
    myLength = length / (SUMOReal) myLanes.size();
}

bool NBEdge::computeLanes2Edges

(

)

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

Definition at line 979 of file NBEdge.cpp.

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

                           {
    // return if this relationship has been build in previous steps or
    //  during the import
    if (myStep>=LANES2EDGES) {
        return true;
    }
    assert(myStep==EDGE2EDGES);
    // get list of possible outgoing edges sorted by direction clockwise
    //  the edge in the backward direction (turnaround) is not in the list
    const std::vector<NBEdge*> *edges = getConnectedSorted();
    if (myConnections.size()!=0&&edges->size()==0) {
        // dead end per definition!?
        myConnections.clear();
    } else {
        // divide the lanes on reachable edges
        divideOnEdges(edges);
    }
    delete edges;
    myStep = LANES2EDGES;
    return true;
}

Position2DVector NBEdge::computeLaneShape

(

unsigned int

lane

)

throw (InvalidArgument) [private]

Computes the shape for the given lane.

Definition at line 746 of file NBEdge.cpp.

References Line2D::atan2DegreeAngle(), Line2D::extrapolateBy(), GeomHelper::getCWAngleDiff(), getID(), MsgHandler::getWarningInstance(), MsgHandler::inform(), Line2D::intersects(), Line2D::intersectsAt(), laneOffset(), myGeom, myLanes, Position2DVector::push_back(), Position2DVector::size(), SUMO_const_laneWidthAndOffset, SUMOReal, toString(), Position2D::x(), and Position2D::y().

Referenced by computeLaneShapes().

                                                                 {
    Position2DVector shape;
    bool haveWarned = false;
    for (int i=0; i<(int) myGeom.size(); i++) {
        if (i==0) {
            Position2D from = myGeom[i];
            Position2D to = myGeom[i+1];
            std::pair<SUMOReal, SUMOReal> offsets = laneOffset(from, to, SUMO_const_laneWidthAndOffset, (unsigned int)(myLanes.size()-1-lane));
            shape.push_back(
                // (methode umbenennen; was heisst hier "-")
                Position2D(from.x()-offsets.first, from.y()-offsets.second));
        } else if (i==myGeom.size()-1) {
            Position2D from = myGeom[i-1];
            Position2D to = myGeom[i];
            std::pair<SUMOReal, SUMOReal> offsets = laneOffset(from, to, SUMO_const_laneWidthAndOffset, (unsigned int)(myLanes.size()-1-lane));
            shape.push_back(
                // (methode umbenennen; was heisst hier "-")
                Position2D(to.x()-offsets.first, to.y()-offsets.second));
        } else {
            Position2D from = myGeom[i-1];
            Position2D me = myGeom[i];
            Position2D to = myGeom[i+1];
            std::pair<SUMOReal, SUMOReal> offsets = laneOffset(from, me, SUMO_const_laneWidthAndOffset, (unsigned int)(myLanes.size()-1-lane));
            std::pair<SUMOReal, SUMOReal> offsets2 = laneOffset(me, to, SUMO_const_laneWidthAndOffset, (unsigned int)(myLanes.size()-1-lane));
            Line2D l1(
                Position2D(from.x()-offsets.first, from.y()-offsets.second),
                Position2D(me.x()-offsets.first, me.y()-offsets.second));
            l1.extrapolateBy(100);
            Line2D l2(
                Position2D(me.x()-offsets2.first, me.y()-offsets2.second),
                Position2D(to.x()-offsets2.first, to.y()-offsets2.second));
            SUMOReal angle = GeomHelper::getCWAngleDiff(l1.atan2DegreeAngle(), l2.atan2DegreeAngle());
            if (angle<10.||angle>350.) {
                shape.push_back(
                    // (methode umbenennen; was heisst hier "-")
                    Position2D(me.x()-offsets.first, me.y()-offsets.second));
                continue;
            }
            l2.extrapolateBy(100);
            if (l1.intersects(l2)) {
                shape.push_back(l1.intersectsAt(l2));
            } else {
                if (!haveWarned) {
                    MsgHandler::getWarningInstance()->inform("In lane '" + getID() + "_" + toString(lane) + "': Could not build shape.");
                    haveWarned = true;
                }
            }
        }
    }
    return shape;
}

void NBEdge::computeLaneShapes

(

)

throw () [private]

Definition at line 728 of file NBEdge.cpp.

References computeLaneShape(), getID(), MsgHandler::getWarningInstance(), MsgHandler::inform(), myFrom, myGeom, myLanes, and myTo.

Referenced by decLaneNo(), incLaneNo(), init(), and setGeometry().

                                  {
    // vissim needs this
    if (myFrom==myTo) {
        return;
    }
    // build the shape of each lane
    for (unsigned int i=0; i<myLanes.size(); i++) {
        try {
            myLanes[i].shape = computeLaneShape(i);
        } catch (InvalidArgument &e) {
            MsgHandler::getWarningInstance()->inform("In edge '" + getID() + "': lane shape could not been determined (" + e.what() + ")");
            myLanes[i].shape = myGeom;
        }
    }
}

unsigned int NBEdge::computePrioritySum

(

std::vector< unsigned int > *

priorities

)

[private]

computes teh sum of the given list's entries (sic!)

Definition at line 1269 of file NBEdge.cpp.

Referenced by divideOnEdges().

                                                              {
    unsigned int sum = 0;
    for (std::vector<unsigned int>::iterator i=priorities->begin(); i!=priorities->end(); i++) {
        sum += (*i);
    }
    return sum;
}

void NBEdge::computeTurningDirections

(

)

computes which edge shall be the turn-around one, if any

Definition at line 530 of file NBEdge.cpp.

References getAngle(), NBNode::getOutgoingEdges(), isConnectedTo(), myConnections, myTo, myTurnDestination, NBHelpers::relAngle(), setTurningDestination(), and SUMOReal.

Referenced by acceptBeingTurning().

                                 {
    myTurnDestination = 0;
    EdgeVector outgoing = myTo->getOutgoingEdges();
    for (EdgeVector::iterator i=outgoing.begin(); i!=outgoing.end(); i++) {
        NBEdge *outedge = *i;
        if (myConnections.size()!=0&&!isConnectedTo(outedge)) {
            continue;
        }
        SUMOReal relAngle =
            NBHelpers::relAngle(getAngle(*myTo), outedge->getAngle(*myTo));
        // do not append the turnaround
        if (fabs(relAngle)>160) {
            setTurningDestination(outedge);
        }
    }
}

void NBEdge::copyConnectionsFrom

(

NBEdge *

src

)

Definition at line 1795 of file NBEdge.cpp.

References myConnections, and myStep.

Referenced by NBEdgeCont::splitAt().

                                       {
    myStep = src->myStep;
    myConnections = src->myConnections;
}

void NBEdge::decLaneNo	(	unsigned int	by,
		int	dir = 0
	)

Definition at line 1769 of file NBEdge.cpp.

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

                                          {
    unsigned int newLaneNo = (unsigned int) myLanes.size() - by;
    while (myLanes.size()>newLaneNo) {
        myLanes.pop_back();
    }
    computeLaneShapes();
    const EdgeVector &incs = myFrom->getIncomingEdges();
    for (EdgeVector::const_iterator i=incs.begin(); i!=incs.end(); ++i) {
        (*i)->invalidateConnections(true);
    }
    if (dir==0) {
        invalidateConnections(true);
    } else {
        const EdgeVector &outs = myTo->getOutgoingEdges();
        assert(outs.size()==1);
        NBEdge *out = outs[0];
        if (dir<0) {
            removeFromConnections(out, 0);
        } else {
            removeFromConnections(out, (int) myLanes.size());
        }
    }
}

void NBEdge::disableConnection4TLS	(	int	fromLane,
		NBEdge *	toEdge,
		int	toLane
	)

Definition at line 1566 of file NBEdge.cpp.

References NBEdge::TLSDisabledConnection::fromLane, myTLSDisabledConnections, NBEdge::TLSDisabledConnection::to, and NBEdge::TLSDisabledConnection::toLane.

                                                                      {
    TLSDisabledConnection c;
    c.fromLane = fromLane;
    c.to = toEdge;
    c.toLane = toLane;
    myTLSDisabledConnections.push_back(c);
}

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

Definition at line 1871 of file NBEdge.cpp.

References myLanes.

Referenced by NIXMLEdgesHandler::myStartElement(), and setVehicleClasses().

                                                              {
    if (lane<0) {
        // if all lanes are meant...
        for (unsigned int i=0; i<myLanes.size(); i++) {
            // ... do it for each lane
            disallowVehicleClass((int) i, vclass);
        }
        return;
    }
    assert(lane<(int) myLanes.size());
    // add it only if not already done
    if (find(myLanes[lane].notAllowed.begin(), myLanes[lane].notAllowed.end(), vclass)==myLanes[lane].notAllowed.end()) {
        myLanes[lane].notAllowed.push_back(vclass);
    }
}

void NBEdge::dismissVehicleClassInformation

(

)

Definition at line 1965 of file NBEdge.cpp.

References myLanes.

                                       {
    for (std::vector<Lane>::iterator i=myLanes.begin(); i!=myLanes.end(); ++i) {
        (*i).allowed.clear();
        (*i).notAllowed.clear();
        (*i).preferred.clear();
    }
}

void NBEdge::divideOnEdges

(

const std::vector< NBEdge * > *

outgoing

)

[private]

divides the lanes on the outgoing edges

Definition at line 1149 of file NBEdge.cpp.

References Bresenham::compute(), computePrioritySum(), NBEdge::ToEdgeConnectionsAdder::getBuiltConnections(), myAmLeftHand, myConnections, myLanes, preparePriorities(), size, and SUMOReal.

Referenced by computeLanes2Edges().

                                                        {
    if (outgoing->size()==0) {
        // we have to do this, because the turnaround may have been added before
        myConnections.clear();
        return;
    }
    // precompute priorities; needed as some kind of assumptions for
    //  priorities of directions (see preparePriorities)
    std::vector<unsigned int> *priorities = preparePriorities(outgoing);

    // compute the sum of priorities (needed for normalisation)
    unsigned int prioSum = computePrioritySum(priorities);
    // compute the resulting number of lanes that should be used to
    //  reach the following edge
    unsigned int size = (unsigned int) outgoing->size();
    std::vector<SUMOReal> resultingLanes;
    resultingLanes.reserve(size);
    SUMOReal sumResulting = 0; // the sum of resulting lanes
    SUMOReal minResulting = 10000; // the least number of lanes to reach an edge
    unsigned int i;
    for (i=0; i<size; i++) {
        // res will be the number of lanes which are meant to reach the
        //  current outgoing edge
        SUMOReal res =
            (SUMOReal)(*priorities)[i] *
            (SUMOReal) myLanes.size() / (SUMOReal) prioSum;
        // do not let this number be greater than the number of available lanes
        if (res>myLanes.size()) {
            res = (SUMOReal) myLanes.size();
        }
        // add it to the list
        resultingLanes.push_back(res);
        sumResulting += res;
        if (minResulting>res) {
            minResulting = res;
        }
    }
    // compute the number of virtual edges
    //  a virtual edge is used as a replacement for a real edge from now on
    //  it shall ollow to divide the existing lanes on this structure without
    //  regarding the structure of outgoing edges
    sumResulting += minResulting / (SUMOReal) 2.;
    unsigned int noVirtual = (unsigned int)(sumResulting / minResulting);
    // compute the transition from virtual to real edges
    std::vector<NBEdge*> transition;
    transition.reserve(size);
    for (i=0; i<size; i++) {
        // tmpNo will be the number of connections from this edge
        //  to the next edge
        assert(i<resultingLanes.size());
        SUMOReal tmpNo = (SUMOReal) resultingLanes[i] / (SUMOReal) minResulting;
        for (SUMOReal j=0; j<tmpNo; j++) {
            assert(outgoing->size()>i);
            transition.push_back((*outgoing)[i]);
        }
    }

    // assign lanes to edges
    //  (conversion from virtual to real edges is done)
    ToEdgeConnectionsAdder adder(/*&myToEdges, */transition);
    Bresenham::compute(&adder, (SUMOReal) myLanes.size(), (SUMOReal) noVirtual);
    const std::map<NBEdge*, std::vector<unsigned int> > &l2eConns = adder.getBuiltConnections();
    myConnections.clear();
    for (std::map<NBEdge*, std::vector<unsigned int> >::const_iterator i=l2eConns.begin(); i!=l2eConns.end(); ++i) {
        const std::vector<unsigned int> lanes = (*i).second;
        for (std::vector<unsigned int>::const_iterator j=lanes.begin(); j!=lanes.end(); ++j) {
            if (myAmLeftHand) {
                myConnections.push_back(Connection(myLanes.size() - 1 - *j, (*i).first, -1));
            } else {
                myConnections.push_back(Connection(*j, (*i).first, -1));
            }
        }
    }
    delete priorities;
}

bool NBEdge::expandableBy

(

NBEdge *

possContinuation

)

const

!! if (myAllowedOnLanes!=possContinuation->myAllowedOnLanes || myNotAllowedOnLanes!=possContinuation->myNotAllowedOnLanes) { return false; }

Definition at line 1612 of file NBEdge.cpp.

References EDGE2EDGES, getConnectedEdges(), getConnectionLanes(), getPriority(), INIT, INIT_REJECT_CONNECTIONS, LANES2EDGES, LANES2LANES_DONE, LANES2LANES_RECHECK, LANES2LANES_USER, myConnections, myLanes, mySpeed, and myStep.

                                                   {
    // ok, the number of lanes must match
    if (myLanes.size()!=possContinuation->myLanes.size()) {
        return false;
    }
    // the priority, too (?)
    if (getPriority()!=possContinuation->getPriority()) {
        return false;
    }
    // the speed allowed
    if (mySpeed!=possContinuation->mySpeed) {
        return false;
    }
    // the vehicle class constraints, too
    // also, check whether the connections - if any exit do allow to join
    //  both edges
    // This edge must have a one-to-one connection to the following lanes
    switch (myStep) {
    case INIT_REJECT_CONNECTIONS:
        break;
    case INIT:
        break;
    case EDGE2EDGES: {
        // the following edge must be connected
        const EdgeVector &conn = getConnectedEdges();
        if (find(conn.begin(), conn.end(), possContinuation)
                ==conn.end()) {

            return false;
        }
    }
    break;
    case LANES2EDGES:
    case LANES2LANES_RECHECK:
    case LANES2LANES_DONE:
    case LANES2LANES_USER: {
        // the possible continuation must be connected
        if (find_if(myConnections.begin(), myConnections.end(), connections_toedge_finder(possContinuation))==myConnections.end()) {
            return false;
        }
        // all lanes must go to the possible continuation
        std::vector<int> conns = getConnectionLanes(possContinuation);
        if (conns.size()!=myLanes.size()) {
            return false;
        }
    }
    break;
    default:
        break;
    }
    return true;
}

std::vector< SUMOVehicleClass > NBEdge::getAllowedVehicleClasses

(

)

const

Definition at line 1918 of file NBEdge.cpp.

References myLanes.

                                       {
    std::vector<SUMOVehicleClass> ret;
    for (std::vector<Lane>::const_iterator i=myLanes.begin(); i!=myLanes.end(); ++i) {
        const std::vector<SUMOVehicleClass> &allowed = (*i).allowed;
        for (std::vector<SUMOVehicleClass>::const_iterator j=allowed.begin(); j!=allowed.end(); ++j) {
            if (find(ret.begin(), ret.end(), *j)==ret.end()) {
                ret.push_back(*j);
            }
        }
    }
    return ret;
}

SUMOReal NBEdge::getAngle

(

const NBNode &

atNode

)

const

Definition at line 549 of file NBEdge.cpp.

References Line2D::atan2DegreeAngle(), Position2DVector::getBegLine(), Position2DVector::getEndLine(), myFrom, myGeom, and myTo.

                                           {
    if (&atNode==myFrom) {
        return myGeom.getBegLine().atan2DegreeAngle();
    } else {
        assert(&atNode==myTo);
        return myGeom.getEndLine().atan2DegreeAngle();
    }
}

SUMOReal NBEdge::getAngle

(

)

const throw () [inline]

Returns the angle of the edge.

The angle is computed within the constructor using NBHelpers::angle

Returns:

This edge's angle

See also:

NBHelpers::angle

Definition at line 283 of file NBEdge.h.

References myAngle.

Referenced by acceptBeingTurning(), NBNode::computeLanes2Lanes(), computeTurningDirections(), NBContHelper::edge_opposite_direction_sorter::getDiff(), NBContHelper::same_connection_edge_sorter::getMinMaxRelAngles(), getNormedAngle(), isTurningDirectionAt(), NBEdge::connections_relative_edgelane_sorter::operator()(), NBContHelper::edge_similar_direction_sorter::operator()(), NBContHelper::relative_edge_sorter::operator()(), NBNode::setPriorityJunctionPriorities(), and setTurningDestination().

                                      {
        return myAngle;
    }

Position2DVector NBEdge::getCCWBoundaryLine	(	const NBNode &	n,
		SUMOReal	offset
	)			const

Definition at line 1591 of file NBEdge.cpp.

References Position2DVector::move2side(), myAmLeftHand, myFrom, and myLanes.

                                                                 {
    Position2DVector ret;
    if (myFrom==(&n)) {
        // outgoing
        ret = !myAmLeftHand ? myLanes.back().shape : myLanes[0].shape;
    } else {
        // incoming
        ret = !myAmLeftHand ? myLanes[0].shape.reverse() : myLanes.back().shape.reverse();
    }
    ret.move2side(-offset);
    return ret;
}

std::vector< NBEdge * > NBEdge::getConnectedEdges

(

)

const throw ()

returns the list of outgoing edges unsorted

Definition at line 1385 of file NBEdge.cpp.

References myConnections.

Referenced by NIVissimDisturbance::addToNode(), expandableBy(), NBContHelper::same_connection_edge_sorter::getMinMaxRelAngles(), and remapConnections().

                                        {
    std::vector<NBEdge*> ret;
    for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if (find(ret.begin(), ret.end(), (*i).toEdge)==ret.end()) {
            ret.push_back((*i).toEdge);
        }
    }
    return ret;
}

const std::vector< NBEdge * > * NBEdge::getConnectedSorted

(

)

returns the list of outgoing edges without the turnaround sorted in clockwise direction

Definition at line 1121 of file NBEdge.cpp.

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

Referenced by computeLanes2Edges(), and writeXMLStep1().

                           {
    // check whether connections exist and if not, use edges from the node
    EdgeVector outgoing;
    if (myConnections.size()==0) {
        outgoing = myTo->getOutgoingEdges();
    } else {
        for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
            if (find(outgoing.begin(), outgoing.end(), (*i).toEdge)==outgoing.end()) {
                outgoing.push_back((*i).toEdge);
            }
        }
    }
    // allocate the sorted container
    unsigned int size = (unsigned int) outgoing.size();
    std::vector<NBEdge*> *edges = new std::vector<NBEdge*>();
    edges->reserve(size);
    for (EdgeVector::const_iterator i=outgoing.begin(); i!=outgoing.end(); i++) {
        NBEdge *outedge = *i;
        if (outedge!=0&&outedge!=myTurnDestination) {
            edges->push_back(outedge);
        }
    }
    sort(edges->begin(), edges->end(), NBContHelper::relative_edge_sorter(this, myTo));
    return edges;
}

std::vector< int > NBEdge::getConnectionLanes

(

NBEdge *

currentOutgoing

)

const

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

Definition at line 1107 of file NBEdge.cpp.

References myConnections, and myTurnDestination.

Referenced by expandableBy().

                                                        {
    std::vector<int> ret;
    if (currentOutgoing!=myTurnDestination) {
        for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
            if ((*i).toEdge==currentOutgoing) {
                ret.push_back((*i).fromLane);
            }
        }
    }
    return ret;
}

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

(

)

[inline]

Definition at line 622 of file NBEdge.h.

References myConnections.

                                            {
        return myConnections;
    }

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

(

)

const [inline]

Definition at line 619 of file NBEdge.h.

References myConnections.

                                                        {
        return myConnections;
    }

std::vector< NBEdge::Connection > NBEdge::getConnectionsFromLane

(

unsigned int

lane

)

const throw ()

Returns connections from a given lane.

Parameters:

[in]

lane

The lane which connections shall be returned

Returns:

The connections from the given lane

See also:

NBEdge::Connection

Definition at line 491 of file NBEdge.cpp.

References myConnections.

Referenced by NIVissimTL::NIVissimTLSignal::addTo(), NBTrafficLightDefinition::collectLinks(), NBOwnTLDef::collectLinks(), NBLoadedTLDef::collectLinks(), moveOutgoingConnectionsFrom(), NBOwnTLDef::myCompute(), NBEdgeCont::savePlain(), and NBRequest::writeLaneResponse().

                                                              {
    std::vector<NBEdge::Connection> ret;
    for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if ((*i).fromLane==lane) {
            ret.push_back(*i);
        }
    }
    return ret;
}

Position2DVector NBEdge::getCWBoundaryLine	(	const NBNode &	n,
		SUMOReal	offset
	)			const

Definition at line 1576 of file NBEdge.cpp.

References Position2DVector::move2side(), myAmLeftHand, myFrom, and myLanes.

                                                                {
    Position2DVector ret;
    if (myFrom==(&n)) {
        // outgoing
        ret = !myAmLeftHand ? myLanes[0].shape : myLanes.back().shape;
    } else {
        // incoming
        ret = !myAmLeftHand ? myLanes.back().shape.reverse() : myLanes[0].shape.reverse();
    }
    ret.move2side(offset);
    return ret;
}

NBNode* const NBEdge::getFromNode

(

)

const throw () [inline]

Returns the origin node of the edge.

Returns:

The node this edge starts at

Definition at line 263 of file NBEdge.h.

References myFrom.

Referenced by NIVissimDisturbance::addToNode(), NBNodeCont::buildOnRamp(), NIVissimDistrictConnection::dict_BuildDistricts(), NBNodeCont::generateNodeClusters(), NBContHelper::edge_by_junction_angle_sorter::getConvAngle(), NIImporter_VISUM::getNamedEdgeContinuating(), NBNodeCont::guessRamps(), NBEdgeCont::guessRoundabouts(), NBNode::isNearDistrict(), NIImporter_VISUM::parse_Lanes(), NBNodeCont::removeIsolatedRoads(), NBEdgeCont::removeUnwishedEdges(), NBEdgeCont::savePlain(), and NIXMLEdgesHandler::setNodes().

                                               {
        return myFrom;
    }

const Position2DVector& NBEdge::getGeometry

(

)

const throw () [inline]

Returns the geometry of the edge.

Returns:

The edge's geometry

Definition at line 322 of file NBEdge.h.

References myGeom.

Referenced by NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), NBNodeCont::guessRamps(), isNearEnough2BeJoined2(), NIXMLEdgesHandler::myStartElement(), NIImporter_VISUM::parse_Lanes(), and NBEdgeCont::savePlain().

                                                        {
        return myGeom;
    }

const std::string& NBEdge::getID

(

)

const throw () [inline]

Returns the id of the edge.

Returns:

This edge's id

Definition at line 239 of file NBEdge.h.

References myID.

Referenced by NIImporter_OpenDrive::addE2EConnectionsSecure(), NIVissimDisturbance::addToNode(), NIVissimConnection::buildEdgeConnections(), NIVissimEdge::buildNBEdge(), NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), NBTrafficLightDefinition::collectEdges(), NBOwnTLDef::collectLinks(), NBNode::computeInternalLaneShape(), computeLaneShape(), computeLaneShapes(), NBNode::eraseDummies(), NIImporter_VISUM::getNamedEdgeContinuating(), NIImporter_VISUM::getReversedContinuating(), NBNodeCont::guessRamps(), NBConnection::NBConnection(), NBRequest::NBRequest(), NBOwnTLDef::edge_by_incoming_priority_sorter::operator()(), NBContHelper::same_connection_edge_sorter::operator()(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_LanesConnections(), NIImporter_VISUM::parse_TurnsToSignalGroups(), NIXMLConnectionsHandler::parseLaneBound(), NBEdgeCont::removeUnwishedEdges(), NBNodeCont::removeUnwishedNodes(), NBConnection::replaceFrom(), NBConnection::replaceTo(), NBEdgeCont::savePlain(), setControllingTLInformation(), and writeSingleSucceeding().

                                           {
        return myID;
    }

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 510 of file NBEdge.cpp.

References myFrom, myFromJunctionPriority, and myToJunctionPriority.

Referenced by NBEdge::MainDirections::MainDirections(), NBOwnTLDef::edge_by_incoming_priority_sorter::operator()(), and NBRequest::setBlocking().

                                                           {
    if (node==myFrom) {
        return myFromJunctionPriority;
    } else {
        return myToJunctionPriority;
    }
}

std::string NBEdge::getLaneID

(

unsigned int

lane

)

Definition at line 1712 of file NBEdge.cpp.

References myID, myLanes, and toString().

                                   {
    assert(lane<myLanes.size());
    return myID + "_" + toString(lane);
}

const Position2DVector & NBEdge::getLaneShape

(

unsigned int

i

)

const throw ()

Returns the shape of the nth lane.

Returns:

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

Definition at line 346 of file NBEdge.cpp.

References myLanes.

Referenced by NBNode::computeInternalLaneShape().

                                                 {
    return myLanes[i].shape;
}

SUMOReal NBEdge::getLaneSpeed

(

unsigned int

lane

)

const

Definition at line 722 of file NBEdge.cpp.

References myLanes.

                                            {
    return myLanes[lane].speed;
}

LaneSpreadFunction NBEdge::getLaneSpreadFunction

(

)

const throw () [inline]

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 378 of file NBEdge.h.

References myLaneSpreadFunction.

Referenced by NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), and NBEdgeCont::savePlain().

                                                             {
        return myLaneSpreadFunction;
    }

SUMOReal NBEdge::getLength

(

)

const throw () [inline]

Returns the computed length of the edge.

Returns:

The edge's computed length

Definition at line 291 of file NBEdge.h.

References myLength.

Referenced by NBJoinedEdgesMap::init(), NIImporter_VISUM::parse_Lanes(), and NBEdgeCont::retrievePossiblySplitted().

                                       {
        return myLength;
    }

int NBEdge::getMaxConnectedLane

(

NBEdge *

of

)

const

Definition at line 1947 of file NBEdge.cpp.

References myConnections.

                                            {
    int ret = -1;
    for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if ((*i).toEdge==of && (*i).toLane>ret) {
            ret = (*i).toLane;
        }
    }
    return ret;
}

SUMOReal NBEdge::getMaxLaneOffset

(

)

Definition at line 1449 of file NBEdge.cpp.

References myLanes, SUMO_const_laneWidthAndOffset, and SUMOReal.

                         {
    return (SUMOReal) SUMO_const_laneWidthAndOffset * myLanes.size();
}

Position2D NBEdge::getMaxLaneOffsetPositionAt	(	NBNode *	node,
		SUMOReal	width
	)			const

Definition at line 1474 of file NBEdge.cpp.

References Position2DVector::length(), myFrom, myLanes, Position2DVector::positionAtLengthPosition(), SUMO_const_halfLaneAndOffset, SUMOReal, and GeomHelper::transfer_to_side().

                                                                     {
    const Position2DVector &shape0 = myLanes[0].shape;
    const Position2DVector &shapel = myLanes.back().shape;
    width = width < shape0.length()/(SUMOReal) 2.0
            ? width
            : shape0.length()/(SUMOReal) 2.0;
    if (node==myFrom) {
        Position2D pos = shape0.positionAtLengthPosition(width);
        GeomHelper::transfer_to_side(pos, shape0[0], shape0[-1], -SUMO_const_halfLaneAndOffset);
        return pos;
    } else {
        Position2D pos = shapel.positionAtLengthPosition(shapel.length() - width);
        GeomHelper::transfer_to_side(pos, shapel[-1], shapel[0], -SUMO_const_halfLaneAndOffset);
        return pos;
    }
}

int NBEdge::getMinConnectedLane

(

NBEdge *

of

)

const

Definition at line 1935 of file NBEdge.cpp.

References myConnections.

                                            {
    int ret = -1;
    for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if ((*i).toEdge==of && (ret==-1 || (*i).toLane<ret)) {
            ret = (*i).toLane;
        }
    }
    return ret;
}

Position2D NBEdge::getMinLaneOffsetPositionAt	(	NBNode *	node,
		SUMOReal	width
	)			const

Definition at line 1455 of file NBEdge.cpp.

References Position2DVector::length(), myFrom, myLanes, Position2DVector::positionAtLengthPosition(), SUMO_const_halfLaneAndOffset, SUMOReal, and GeomHelper::transfer_to_side().

                                                                     {
    const Position2DVector &shape0 = myLanes[0].shape;
    const Position2DVector &shapel = myLanes.back().shape;
    width = width < shape0.length()/(SUMOReal) 2.0
            ? width
            : shape0.length()/(SUMOReal) 2.0;
    if (node==myFrom) {
        Position2D pos =  shapel.positionAtLengthPosition(width);
        GeomHelper::transfer_to_side(pos, shapel[0], shapel[-1], SUMO_const_halfLaneAndOffset);
        return pos;
    } else {
        Position2D pos = shape0.positionAtLengthPosition(shape0.length() - width);
        GeomHelper::transfer_to_side(pos, shape0[-1], shape0[0], SUMO_const_halfLaneAndOffset);
        return pos;
    }
}

unsigned int NBEdge::getNoLanes

(

)

const throw () [inline]

Returns the number of lanes.

Returns:

This edge's number of lanes

Definition at line 247 of file NBEdge.h.

References myLanes.

Referenced by NIVissimTL::NIVissimTLSignal::addTo(), appendTurnaround(), NIVissimConnection::buildEdgeConnections(), NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), NBNodeCont::checkHighwayRampOrder(), NBTrafficLightDefinition::collectLinks(), NBOwnTLDef::collectLinks(), NBLoadedTLDef::collectLinks(), NBNode::computeInternalLaneShape(), NBNode::computeLanes2Lanes(), NBNode::ApproachingDivider::execute(), NBNodeCont::guessRamps(), NBNode::isSimpleContinuation(), NBNodeCont::mayNeedOffRamp(), NBNodeCont::mayNeedOnRamp(), moveOutgoingConnectionsFrom(), NBOwnTLDef::myCompute(), NIXMLEdgesHandler::myEndElement(), NIXMLEdgesHandler::myStartElement(), NBContHelper::edge_by_priority_sorter::operator()(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_LanesConnections(), samePriority(), NBEdgeCont::savePlain(), NBLoadedTLDef::setTLControllingInformation(), NBEdgeCont::splitAt(), and NBNode::ApproachingDivider::spread().

                                            {
        return (unsigned int) myLanes.size();
    }

SUMOReal NBEdge::getNormedAngle

(

const NBNode &

atNode

)

const

Definition at line 1730 of file NBEdge.cpp.

References getAngle(), and SUMOReal.

                                                 {
    SUMOReal angle = getAngle(atNode);
    if (angle<0) {
        angle = 360 + angle;
    }
    assert(angle>=0&&angle<360);
    return angle;
}

SUMOReal NBEdge::getNormedAngle

(

)

const

Definition at line 1741 of file NBEdge.cpp.

References myAngle, and SUMOReal.

Referenced by NBContHelper::edge_by_junction_angle_sorter::getConvAngle().

                             {
    SUMOReal angle = myAngle;
    if (angle<0) {
        angle = 360 + angle;
    }
    assert(angle>=0&&angle<360);
    return angle;
}

int NBEdge::getPriority

(

)

const throw () [inline]

Returns the priority of the edge.

Returns:

This edge's priority

Definition at line 255 of file NBEdge.h.

References myPriority.

Referenced by expandableBy(), NIXMLEdgesHandler::myStartElement(), NBContHelper::edge_by_priority_sorter::operator()(), and samePriority().

                                    {
        return myPriority;
    }

SUMOReal NBEdge::getSpeed

(

)

const throw () [inline]

Returns the speed allowed on this edge.

Returns:

The maximum speed allowed on this edge

Definition at line 299 of file NBEdge.h.

References mySpeed.

Referenced by NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), NBNodeCont::checkHighwayRampOrder(), NBNodeCont::mayNeedOffRamp(), NBNodeCont::mayNeedOnRamp(), NIXMLEdgesHandler::myStartElement(), NBContHelper::edge_by_priority_sorter::operator()(), samePriority(), and NBEdgeCont::savePlain().

                                      {
        return mySpeed;
    }

EdgeBuildingStep NBEdge::getStep

(

)

const throw () [inline]

The building step of this edge.

Returns:

The current building step for this edge

Todo:

Recheck usage!

See also:

EdgeBuildingStep

Definition at line 309 of file NBEdge.h.

References myStep.

                                             {
        return myStep;
    }

NBNode* const NBEdge::getToNode

(

)

const throw () [inline]

Returns the destination node of the edge.

Returns:

The node this edge ends at

Definition at line 271 of file NBEdge.h.

References myTo.

Referenced by NIVissimDisturbance::addToNode(), NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), NBLoadedTLDef::collectNodes(), NIVissimDistrictConnection::dict_BuildDistricts(), NBNodeCont::generateNodeClusters(), NBNode::getCrossingNames_dividedBySpace(), NBNode::getCrossingSourcesNames_dividedBySpace(), NIImporter_VISUM::getNamedEdgeContinuating(), NBNode::getOppositeIncoming(), NBNodeCont::guessRamps(), NBEdgeCont::guessRoundabouts(), NBNode::isNearDistrict(), NBOwnTLDef::myCompute(), NIXMLConnectionsHandler::myStartElement(), NBOwnTLDef::edge_by_incoming_priority_sorter::operator()(), NBContHelper::edge_with_destination_finder::operator()(), NIImporter_VISUM::parse_Lanes(), NIXMLConnectionsHandler::parseLaneBound(), NBNodeCont::recheckEdges(), NBNodeCont::removeIsolatedRoads(), NBEdgeCont::removeUnwishedEdges(), NBNodeCont::removeUnwishedNodes(), NBEdgeCont::savePlain(), NIXMLEdgesHandler::setNodes(), and NBNode::swapWhenReversed().

                                             {
        return myTo;
    }

NBEdge * NBEdge::getTurnDestination

(

)

const

Definition at line 1706 of file NBEdge.cpp.

References myTurnDestination.

Referenced by NBNode::computeInternalLaneShape(), NBNode::computeLanes2Lanes(), NBEdgeCont::guessRoundabouts(), moveConnectionToLeft(), moveConnectionToRight(), and writeXMLStep1().

                                 {
    return myTurnDestination;
}

const std::string& NBEdge::getTypeID

(

)

const throw () [inline]

Definition at line 567 of file NBEdge.h.

References myType.

Referenced by NIXMLEdgesHandler::myStartElement().

                                               {
        return myType;
    }

bool NBEdge::hasConnectionTo	(	NBEdge *	destEdge,
		unsigned int	destLane
	)			const throw ()

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

Parameters:

[in]	destEdge	The connection's destination edge
[in]	destLane	The connection's destination lane

Returns:

whether a connection to the specified lane exists

Definition at line 503 of file NBEdge.cpp.

References myConnections.

Referenced by setConnection().

                                                                             {
    return destEdge!=0&&find_if(myConnections.begin(), myConnections.end(), connections_toedgelane_finder(destEdge, destLane))!=myConnections.end();
}

bool NBEdge::hasRestrictions

(

)

const

Definition at line 913 of file NBEdge.cpp.

References myLanes.

Referenced by NBEdgeCont::savePlain().

                              {
    for (std::vector<Lane>::const_iterator i=myLanes.begin(); i!=myLanes.end(); ++i) {
        if ((*i).allowed.size()!=0 || (*i).notAllowed.size()!=0) {
            return true;
        }
    }
    return false;
}

bool NBEdge::hasSignalisedConnectionTo

(

const NBEdge *const

e

)

const throw ()

Definition at line 1695 of file NBEdge.cpp.

References myConnections.

                                                                      {
    for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if ((*i).toEdge==e && (*i).tlID!="") {
            return true;
        }
    }
    return false;
}

void NBEdge::incLaneNo

(

unsigned int

by

)

Definition at line 1752 of file NBEdge.cpp.

References computeLaneShapes(), NBNode::getIncomingEdges(), invalidateConnections(), myFrom, myLanes, mySpeed, and NBEdge::Lane::speed.

Referenced by NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), and NIImporter_VISUM::parse_Lanes().

                                 {
    unsigned int newLaneNo = (unsigned int) myLanes.size() + by;
    while (myLanes.size()<newLaneNo) {
        Lane l;
        l.speed = mySpeed;
        myLanes.push_back(l);
    }
    computeLaneShapes();
    const EdgeVector &incs = myFrom->getIncomingEdges();
    for (EdgeVector::const_iterator i=incs.begin(); i!=incs.end(); ++i) {
        (*i)->invalidateConnections(true);
    }
    invalidateConnections(true);
}

void NBEdge::init	(	unsigned int	noLanes,
		bool	tryIgnoreNodePositions
	)			throw (ProcessError) [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

Definition at line 213 of file NBEdge.cpp.

References NBNode::addIncomingEdge(), NBNode::addOutgoingEdge(), NBHelpers::angle(), computeLaneShapes(), Position2D::distanceTo(), NBNode::getPosition(), myAngle, myFrom, myGeom, myID, myLanes, myLength, mySpeed, myTo, Position2DVector::push_back(), Position2DVector::push_back_noDoublePos(), Position2DVector::push_front(), Position2DVector::push_front_noDoublePos(), Position2DVector::removeDoublePoints(), Position2DVector::size(), NBEdge::Lane::speed, Position2D::x(), and Position2D::y().

Referenced by NBEdge(), and reinit().

                                                                                  {
    if (noLanes==0) {
        throw ProcessError("Edge '" + myID + "' needs at least one lane.");
    }
    if (myFrom==0||myTo==0) {
        throw ProcessError("At least one of edge's '" + myID + "' nodes is not known.");
    }
    // revisit geometry
    //  should have at least two points at the end...
    //  and in dome cases, the node positions must be added
    myGeom.removeDoublePoints();
    if (!tryIgnoreNodePositions||myGeom.size()<2) {
        if (myGeom.size()==0) {
            myGeom.push_back(myTo->getPosition());
            myGeom.push_front(myFrom->getPosition());
        } else {
            Position2DVector v;
            v = myGeom;
            v.push_back_noDoublePos(myTo->getPosition());
            v.push_front_noDoublePos(myFrom->getPosition());
            if (v.size()<2) {
                myGeom.push_back(myTo->getPosition());
                myGeom.push_front(myFrom->getPosition());
            } else {
                myGeom = v;
            }
        }
    }
    //
    myAngle = NBHelpers::angle(
                  myFrom->getPosition().x(), myFrom->getPosition().y(),
                  myTo->getPosition().x(), myTo->getPosition().y()
              );
    myFrom->addOutgoingEdge(this);
    myTo->addIncomingEdge(this);
    // prepare container
    myLength = myFrom->getPosition().distanceTo(myTo->getPosition());
    assert(myGeom.size()>=2);
    myLanes.clear();
    for (unsigned int i=0; i<noLanes; i++) {
        Lane l;
        l.speed = mySpeed;
        myLanes.push_back(l);
    }
    computeLaneShapes();
}

void NBEdge::invalidateConnections

(

bool

reallowSetting = false

)

Definition at line 1431 of file NBEdge.cpp.

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

Referenced by addLane2LaneConnections(), NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), decLaneNo(), incLaneNo(), and NIXMLEdgesHandler::myEndElement().

                                                 {
    myTurnDestination = 0;
    myConnections.clear();
    if (reallowSetting) {
        myStep = INIT;
    } else {
        myStep = INIT_REJECT_CONNECTIONS;
    }
}

bool NBEdge::isConnectedTo

(

NBEdge *

e

)

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

Definition at line 1372 of file NBEdge.cpp.

References myConnections, and myTurnDestination.

Referenced by computeTurningDirections(), and NBNode::eraseDummies().

                               {
    if (e==myTurnDestination) {
        return true;
    }
    return
        find_if(myConnections.begin(), myConnections.end(), connections_toedge_finder(e))
        !=
        myConnections.end();

}

bool NBEdge::isInnerEdge

(

)

const throw () [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 524 of file NBEdge.h.

References myAmInnerEdge.

                                     {
        return myAmInnerEdge;
    }

bool NBEdge::isMacroscopicConnector

(

)

throw () [inline]

Returns whether this edge was marked as a macroscopic connector.

Returns:

Whether this edge was marked as a macroscopic connector

Definition at line 509 of file NBEdge.h.

References myAmMacroscopicConnector.

Referenced by NBNodeCont::mayNeedOffRamp(), NBNodeCont::mayNeedOnRamp(), and writeXMLStep1().

                                          {
        return myAmMacroscopicConnector;
    }

bool NBEdge::isNearEnough2BeJoined2

(

NBEdge *

e

)

Definition at line 1719 of file NBEdge.cpp.

References Position2DVector::distances(), Position2DVector::distancesExt(), getGeometry(), max, VectorHelper< T >::maxValue(), myGeom, and SUMOReal.

                                        {
    DoubleVector distances = myGeom.distances(e->getGeometry());
    if (distances.size()==0) {
        distances = e->getGeometry().distancesExt(myGeom);
    }
    SUMOReal max = VectorHelper<SUMOReal>::maxValue(distances);
    return max<7;
}

bool NBEdge::isTurningDirectionAt	(	const NBNode *	n,
		const NBEdge *const	edge
	)			const throw ()

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

Parameters:

[in]	n	The node at which this may be turnaround direction
[in]	edge	The edge which may be the turnaround direction

Returns:

Whether the given edge is this edge's turnaround direction

Definition at line 1300 of file NBEdge.cpp.

References getAngle(), myFrom, myTo, myTurnDestination, and SUMOReal.

Referenced by NBOwnTLDef::myCompute(), NBContHelper::opposite_finder::operator()(), NBRequest::setBlocking(), and NBNode::swapWhenReversed().

                                                                                     {
    // maybe it was already set as the turning direction
    if (edge == myTurnDestination) {
        return true;
    } else if (myTurnDestination!=0) {
        // otherwise - it's not if a turning direction exists
        return false;
    }
    // if the same nodes are connected
    if (myFrom==edge->myTo &&myTo==edge->myFrom) {
        return true;
    }
    // we have to checke whether the connection between the nodes is
    //  geometrically similar
    SUMOReal thisFromAngle2 = getAngle(*n);
    SUMOReal otherToAngle2 = edge->getAngle(*n);
    if (thisFromAngle2<otherToAngle2) {
        std::swap(thisFromAngle2, otherToAngle2);
    }
    if (thisFromAngle2-otherToAngle2>170&&thisFromAngle2-otherToAngle2<190) {
        return true;
    }
    return false;
}

std::pair< SUMOReal, SUMOReal > NBEdge::laneOffset	(	const Position2D &	from,
		const Position2D &	to,
		SUMOReal	lanewidth,
		unsigned int	lane
	)			throw (InvalidArgument) [private]

Computes the offset from the edge shape on the current segment.

Definition at line 800 of file NBEdge.cpp.

References GeomHelper::getNormal90D_CW(), LANESPREAD_RIGHT, myAmLeftHand, myLanes, myLaneSpreadFunction, and SUMOReal.

Referenced by computeLaneShape().

                                                                                 {
    std::pair<SUMOReal, SUMOReal> offsets =
        GeomHelper::getNormal90D_CW(from, to, lanewidth);
    SUMOReal xoff = offsets.first / (SUMOReal) 2.0;
    SUMOReal yoff = offsets.second / (SUMOReal) 2.0;
    if (myLaneSpreadFunction==LANESPREAD_RIGHT) {
        xoff += (offsets.first * (SUMOReal) lane);
        yoff += (offsets.second * (SUMOReal) lane);
    } else {
        xoff += (offsets.first * (SUMOReal) lane) - (offsets.first * (SUMOReal) myLanes.size() / (SUMOReal) 2.0);
        yoff += (offsets.second * (SUMOReal) lane) - (offsets.second * (SUMOReal) myLanes.size() / (SUMOReal) 2.0);
    }
    if (myAmLeftHand) {
        return std::pair<SUMOReal, SUMOReal>(-xoff, -yoff);
    } else {
        return std::pair<SUMOReal, SUMOReal>(xoff, yoff);
    }
}

bool NBEdge::lanesWereAssigned

(

)

const

Definition at line 1443 of file NBEdge.cpp.

References LANES2LANES_DONE, LANES2LANES_USER, and myStep.

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

                                {
    return myStep==LANES2LANES_DONE||myStep==LANES2LANES_USER;
}

void NBEdge::markAsInLane2LaneState

(

)

Definition at line 1802 of file NBEdge.cpp.

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

                               {
    assert(myTo->getOutgoingEdges().size()==0);
    myStep = LANES2LANES_DONE;
}

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

Definition at line 1493 of file NBEdge.cpp.

References NBEdge::TLSDisabledConnection::fromLane, myTLSDisabledConnections, NBEdge::TLSDisabledConnection::to, and NBEdge::TLSDisabledConnection::toLane.

Referenced by NBTrafficLightDefinition::collectLinks(), NBOwnTLDef::collectLinks(), and NBOwnTLDef::myCompute().

                                                                                 {
    TLSDisabledConnection tpl;
    tpl.fromLane = fromLane;
    tpl.to = toEdge;
    tpl.toLane = toLane;
    std::vector<TLSDisabledConnection>::const_iterator i = find_if(myTLSDisabledConnections.begin(), myTLSDisabledConnections.end(), tls_disable_finder(tpl));
    return i==myTLSDisabledConnections.end();
}

void NBEdge::moveConnectionToLeft

(

unsigned int

lane

)

[private]

moves a connection one place to the left; Attention! no checking for field validity

Definition at line 1060 of file NBEdge.cpp.

References getTurnDestination(), L2L_VALIDATED, myAmLeftHand, myConnections, setConnection(), NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by recheckLanes().

                                              {
    unsigned int index = 0;
    if (myAmLeftHand) {
        for (int i=(int) myConnections.size()-1; i>=0; --i) {
            if (myConnections[i].fromLane==lane&&getTurnDestination()!=myConnections[i].toEdge) {
                index = i;
            }
        }
    } else {
        for (unsigned int i=0; i<myConnections.size(); ++i) {
            if (myConnections[i].fromLane==lane) {
                index = i;
            }
        }
    }
    std::vector<Connection>::iterator i = myConnections.begin() + index;
    Connection c = *i;
    myConnections.erase(i);
    setConnection(lane+1, c.toEdge, c.toLane, L2L_VALIDATED, false);
}

void NBEdge::moveConnectionToRight

(

unsigned int

lane

)

[private]

moves a connection one place to the right; Attention! no checking for field validity

Definition at line 1083 of file NBEdge.cpp.

References getTurnDestination(), L2L_VALIDATED, myAmLeftHand, myConnections, setConnection(), NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by recheckLanes().

                                               {
    if (myAmLeftHand) {
        for (int i=(int) myConnections.size()-1; i>=0; --i) {
            if (myConnections[i].fromLane==lane&&getTurnDestination()!=myConnections[i].toEdge) {
                Connection c = myConnections[i];
                myConnections.erase(myConnections.begin() + i);
                setConnection(lane-1, c.toEdge, c.toLane, L2L_VALIDATED, false);
                return;
            }
        }
    } else {
        for (std::vector<Connection>::iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
            if ((*i).fromLane==lane) {
                Connection c = *i;
                i = myConnections.erase(i);
                setConnection(lane-1, c.toEdge, c.toLane, L2L_VALIDATED, false);
                return;
            }
        }
    }
}

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

Definition at line 1357 of file NBEdge.cpp.

References addLane2LaneConnection(), getConnectionsFromLane(), getNoLanes(), L2L_COMPUTED, NBEdge::Connection::tlID, NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by NBEdgeCont::joinSameNodeConnectingEdges().

                                                                   {
    unsigned int lanes = e->getNoLanes();
    for (unsigned int i=0; i<lanes; i++) {
        std::vector<NBEdge::Connection> elv = e->getConnectionsFromLane(i);
        for (std::vector<NBEdge::Connection>::iterator j=elv.begin(); j!=elv.end(); j++) {
            NBEdge::Connection el = *j;
            assert(el.tlID=="");
            bool ok = addLane2LaneConnection(i+laneOff, el.toEdge, el.toLane, L2L_COMPUTED);
            assert(ok);
        }
    }
}

NBEdge& NBEdge::operator=

(

const NBEdge &

s

)

[private]

invalidated assignment operator

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

Definition at line 1889 of file NBEdge.cpp.

References myLanes.

Referenced by NIXMLEdgesHandler::myStartElement().

                                                            {
    if (lane<0) {
        // if all lanes are meant...
        for (unsigned int i=0; i<myLanes.size(); i++) {
            // ... do it for each lane
            preferVehicleClass((int) i, vclass);
        }
        return;
    }
    assert(lane<(int) myLanes.size());
    // add it only if not already done
    if (find(myLanes[lane].preferred.begin(), myLanes[lane].preferred.end(), vclass)==myLanes[lane].preferred.end()) {
        myLanes[lane].preferred.push_back(vclass);
    }
}

std::vector< unsigned int > * NBEdge::preparePriorities

(

const std::vector< NBEdge * > *

outgoing

)

[private]

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

Definition at line 1227 of file NBEdge.cpp.

References NBEdge::MainDirections::DIR_FORWARD, NBEdge::MainDirections::DIR_RIGHTMOST, NBEdge::MainDirections::empty(), NBEdge::MainDirections::includes(), myLanes, myTo, and size.

Referenced by divideOnEdges().

                                                            {
    // copy the priorities first
    std::vector<unsigned int> *priorities = new std::vector<unsigned int>();
    if (outgoing->size()==0) {
        return priorities;
    }
    priorities->reserve(outgoing->size());
    std::vector<NBEdge*>::const_iterator i;
    for (i=outgoing->begin(); i!=outgoing->end(); i++) {
        int prio = (*i)->getJunctionPriority(myTo);
        assert((prio+1)*2>0);
        prio = (prio+1) * 2;
        priorities->push_back(prio);
    }
    // when the right turning direction has not a higher priority, divide
    //  the importance by 2 due to the possibility to leave the junction
    //  faster from this lane
    MainDirections mainDirections(*outgoing, this, myTo);
    std::vector<NBEdge*> tmp(*outgoing);
    sort(tmp.begin(), tmp.end(), NBContHelper::edge_similar_direction_sorter(this));
    i=find(outgoing->begin(), outgoing->end(), *(tmp.begin()));
    unsigned int dist = (unsigned int) distance(outgoing->begin(), i);
    if (dist!=0&&!mainDirections.includes(MainDirections::DIR_RIGHTMOST)) {
        assert(priorities->size()>0);
        (*priorities)[0] = (*priorities)[0] / 2;
    }
    // HEURISTIC:
    // when no higher priority exists, let the forward direction be
    //  the main direction
    if (mainDirections.empty()) {
        assert(dist<priorities->size());
        (*priorities)[dist] = (*priorities)[dist] * 2;
    }
    if (mainDirections.includes(MainDirections::DIR_FORWARD)&&myLanes.size()>2) {
        (*priorities)[dist] = (*priorities)[dist] * 2;
    }
    // return
    return priorities;
}

bool NBEdge::recheckLanes

(

)

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

Definition at line 1003 of file NBEdge.cpp.

References L2L_VALIDATED, LANES2LANES_DONE, LANES2LANES_USER, moveConnectionToLeft(), moveConnectionToRight(), myConnections, myLanes, myStep, and setConnection().

                     {
    std::vector<unsigned int> connNumbersPerLane(myLanes.size(), 0);
    for (std::vector<Connection>::iterator i=myConnections.begin(); i!=myConnections.end();) {
        if ((*i).toEdge==0||(*i).fromLane<0||(*i).toLane<0) {
            i = myConnections.erase(i);
        } else {
            if ((*i).fromLane>=0) {
                ++connNumbersPerLane[(*i).fromLane];
            }
            ++i;
        }
    }
    if (myStep!=LANES2LANES_DONE&&myStep!=LANES2LANES_USER) {
        // check #1:
        // If there is a lane with no connections and any neighbour lane has
        //  more than one connections, try to move one of them.
        // This check is only done for edges which connections were assigned
        //  using the standard algorithm.
        for (unsigned int i=0; i<myLanes.size(); i++) {
            if (connNumbersPerLane[i]==0) {
                if (i>0&&connNumbersPerLane[i-1]>1) {
                    moveConnectionToLeft(i-1);
                } else if (i<myLanes.size()-1&&connNumbersPerLane[i+1]>1) {
                    moveConnectionToRight(i+1);
                }
            }
        }
    }
    // check:
    // Go through all lanes and add an empty connection if no connection
    //  is yet set.
    // This check must be done for all lanes to assert that there is at
    //  least a dead end information (needed later for building the
    //  node request
    for (unsigned int i=0; i<myLanes.size(); i++) {
        connNumbersPerLane[i] = 0;
    }
    for (std::vector<Connection>::iterator i=myConnections.begin(); i!=myConnections.end();) {
        if ((*i).toEdge==0||(*i).fromLane<0||(*i).toLane<0) {
            i = myConnections.erase(i);
        } else {
            if ((*i).fromLane>=0) {
                ++connNumbersPerLane[(*i).fromLane];
            }
            ++i;
        }
    }
    for (unsigned int i=0; i<myLanes.size(); i++) {
        if (connNumbersPerLane[i]==0) {
            setConnection(i, 0, 0, L2L_VALIDATED, false);
        }
    }
    return true;
}

void NBEdge::reinit	(	NBNode *	from,
		NBNode *	to,
		std::string	type,
		SUMOReal	speed,
		unsigned int	nolanes,
		int	priority,
		Position2DVector	geom,
		LaneSpreadFunction	spread = LANESPREAD_RIGHT
	)			throw (ProcessError)

Resets initial values.

Parameters:

[in]	position	The position of the node
[in]	type	The type of the node

Definition at line 187 of file NBEdge.cpp.

References StringUtils::convertUmlaute(), init(), myFrom, myGeom, myLaneSpreadFunction, myLoadedLength, myPriority, mySpeed, myTo, myType, NBNode::removeIncoming(), and NBNode::removeOutgoing().

Referenced by NIXMLEdgesHandler::myStartElement().

                                                                                     {
    if (myFrom!=from) {
        myFrom->removeOutgoing(this);
    }
    if (myTo!=to) {
        myTo->removeIncoming(this);
    }
    myType = StringUtils::convertUmlaute(type);
    myFrom = from;
    myTo = to;
    myPriority = priority;
    mySpeed = speed;
    //?myTurnDestination(0),
    //?myFromJunctionPriority(-1), myToJunctionPriority(-1),
    myGeom = geom;
    myLaneSpreadFunction = spread;
    myLoadedLength = -1;
    //?, myAmTurningWithAngle(0), myAmTurningOf(0),
    //?myAmInnerEdge(false), myAmMacroscopicConnector(false)
    init(nolanes, false);
}

void NBEdge::remapConnections

(

const EdgeVector &

incoming

)

Remaps the connection in a way tha allows the removal of it This edges (which is a "dummy" edge, in fact) connections are spread over the incoming non-dummy edges.

Definition at line 1397 of file NBEdge.cpp.

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

Referenced by NBNode::eraseDummies().

                                                   {
    std::vector<NBEdge*> connected = getConnectedEdges();
    for (EdgeVector::const_iterator i=incoming.begin(); i!=incoming.end(); i++) {
        NBEdge *inc = *i;
        // We have to do this
        inc->myStep = EDGE2EDGES;
        // add all connections
        for (EdgeVector::iterator j=connected.begin(); j!=connected.end(); j++) {
            inc->addEdge2EdgeConnection(*j);
        }
        inc->removeFromConnections(this);
    }
}

void NBEdge::removeFromConnections	(	NBEdge *	which,
		int	lane = -1
	)

Definition at line 1413 of file NBEdge.cpp.

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

Referenced by decLaneNo(), NIXMLConnectionsHandler::myStartElement(), and remapConnections().

                                                     {
    // remove from "myConnections"
    for (std::vector<Connection>::iterator i=myConnections.begin(); i!=myConnections.end();) {
        Connection &c = *i;
        if (c.toEdge==which && (lane<0 || c.fromLane==lane)) {
            i = myConnections.erase(i);
        } else {
            ++i;
        }
    }
    // check whether it was the turn destination
    if (myTurnDestination==which&&lane<0) {
        myTurnDestination = 0;
    }
}

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

Definition at line 1342 of file NBEdge.cpp.

References myConnections, and myTurnDestination.

Referenced by NBNode::replaceOutgoing().

                                                                            {
    // replace in "_connectedEdges"
    for (std::vector<Connection>::iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if ((*i).toEdge==which) {
            (*i).toEdge = by;
        }
    }
    // check whether it was the turn destination
    if (myTurnDestination==which) {
        myTurnDestination = by;
    }
}

void NBEdge::reshiftPosition	(	SUMOReal	xoff,
		SUMOReal	yoff
	)			throw ()

Applies an offset to the edge.

Parameters:

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

Definition at line 364 of file NBEdge.cpp.

References myGeom, myLanes, and Position2DVector::reshiftRotate().

                                                            {
    myGeom.reshiftRotate(xoff, yoff, 0);
    for (unsigned int i=0; i<myLanes.size(); i++) {
        myLanes[i].shape.reshiftRotate(xoff, yoff, 0);
    }
}

void NBEdge::setAsMacroscopicConnector

(

)

throw () [inline]

Marks this edge as a macroscopic connector.

Definition at line 501 of file NBEdge.h.

References myAmMacroscopicConnector.

Referenced by NIImporter_VISUM::parse_Connectors().

                                             {
        myAmMacroscopicConnector = true;
    }

void NBEdge::setConnection	(	unsigned int	lane,
		NBEdge *	destEdge,
		unsigned int	destLane,
		Lane2LaneInfoType	type,
		bool	mayUseSameDestination = false,
		bool	mayDefinitelyPass = false
	)			throw ()

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 434 of file NBEdge.cpp.

References MsgHandler::getErrorInstance(), hasConnectionTo(), MsgHandler::inform(), INIT_REJECT_CONNECTIONS, L2L_COMPUTED, L2L_USER, LANES2LANES_DONE, LANES2LANES_RECHECK, LANES2LANES_USER, myConnections, myID, myLanes, myStep, and toString().

Referenced by addLane2LaneConnection(), appendTurnaround(), NBNode::computeLanes2Lanes(), moveConnectionToLeft(), moveConnectionToRight(), and recheckLanes().

                                                      {
    if (myStep==INIT_REJECT_CONNECTIONS) {
        return;
    }
    assert(destLane<=10);
    assert(lane<=10);
    // some kind of a misbehaviour which may occure when the junction's outgoing
    //  edge priorities were not properly computed, what may happen due to
    //  an incomplete or not proper input
    // what happens is that under some circumstances a single lane may set to
    //  be approached more than once by the one of our lanes.
    //  This must not be!
    // we test whether it is the case and do nothing if so - the connection
    //  will be refused
    //
    if (!mayUseSameDestination && hasConnectionTo(destEdge, destLane)) {
        return;
    }
    if (find_if(myConnections.begin(), myConnections.end(), connections_finder(lane, destEdge, destLane))!=myConnections.end()) {
        return;
    }
    if (myLanes.size()<=lane) {
        MsgHandler::getErrorInstance()->inform("Could not set connection from '" + myID + "_" + toString(lane) + "' to '" + destEdge->getID() + "_" + toString(destLane) + "'.");
        return;
    }
    for (std::vector<Connection>::iterator i=myConnections.begin(); i!=myConnections.end();) {
        if ((*i).toEdge==destEdge && ((*i).fromLane==-1 || (*i).toLane==-1)) {
            i = myConnections.erase(i);
        } else {
            ++i;
        }
    }
    myConnections.push_back(Connection(lane, destEdge, destLane));
    if (mayDefinitelyPass) {
        myConnections.back().mayDefinitelyPass = true;
    }
    if (type==L2L_USER) {
        myStep = LANES2LANES_USER;
    } else {
        // check whether we have to take another look at it later
        if (type==L2L_COMPUTED) {
            // yes, the connection was set using an algorithm which requires a recheck
            myStep = LANES2LANES_RECHECK;
        } else {
            // ok, let's only not recheck it if we did no add something that has to be recheked
            if (myStep!=LANES2LANES_RECHECK) {
                myStep = LANES2LANES_DONE;
            }
        }
    }
}

bool NBEdge::setControllingTLInformation	(	int	fromLane,
		NBEdge *	toEdge,
		int	toLane,
		const std::string &	tlID,
		unsigned int	tlPos
	)

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

Definition at line 1504 of file NBEdge.cpp.

References NBEdge::TLSDisabledConnection::fromLane, getID(), myConnections, myLanes, myTLSDisabledConnections, NBEdge::Connection::tlID, NBEdge::Connection::tlLinkNo, NBEdge::TLSDisabledConnection::to, NBEdge::TLSDisabledConnection::toLane, and WRITE_WARNING.

Referenced by NBTrafficLightDefinition::collectLinks(), NBOwnTLDef::setTLControllingInformation(), and NBLoadedTLDef::setTLControllingInformation().

                                                                               {
    // check whether the connection was not set as not to be controled previously
    TLSDisabledConnection tpl;
    tpl.fromLane = fromLane;
    tpl.to = toEdge;
    tpl.toLane = toLane;
    std::vector<TLSDisabledConnection>::iterator i = find_if(myTLSDisabledConnections.begin(), myTLSDisabledConnections.end(), tls_disable_finder(tpl));
    if (i!=myTLSDisabledConnections.end()) {
        return false;
    }

    assert(fromLane<0||fromLane<(int) myLanes.size());
    // try to use information about the connections if given
    if (fromLane>=0&&toLane>=0) {
        // find the specified connection
        std::vector<Connection>::iterator i =
            find_if(myConnections.begin(), myConnections.end(), connections_finder(fromLane, toEdge, toLane));
        // ok, we have to test this as on the removal of dummy edges some connections
        //  will be reassigned
        if (i!=myConnections.end()) {
            // get the connection
            Connection &connection = *i;
            // set the information about the tl
            connection.tlID = tlID;
            connection.tlLinkNo = tlPos;
            return true;
        }
    }
    // if the original connection was not found, set the information for all
    //  connections
    unsigned int no = 0;
    bool hadError = false;
    for (std::vector<Connection>::iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if ((*i).toEdge!=toEdge) {
            continue;
        }
        if (fromLane>=0&&fromLane!=(*i).fromLane) {
            continue;
        }
        if (toLane>=0&&toLane!=(*i).toLane) {
            continue;
        }
        if ((*i).tlID=="") {
            (*i).tlID = tlID;
            (*i).tlLinkNo = tlPos;
            no++;
        } else {
            if ((*i).tlID!=tlID&&(*i).tlLinkNo==tlPos) {
                WRITE_WARNING("The lane " + toString<int>((*i).fromLane)+ " on edge " + getID()+ " already had a traffic light signal.");
                hadError = true;
            }
        }
    }
    if (hadError&&no==0) {
        WRITE_WARNING("Could not set any signal of the traffic light '" + tlID + "' (unknown group)");
    }
    return true;
}

void NBEdge::setGeometry

(

const Position2DVector &

g

)

throw ()

(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

Todo:

Recheck usage, disallow access

See also:

computeLaneShapes

Definition at line 266 of file NBEdge.cpp.

References computeLaneShapes(), and myGeom.

Referenced by NBNodeCont::buildOffRamp(), NBNodeCont::buildOnRamp(), and NBNodeCont::guessRamps().

                                                     {
    myGeom = s;
    computeLaneShapes();
}

void NBEdge::setIsInnerEdge

(

)

throw () [inline]

Marks this edge being within an intersection.

Definition at line 516 of file NBEdge.h.

References myAmInnerEdge.

                                  {
        myAmInnerEdge = true;
    }

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 520 of file NBEdge.cpp.

References myFrom, myFromJunctionPriority, and myToJunctionPriority.

Referenced by NBNode::extractAndMarkFirst(), NBEdgeCont::guessRoundabouts(), and NBNode::setPriorityJunctionPriorities().

                                                               {
    if (node==myFrom) {
        myFromJunctionPriority = prio;
    } else {
        myToJunctionPriority = prio;
    }
}

void NBEdge::setLaneSpeed	(	unsigned int	lane,
		SUMOReal	speed
	)

Definition at line 716 of file NBEdge.cpp.

References myLanes.

Referenced by NIVissimEdge::buildNBEdge(), and NBEdgeCont::splitAt().

                                                      {
    myLanes[lane].speed = speed;
}

void NBEdge::setLaneSpreadFunction

(

LaneSpreadFunction

spread

)

throw ()

(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 352 of file NBEdge.cpp.

References myLaneSpreadFunction.

Referenced by NIImporter_VISUM::parse_Edges().

                                                               {
    myLaneSpreadFunction = spread;
}

void NBEdge::setLeftHanded

(

)

throw () [inline]

Marks this edge to be left-handed.

Definition at line 228 of file NBEdge.h.

References myAmLeftHand.

                                 {
        myAmLeftHand = true;
    }

void NBEdge::setLoadedLength

(

SUMOReal

val

)

Definition at line 1959 of file NBEdge.cpp.

References myLoadedLength.

Referenced by NIXMLEdgesHandler::myStartElement().

                                    {
    myLoadedLength = val;
}

void NBEdge::setTurningDestination

(

NBEdge *

e

)

Definition at line 560 of file NBEdge.cpp.

References acceptBeingTurning(), getAngle(), myTurnDestination, NBHelpers::relAngle(), and SUMOReal.

Referenced by computeTurningDirections(), and NIImporter_VISUM::parse_Turns().

                                       {
    SUMOReal cur = fabs(NBHelpers::relAngle(getAngle(), e->getAngle()));
    SUMOReal old =
        myTurnDestination==0
        ? 0
        : fabs(NBHelpers::relAngle(getAngle(), myTurnDestination->getAngle()));
    if (cur>old
            &&
            e->acceptBeingTurning(this)) {

        myTurnDestination = e;
    }
}

void NBEdge::setVehicleClasses	(	const std::vector< SUMOVehicleClass > &	allowed,
		const std::vector< SUMOVehicleClass > &	disallowed,
		int	lane = -1
	)

Definition at line 1907 of file NBEdge.cpp.

References allowVehicleClass(), and disallowVehicleClass().

Referenced by NIImporter_OpenStreetMap::insertEdge().

                                                                                                                             {
    for (std::vector<SUMOVehicleClass>::const_iterator i=allowed.begin(); i!=allowed.end(); ++i) {
        allowVehicleClass(lane, *i);
    }
    for (std::vector<SUMOVehicleClass>::const_iterator i=disallowed.begin(); i!=disallowed.end(); ++i) {
        disallowVehicleClass(lane, *i);
    }
}

void NBEdge::sortOutgoingLanesConnections

(

)

sorts the connections of outgoing lanes (!!! Kaskade beschreiben)

Definition at line 1294 of file NBEdge.cpp.

References myConnections, and myTo.

                                     {
    sort(myConnections.begin(), myConnections.end(), connections_relative_edgelane_sorter(this, myTo));
}

bool NBEdge::splitGeometry	(	NBEdgeCont &	ec,
		NBNodeCont &	nc
	)			[private]

Definition at line 1809 of file NBEdge.cpp.

References NBNode::addIncomingEdge(), Position2DVector::clear(), NBNode::getPosition(), INIT, NBEdgeCont::insert(), NBNodeCont::insert(), myFrom, myGeom, myID, myLanes, myLaneSpreadFunction, myPriority, mySpeed, myStep, myTo, myType, NBEdge(), Position2DVector::push_back(), NBNode::removeIncoming(), NBNodeCont::retrieve(), Position2DVector::size(), and toString().

                                                    {
    // check whether there any splits to perform
    if (myGeom.size()<3) {
        return false;
    }
    // ok, split
    NBNode *newFrom = myFrom;
    NBNode *myLastNode = myTo;
    NBNode *newTo = 0;
    NBEdge *currentEdge = this;
    for (int i=1; i<(int) myGeom.size()-1; i++) {
        // build the node first
        if (i!=myGeom.size()-2) {
            std::string nodename = myID + "_in_between#" + toString(i);
            if (!nc.insert(nodename, myGeom[i])) {
                throw ProcessError("Error on adding in-between node '" + nodename + "'.");
            }
            newTo = nc.retrieve(nodename);
        } else {
            newTo = myLastNode;
        }
        if (i==1) {
            currentEdge->myTo->removeIncoming(this);
            currentEdge->myTo = newTo;
            newTo->addIncomingEdge(currentEdge);
        } else {
            std::string edgename = myID + "[" + toString(i-1) + "]";
            currentEdge = new NBEdge(edgename, newFrom, newTo, myType, mySpeed, (unsigned int) myLanes.size(),
                                     myPriority, myLaneSpreadFunction);
            if (!ec.insert(currentEdge, true)) {
                throw ProcessError("Error on adding splitted edge '" + edgename + "'.");
            }
        }
        newFrom = newTo;
    }
    myGeom.clear();
    myGeom.push_back(myFrom->getPosition());
    myGeom.push_back(myTo->getPosition());
    myStep = INIT;
    return true;
}

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

Returns the node at the given edges length (using an epsilon) 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 1328 of file NBEdge.cpp.

References myFrom, myLength, and myTo.

                                                                   {
    // return the from-node when the position is at the begin of the edge
    if (pos<tolerance) {
        return myFrom;
    }
    // return the to-node when the position is at the end of the edge
    if (pos>myLength-tolerance) {
        return myTo;
    }
    return 0;
}

SUMOReal NBEdge::width

(

)

const

Definition at line 1606 of file NBEdge.cpp.

References myLanes, SUMO_const_laneOffset, SUMO_const_laneWidth, and SUMOReal.

                    {
    return (SUMOReal) myLanes.size() * SUMO_const_laneWidth + (SUMOReal)(myLanes.size()-1) * SUMO_const_laneOffset;
}

void NBEdge::writeLane	(	OutputDevice &	into,
		NBEdge::Lane &	lane,
		unsigned int	index
	)			const [private]

writes information about the described lane into the given stream

Definition at line 649 of file NBEdge.cpp.

References NBEdge::Lane::allowed, getVehicleClassName(), myID, myLength, myLoadedLength, NBEdge::Lane::notAllowed, NBEdge::Lane::preferred, NBEdge::Lane::shape, NBEdge::Lane::speed, SUMOReal, toString(), and WRITE_WARNING.

Referenced by writeXMLStep1().

                                                                                {
    // output the lane's attributes
    into << "         <lane id=\"" << myID << '_' << index << "\"";
    // the first lane of an edge will be the depart lane
    if (index==0) {
        into << " depart=\"1\"";
    } else {
        into << " depart=\"0\"";
    }
    // write the list of allowed/disallowed vehicle classes
    std::vector<SUMOVehicleClass>::const_iterator i;
    bool hadOne = false;
    if (lane.allowed.size() > 0) {
        into << " allow=\"";
        for (i=lane.allowed.begin(); i!=lane.allowed.end(); ++i) {
            if (hadOne) {
                into << ' ';
            }
            into << getVehicleClassName(*i);
            hadOne = true;
        }
        into << '\"';
    }
    if (lane.notAllowed.size() > 0) {
        hadOne = false;
        into << " disallow=\"";
        for (i=lane.notAllowed.begin(); i!=lane.notAllowed.end(); ++i) {
            if (hadOne) {
                into << ' ';
            }
            into << getVehicleClassName(*i);
            hadOne = true;
        }
        into << '\"';
    }
    if (lane.preferred.size() > 0) {
        hadOne = false;
        into << "\" prefer=\"";
        for (i=lane.preferred.begin(); i!=lane.preferred.end(); ++i) {
            if (hadOne) {
                into << ' ';
            }
            into << getVehicleClassName(*i);
            hadOne = true;
        }
        into << '\"';
    }
    // some further information
    if (lane.speed==0) {
        WRITE_WARNING("Lane #" + toString(index) + " of edge '" + myID + "' has a maximum velocity of 0.");
    } else if (lane.speed<0) {
        throw ProcessError("Negative velocity (" + toString(lane.speed) + " on edge '" + myID + "' lane#" + toString(index) + ".");

    }
    SUMOReal length = myLength;
    if (myLoadedLength>0) {
        length = myLoadedLength;
    }
    if (length<=0) {
        length = (SUMOReal) .1;
    }
    into << " maxspeed=\"" << lane.speed << "\" length=\"" << length << "\"";
    into << " shape=\"" << lane.shape << "\"/>\n";
}

void NBEdge::writeLanesPlain

(

OutputDevice &

into

)

Definition at line 924 of file NBEdge.cpp.

References NBEdge::Lane::allowed, getVehicleClassName(), myLanes, and NBEdge::Lane::notAllowed.

Referenced by NBEdgeCont::savePlain().

                                          {
    for (unsigned int i=0; i<myLanes.size(); ++i) {
        into << "      <lane id=\"" << i << "\"";
        const Lane &lane = myLanes[i];
        // write allowed lanes
        if (lane.allowed.size()!=0) {
            bool hadOne = false;
            into << " allow=\"";
            std::vector<SUMOVehicleClass>::const_iterator i;
            for (i=lane.allowed.begin(); i!=lane.allowed.end(); ++i) {
                if (hadOne) {
                    into << ' ';
                }
                into << getVehicleClassName(*i);
                hadOne = true;
            }
            into << "\"";
        }
        if (lane.notAllowed.size()!=0) {
            bool hadOne = false;
            into << " disallow=\"";
            std::vector<SUMOVehicleClass>::const_iterator i;
            for (i=lane.notAllowed.begin(); i!=lane.notAllowed.end(); ++i) {
                if (hadOne) {
                    into << ' ';
                }
                into << getVehicleClassName(*i);
                hadOne = true;
            }
            into << "\"";
        }
        into << "/>\n";
    }
}

void NBEdge::writeSingleSucceeding	(	OutputDevice &	into,
		const NBEdge::Connection &	c,
		bool	includeInternal
	)			[private]

Definition at line 841 of file NBEdge.cpp.

References NBEdge::Connection::fromLane, NBNode::getCrossingPosition(), getID(), NBNode::getInternalLaneID(), NBNode::getMMLDirection(), NBEdge::Connection::mayDefinitelyPass, MMLDIR_LEFT, MMLDIR_PARTLEFT, MMLDIR_PARTRIGHT, MMLDIR_RIGHT, MMLDIR_STRAIGHT, MMLDIR_TURN, NBNode::mustBrake(), myAmInnerEdge, myTo, NBNode::stateCode(), NBEdge::Connection::tlID, NBEdge::Connection::tlLinkNo, NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

Referenced by writeSucceeding().

                                                                                                 {
    // check whether the connected lane is invalid
    //  (should not happen; this is an artefact left from previous versions)
    if (c.toEdge==0) {
        into << "      <succlane lane=\"SUMO_NO_DESTINATION\""; // !!! check dummy values
        if (c.tlID!="") {
            into << " tl=\"" << c.tlID << "\"";
            into << " linkno=\"" << c.tlLinkNo << "\"";
        }
        into << " yield=\"1\" " << "dir=\"s\" state=\"O\"/>\n"; // !!! check dummy values
        return;
    }
    // write the id
    into << "      <succlane lane=\"" << c.toEdge->getID() << '_' << c.toLane << '\"'; // !!! classe LaneEdge mit getLaneID
    if (includeInternal) {
        into << " via=\"" << myTo->getInternalLaneID(this, c.fromLane, c.toEdge, c.toLane) << "_0\"";
    }
    // set information about the controlling tl if any
    if (c.tlID!="") {
        into << " tl=\"" << c.tlID << "\"";
        into << " linkno=\"" << c.tlLinkNo << "\"";
    }
    // write information whether the connection yields
    if ((myAmInnerEdge||!myTo->mustBrake(this, c.toEdge, c.toLane)) || c.mayDefinitelyPass) {
        into << " yield=\"0\"";
    } else {
        into << " yield=\"1\"";
    }
    // write the direction information
    NBMMLDirection dir = myTo->getMMLDirection(this, c.toEdge);
    into << " dir=\"";
    switch (dir) {
    case MMLDIR_STRAIGHT:
        into << "s";
        break;
    case MMLDIR_LEFT:
        into << "l";
        break;
    case MMLDIR_RIGHT:
        into << "r";
        break;
    case MMLDIR_TURN:
        into << "t";
        break;
    case MMLDIR_PARTLEFT:
        into << "L";
        break;
    case MMLDIR_PARTRIGHT:
        into << "R";
        break;
    default:
        // should not happen
        assert(false);
        break;
    }
    into << "\" ";
    // write the state information
    if (c.tlID!="") {
        into << "state=\"t";
    } else {
        into << "state=\"" << myTo->stateCode(this, c.toEdge, c.toLane, c.mayDefinitelyPass);
    }
    if (myTo->getCrossingPosition(this, c.fromLane, c.toEdge, c.toLane).first>=0) {
        into << "\" int_end=\"x";
    }

    // close
    into << "\"/>\n";
}

void NBEdge::writeSucceeding	(	OutputDevice &	into,
		unsigned int	lane,
		bool	includeInternal
	)			[private]

Definition at line 822 of file NBEdge.cpp.

References NBNode::getID(), myConnections, myID, myTo, and writeSingleSucceeding().

Referenced by writeXMLStep2().

                                                                                   {
    into << "   <succ edge=\"" << myID << "\" lane=\"" << myID << "_" << lane << "\" junction=\"" << myTo->getID() << "\">\n";
    // output list of connected lanes
    unsigned int count = 0;
    for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
        if ((*i).fromLane==lane) {
            writeSingleSucceeding(into, *i, includeInternal);
            ++count;
        }
    }
    // the lane may be unconnented; output information about being invalid
    if (count==0) {
        into << "      <succlane lane=\"SUMO_NO_DESTINATION\" yield=\"1\"/>\n";
    }
    into << "   </succ>\n\n";
}

void NBEdge::writeXMLStep1

(

OutputDevice &

into

)

writes the edge definition with lanes and connected edges into the given stream

Definition at line 598 of file NBEdge.cpp.

References getConnectedSorted(), NBNode::getID(), getTurnDestination(), isMacroscopicConnector(), myAmInnerEdge, myConnections, myFrom, myID, myLanes, myPriority, myTo, myType, and writeLane().

                                        {
    // write the edge's begin
    into << "   <edge id=\"" << myID <<
    "\" from=\"" << myFrom->getID() <<
    "\" to=\"" << myTo->getID() <<
    "\" priority=\"" << myPriority <<
    "\" type=\"" << myType;
    if (isMacroscopicConnector()) {
        into << "\" function=\"connector";
    } else {
        into << "\" function=\"normal";
    }
    if (myAmInnerEdge) {
        into << "\" inner=\"x";
    }
    into << "\">\n";
    // write the lanes
    into << "      <lanes>\n";
    for (unsigned int i=0; i<(unsigned int) myLanes.size(); i++) {
        writeLane(into, myLanes[i], i);
    }
    into << "      </lanes>\n";
    // write the list of connected edges
    const std::vector<NBEdge*> *tmp = getConnectedSorted();
    std::vector<NBEdge*> sortedConnected = *tmp;
    if (getTurnDestination()!=0) {
        sortedConnected.push_back(getTurnDestination());
    }
    delete tmp;
    for (std::vector<NBEdge*>::iterator l=sortedConnected.begin(); l!=sortedConnected.end(); l++) {
        LaneVector lanes;
        for (std::vector<Connection>::const_iterator i=myConnections.begin(); i!=myConnections.end(); ++i) {
            if ((*i).toEdge==*l && find(lanes.begin(), lanes.end(), (*i).fromLane)==lanes.end()) {
                lanes.push_back((*i).fromLane);
            }
        }
    }
    // close the edge
    into << "   </edge>\n\n";
}

void NBEdge::writeXMLStep2	(	OutputDevice &	into,
		bool	includeInternal
	)

writes the succeeding lane information

Definition at line 641 of file NBEdge.cpp.

References myLanes, and writeSucceeding().

                                                              {
    for (unsigned int i=0; i<myLanes.size(); i++) {
        writeSucceeding(into, i, includeInternal);
    }
}

---

Friends And Related Function Documentation

friend class NBEdgeCont [friend]

Definition at line 670 of file NBEdge.h.

friend class NBEdgeSuccessorBuilder [friend]

friend class used for the computation of connections to following edges

Definition at line 668 of file NBEdge.h.

---

Field Documentation

bool NBEdge::myAmInnerEdge [private]

Information whether this is a junction-inner edge.

Definition at line 931 of file NBEdge.h.

Referenced by isInnerEdge(), setIsInnerEdge(), writeSingleSucceeding(), and writeXMLStep1().

bool NBEdge::myAmLeftHand [private]

Whether this edge is a left-hand edge.

Definition at line 918 of file NBEdge.h.

Referenced by divideOnEdges(), getCCWBoundaryLine(), getCWBoundaryLine(), laneOffset(), moveConnectionToLeft(), moveConnectionToRight(), and setLeftHanded().

bool NBEdge::myAmMacroscopicConnector [private]

Information whether this edge is a (macroscopic) connector.

Definition at line 934 of file NBEdge.h.

Referenced by isMacroscopicConnector(), and setAsMacroscopicConnector().

NBEdge* NBEdge::myAmTurningOf [private]

Was assigned as a turning edge of this one.

Definition at line 927 of file NBEdge.h.

Referenced by acceptBeingTurning().

SUMOReal NBEdge::myAmTurningWithAngle [private]

Was assigned as a turn with this angle.

Definition at line 925 of file NBEdge.h.

Referenced by acceptBeingTurning().

SUMOReal NBEdge::myAngle [private]

The angle of the edge.

Definition at line 881 of file NBEdge.h.

Referenced by getAngle(), getNormedAngle(), and init().

std::vector<Connection> NBEdge::myConnections [private]

List of connections to following edges.

See also:

Connection

Definition at line 892 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), append(), computeEdge2Edges(), computeLanes2Edges(), computeTurningDirections(), copyConnectionsFrom(), divideOnEdges(), expandableBy(), getConnectedEdges(), getConnectedSorted(), getConnectionLanes(), getConnections(), getConnectionsFromLane(), getMaxConnectedLane(), getMinConnectedLane(), hasConnectionTo(), hasSignalisedConnectionTo(), invalidateConnections(), isConnectedTo(), moveConnectionToLeft(), moveConnectionToRight(), recheckLanes(), removeFromConnections(), replaceInConnections(), setConnection(), setControllingTLInformation(), sortOutgoingLanesConnections(), writeSucceeding(), and writeXMLStep1().

NBNode* NBEdge::myFrom [private]

The source and the destination node.

Definition at line 875 of file NBEdge.h.

Referenced by computeEdgeShape(), computeLaneShapes(), decLaneNo(), getAngle(), getCCWBoundaryLine(), getCWBoundaryLine(), getFromNode(), getJunctionPriority(), getMaxLaneOffsetPositionAt(), getMinLaneOffsetPositionAt(), incLaneNo(), init(), isTurningDirectionAt(), reinit(), NBEdgeCont::retrievePossiblySplitted(), setJunctionPriority(), splitGeometry(), tryGetNodeAtPosition(), and writeXMLStep1().

int NBEdge::myFromJunctionPriority [private]

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

Definition at line 898 of file NBEdge.h.

Referenced by getJunctionPriority(), and setJunctionPriority().

Position2DVector NBEdge::myGeom [private]

The geometry for the edge.

Definition at line 904 of file NBEdge.h.

Referenced by addGeometryPoint(), append(), computeLaneShape(), computeLaneShapes(), getAngle(), getGeometry(), init(), isNearEnough2BeJoined2(), reinit(), reshiftPosition(), setGeometry(), and splitGeometry().

std::string NBEdge::myID [private]

The id of the edge.

Definition at line 869 of file NBEdge.h.

Referenced by getID(), getLaneID(), init(), setConnection(), splitGeometry(), writeLane(), writeSucceeding(), and writeXMLStep1().

std::vector<Lane> NBEdge::myLanes [private]

Lane information.

See also:

Lane

Definition at line 912 of file NBEdge.h.

Referenced by allowVehicleClass(), append(), appendTurnaround(), computeEdgeShape(), computeLaneShape(), computeLaneShapes(), decLaneNo(), disallowVehicleClass(), dismissVehicleClassInformation(), divideOnEdges(), expandableBy(), getAllowedVehicleClasses(), getCCWBoundaryLine(), getCWBoundaryLine(), getLaneID(), getLaneShape(), getLaneSpeed(), getMaxLaneOffset(), getMaxLaneOffsetPositionAt(), getMinLaneOffsetPositionAt(), getNoLanes(), hasRestrictions(), incLaneNo(), init(), laneOffset(), preferVehicleClass(), preparePriorities(), recheckLanes(), reshiftPosition(), setConnection(), setControllingTLInformation(), setLaneSpeed(), splitGeometry(), width(), writeLanesPlain(), writeXMLStep1(), and writeXMLStep2().

LaneSpreadFunction NBEdge::myLaneSpreadFunction [private]

The information about how to spread the lanes.

Definition at line 907 of file NBEdge.h.

Referenced by getLaneSpreadFunction(), laneOffset(), reinit(), setLaneSpreadFunction(), and splitGeometry().

SUMOReal NBEdge::myLength [private]

The length of the edge.

Definition at line 878 of file NBEdge.h.

Referenced by append(), computeEdgeShape(), getLength(), init(), tryGetNodeAtPosition(), and writeLane().

SUMOReal NBEdge::myLoadedLength [private]

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

Definition at line 915 of file NBEdge.h.

Referenced by reinit(), setLoadedLength(), and writeLane().

int NBEdge::myPriority [private]

The priority of the edge.

Definition at line 884 of file NBEdge.h.

Referenced by getPriority(), reinit(), splitGeometry(), and writeXMLStep1().

SUMOReal NBEdge::mySpeed [private]

The maximal speed.

Definition at line 887 of file NBEdge.h.

Referenced by expandableBy(), getSpeed(), incLaneNo(), init(), reinit(), and splitGeometry().

EdgeBuildingStep NBEdge::myStep [private]

The building step.

See also:

EdgeBuildingStep

Definition at line 866 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), addLane2LaneConnection(), append(), computeEdge2Edges(), computeLanes2Edges(), copyConnectionsFrom(), expandableBy(), getStep(), invalidateConnections(), lanesWereAssigned(), markAsInLane2LaneState(), recheckLanes(), remapConnections(), setConnection(), and splitGeometry().

std::vector<TLSDisabledConnection> NBEdge::myTLSDisabledConnections [private]

Definition at line 942 of file NBEdge.h.

Referenced by disableConnection4TLS(), mayBeTLSControlled(), and setControllingTLInformation().

NBNode * NBEdge::myTo [private]

Definition at line 875 of file NBEdge.h.

Referenced by addEdge2EdgeConnection(), addLane2LaneConnection(), append(), appendTurnaround(), computeEdge2Edges(), computeEdgeShape(), computeLaneShapes(), computeTurningDirections(), decLaneNo(), getAngle(), getConnectedSorted(), getToNode(), init(), isTurningDirectionAt(), markAsInLane2LaneState(), preparePriorities(), reinit(), NBEdgeCont::retrievePossiblySplitted(), sortOutgoingLanesConnections(), splitGeometry(), tryGetNodeAtPosition(), writeSingleSucceeding(), writeSucceeding(), and writeXMLStep1().

int NBEdge::myToJunctionPriority [private]

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

Definition at line 901 of file NBEdge.h.

Referenced by getJunctionPriority(), and setJunctionPriority().

NBEdge* NBEdge::myTurnDestination [private]

The turn destination edge.

Definition at line 895 of file NBEdge.h.

Referenced by append(), appendTurnaround(), computeTurningDirections(), getConnectedSorted(), getConnectionLanes(), getTurnDestination(), invalidateConnections(), isConnectedTo(), isTurningDirectionAt(), removeFromConnections(), replaceInConnections(), and setTurningDestination().

std::string NBEdge::myType [private]

The type of the edge.

Definition at line 872 of file NBEdge.h.

Referenced by getTypeID(), reinit(), splitGeometry(), and writeXMLStep1().

---

The documentation for this class was generated from the following files:

• NBEdge.h
• NBEdge.cpp