47 #ifdef CHECK_MEMORY_LEAKS
49 #endif // CHECK_MEMORY_LEAKS
56 const std::vector<NBNode*>& junctions,
SUMOTime offset,
59 myHaveSinglePhase(false)
66 myHaveSinglePhase(false)
73 myHaveSinglePhase(false)
106 for (
unsigned int e1l = 0; e1l < e1->
getNumLanes(); e1l++) {
108 for (
unsigned int e2l = 0; e2l < e2->
getNumLanes(); e2l++) {
110 for (std::vector<NBEdge::Connection>::iterator e1c = approached1.begin(); e1c != approached1.end(); ++e1c) {
114 for (std::vector<NBEdge::Connection>::iterator e2c = approached2.begin(); e2c != approached2.end(); ++e2c) {
118 if (!
foes(e1, (*e1c).toEdge, e2, (*e2c).toEdge)) {
130 std::pair<NBEdge*, NBEdge*>
132 std::pair<NBEdge*, NBEdge*> bestPair(static_cast<NBEdge*>(0), static_cast<NBEdge*>(0));
134 for (EdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
135 for (EdgeVector::const_iterator j = i + 1; j != edges.end(); ++j) {
137 if (value > bestValue) {
139 bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
140 }
else if (value == bestValue) {
142 const SUMOReal oa =
GeomHelper::getMinAngleDiff(bestPair.first->getAngleAtNode(bestPair.first->getToNode()), bestPair.second->getAngleAtNode(bestPair.second->getToNode()));
144 if (bestPair.first->getID() < (*i)->getID()) {
145 bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
147 }
else if (oa < ca) {
148 bestPair = std::pair<NBEdge*, NBEdge*>(*i, *j);
157 std::pair<NBEdge*, NBEdge*>
159 if (incoming.size() == 1) {
161 std::pair<NBEdge*, NBEdge*> ret(*incoming.begin(),
static_cast<NBEdge*
>(0));
169 used.push_back(*incoming.begin());
172 for (EdgeVector::iterator i = incoming.begin() + 1; i != incoming.end() && prio ==
getToPrio(*i); ++i) {
176 if (used.size() < 2) {
180 incoming.erase(find(incoming.begin(), incoming.end(), ret.first));
181 incoming.erase(find(incoming.begin(), incoming.end(), ret.second));
198 std::vector<bool> isTurnaround;
199 std::vector<int> fromLanes;
200 unsigned int noLanesAll = 0;
201 unsigned int noLinksAll = 0;
202 for (
unsigned int i1 = 0; i1 < incoming.size(); i1++) {
203 unsigned int noLanes = incoming[i1]->getNumLanes();
204 noLanesAll += noLanes;
205 for (
unsigned int i2 = 0; i2 < noLanes; i2++) {
206 NBEdge* fromEdge = incoming[i1];
208 noLinksAll += (
unsigned int) approached.size();
209 for (
unsigned int i3 = 0; i3 < approached.size(); i3++) {
210 if (!fromEdge->
mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
214 assert(i3 < approached.size());
215 NBEdge* toEdge = approached[i3].toEdge;
216 fromEdges.push_back(fromEdge);
217 fromLanes.push_back((
int)i2);
218 toEdges.push_back(toEdge);
222 isTurnaround.push_back(
true);
228 std::vector<NBNode::Crossing> crossings;
230 const std::vector<NBNode::Crossing>& c = (*i)->getCrossings();
233 (*i)->setCrossingTLIndices(noLinksAll);
235 copy(c.begin(), c.end(), std::back_inserter(crossings));
236 noLinksAll += (
unsigned int)c.size();
243 while (toProc.size() > 0) {
244 std::pair<NBEdge*, NBEdge*> chosen;
245 if (incoming.size() == 2) {
248 SUMOReal angle = fabs(
NBHelpers::relAngle(toProc[0]->getAngleAtNode(toProc[0]->getToNode()), toProc[1]->getAngleAtNode(toProc[1]->getToNode())));
251 chosen = std::pair<NBEdge*, NBEdge*>(toProc[0],
static_cast<NBEdge*
>(0));
252 toProc.erase(toProc.begin());
259 unsigned int pos = 0;
260 std::string state((
size_t) noLinksAll,
'r');
262 for (
unsigned int i1 = 0; i1 < (
unsigned int) incoming.size(); ++i1) {
263 NBEdge* fromEdge = incoming[i1];
264 const bool inChosen = fromEdge == chosen.first || fromEdge == chosen.second;
265 const unsigned int numLanes = fromEdge->
getNumLanes();
266 for (
unsigned int i2 = 0; i2 < numLanes; i2++) {
268 for (
unsigned int i3 = 0; i3 < approached.size(); ++i3) {
269 if (!fromEdge->
mayBeTLSControlled(i2, approached[i3].toEdge, approached[i3].toLane)) {
282 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
283 if (state[i1] ==
'G') {
287 for (
unsigned int i2 = 0; i2 < pos && !
isForbidden; ++i2) {
288 if (state[i2] ==
'G' && !isTurnaround[i2] &&
289 (
forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1],
true) ||
forbids(fromEdges[i1], toEdges[i1], fromEdges[i2], toEdges[i2],
true))) {
293 if (!isForbidden && !
hasCrossing(fromEdges[i1], toEdges[i1], crossings)) {
298 bool haveForbiddenLeftMover =
false;
299 std::vector<bool> rightTurnConflicts(pos,
false);
300 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
301 if (state[i1] !=
'G') {
304 for (
unsigned int i2 = 0; i2 < pos; ++i2) {
305 if ((state[i2] ==
'G' || state[i2] ==
'g')) {
306 if (fromEdges[i2]->getToNode()->rightTurnConflict(
307 fromEdges[i1], toEdges[i1], fromLanes[i1], fromEdges[i2], toEdges[i2], fromLanes[i2])) {
308 rightTurnConflicts[i1] =
true;
310 if (
forbids(fromEdges[i2], toEdges[i2], fromEdges[i1], toEdges[i1],
true) || rightTurnConflicts[i1]) {
313 if (!isTurnaround[i1]) {
314 haveForbiddenLeftMover =
true;
320 const std::string vehicleState = state;
323 for (
unsigned int i1 = pos; i1 < pos + crossings.size(); ++i1) {
327 if (brakingTime > 0) {
329 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
330 if (state[i1] !=
'G' && state[i1] !=
'g') {
333 if ((vehicleState[i1] >=
'a' && vehicleState[i1] <=
'z') && haveForbiddenLeftMover && !rightTurnConflicts[i1]) {
339 logic->
addStep(brakingTime, state);
344 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
345 if (state[i1] ==
'Y' || state[i1] ==
'y') {
349 if (state[i1] ==
'g') {
354 logic->
addStep(leftTurnTime, state);
357 if (brakingTime > 0) {
358 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
359 if (state[i1] !=
'G' && state[i1] !=
'g') {
365 logic->
addStep(brakingTime, state);
372 if (totalDuration > 0) {
373 if (totalDuration > 3 * (greenTime + 2 * brakingTime + leftTurnTime)) {
389 for (std::vector<NBNode::Crossing>::const_iterator it = crossings.begin(); it != crossings.end(); it++) {
393 for (EdgeVector::const_iterator it_e = cross.
edges.begin(); it_e != cross.
edges.end(); ++it_e) {
394 const NBEdge* edge = *it_e;
395 if (edge == from || edge == to) {
407 std::string state,
const std::vector<NBNode::Crossing>& crossings,
const EdgeVector& fromEdges,
const EdgeVector& toEdges) {
410 const std::string orig = state;
414 logic->
addStep(greenTime, state);
416 const SUMOTime pedTime = greenTime - pedClearingTime;
417 if (pedTime >= minPedTime) {
419 const size_t pedStates = crossings.size();
420 logic->
addStep(pedTime, state);
421 state = state.substr(0, state.size() - pedStates) + std::string(pedStates,
'r');
422 logic->
addStep(pedClearingTime, state);
426 logic->
addStep(greenTime, state);
435 std::string result = state;
436 const unsigned int pos = (
unsigned int)(state.size() - crossings.size());
437 for (
int ic = 0; ic < (int)crossings.size(); ++ic) {
438 const int i1 = pos + ic;
441 for (
unsigned int i2 = 0; i2 < pos && !
isForbidden; ++i2) {
443 if (fromEdges[i2] != 0 && toEdges[i2] != 0 && fromEdges[i2]->getToNode() == cross.
node) {
444 for (EdgeVector::const_iterator it = cross.
edges.begin(); it != cross.
edges.end(); ++it) {
447 if (state[i2] !=
'r' && (edge == fromEdges[i2] ||
463 for (
unsigned int i1 = 0; i1 < pos; ++i1) {
464 if (result[i1] ==
'G') {
465 for (
int ic = 0; ic < (int)crossings.size(); ++ic) {
467 if (fromEdges[i1] != 0 && toEdges[i1] != 0 && fromEdges[i1]->getToNode() == crossing.
node) {
468 const int i2 = pos + ic;
static std::string patchStateForCrossings(const std::string &state, const std::vector< NBNode::Crossing > &crossings, const EdgeVector &fromEdges, const EdgeVector &toEdges)
compute phase state in regard to pedestrian crossings
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
void closeBuilding()
closes the building process
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.
static bool hasCrossing(const NBEdge *from, const NBEdge *to, const std::vector< NBNode::Crossing > &crossings)
compute whether the given connection is crossed by pedestrians
bool isForbidden(SVCPermissions permissions)
Returns whether an edge with the given permission is a forbidden edge.
const EdgeVector & getIncomingEdges() const
Returns the list of incoming edges (must be build first)
NBTrafficLightLogic * computeLogicAndConts(unsigned int brakingTimeSeconds, bool onlyConts=false)
helper function for myCompute
void removeTrafficLight(NBTrafficLightDefinition *tlDef)
Removes the given traffic light from this node.
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.
virtual void collectEdges()
Build the list of participating edges.
bool mustBrakeForCrossing(const NBEdge *const from, const NBEdge *const to, const Crossing &crossing) const
Returns the information whether the described flow must brake for the given crossing.
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.
bool myHaveSinglePhase
Whether left-mover should not have an additional phase.
unsigned int getNumLanes() const
Returns the number of lanes.
bool isTurningDirectionAt(const NBEdge *const edge) const
Returns whether the given edge is the opposite direction to this edge.
Storage for edges, including some functionality operating on multiple edges.
The link is a (hard) right direction.
static std::string addPedestrianPhases(NBTrafficLightLogic *logic, SUMOTime greenTime, std::string state, const std::vector< NBNode::Crossing > &crossings, const EdgeVector &fromEdges, const EdgeVector &toEdges)
add 1 or 2 phases depending on the presence of pedestrian crossings
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.
bool myNeedsContRelationReady
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.
const NBNode * node
The parent node of this crossing.
NeedsContRelation myNeedsContRelation
EdgeVector edges
The edges being crossed.
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.
A definition of a pedestrian crossing.
void initNeedsContRelation() const
static SUMOReal relAngle(SUMOReal angle1, SUMOReal angle2)
data structure for caching needsCont information
std::vector< NBNode * > myControlledNodes
The container with participating nodes.
A traffic light logics which must be computed (only nodes/edges are given)
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.
NBEdge * getTurnDestination(bool possibleDestination=false) const
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.