NBOwnTLDef Class Reference

#include <NBOwnTLDef.h>

Inheritance diagram for NBOwnTLDef:

---

Detailed Description

A traffic light logics which must be computed (only nodes/edges are given).

Definition at line 51 of file NBOwnTLDef.h.

Public Types
enum	TLColor {   TLCOLOR_RED, TLCOLOR_YELLOW, TLCOLOR_REDYELLOW, TLCOLOR_GREEN,   TLCOLOR_BLINK }
	An enumeration of possible tl-signal states. More...
Public Member Functions
void	addControlledInnerEdges (const std::vector< std::string > &edges) throw ()
	Adds the given ids into the list of edges not controlled by the tls.
NBTrafficLightLogic *	compute (const NBEdgeCont &ec, OptionsCont &oc) throw ()
	Computes the traffic light logic.
bool	foes (const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const throw ()
	Returns the information whether the given flows cross.
bool	forbids (const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority) const throw ()
	Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
const std::string &	getID () const throw ()
	Returns the id.
const EdgeVector &	getIncomingEdges () const throw ()
	Returns the list of incoming edges (must be build first).
bool	isLeftMover (const NBEdge *const from, const NBEdge *const to) const throw ()
	returns the information whether the given link is a left-mover
bool	mustBrake (const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, bool regardNonSignalisedLowerPriority) const throw ()
	Returns the information whether the described flow must let any other flow pass.
bool	mustBrake (const NBConnection &possProhibited, const NBConnection &possProhibitor, bool regardNonSignalisedLowerPriority) const throw ()
	Returns the information whether the described flow must let the other flow pass.
bool	mustBrake (const NBEdge *const from, const NBEdge *const to) const throw ()
	Returns the information whether the described flow must let any other flow pass.
	NBOwnTLDef (const std::string &id) throw ()
	Constructor.
	NBOwnTLDef (const std::string &id, NBNode *junction) throw ()
	Constructor.
	NBOwnTLDef (const std::string &id, const std::vector< NBNode * > &junctions) throw ()
	Constructor.
void	setParticipantsInformation () throw ()
	Builds the list of participating nodes/edges/links.
	~NBOwnTLDef () throw ()
	Destructor.
Access to controlled nodes
void	addNode (NBNode *node) throw ()
	Adds a node to the traffic light logic.
const std::vector< NBNode * > &	getNodes () const throw ()
	Returns the list of controlled nodes.
void	removeNode (NBNode *node) throw ()
	Removes the given node from the list of controlled nodes.
Public methods from NBTrafficLightDefinition-interface
void	remapRemoved (NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing) throw ()
	Replaces occurences of the removed edge in incoming/outgoing edges of all definitions.
void	setTLControllingInformation (const NBEdgeCont &ec) const throw ()
	Informs edges about being controlled by a tls.
Protected Member Functions
void	collectEdges () throw ()
	Build the list of participating edges.
unsigned int	computeBrakingTime (SUMOReal minDecel) const throw ()
	Computes the time vehicles may need to brake.
SUMOReal	computeUnblockedWeightedStreamNumber (const NBEdge *const e1, const NBEdge *const e2) throw ()
	Returns how many streams outgoing from the edges can pass the junction without being blocked.
std::pair< NBEdge *, NBEdge * >	getBestCombination (const std::vector< NBEdge * > &edges) throw ()
	Returns the combination of two edges from the given which has most unblocked streams.
std::pair< NBEdge *, NBEdge * >	getBestPair (std::vector< NBEdge * > &incoming) throw ()
	Returns the combination of two edges from the given which has most unblocked streams.
SUMOReal	getDirectionalWeight (NBMMLDirection dir) throw ()
	Returns the weight of a stream given its direction.
std::pair< unsigned int, unsigned int >	getSizes () const throw ()
	Returns a pair of <number participating lanes, number participating links>.
int	getToPrio (const NBEdge *const e) throw ()
	Returns this edge's priority at the node it ends at.
Protected methods from NBTrafficLightDefinition-interface
void	collectLinks () throw (ProcessError)
	Collects the links participating in this traffic light Exceptions: ProcessError  If a link could not be found.
void	collectNodes () throw ()
	Collects the nodes participating in this traffic light.
NBTrafficLightLogic *	myCompute (const NBEdgeCont &ec, unsigned int brakingTime) throw ()
	Computes the traffic light logic finally in dependence to the type.
void	replaceRemoved (NBEdge *removed, int removedLane, NBEdge *by, int byLane) throw ()
	Replaces a removed edge/lane.
Protected Attributes
std::vector< std::string >	myControlledInnerEdges
	List of inner edges that shall be controlled, though.
NBConnectionVector	myControlledLinks
	The list of controlled links.
std::vector< NBNode * >	myControlledNodes
	The container with participating nodes.
EdgeVector	myEdgesWithin
	The list of edges within the area controlled by the tls.
std::string	myID
	The name of the object.
EdgeVector	myIncomingEdges
	The list of incoming edges.
Data Structures
class	edge_by_incoming_priority_sorter
	Sorts edges by their priority within the node they end at. More...

---

Member Enumeration Documentation

enum NBTrafficLightDefinition::TLColor [inherited]

An enumeration of possible tl-signal states.

Enumerator:

TLCOLOR_RED	Signal shows red.
TLCOLOR_YELLOW	Signal shows yellow.
TLCOLOR_REDYELLOW	Signal shows red/yellow (unused).
TLCOLOR_GREEN	Signal shows green.
TLCOLOR_BLINK	Signal is blinking yellow.

Definition at line 76 of file NBTrafficLightDefinition.h.

                 {
        TLCOLOR_RED,
        TLCOLOR_YELLOW,
        TLCOLOR_REDYELLOW,
        TLCOLOR_GREEN,
        TLCOLOR_BLINK
    };

---

Constructor & Destructor Documentation

NBOwnTLDef::NBOwnTLDef	(	const std::string &	id,
		const std::vector< NBNode * > &	junctions
	)			throw ()

Constructor.

Parameters:

[in]	id	The id of the tls
[in]	junctions	Junctions controlled by this tls

Definition at line 50 of file NBOwnTLDef.cpp.

        : NBTrafficLightDefinition(id, junctions) {}

NBOwnTLDef::NBOwnTLDef	(	const std::string &	id,
		NBNode *	junction
	)			throw ()

Constructor.

Parameters:

[in]	id	The id of the tls
[in]	junction	The junction controlled by this tls

Definition at line 55 of file NBOwnTLDef.cpp.

        : NBTrafficLightDefinition(id, junction) {}

NBOwnTLDef::NBOwnTLDef

(

const std::string &

id

)

throw ()

Constructor.

Parameters:

[in]

id

The id of the tls

Definition at line 59 of file NBOwnTLDef.cpp.

        : NBTrafficLightDefinition(id) {}

NBOwnTLDef::~NBOwnTLDef

(

)

throw ()

Destructor.

Definition at line 63 of file NBOwnTLDef.cpp.

{}

---

Member Function Documentation

void NBTrafficLightDefinition::addControlledInnerEdges

(

const std::vector< std::string > &

edges

)

throw () [inherited]

Adds the given ids into the list of edges not controlled by the tls.

Parameters:

[in]

edges

The list of edge ids to add the inner edges to

Definition at line 368 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledInnerEdges.

Referenced by NIXMLNodesHandler::processTrafficLightDefinitions().

                                                                                           {
    copy(edges.begin(), edges.end(), back_inserter(myControlledInnerEdges));
}

void NBTrafficLightDefinition::addNode

(

NBNode *

node

)

throw () [inherited]

Adds a node to the traffic light logic.

Parameters:

[in]

node

A further node that shall be controlled by the tls

Definition at line 348 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by NBLoadedTLDef::addToSignalGroup(), and NIXMLNodesHandler::processTrafficLightDefinitions().

                                                      {
    if (std::find(myControlledNodes.begin(), myControlledNodes.end(), node)==myControlledNodes.end()) {
        myControlledNodes.push_back(node);
        std::sort(myControlledNodes.begin(), myControlledNodes.end(), NBNode::nodes_by_id_sorter());
        node->addTrafficLight(this);
    }
}

void NBTrafficLightDefinition::collectEdges

(

)

throw () [protected, inherited]

Build the list of participating edges.

Definition at line 121 of file NBTrafficLightDefinition.cpp.

References NBEdge::getID(), NBTrafficLightDefinition::myControlledInnerEdges, NBTrafficLightDefinition::myControlledNodes, NBTrafficLightDefinition::myEdgesWithin, and NBTrafficLightDefinition::myIncomingEdges.

Referenced by NBTrafficLightDefinition::setParticipantsInformation(), and setParticipantsInformation().

                                               {
    EdgeVector myOutgoing;
    // collect the edges from the participating nodes
    for (std::vector<NBNode*>::iterator i=myControlledNodes.begin(); i!=myControlledNodes.end(); i++) {
        const EdgeVector &incoming = (*i)->getIncomingEdges();
        copy(incoming.begin(), incoming.end(), back_inserter(myIncomingEdges));
        const EdgeVector &outgoing = (*i)->getOutgoingEdges();
        copy(outgoing.begin(), outgoing.end(), back_inserter(myOutgoing));
    }
    // check which of the edges are completely within the junction
    //  remove these edges from the list of incoming edges
    //  add them to the list of edges lying within the node
    for (EdgeVector::iterator j=myIncomingEdges.begin(); j!=myIncomingEdges.end();) {
        NBEdge *edge = *j;
        // an edge lies within the logic if it is outgoing as well as incoming
        EdgeVector::iterator k = find(myOutgoing.begin(), myOutgoing.end(), edge);
        if (k!=myOutgoing.end()) {
            if (find(myControlledInnerEdges.begin(), myControlledInnerEdges.end(), edge->getID())==myControlledInnerEdges.end()) {
                myEdgesWithin.push_back(edge);
                (*j)->setIsInnerEdge();
                j = myIncomingEdges.erase(j);
                continue;
            }
        }
        ++j;
    }
}

void NBOwnTLDef::collectLinks

(

)

throw (ProcessError) [protected, virtual]

Collects the links participating in this traffic light

Exceptions:

ProcessError

If a link could not be found.

See also:

NBTrafficLightDefinition::collectLinks

Reimplemented from NBTrafficLightDefinition.

Definition at line 343 of file NBOwnTLDef.cpp.

References NBEdge::Connection::fromLane, NBEdge::getConnectionsFromLane(), NBEdge::getID(), NBEdge::getNoLanes(), NBEdge::mayBeTLSControlled(), NBTrafficLightDefinition::myControlledLinks, NBTrafficLightDefinition::myIncomingEdges, NBEdge::Connection::toEdge, NBEdge::Connection::toLane, and toString().

Referenced by setParticipantsInformation().

                                             {
    // build the list of links which are controled by the traffic light
    for (EdgeVector::iterator i=myIncomingEdges.begin(); i!=myIncomingEdges.end(); i++) {
        NBEdge *incoming = *i;
        unsigned int noLanes = incoming->getNoLanes();
        for (unsigned int j=0; j<noLanes; j++) {
            std::vector<NBEdge::Connection> connected = incoming->getConnectionsFromLane(j);
            for (std::vector<NBEdge::Connection>::iterator k=connected.begin(); k!=connected.end(); k++) {
                const NBEdge::Connection &el = *k;
                if (incoming->mayBeTLSControlled(el.fromLane, el.toEdge, el.toLane)) {
                    if (el.toEdge!=0&&el.toLane>=(int) el.toEdge->getNoLanes()) {
                        throw ProcessError("Connection '" + incoming->getID() + "_" + toString(j) + "->" + el.toEdge->getID() + "_" + toString(el.toLane) + "' yields in a not existing lane.");
                    }
                    myControlledLinks.push_back(NBConnection(incoming, j, el.toEdge, el.toLane));
                }
            }
        }
    }
}

void NBOwnTLDef::collectNodes

(

)

throw () [protected]

Collects the nodes participating in this traffic light.

See also:

NBTrafficLightDefinition::collectNodes

Definition at line 339 of file NBOwnTLDef.cpp.

Referenced by setParticipantsInformation().

{}

NBTrafficLightLogic * NBTrafficLightDefinition::compute	(	const NBEdgeCont &	ec,
		OptionsCont &	oc
	)			throw () [inherited]

Computes the traffic light logic.

Does some initialisation at first, then calls myCompute to finally build the tl-logic

Parameters:

[in]	ec	The edge container in order to retrieve edge information
[in]	oc	The options container holding options needed during the building

Returns:

The built logic (may be 0)

Definition at line 88 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::computeBrakingTime(), Named::getID(), NBTrafficLightDefinition::myCompute(), NBTrafficLightDefinition::myIncomingEdges, and WRITE_WARNING.

Referenced by NBTrafficLightLogicCont::computeLogics().

                                                                               {
    // it is not really a traffic light if no incoming edge exists
    if (myIncomingEdges.size()==0) {
        WRITE_WARNING("The traffic light '" + getID() + "' has no incoming edges; it will not be build.");
        return 0;
    }
    // compute the time needed to brake
    unsigned int brakingTime = computeBrakingTime(oc.getFloat("min-decel"));
    // perform the computation depending on whether the traffic light
    //  definition was loaded or shall be computed new completely
    if (oc.isSet("traffic-light-yellow")) {
        brakingTime = oc.getInt("traffic-light-yellow");
    }
    return myCompute(ec, brakingTime);
}

unsigned int NBTrafficLightDefinition::computeBrakingTime

(

SUMOReal

minDecel

)

const throw () [protected, inherited]

Computes the time vehicles may need to brake.

This time depends on the maximum speed allowed on incoming junctions. It is computed as max_speed_allowed / minimum_vehicle_decleration

Definition at line 106 of file NBTrafficLightDefinition.cpp.

References NBContHelper::maxSpeed(), NBTrafficLightDefinition::myIncomingEdges, and SUMOReal.

Referenced by NBTrafficLightDefinition::compute().

                                                                            {
    SUMOReal vmax = NBContHelper::maxSpeed(myIncomingEdges);
    return (unsigned int)(vmax / minDecel);
}

SUMOReal NBOwnTLDef::computeUnblockedWeightedStreamNumber	(	const NBEdge *const	e1,
		const NBEdge *const	e2
	)			throw () [protected]

Returns how many streams outgoing from the edges can pass the junction without being blocked.

Parameters:

[in]	e1	The first edge
[in]	e2	The second edge

Todo:

There are several magic numbers; describe

Definition at line 90 of file NBOwnTLDef.cpp.

References NBTrafficLightDefinition::foes(), getDirectionalWeight(), and SUMOReal.

Referenced by getBestCombination().

                                                                                                         {
    SUMOReal val = 0;
    for (unsigned int e1l=0; e1l<e1->getNoLanes(); e1l++) {
        std::vector<NBEdge::Connection> approached1 = e1->getConnectionsFromLane(e1l);
        for (unsigned int e2l=0; e2l<e2->getNoLanes(); e2l++) {
            std::vector<NBEdge::Connection> approached2 = e2->getConnectionsFromLane(e2l);
            for (std::vector<NBEdge::Connection>::iterator e1c=approached1.begin(); e1c!=approached1.end(); ++e1c) {
                if (e1->getTurnDestination()==(*e1c).toEdge) {
                    continue;
                }
                for (std::vector<NBEdge::Connection>::iterator e2c=approached2.begin(); e2c!=approached2.end(); ++e2c) {
                    if (e2->getTurnDestination()==(*e2c).toEdge) {
                        continue;
                    }
                    if (!foes(e1, (*e1c).toEdge, e2, (*e2c).toEdge)) {
                        val += getDirectionalWeight(e1->getToNode()->getMMLDirection(e1, (*e1c).toEdge));
                        val += getDirectionalWeight(e2->getToNode()->getMMLDirection(e2, (*e2c).toEdge));
                    }
                }
            }
        }
    }
    return val;
}

bool NBTrafficLightDefinition::foes	(	const NBEdge *const	from1,
		const NBEdge *const	to1,
		const NBEdge *const	from2,
		const NBEdge *const	to2
	)			const throw () [inherited]

Returns the information whether the given flows cross.

Parameters:

[in]	from1	The starting edge of the first stream
[in]	to1	The ending edge of the first stream
[in]	from2	The starting edge of the second stream
[in]	to2	The ending edge of the second stream

Returns:

Whether both stream are foes (cross)

Definition at line 325 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by computeUnblockedWeightedStreamNumber().

                                                                                                   {
    if (to1==0||to2==0) {
        return false;
    }
    // retrieve both nodes (it is possible that a connection
    std::vector<NBNode*>::const_iterator incoming =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_incoming_finder(from1));
    std::vector<NBNode*>::const_iterator outgoing =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_outgoing_finder(to1));
    assert(incoming!=myControlledNodes.end());
    NBNode *incnode = *incoming;
    NBNode *outnode = *outgoing;
    if (incnode!=outnode) {
        return false;
    }
    return incnode->foes(from1, to1, from2, to2);
}

