SUMO - Simulation of Urban MObility
NBTrafficLightDefinition.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2002-2018 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
17 // The base class for traffic light logic definitions
18 /****************************************************************************/
19 #ifndef NBTrafficLightDefinition_h
20 #define NBTrafficLightDefinition_h
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
28 #include <vector>
29 #include <string>
30 #include <bitset>
31 #include <utility>
32 #include <set>
33 #include <utils/common/StdDefs.h>
34 #include <utils/common/Named.h>
36 #include <utils/common/SUMOTime.h>
39 #include "NBCont.h"
40 #include "NBConnection.h"
41 #include "NBConnectionDefs.h"
43 
44 
45 // ===========================================================================
46 // class declarations
47 // ===========================================================================
48 class NBNode;
49 class OptionsCont;
51 
52 
53 // ===========================================================================
54 // class definitions
55 // ===========================================================================
69 public:
70 
72  static const std::string DefaultProgramID;
73 
78  enum TLColor {
89  };
90 
91 
99  NBTrafficLightDefinition(const std::string& id,
100  const std::vector<NBNode*>& junctions,
101  const std::string& programID,
102  SUMOTime offset,
103  TrafficLightType type);
104 
105 
113  NBTrafficLightDefinition(const std::string& id,
114  NBNode* junction,
115  const std::string& programID,
116  SUMOTime offset,
117  TrafficLightType type);
118 
119 
126  NBTrafficLightDefinition(const std::string& id, const std::string& programID,
127  SUMOTime offset,
128  TrafficLightType type);
129 
130 
132  virtual ~NBTrafficLightDefinition();
133 
134 
144 
145 
146 
149 
153  virtual void addNode(NBNode* node);
154 
155 
159  virtual void removeNode(NBNode* node);
160 
165  virtual void removeConnection(const NBConnection& conn, bool reconstruct = true) {
166  UNUSED_PARAMETER(conn);
167  UNUSED_PARAMETER(reconstruct);
168  }
169 
173  const std::vector<NBNode*>& getNodes() const {
174  return myControlledNodes;
175  }
177 
178 
189  bool mustBrake(const NBEdge* const from, const NBEdge* const to) const;
190 
191 
199  bool mustBrake(const NBConnection& possProhibited,
200  const NBConnection& possProhibitor,
201  bool regardNonSignalisedLowerPriority) const;
202 
212  bool mustBrake(const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
213  const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
214  bool regardNonSignalisedLowerPriority) const;
215 
216 
227  bool forbids(const NBEdge* const possProhibitorFrom, const NBEdge* const possProhibitorTo,
228  const NBEdge* const possProhibitedFrom, const NBEdge* const possProhibitedTo,
229  bool regardNonSignalisedLowerPriority,
230  bool sameNodeOnly = false) const;
231 
232 
240  bool foes(const NBEdge* const from1, const NBEdge* const to1,
241  const NBEdge* const from2, const NBEdge* const to2) const;
242 
243 
246  virtual void setTLControllingInformation() const = 0;
247 
248 
251  virtual void setParticipantsInformation();
252 
253 
257  void addControlledInnerEdges(const std::vector<std::string>& edges);
258 
261  std::vector<std::string> getControlledInnerEdges() const;
262 
268  virtual void remapRemoved(NBEdge* removed,
269  const EdgeVector& incoming, const EdgeVector& outgoing) = 0;
270 
271 
278  virtual void replaceRemoved(NBEdge* removed, int removedLane,
279  NBEdge* by, int byLane) = 0;
280 
282  virtual void shiftTLConnectionLaneIndex(NBEdge* edge, int offset, int threshold = -1) {
283  UNUSED_PARAMETER(edge);
284  UNUSED_PARAMETER(offset);
285  UNUSED_PARAMETER(threshold);
286  }
287 
291  const EdgeVector& getIncomingEdges() const;
292 
293 
296  return myControlledLinks;
297  }
298 
299 
302  return myControlledLinks;
303  }
304 
305 
309  const std::string& getProgramID() const {
310  return mySubID;
311  };
312 
313 
317  void setProgramID(const std::string& programID) {
318  mySubID = programID;
319  }
320 
321 
326  return myOffset;
327  }
328 
329 
332  return myType;
333  }
334 
336  virtual void setType(TrafficLightType type) {
337  myType = type;
338  }
339 
340  /* @brief computes whether the given stream may have green minor while the
341  * other stream has green major in the same phase
342  */
343  bool needsCont(const NBEdge* fromE, const NBEdge* toE, const NBEdge* otherFromE, const NBEdge* otherToE) const;
344 
346  virtual bool rightOnRedConflict(int index, int foeIndex) const;
347 
348  /* initialize myNeedsContRelation and set myNeedsContRelationReady to true
349  * This information is a byproduct of NBOwnTLDef::myCompute. All other
350  * subclasses instantiate a private instance of NBOwnTLDef to answer this query */
351  virtual void initNeedsContRelation() const;
352 
354  virtual int getMaxIndex() = 0;
355 
357  virtual int getMaxValidIndex() {
358  return getMaxIndex();
359  }
360 
366  int computeBrakingTime(double minDecel) const;
367 
369  virtual bool usingSignalGroups() const {
370  return false;
371  };
372 
374  std::string getDescription() const;
375 
376 
377 protected:
379  static const std::string DummyID;
380 
385  virtual NBTrafficLightLogic* myCompute(int brakingTime) = 0;
386 
387 
391  virtual void collectLinks() = 0;
392 
393 
396  virtual void collectEdges();
397 
398 
399  // @return whether this traffic light is invalid and should be computed
400  virtual bool amInvalid() const;
401 
403  void collectAllLinks();
404 
405 protected:
407  std::vector<NBNode*> myControlledNodes;
408 
411 
414 
417 
419  std::set<std::string> myControlledInnerEdges;
420 
422  std::string mySubID;
423 
426 
429 
431  struct StreamPair {
432  StreamPair(const NBEdge* _from1, const NBEdge* _to1, const NBEdge* _from2, const NBEdge* _to2):
433  from1(_from1),
434  to1(_to1),
435  from2(_from2),
436  to2(_to2) {}
437 
438  bool operator==(const StreamPair& o) const {
439  return (from1 == o.from1 && to1 == o.to1
440  && from2 == o.from2 && to2 == o.to2);
441  }
442 
443  bool operator<(const StreamPair& o) const {
444  if (from1 != o.from1) {
445  return from1 < o.from1;
446  }
447  if (to1 != o.to1) {
448  return to1 < o.to1;
449  }
450  if (from2 != o.from2) {
451  return from2 < o.from2;
452  }
453  return to2 < o.to2;
454  }
455 
456  const NBEdge* from1;
457  const NBEdge* to1;
458  const NBEdge* from2;
459  const NBEdge* to2;
460  };
461  typedef std::set<StreamPair> NeedsContRelation;
462  mutable NeedsContRelation myNeedsContRelation;
464 
465  typedef std::set<std::pair<int, int> > RightOnRedConflicts;
466  mutable RightOnRedConflicts myRightOnRedConflicts;
468 
469 private:
470  static std::set<NBEdge*> collectReachable(EdgeVector outer, const EdgeVector& within, bool checkControlled);
471 
472 
473 };
474 
475 
476 #endif
477 
478 /****************************************************************************/
479 
bool operator==(const StreamPair &o) const
virtual void setParticipantsInformation()
Builds the list of participating nodes/edges/links.
StreamPair(const NBEdge *_from1, const NBEdge *_to1, const NBEdge *_from2, const NBEdge *_to2)
TrafficLightType myType
The algorithm type for the traffic light.
long long int SUMOTime
Definition: SUMOTime.h:36
virtual bool rightOnRedConflict(int index, int foeIndex) const
whether the given index must yield to the foeIndex while turning right on a red light ...
virtual void addNode(NBNode *node)
Adds a node to the traffic light logic.
virtual void removeConnection(const NBConnection &conn, bool reconstruct=true)
removes the given connection from the traffic light if recontruct=true, reconstructs the logic and in...
virtual bool usingSignalGroups() const
whether this definition uses signal group (multiple connections with the same link index) ...
void collectAllLinks()
helper method for use in NBOwnTLDef and NBLoadedSUMOTLDef
static const std::string DummyID
id for temporary definitions
RightOnRedConflicts myRightOnRedConflicts
A SUMO-compliant built logic for a traffic light.
EdgeVector myIncomingEdges
The list of incoming edges.
virtual ~NBTrafficLightDefinition()
Destructor.
The representation of a single edge during network building.
Definition: NBEdge.h:65
TrafficLightType getType() const
get the algorithm type (static etc..)
const NBConnectionVector & getControlledLinks() const
returns the controlled links (depends on previous call to collectLinks)
NBTrafficLightLogic * compute(OptionsCont &oc)
Computes the traffic light logic.
The base class for traffic light logic definitions.
virtual void replaceRemoved(NBEdge *removed, int removedLane, NBEdge *by, int byLane)=0
Replaces a removed edge/lane.
virtual void shiftTLConnectionLaneIndex(NBEdge *edge, int offset, int threshold=-1)
patches (loaded) signal plans by modifying lane indices
static const SUMOTime UNSPECIFIED_DURATION
std::set< std::pair< int, int > > RightOnRedConflicts
int computeBrakingTime(double minDecel) const
Computes the time vehicles may need to brake.
bool needsCont(const NBEdge *fromE, const NBEdge *toE, const NBEdge *otherFromE, const NBEdge *otherToE) const
TLColor
An enumeration of possible tl-signal states.
NBTrafficLightDefinition(const std::string &id, const std::vector< NBNode *> &junctions, const std::string &programID, SUMOTime offset, TrafficLightType type)
Constructor.
SUMOTime myOffset
The offset in the program.
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:33
NBConnectionVector & getControlledLinks()
returns the controlled links (non const version)
virtual void collectLinks()=0
Collects the links participating in this traffic light.
virtual void initNeedsContRelation() const
std::set< StreamPair > NeedsContRelation
SUMOTime getOffset()
Returns the offset.
virtual void collectEdges()
Build the list of participating edges.
std::string getDescription() const
get ID and programID together (for convenient debugging)
virtual int getMaxIndex()=0
Returns the maximum index controlled by this traffic light and assigned to a connection.
std::set< std::string > myControlledInnerEdges
Set of inner edges that shall be controlled, though.
virtual void remapRemoved(NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing)=0
Replaces occurences of the removed edge in incoming/outgoing edges of all definitions.
bool operator<(const StreamPair &o) const
virtual NBTrafficLightLogic * myCompute(int brakingTime)=0
Computes the traffic light logic finally in dependence to the type.
static const std::string DefaultProgramID
void setProgramID(const std::string &programID)
Sets the programID.
void addControlledInnerEdges(const std::vector< std::string > &edges)
Adds the given ids into the list of inner edges controlled by the tls.
const std::string & getProgramID() const
Returns the ProgramID.
An upper class for objects with additional parameters.
Definition: Parameterised.h:44
virtual void removeNode(NBNode *node)
Removes the given node from the list of controlled nodes.
Base class for objects which have an id.
Definition: Named.h:58
std::vector< NBConnection > NBConnectionVector
Definition of a connection vector.
const EdgeVector & getIncomingEdges() const
Returns the list of incoming edges (must be build first)
bool forbids(const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority, bool sameNodeOnly=false) const
Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
std::vector< NBEdge * > EdgeVector
container for (sorted) edges
Definition: NBCont.h:34
const std::vector< NBNode * > & getNodes() const
Returns the list of controlled nodes.
A storage for options typed value containers)
Definition: OptionsCont.h:92
Represents a single node (junction) during network building.
Definition: NBNode.h:68
data structure for caching needsCont information
virtual int getMaxValidIndex()
Returns the maximum index controlled by this traffic light.
std::vector< NBNode * > myControlledNodes
The container with participating nodes.
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.
static std::set< NBEdge * > collectReachable(EdgeVector outer, const EdgeVector &within, bool checkControlled)
NBConnectionVector myControlledLinks
The list of controlled links.
bool mustBrake(const NBEdge *const from, const NBEdge *const to) const
Returns the information whether the described flow must let any other flow pass.
std::vector< std::string > getControlledInnerEdges() const
Retrieve the ids of edges explicitly controlled by the tls.
EdgeVector myEdgesWithin
The list of edges within the area controlled by the tls.
virtual void setTLControllingInformation() const =0
Informs edges about being controlled by a tls.
virtual void setType(TrafficLightType type)
set the algorithm type (static etc..)
std::string mySubID
The tls program&#39;s subid.
TrafficLightType