46 #ifdef CHECK_MEMORY_LEAKS
48 #endif // CHECK_MEMORY_LEAKS
55 const std::vector<NBNode*>& junctions,
SUMOTime offset,
99 for (
unsigned int e1l = 0; e1l < e1->
getNumLanes(); e1l++) {
101 for (
unsigned int e2l = 0; e2l < e2->
getNumLanes(); e2l++) {
103 for (std::vector<NBEdge::Connection>::iterator e1c = approached1.begin(); e1c != approached1.end(); ++e1c) {
107 for (std::vector<NBEdge::Connection>::iterator e2c = approached2.begin(); e2c != approached2.end(); ++e2c) {
111 if (!
foes(e1, (*e1c).toEdge, e2, (*e2c).toEdge)) {
123 std::pair<NBEdge*, NBEdge*>
125 std::pair<NBEdge*, NBEdge*> bestPair(static_cast<NBEdge*>(0), static_cast<NBEdge*>(0));
127 for (EdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
128 for (EdgeVector::const_iterator j = i + 1; j != edges.end(); ++j) {
130 if (value > bestValue) {
132 bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
133 }
else if (value == bestValue) {
135 const SUMOReal oa =
GeomHelper::getMinAngleDiff(bestPair.first->getAngleAtNode(bestPair.first->getToNode()), bestPair.second->getAngleAtNode(bestPair.second->getToNode()));
137 if (bestPair.first->getID() < (*i)->getID()) {
138 bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
140 }
else if (oa < ca) {
141 bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
150 std::pair<NBEdge*, NBEdge*>
152 if (incoming.size() == 1) {
154 std::pair<NBEdge*, NBEdge*> ret(*incoming.begin(),
static_cast<NBEdge*
>(0));
162 used.push_back(*incoming.begin());
165 for (EdgeVector::iterator i = incoming.begin() + 1; i != incoming.end() && prio !=
getToPrio(*i); ++i) {
169 if (used.size() < 2) {
173 incoming.erase(find(incoming.begin(), incoming.end(), ret.first));
174 incoming.erase(find(incoming.begin(), incoming.end(), ret.second));
181 unsigned int brakingTimeSeconds) {
187 std::vector<bool> isLeftMoverV, isTurnaround;
188 unsigned int noLanesAll = 0;
189 unsigned int noLinksAll = 0;
190 for (
unsigned int i1 = 0; i1 < incoming.size(); i1++) {
191 unsigned int noLanes = incoming[i1]->getNumLanes();
192 noLanesAll += noLanes;
193 for (
unsigned int i2 = 0; i2 < noLanes; i2++) {
194 NBEdge* fromEdge = incoming[i1];
196 noLinksAll += (
unsigned int) approached.size();
197 for (
unsigned int i3 = 0; i3 < approached.size(); i3++) {
198 if (!fromEdge->
mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
202 assert(i3 < approached.size());
203 NBEdge* toEdge = approached[i3].toEdge;
204 fromEdges.push_back(fromEdge);
206 toEdges.push_back(toEdge);
208 isLeftMoverV.push_back(
213 isTurnaround.push_back(
217 isLeftMoverV.push_back(
true);
218 isTurnaround.push_back(
true);
228 while (toProc.size() > 0) {
229 std::pair<NBEdge*, NBEdge*> chosen;
230 if (incoming.size() == 2) {
231 chosen = std::pair<NBEdge*, NBEdge*>(toProc[0],
static_cast<NBEdge*
>(0));
232 toProc.erase(toProc.begin());
236 unsigned int pos = 0;
237 std::string state((
size_t) noLinksAll,
'o');
239 for (
unsigned int i1 = 0; i1 < (
unsigned int) incoming.size(); ++i1) {
240 NBEdge* fromEdge = incoming[i1];
241 const bool inChosen = fromEdge == chosen.first || fromEdge == chosen.second;
242 const unsigned int numLanes = fromEdge->
getNumLanes();
243 for (
unsigned int i2 = 0; i2 < numLanes; i2++) {
245 for (
unsigned int i3 = 0; i3 < approached.size(); ++i3) {
246 if (!fromEdge->
mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
259 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
260 if (state[i1] ==
'G') {
263 bool isForbidden =
false;
264 for (
unsigned int i2 = 0; i2 < pos && !isForbidden; ++i2) {
265 if (state[i2] ==
'G' && !isTurnaround[i2] &&
266 (
forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1],
true) ||
forbids(fromEdges[i1], toEdges[i1], fromEdges[i2], toEdges[i2],
true))) {
275 bool haveForbiddenLeftMover =
false;
276 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
277 if (state[i1] !=
'G') {
280 for (
unsigned int i2 = 0; i2 < pos; ++i2) {
281 if ((state[i2] ==
'G' || state[i2] ==
'g') &&
forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1],
true)) {
283 if (!isTurnaround[i1]) {
284 haveForbiddenLeftMover =
true;
290 logic->
addStep(greenTime, state);
292 if (brakingTime > 0) {
294 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
295 if (state[i1] !=
'G' && state[i1] !=
'g') {
298 if ((state[i1] >=
'a' && state[i1] <=
'z') && haveForbiddenLeftMover) {
304 logic->
addStep(brakingTime, state);
307 if (haveForbiddenLeftMover) {
309 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
310 if (state[i1] ==
'Y' || state[i1] ==
'y') {
314 if (state[i1] ==
'g') {
319 logic->
addStep(leftTurnTime, state);
322 if (brakingTime > 0) {
323 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
324 if (state[i1] !=
'G' && state[i1] !=
'g') {
330 logic->
addStep(brakingTime, state);
335 if (totalDuration > 0) {
336 if (totalDuration > 3 * (greenTime + 2 * brakingTime + leftTurnTime)) {
The link is a partial left direction.
bool setControllingTLInformation(const NBConnection &c, const std::string &tlID)
Returns if the link could be set as to be controlled.
TrafficLightType myType
The algorithm type for the traffic light.
void collectAllLinks()
helper method for use in NBOwnTLDef and NBLoadedSUMOTLDef
A SUMO-compliant built logic for a traffic light.
const std::string & getProgramID() const
Returns the ProgramID.
The representation of a single edge during network building.
bool mayBeTLSControlled(int fromLane, NBEdge *toEdge, int toLane) const
The link is a 180 degree turn.
void collectNodes()
Collects the nodes participating in this traffic light.
std::string time2string(SUMOTime t)
The base class for traffic light logic definitions.
const EdgeVector & getIncomingEdges() const
Returns the list of incoming edges (must be build first)
bool isTurningDirectionAt(const NBNode *n, const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
std::vector< Connection > getConnectionsFromLane(unsigned int lane) const
Returns connections from a given lane.
SUMOTime myOffset
The offset in the program.
NBEdge * getFrom() const
returns the from-edge (start of the connection)
The link is a (hard) left direction.
#define WRITE_WARNING(msg)
std::pair< NBEdge *, NBEdge * > getBestPair(EdgeVector &incoming)
Returns the combination of two edges from the given which has most unblocked streams.
static OptionsCont & getOptions()
Retrieves the options.
LinkDirection
The different directions a link between two lanes may take (or a stream between two edges)...
The link is a straight direction.
const std::string & getID() const
Returns the id.
void collectEdges()
Build the list of participating edges.
void replaceRemoved(NBEdge *removed, int removedLane, NBEdge *by, int byLane)
Replaces a removed edge/lane.
std::pair< NBEdge *, NBEdge * > getBestCombination(const EdgeVector &edges)
Returns the combination of two edges from the given which has most unblocked streams.
unsigned int getNumLanes() const
Returns the number of lanes.
Storage for edges, including some functionality operating on multiple edges.
The link is a (hard) right direction.
The link is a partial right direction.
SUMOTime getDuration() const
Returns the duration of the complete cycle.
int getJunctionPriority(const NBNode *const node) const
Returns the junction priority (normalised for the node currently build)
SUMOReal computeUnblockedWeightedStreamNumber(const NBEdge *const e1, const NBEdge *const e2)
Returns how many streams outgoing from the edges can pass the junction without being blocked...
NBOwnTLDef(const std::string &id, const std::vector< NBNode * > &junctions, SUMOTime offset, TrafficLightType type)
Constructor.
NBNode * getToNode() const
Returns the destination node of the edge.
void setTLControllingInformation(const NBEdgeCont &ec) const
Informs edges about being controlled by a tls.
void collectLinks()
Collects the links participating in this traffic light If a link could not be found.
SUMOReal getDirectionalWeight(LinkDirection dir)
Returns the weight of a stream given its direction.
std::vector< NBEdge * > EdgeVector
NBTrafficLightLogic * myCompute(const NBEdgeCont &ec, unsigned int brakingTimeSeconds)
Computes the traffic light logic finally in dependence to the type.
static SUMOReal getMinAngleDiff(SUMOReal angle1, SUMOReal angle2)
Returns the minimum distance (clockwise/counter-clockwise) between both angles.
Represents a single node (junction) during network building.
bool forbids(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
NBEdge * getTurnDestination() const
bool isLeftMover(const NBEdge *const from, const NBEdge *const to) const
returns the information whether the given link is a left-mover
void addStep(SUMOTime duration, const std::string &state, int index=-1)
Adds a phase to the logic.
Sorts edges by their priority within the node they end at.
void setParticipantsInformation()
Builds the list of participating nodes/edges/links.
NBConnectionVector myControlledLinks
The list of controlled links.
int getToPrio(const NBEdge *const e)
Returns this edge's priority at the node it ends at.
void remapRemoved(NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing)
Replaces occurences of the removed edge in incoming/outgoing edges of all definitions.
The link has no direction (is a dead end link)
bool foes(const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const
Returns the information whether the given flows cross.
LinkDirection getDirection(const NBEdge *const incoming, const NBEdge *const outgoing) const
Returns the representation of the described stream's direction.