bool NBTrafficLightDefinition::forbids	(	const NBEdge *const	possProhibitorFrom,
		const NBEdge *const	possProhibitorTo,
		const NBEdge *const	possProhibitedFrom,
		const NBEdge *const	possProhibitedTo,
		bool	regardNonSignalisedLowerPriority
	)			const throw () [inherited]

Returns the information whether "prohibited" flow must let "prohibitor" flow pass.

Parameters:

[in]	possProhibitedFrom	The maybe prohibited connection's begin
[in]	possProhibitedTo	The maybe prohibited connection's end
[in]	possProhibitorFrom	The maybe prohibiting connection's begin
[in]	possProhibitorTo	The maybe prohibiting connection's end
[in]	regardNonSignalisedLowerPriority	Whether the right of way rules without traffic lights shall be regarded

Returns:

Whether the second flow prohibits the first one

See also:

forbids

Definition at line 248 of file NBTrafficLightDefinition.cpp.

References NBNode::foes(), NBNode::forbids(), and NBTrafficLightDefinition::myControlledNodes.

Referenced by NBTrafficLightDefinition::mustBrake(), and myCompute().

                                                                                       {
    if (possProhibitorFrom==0||possProhibitorTo==0||possProhibitedFrom==0||possProhibitedTo==0) {
        return false;
    }
    // retrieve both nodes
    std::vector<NBNode*>::const_iterator incoming =
        find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_incoming_finder(possProhibitorFrom));
    std::vector<NBNode*>::const_iterator outgoing =
        find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_outgoing_finder(possProhibitedTo));
    assert(incoming!=myControlledNodes.end());
    NBNode *incnode = *incoming;
    NBNode *outnode = *outgoing;
    EdgeVector::const_iterator i;
    if (incnode!=outnode) {
        // the links are located at different nodes
        const EdgeVector &ev1 = possProhibitedTo->getConnectedEdges();
        // go through the following edge,
        //  check whether one of these connections is prohibited
        for (i=ev1.begin(); i!=ev1.end(); ++i) {
            std::vector<NBNode*>::const_iterator outgoing2 =
                find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_outgoing_finder(*i));
            if (outgoing2==myControlledNodes.end()) {
                continue;
            }
            NBNode *outnode2 = *outgoing2;
            if (incnode!=outnode2) {
                continue;
            }
            bool ret1 = incnode->foes(possProhibitorTo, *i,
                                      possProhibitedFrom, possProhibitedTo);
            bool ret2 = incnode->forbids(possProhibitorFrom, possProhibitorTo,
                                         possProhibitedTo, *i,
                                         regardNonSignalisedLowerPriority);
            bool ret = ret1||ret2;
            if (ret) {
                return true;
            }
        }

        const EdgeVector &ev2 = possProhibitorTo->getConnectedEdges();
        // go through the following edge,
        //  check whether one of these connections is prohibited
        for (i=ev2.begin(); i!=ev2.end(); ++i) {
            std::vector<NBNode*>::const_iterator incoming2 =
                find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_incoming_finder(possProhibitorTo));
            if (incoming2==myControlledNodes.end()) {
                continue;
            }
            NBNode *incnode2 = *incoming2;
            if (incnode2!=outnode) {
                continue;
            }
            bool ret1 = incnode2->foes(possProhibitorTo, *i,
                                       possProhibitedFrom, possProhibitedTo);
            bool ret2 = incnode2->forbids(possProhibitorTo, *i,
                                          possProhibitedFrom, possProhibitedTo,
                                          regardNonSignalisedLowerPriority);
            bool ret = ret1||ret2;
            if (ret) {
                return true;
            }
        }
        return false;
    }
    // both links are located at the same node
    //  check using this node's information
    return incnode->forbids(possProhibitorFrom, possProhibitorTo,
                            possProhibitedFrom, possProhibitedTo,
                            regardNonSignalisedLowerPriority);
}

