SUMO - Simulation of Urban MObility
GUITrafficLightLogicWrapper.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2017 German Aerospace Center (DLR) and others.
4 /****************************************************************************/
5 //
6 // This program and the accompanying materials
7 // are made available under the terms of the Eclipse Public License v2.0
8 // which accompanies this distribution, and is available at
9 // http://www.eclipse.org/legal/epl-v20.html
10 //
11 /****************************************************************************/
20 // A wrapper for tl-logics to allow their visualisation and interaction
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #ifdef _MSC_VER
28 #include <windows_config.h>
29 #else
30 #include <config.h>
31 #endif
32 
33 #include <cassert>
38 #include <utils/gui/div/GLHelper.h>
42 #include <microsim/MSLane.h>
49 #include <gui/GUIGlobals.h>
51 #include "GUINet.h"
53 
54 
55 // ===========================================================================
56 // FOX callback mapping
57 // ===========================================================================
64 };
65 
66 // Object implementation
68 
69 
70 // ===========================================================================
71 // method definitions
72 // ===========================================================================
73 /* -------------------------------------------------------------------------
74  * GUITrafficLightLogicWrapper::GUITrafficLightLogicWrapperPopupMenu - methods
75  * ----------------------------------------------------------------------- */
77  GUIMainWindow& app, GUISUMOAbstractView& parent,
78  GUIGlObject& o)
79  : GUIGLObjectPopupMenu(app, parent, o) {}
80 
81 
83 
84 
85 
86 long
88  FXObject*, FXSelector, void*) {
89  assert(myObject->getType() == GLO_TLLOGIC);
91  return 1;
92 }
93 
94 
95 long
97  FXObject*, FXSelector, void*) {
98  assert(myObject->getType() == GLO_TLLOGIC);
100  return 1;
101 }
102 
103 
104 long
106  FXObject*, FXSelector /*sel*/, void*) {
107  assert(myObject->getType() == GLO_TLLOGIC);
109  return 1;
110 }
111 
112 
113 long
115  FXObject*, FXSelector sel, void*) {
116  assert(myObject->getType() == GLO_TLLOGIC);
117  static_cast<GUITrafficLightLogicWrapper*>(myObject)->switchTLSLogic(FXSELID(sel) - MID_SWITCH);
118  return 1;
119 }
120 
121 
122 
123 /* -------------------------------------------------------------------------
124  * GUITrafficLightLogicWrapper - methods
125  * ----------------------------------------------------------------------- */
127  MSTLLogicControl& control, MSTrafficLightLogic& tll) :
128  GUIGlObject(GLO_TLLOGIC, tll.getID()),
129  myTLLogicControl(control), myTLLogic(tll) {}
130 
131 
133 
134 
137  GUISUMOAbstractView& parent) {
138  myApp = &app;
139  GUIGLObjectPopupMenu* ret = new GUITrafficLightLogicWrapperPopupMenu(app, parent, *this);
140  buildPopupHeader(ret, app);
142  //
144  std::vector<MSTrafficLightLogic*> logics = vars.getAllLogics();
145  if (logics.size() > 1) {
146  std::vector<MSTrafficLightLogic*>::const_iterator i;
147  int index = 0;
148  for (i = logics.begin(); i != logics.end(); ++i, ++index) {
149  if (!vars.isActive(*i)) {
150  new FXMenuCommand(ret, ("Switch to '" + (*i)->getProgramID() + "'").c_str(),
151  GUIIconSubSys::getIcon(ICON_FLAG_MINUS), ret, (FXSelector)(MID_SWITCH + index));
152  }
153  }
154  new FXMenuSeparator(ret);
155  }
156  new FXMenuCommand(ret, "Switch off", GUIIconSubSys::getIcon(ICON_FLAG_MINUS), ret, MID_SWITCH_OFF);
157  new FXMenuCommand(ret, "Track Phases", 0, ret, MID_TRACKPHASES);
158  new FXMenuCommand(ret, "Show Phases", 0, ret, MID_SHOWPHASES);
159  new FXMenuSeparator(ret);
163  new FXMenuCommand(ret, ("phase: " + toString(tll->getCurrentPhaseIndex())).c_str(), 0, 0, 0);
164  new FXMenuSeparator(ret);
165  buildShowParamsPopupEntry(ret, false);
166  buildPositionCopyEntry(ret, false);
167  return ret;
168 }
169 
170 
171 void
175  new FuncBinding_StringParam<MSTLLogicControl, std::pair<SUMOTime, MSPhaseDefinition> >
177  window->create();
178  window->show();
179 }
180 
181 
182 void
186  static_cast<MSSimpleTrafficLightLogic&>(myTLLogic).getPhases());
187  window->setBeginTime(0);
188  window->create();
189  window->show();
190 }
191 
192 
197  new GUIParameterTableWindow(app, *this, 3 + (int)myTLLogic.getMap().size());
198  ret->mkItem("tlLogic [id]", false, myTLLogic.getID());
199  ret->mkItem("program", false, myTLLogic.getProgramID());
200  // close building
201  ret->closeBuilding(&myTLLogic);
202  return ret;
203 }
204 
205 
206 Boundary
208  Boundary ret;
210  for (MSTrafficLightLogic::LaneVectorVector::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
211  const MSTrafficLightLogic::LaneVector& lanes2 = (*i);
212  for (MSTrafficLightLogic::LaneVector::const_iterator j = lanes2.begin(); j != lanes2.end(); ++j) {
213  ret.add((*j)->getShape()[-1]);
214  }
215  }
216  ret.grow(20);
217  return ret;
218 }
219 
220 
221 void
223  if (to == -1) {
227  } else {
229  std::vector<MSTrafficLightLogic*> logics = vars.getAllLogics();
230  myTLLogicControl.switchTo(myTLLogic.getID(), logics[to]->getProgramID());
231  }
232 }
233 
234 
235 int
237  return myTLLogic.getLinkIndex(link);
238 }
239 
240 
241 void
243  if (s.gaming) {
244  if (!MSNet::getInstance()->getTLSControl().isActive(&myTLLogic)) {
245  return;
246  };
247  const std::string& curState = myTLLogic.getCurrentPhaseDef().getState();
248  if (curState.find_first_of("gG") == std::string::npos) {
249  // no link is 'green' at the moment. find those that turn green next
251  int curPhaseIdx = myTLLogic.getCurrentPhaseIndex();
252  int phaseIdx = (curPhaseIdx + 1) % phases.size();
253  std::vector<int> nextGreen;
254  while (phaseIdx != curPhaseIdx) {
255  const std::string& state = phases[phaseIdx]->getState();
256  for (int linkIdx = 0; linkIdx < (int)state.size(); linkIdx++) {
257  if ((LinkState)state[linkIdx] == LINKSTATE_TL_GREEN_MINOR ||
258  (LinkState)state[linkIdx] == LINKSTATE_TL_GREEN_MAJOR) {
259  nextGreen.push_back(linkIdx);
260  }
261  }
262  if (nextGreen.size() > 0) {
263  break;
264  }
265  phaseIdx = (phaseIdx + 1) % phases.size();
266  }
267  // highlight nextGreen links
268  for (std::vector<int>::iterator it_idx = nextGreen.begin(); it_idx != nextGreen.end(); it_idx++) {
269  const MSTrafficLightLogic::LaneVector& lanes = myTLLogic.getLanesAt(*it_idx);
270  for (MSTrafficLightLogic::LaneVector::const_iterator it_lane = lanes.begin(); it_lane != lanes.end(); it_lane++) {
271  glPushMatrix();
272  glColor3d(0, 1, 0);
273  Position pos = (*it_lane)->getShape().back();
274  glTranslated(pos.x(), pos.y(), GLO_MAX);
275  GLHelper::drawFilledCircle((*it_lane)->getWidth() / 2.);
276  glPopMatrix();
277  }
278  }
279  }
280  }
281 }
282 
283 
284 /****************************************************************************/
285 
The link has green light, may pass.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
const std::string & getState() const
Returns the state within this phase.
long onCmdBegin2TrackPhases(FXObject *, FXSelector, void *)
Called if the phases shall be begun to track.
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
Begin to track phases - menu entry.
Definition: GUIAppEnum.h:248
Storage for all programs of a single tls.
void buildNameCopyPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds entries which allow to copy the name / typed name into the clipboard.
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
bool gaming
whether the application is in gaming mode or not
The link has green light, has to brake.
Stores the information about how to visualize structures.
double y() const
Returns the y-position.
Definition: Position.h:67
const LaneVectorVector & getLaneVectors() const
Returns the list of lists of all lanes controlled by this tls.
void create()
Creates the window (FOX-Toolkit)
void begin2TrackPhases()
Builds a GUITLLogicPhasesTrackerWindow which will receive new phases.
double x() const
Returns the x-position.
Definition: Position.h:62
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:167
MSTLLogicControl & myTLLogicControl
Reference to the according tls.
virtual int getCurrentPhaseIndex() const =0
Returns the current index within the program.
GUIMainWindow * myApp
The main application.
const std::string & getID() const
Returns the id.
Definition: Named.h:65
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
static void drawFilledCircle(double width, int steps=8)
Draws a filled circle around (0,0)
Definition: GLHelper.cpp:350
Show TLS phases - popup entry.
Definition: GUIAppEnum.h:244
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used, also builds an entry for copying the geo-position.
int getLinkIndex(const MSLink *const link) const
Returns the index of the given link.
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:47
FXDEFMAP(GUIDialog_AppSettings) GUIDialog_AppSettingsMap[]
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
void showPhases()
Builds a GUITLLogicPhasesTrackerWindow which displays the phase diagram.
const LaneVector & getLanesAt(int i) const
Returns the list of lanes that are controlled by the signals at the given position.
A class that stores and controls tls and switching of their programs.
std::vector< MSTrafficLightLogic * > getAllLogics() const
GUIGlID createTLWrapper(MSTrafficLightLogic *tll)
creates a wrapper for the given logic and returns the GlID
Definition: GUINet.cpp:150
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:55
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
GUITrafficLightLogicWrapperPopupMenuMap[]
const std::string & getProgramID() const
Returns this tl-logic&#39;s id.
static GUINet * getGUIInstance()
Returns the pointer to the unique instance of GUINet (singleton).
Definition: GUINet.cpp:506
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:45
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
void switchTLSLogic(int to)
Builds a GUITLLogicPhasesTrackerWindow which displays the phase diagram.
a tl-logic
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
MSTrafficLightLogic & myTLLogic
The wrapped tl-logic.
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:301
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
virtual const Phases & getPhases() const =0
Returns the phases of this tls program.
std::vector< MSLane * > LaneVector
Definition of the list of arrival lanes subjected to this tls.
std::vector< LaneVector > LaneVectorVector
Definition of a list that holds lists of lanes that do have the same attribute.
int getLinkIndex(const MSLink *const link) const
Returns the index of the given link within the according tls.
const std::map< std::string, std::string > & getMap() const
Returns the inner key/value map.
bool isActive(const MSTrafficLightLogic *tl) const
The popup menu of a globject.
void buildSelectionPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to (de)select the object.
This window displays a phase diagram for a chosen tl-logic.
GUITrafficLightLogicWrapper(MSTLLogicControl &control, MSTrafficLightLogic &tll)
Constructor.
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
The parent class for traffic light logics.
void setBeginTime(SUMOTime time)
Sets the time the display shall be shown as beginning at.
empty max
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
GUITLLogicPhasesTrackerWindow()
protected constructor for FOX
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:85
GUIGlObject * myObject
The object that belongs to this popup-menu.
void mkItem(const char *name, bool dynamic, ValueSource< unsigned > *src)
Adds a row which obtains its value from an unsigned-ValueSource.
A window containing a gl-object&#39;s parameter.
static FXIcon * getIcon(GUIIcon which)
returns a icon previously defined in the enum GUIIcon
long onCmdShowPhases(FXObject *, FXSelector, void *)
Called if the phases shall be shown.
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.