std::pair< NBEdge *, NBEdge * > NBOwnTLDef::getBestCombination

(

const std::vector< NBEdge * > &

edges

)

throw () [protected]

Returns the combination of two edges from the given which has most unblocked streams.

Parameters:

[in]

edges

The list of edges to include in the computation

Returns:

The two edges for which the weighted number of unblocked streams is the highest

Definition at line 117 of file NBOwnTLDef.cpp.

References computeUnblockedWeightedStreamNumber(), GeomHelper::getMinAngleDiff(), and SUMOReal.

Referenced by getBestPair().

                                                                      {
    std::pair<NBEdge*, NBEdge*> bestPair(0,0);
    SUMOReal bestValue = -1;
    for (std::vector<NBEdge*>::const_iterator i=edges.begin(); i!=edges.end(); ++i) {
        for (std::vector<NBEdge*>::const_iterator j=i+1; j!=edges.end(); ++j) {
            SUMOReal value = computeUnblockedWeightedStreamNumber(*i, *j);
            if (value>bestValue) {
                bestValue = value;
                bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
            } else if (value==bestValue) {
                SUMOReal ca = GeomHelper::getMinAngleDiff((*i)->getAngle(*(*i)->getToNode()), (*j)->getAngle(*(*j)->getToNode()));
                SUMOReal oa = GeomHelper::getMinAngleDiff(bestPair.first->getAngle(*bestPair.first->getToNode()), bestPair.second->getAngle(*bestPair.second->getToNode()));
                if (oa<ca) {
                    bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
                }
            }
        }
    }
    return bestPair;
}

std::pair< NBEdge *, NBEdge * > NBOwnTLDef::getBestPair

(

std::vector< NBEdge * > &

incoming

)

throw () [protected]

Returns the combination of two edges from the given which has most unblocked streams.

The chosen edges are removed from the given vector

Parameters:

in,changed]

incoming The list of edges which are participating in the logic

Returns:

The two edges for which the weighted number of unblocked streams is the highest

Definition at line 140 of file NBOwnTLDef.cpp.

References getBestCombination(), and getToPrio().

Referenced by myCompute().

                                                            {
    if (incoming.size()==1) {
        // only one there - return the one
        std::pair<NBEdge*, NBEdge*> ret(*incoming.begin(), 0);
        incoming.clear();
        return ret;
    }
    // determine the best combination
    //  by priority, first
    std::vector<NBEdge*> used;
    std::sort(incoming.begin(), incoming.end(), edge_by_incoming_priority_sorter());
    used.push_back(*incoming.begin()); // the first will definitely be used
    // get the ones with the same priority
    int prio = getToPrio(*used.begin());
    for (std::vector<NBEdge*>::iterator i=incoming.begin()+1; i!=incoming.end()&&prio!=getToPrio(*i); ++i) {
        used.push_back(*i);
    }
    //  if there only lower priorised, use these, too
    if (used.size()<2) {
        used = incoming;
    }
    std::pair<NBEdge*, NBEdge*> ret = getBestCombination(used);
    incoming.erase(find(incoming.begin(), incoming.end(), ret.first));
    incoming.erase(find(incoming.begin(), incoming.end(), ret.second));
    return ret;
}

SUMOReal NBOwnTLDef::getDirectionalWeight

(

NBMMLDirection

dir

)

throw () [protected]

Returns the weight of a stream given its direction.

Parameters:

[in]

dir

The direction of the stream

Returns:

This stream's weight

Todo:

There are several magic numbers; describe

Definition at line 73 of file NBOwnTLDef.cpp.

References MMLDIR_LEFT, MMLDIR_NODIR, MMLDIR_PARTLEFT, MMLDIR_PARTRIGHT, MMLDIR_RIGHT, MMLDIR_STRAIGHT, and MMLDIR_TURN.

Referenced by computeUnblockedWeightedStreamNumber().

                                                           {
    switch (dir) {
    case MMLDIR_STRAIGHT:
    case MMLDIR_PARTLEFT:
    case MMLDIR_PARTRIGHT:
        return 2.;
    case MMLDIR_LEFT:
    case MMLDIR_RIGHT:
        return .5;
    case MMLDIR_NODIR:
    case MMLDIR_TURN:
        return 0;
    }
    return 0;
}

const std::string& Named::getID

(

)

const throw () [inline, inherited]

Returns the id.

Returns:

The stored id

Definition at line 59 of file Named.h.

References Named::myID.

Referenced by RORouteDef_Alternatives::addAlternative(), MSRouteProbe::addRoute(), MSEmitter::MSEmitter_FileTriggeredChild::buildAndScheduleFlowVehicle(), MSCalibrator::MSCalibrator_FileTriggeredChild::buildAndScheduleFlowVehicle(), RORouteDef_Complete::buildCurrentRoute(), ODDistrictHandler::closeDistrict(), NBTrafficLightDefinition::collectLinks(), NBTrafficLightDefinition::compute(), GUIPointOfInterest::drawGL(), MSInductLoop::enterDetectorByMove(), MSVTypeProbe::execute(), MSNet::getBusStopID(), GUITriggeredRerouter::getMicrosimID(), GUIPointOfInterest::getMicrosimID(), GUILaneSpeedTrigger::getMicrosimID(), GUIInductLoop::MyWrapper::getMicrosimID(), GUIEmitter::getMicrosimID(), GUIBusStop::getMicrosimID(), GUI_E2_ZS_Collector::MyWrapper::getMicrosimID(), traci::TraCIServer::handlePoiDomain(), RORDLoader_SUMOBase::myCharacters(), myCompute(), NBLoadedTLDef::myCompute(), MSTriggeredRerouter::myStartElement(), MSLaneSpeedTrigger::myStartElement(), MSEmitter::MSEmitter_FileTriggeredChild::myStartElement(), MSCalibrator::MSCalibrator_FileTriggeredChild::myStartElement(), NBLoadedTLDef::SignalGroup::patchTYellow(), TraCIServerAPI_Vehicle::processGet(), MSVehicle::replaceRoute(), MSVehicle::saveState(), setTLControllingInformation(), NBLoadedTLDef::setTLControllingInformation(), RORDLoader_SUMOBase::startRoute(), GUIEmitter::GUIEmitterChild_UserTriggeredChild::wrappedExecute(), NBTrafficLightLogic::writeXML(), MSRouteProbe::writeXMLOutput(), MSInductLoop::writeXMLOutput(), MSE2Collector::writeXMLOutput(), and MSVehicle::~MSVehicle().

                                           {
        return myID;
    }

const EdgeVector & NBTrafficLightDefinition::getIncomingEdges

(

)

const throw () [inherited]

Returns the list of incoming edges (must be build first).

Returns:

The edges which are incoming into the tls

Definition at line 374 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myIncomingEdges.

Referenced by myCompute().

                                                         {
    return myIncomingEdges;
}

const std::vector<NBNode*>& NBTrafficLightDefinition::getNodes

(

)

const throw () [inline, inherited]

Returns the list of controlled nodes.

Returns:

Controlled nodes

Definition at line 147 of file NBTrafficLightDefinition.h.

References NBTrafficLightDefinition::myControlledNodes.

                                                       {
        return myControlledNodes;
    }

std::pair< unsigned int, unsigned int > NBTrafficLightDefinition::getSizes

(

)

const throw () [protected, inherited]

Returns a pair of <number participating lanes, number participating links>.

Returns:

The numbers of lanes and links controlled by this tls

Definition at line 180 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myIncomingEdges.

                                                 {
    unsigned int noLanes = 0;
    unsigned int noLinks = 0;
    for (EdgeVector::const_iterator i=myIncomingEdges.begin(); i!=myIncomingEdges.end(); i++) {
        unsigned int noLanesEdge = (*i)->getNoLanes();
        for (unsigned int j=0; j<noLanesEdge; j++) {
            assert((*i)->getConnectionsFromLane(j).size()!=0);
            noLinks += (unsigned int)(*i)->getConnectionsFromLane(j).size();
        }
        noLanes += noLanesEdge;
    }
    return std::pair<unsigned int, unsigned int>(noLanes, noLinks);
}

int NBOwnTLDef::getToPrio

(

const NBEdge *const

e

)

throw () [protected]

Returns this edge's priority at the node it ends at.

Parameters:

[in]

e

The edge to ask for his priority

Returns:

The edge's priority at his destination node

Definition at line 67 of file NBOwnTLDef.cpp.

Referenced by getBestPair().

                                                    {
    return e->getJunctionPriority(e->getToNode());
}

bool NBTrafficLightDefinition::isLeftMover	(	const NBEdge *const	from,
		const NBEdge *const	to
	)			const throw () [inherited]

returns the information whether the given link is a left-mover

Parameters:

[in]	from	The connection's start edge
[in]	to	The connection's end edge

Returns:

Whether the connection is a left-mover

Definition at line 196 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by myCompute().

                                                                                                     {
    // the destination edge may be unused
    if (to==0) {
        return false;
    }
    // get the node which is holding this connection
    std::vector<NBNode*>::const_iterator i =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_incoming_finder(from));
    assert(i!=myControlledNodes.end());
    NBNode *node = *i;
    return node->isLeftMover(from, to);
}

bool NBTrafficLightDefinition::mustBrake	(	const NBEdge *const	possProhibitedFrom,
		const NBEdge *const	possProhibitedTo,
		const NBEdge *const	possProhibitorFrom,
		const NBEdge *const	possProhibitorTo,
		bool	regardNonSignalisedLowerPriority
	)			const throw () [inherited]

Returns the information whether the described flow must let any other flow pass.

Parameters:

[in]	possProhibitedFrom	The maybe prohibited connection's begin
[in]	possProhibitedTo	The maybe prohibited connection's end
[in]	possProhibitorFrom	The maybe prohibiting connection's begin
[in]	possProhibitorTo	The maybe prohibiting connection's end
[in]	regardNonSignalisedLowerPriority	Whether the right of way rules without traffic lights shall be regarded

Returns:

Whether the second flow prohibits the first one

See also:

forbids

Definition at line 226 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::forbids().

                                                                                         {
    return forbids(possProhibitorFrom, possProhibitorTo,
                   possProhibitedFrom, possProhibitedTo,
                   regardNonSignalisedLowerPriority);
}

bool NBTrafficLightDefinition::mustBrake	(	const NBConnection &	possProhibited,
		const NBConnection &	possProhibitor,
		bool	regardNonSignalisedLowerPriority
	)			const throw () [inherited]

Returns the information whether the described flow must let the other flow pass.

Parameters:

[in]	possProhibited	The maybe prohibited connection
[in]	possProhibitor	The maybe prohibiting connection
[in]	regardNonSignalisedLowerPriority	Whether the right of way rules without traffic lights shall be regarded

Returns:

Whether the second flow prohibits the first one

See also:

forbids

Definition at line 238 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::forbids().

                                                                                         {
    return forbids(possProhibitor.getFrom(), possProhibitor.getTo(),
                   possProhibited.getFrom(), possProhibited.getTo(),
                   regardNonSignalisedLowerPriority);
}

bool NBTrafficLightDefinition::mustBrake	(	const NBEdge *const	from,
		const NBEdge *const	to
	)			const throw () [inherited]

Returns the information whether the described flow must let any other flow pass.

If the from/to connection passes only one junction (from is incoming into same node as to outgoes from) the node is asked whether the flow must brake- Otherwise true is returned (recheck!) "from" must be an incoming edge into one of the participating nodes!

Parameters:

[in]	from	The connection's start edge
[in]	to	The connection's end edge

Returns:

Whether the described connection must brake (has higher priorised foes)

Definition at line 212 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by NBLoadedTLDef::mustBrake().

                                                                                                    {
    std::vector<NBNode*>::const_iterator i =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_incoming_finder(from));
    assert(i!=myControlledNodes.end());
    NBNode *node = *i;
    if (!node->hasOutgoing(to)) {
        return true; // !!!
    }
    return node->mustBrake(from, to, -1);
}

NBTrafficLightLogic * NBOwnTLDef::myCompute	(	const NBEdgeCont &	ec,
		unsigned int	brakingTime
	)			throw () [protected, virtual]

Computes the traffic light logic finally in dependence to the type.

Parameters:

[in]	ec	The edge container
[in]	brakingTime	Duration a vehicle needs for braking in front of the tls

Returns:

The computed logic

See also:

NBTrafficLightDefinition::myCompute

Implements NBTrafficLightDefinition.

Definition at line 169 of file NBOwnTLDef.cpp.

References NBTrafficLightLogic::addStep(), NBTrafficLightDefinition::forbids(), getBestPair(), NBEdge::getConnectionsFromLane(), NBTrafficLightLogic::getDuration(), Named::getID(), NBTrafficLightDefinition::getIncomingEdges(), OptionsCont::getInt(), NBEdge::getNoLanes(), OptionsCont::getOptions(), NBEdge::getToNode(), NBTrafficLightDefinition::isLeftMover(), NBEdge::isTurningDirectionAt(), and NBEdge::mayBeTLSControlled().

                                                        {
    // build complete lists first
    const EdgeVector &incoming = getIncomingEdges();
    std::vector<NBEdge*> fromEdges, toEdges;
    std::vector<bool> isLeftMoverV, isTurnaround;
    unsigned int noLanesAll = 0;
    unsigned int noLinksAll = 0;
    for (unsigned int i1=0; i1<incoming.size(); i1++) {
        unsigned int noLanes = incoming[i1]->getNoLanes();
        noLanesAll += noLanes;
        for (unsigned int i2=0; i2<noLanes; i2++) {
            NBEdge *fromEdge = incoming[i1];
            std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
            noLinksAll += (unsigned int) approached.size();
            for (unsigned int i3=0; i3<approached.size(); i3++) {
                if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
                    --noLinksAll;
                    continue;
                }
                assert(i3<approached.size());
                NBEdge *toEdge = approached[i3].toEdge;
                fromEdges.push_back(fromEdge);
                //myFromLanes.push_back(i2);
                toEdges.push_back(toEdge);
                if (toEdge!=0) {
                    isLeftMoverV.push_back(
                        isLeftMover(fromEdge, toEdge)
                        ||
                        fromEdge->isTurningDirectionAt(fromEdge->getToNode(), toEdge));

                    isTurnaround.push_back(
                        fromEdge->isTurningDirectionAt(
                            fromEdge->getToNode(), toEdge));
                } else {
                    isLeftMoverV.push_back(true);
                    isTurnaround.push_back(true);
                }
            }
        }
    }

    NBTrafficLightLogic *logic = new NBTrafficLightLogic(getID(), "0", noLinksAll);
    std::vector<NBEdge*> toProc = incoming;
    // build all phases
    while (toProc.size()>0) {
        std::pair<NBEdge*, NBEdge*> chosen;
        if (incoming.size()==2) {
            chosen = std::pair<NBEdge*, NBEdge*>(toProc[0], 0);
            toProc.erase(toProc.begin());
        } else {
            chosen = getBestPair(toProc);
        }
        unsigned int pos = 0;
        unsigned int duration = 31;
        if (OptionsCont::getOptions().isSet("traffic-light-green")) {
            duration = OptionsCont::getOptions().getInt("traffic-light-green");
        }
        std::string state((size_t) noLinksAll, 'o');
        // plain straight movers
        for (unsigned int i1=0; i1<(unsigned int) incoming.size(); ++i1) {
            NBEdge *fromEdge = incoming[i1];
            bool inChosen = fromEdge==chosen.first||fromEdge==chosen.second;//chosen.find(fromEdge)!=chosen.end();
            unsigned int noLanes = fromEdge->getNoLanes();
            for (unsigned int i2=0; i2<noLanes; i2++) {
                std::vector<NBEdge::Connection> approached = fromEdge->getConnectionsFromLane(i2);
                for (unsigned int i3=0; i3<approached.size(); ++i3) {
                    if (!fromEdge->mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
                        continue;
                    }
                    if (inChosen) {
                        state[pos] = 'G';
                    } else {
                        state[pos] = 'r';
                    }
                    ++pos;
                }
            }
        }
        // correct behaviour for those that are not in chosen, but may drive, though
        for (unsigned int i1=0; i1<pos; ++i1) {
            if (state[i1]=='G') {
                continue;
            }
            bool isForbidden = false;
            for (unsigned int i2=0; i2<pos&&!isForbidden; ++i2) {
                if (state[i2]=='G'&&!isTurnaround[i2]&&
                        (forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true)||forbids(fromEdges[i1], toEdges[i1], fromEdges[i2], toEdges[i2], true))) {
                    isForbidden = true;
                }
            }
            if (!isForbidden) {
                state[i1] = 'G';
            }
        }
        // correct behaviour for those that have to wait (mainly left-mover)
        bool haveForbiddenLeftMover = false;
        for (unsigned int i1=0; i1<pos; ++i1) {
            if (state[i1]!='G') {
                continue;
            }
            for (unsigned int i2=0; i2<pos; ++i2) {
                if ((state[i2]=='G'||state[i2]=='g')&&forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1], true)) {
                    state[i1] = 'g';
                    if (!isTurnaround[i1]) {
                        haveForbiddenLeftMover = true;
                    }
                }
            }
        }

        // add step
        logic->addStep(duration, state);

        if (brakingTime>0) {
            // build yellow (straight)
            duration = brakingTime;
            for (unsigned int i1=0; i1<pos; ++i1) {
                if (state[i1]!='G'&&state[i1]!='g') {
                    continue;
                }
                if ((state[i1]>='a'&&state[i1]<='z')&&haveForbiddenLeftMover) {
                    continue;
                }
                state[i1] = 'y';
            }
            // add step
            logic->addStep(duration, state);
        }

        if (haveForbiddenLeftMover) {
            // build left green
            duration = 6;
            for (unsigned int i1=0; i1<pos; ++i1) {
                if (state[i1]=='Y'||state[i1]=='y') {
                    state[i1] = 'r';
                    continue;
                }
                if (state[i1]=='g') {
                    state[i1] = 'G';
                }
            }
            // add step
            logic->addStep(duration, state);

            // build left yellow
            if (brakingTime>0) {
                duration = brakingTime;
                for (unsigned int i1=0; i1<pos; ++i1) {
                    if (state[i1]!='G'&&state[i1]!='g') {
                        continue;
                    }
                    state[i1] = 'y';
                }
                // add step
                logic->addStep(duration, state);
            }
        }
    }
    if (logic->getDuration()>0) {
        return logic;
    } else {
        delete logic;
        return 0;
    }

}

void NBOwnTLDef::remapRemoved	(	NBEdge *	removed,
		const EdgeVector &	incoming,
		const EdgeVector &	outgoing
	)			throw () [virtual]

Replaces occurences of the removed edge in incoming/outgoing edges of all definitions.

Parameters:

[in]	removed	The removed edge
[in]	incoming	The edges to use instead if an incoming edge was removed
[in]	outgoing	The edges to use instead if an outgoing edge was removed

See also:

NBTrafficLightDefinition::remapRemoved

Implements NBTrafficLightDefinition.

Definition at line 390 of file NBOwnTLDef.cpp.

                                                                 {}

void NBTrafficLightDefinition::removeNode

(

NBNode *

node

)

throw () [inherited]

Removes the given node from the list of controlled nodes.

Parameters:

[in]

node

The node that shall not be controlled by the tls any more

Definition at line 358 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

                                                         {
    std::vector<NBNode*>::iterator i = std::find(myControlledNodes.begin(), myControlledNodes.end(), node);
    if (i!=myControlledNodes.end()) {
        myControlledNodes.erase(i);
    }
    // !!! remove in node?
}

void NBOwnTLDef::replaceRemoved	(	NBEdge *	removed,
		int	removedLane,
		NBEdge *	by,
		int	byLane
	)			throw () [protected, virtual]

Replaces a removed edge/lane.

Parameters:

[in]	removed	The edge to replace
[in]	removedLane	The lane of this edge to replace
[in]	by	The edge to insert instead
[in]	byLane	This edge's lane to insert instead

See also:

NBTrafficLightDefinition::replaceRemoved

Implements NBTrafficLightDefinition.

Definition at line 395 of file NBOwnTLDef.cpp.

                                                                    {}

void NBOwnTLDef::setParticipantsInformation

(

)

throw () [virtual]

Builds the list of participating nodes/edges/links.

See also:

NBTrafficLightDefinition::setParticipantsInformation

Reimplemented from NBTrafficLightDefinition.

Definition at line 365 of file NBOwnTLDef.cpp.

References NBTrafficLightDefinition::collectEdges(), collectLinks(), and collectNodes().

                                               {
    // assign participating nodes to the request
    collectNodes();
    // collect the information about participating edges and links
    collectEdges();
    collectLinks();
}

void NBOwnTLDef::setTLControllingInformation

(

const NBEdgeCont &

ec

)

const throw () [virtual]

Informs edges about being controlled by a tls.

Parameters:

[in]

ec

The container of edges

See also:

NBTrafficLightDefinition::setTLControllingInformation

Implements NBTrafficLightDefinition.

Definition at line 375 of file NBOwnTLDef.cpp.

References NBConnection::getFrom(), NBConnection::getFromLane(), Named::getID(), NBConnection::getTo(), NBConnection::getToLane(), NBTrafficLightDefinition::myControlledLinks, and NBEdge::setControllingTLInformation().

                                                                        {
    // set the information about the link's positions within the tl into the
    //  edges the links are starting at, respectively
    unsigned int pos = 0;
    for (NBConnectionVector::const_iterator j=myControlledLinks.begin(); j!=myControlledLinks.end(); ++j) {
        const NBConnection &conn = *j;
        NBEdge *edge = conn.getFrom();
        if (edge->setControllingTLInformation(conn.getFromLane(), conn.getTo(), conn.getToLane(), getID(), pos)) {
            pos++;
        }
    }
}

---

Field Documentation

std::vector<std::string> NBTrafficLightDefinition::myControlledInnerEdges [protected, inherited]

List of inner edges that shall be controlled, though.

Definition at line 315 of file NBTrafficLightDefinition.h.

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

NBConnectionVector NBTrafficLightDefinition::myControlledLinks [protected, inherited]

The list of controlled links.

Definition at line 312 of file NBTrafficLightDefinition.h.

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

std::vector<NBNode*> NBTrafficLightDefinition::myControlledNodes [protected, inherited]

The container with participating nodes.

Definition at line 303 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::addNode(), NBTrafficLightDefinition::collectEdges(), NBLoadedTLDef::collectNodes(), NBTrafficLightDefinition::foes(), NBTrafficLightDefinition::forbids(), NBTrafficLightDefinition::getNodes(), NBTrafficLightDefinition::isLeftMover(), NBTrafficLightDefinition::mustBrake(), and NBTrafficLightDefinition::removeNode().

EdgeVector NBTrafficLightDefinition::myEdgesWithin [protected, inherited]

The list of edges within the area controlled by the tls.

Definition at line 309 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::collectEdges().

std::string Named::myID [protected, inherited]

The name of the object.

Definition at line 66 of file Named.h.

Referenced by RORouteDef_OrigDest::buildCurrentRoute(), RORouteDef_Complete::buildCurrentRoute(), RORouteDef_Alternatives::buildCurrentRoute(), and Named::getID().

EdgeVector NBTrafficLightDefinition::myIncomingEdges [protected, inherited]

The list of incoming edges.

Definition at line 306 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::collectEdges(), NBTrafficLightDefinition::collectLinks(), collectLinks(), NBLoadedTLDef::collectLinks(), NBTrafficLightDefinition::compute(), NBTrafficLightDefinition::computeBrakingTime(), NBTrafficLightDefinition::getIncomingEdges(), and NBTrafficLightDefinition::getSizes().

---

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

• NBOwnTLDef.h
• NBOwnTLDef.cpp