Eclipse 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-2023 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
21// A wrapper for tl-logics to allow their visualisation and interaction
22/****************************************************************************/
23#include <config.h>
24
25#include <cassert>
35#include <microsim/MSLane.h>
47#include <gui/GUIGlobals.h>
50
52#include "GUINet.h"
53
54// ===========================================================================
55// FOX callback mapping
56// ===========================================================================
64};
65
66// Object implementation
68
69
70// ===========================================================================
71// method definitions
72// ===========================================================================
73/* -------------------------------------------------------------------------
74 * GUITrafficLightLogicWrapper::GUITrafficLightLogicWrapperPopupMenu - methods
75 * ----------------------------------------------------------------------- */
78 GUIGlObject& o)
79 : GUIGLObjectPopupMenu(app, parent, o) {}
80
81
83
84
85
86long
88 FXObject*, FXSelector, void*) {
89 assert(myObject->getType() == GLO_TLLOGIC);
90 static_cast<GUITrafficLightLogicWrapper*>(myObject)->begin2TrackPhases();
91 return 1;
92}
93
94
95long
97 FXObject*, FXSelector, void*) {
98 assert(myObject->getType() == GLO_TLLOGIC);
99 static_cast<GUITrafficLightLogicWrapper*>(myObject)->showPhases();
100 return 1;
101}
102
103long
105 FXObject*, FXSelector, void*) {
106 assert(myObject->getType() == GLO_TLLOGIC);
107 GUITrafficLightLogicWrapper* w = static_cast<GUITrafficLightLogicWrapper*>(myObject);
109 if (act != nullptr) {
110 act->setShowDetectors(!act->showDetectors());
111 } else {
113 if (db != nullptr) {
115 } else {
116 NEMALogic* nema = dynamic_cast<NEMALogic*>(&w->getTLLogic());
117 if (nema != nullptr) {
118 nema->setShowDetectors(!nema->showDetectors());
119 }
120 }
121 }
122 myParent->update();
123 return 1;
124}
125
126long
128 FXObject*, FXSelector /*sel*/, void*) {
129 assert(myObject->getType() == GLO_TLLOGIC);
130 static_cast<GUITrafficLightLogicWrapper*>(myObject)->switchTLSLogic(-1);
131 myParent->update();
132 return 1;
133}
134
135
136long
138 FXObject*, FXSelector sel, void*) {
139 assert(myObject->getType() == GLO_TLLOGIC);
140 static_cast<GUITrafficLightLogicWrapper*>(myObject)->switchTLSLogic(FXSELID(sel) - MID_SWITCH);
141 myParent->update();
142 return 1;
143}
144
145
146
147/* -------------------------------------------------------------------------
148 * GUITrafficLightLogicWrapper - methods
149 * ----------------------------------------------------------------------- */
151 GUIGlObject(GLO_TLLOGIC, tll.getID(), GUIIconSubSys::getIcon(GUIIcon::LOCATETLS)),
152 myTLLogicControl(control), myTLLogic(tll) {
153}
154
155
157
158
161 GUISUMOAbstractView& parent) {
162 myApp = &app;
163 GUIGLObjectPopupMenu* ret = new GUITrafficLightLogicWrapperPopupMenu(app, parent, *this);
164 buildPopupHeader(ret, app);
167 std::vector<MSTrafficLightLogic*> logics = vars.getAllLogics();
168 if (logics.size() > 1) {
169 std::vector<MSTrafficLightLogic*>::const_iterator i;
170 int index = 0;
171 for (i = logics.begin(); i != logics.end(); ++i, ++index) {
172 if (!vars.isActive(*i) && dynamic_cast<MSOffTrafficLightLogic*>(*i) == nullptr) {
173 GUIDesigns::buildFXMenuCommand(ret, ("Switch to '" + (*i)->getProgramID() + "'").c_str(),
174 GUIIconSubSys::getIcon(GUIIcon::FLAG_MINUS), ret, (FXSelector)(MID_SWITCH + index));
175 }
176 }
177 new FXMenuSeparator(ret);
178 }
179 MSOffTrafficLightLogic* offLogic = dynamic_cast<MSOffTrafficLightLogic*>(vars.getActive());
180 if (offLogic == nullptr) {
182 }
183 GUIDesigns::buildFXMenuCommand(ret, "Track Phases", nullptr, ret, MID_TRACKPHASES);
184 GUIDesigns::buildFXMenuCommand(ret, "Show Phases", nullptr, ret, MID_SHOWPHASES);
186 if (act != nullptr) {
187 GUIDesigns::buildFXMenuCommand(ret, act->showDetectors() ? "Hide Detectors" : "Show Detectors", nullptr, ret, MID_SHOW_DETECTORS);
188 }
190 if (db != nullptr) {
191 GUIDesigns::buildFXMenuCommand(ret, db->showDetectors() ? "Hide Detectors" : "Show Detectors", nullptr, ret, MID_SHOW_DETECTORS);
192 }
193 NEMALogic* nema = dynamic_cast<NEMALogic*>(&myTLLogic);
194 if (nema != nullptr) {
195 GUIDesigns::buildFXMenuCommand(ret, nema->showDetectors() ? "Hide Detectors" : "Show Detectors", nullptr, ret, MID_SHOW_DETECTORS);
196 }
197 new FXMenuSeparator(ret);
201 GUIDesigns::buildFXMenuCommand(ret, "phase: " + toString(tll->getCurrentPhaseIndex()), nullptr, nullptr, 0);
202 const std::string& name = tll->getCurrentPhaseDef().getName();
203 if (name != "") {
204 GUIDesigns::buildFXMenuCommand(ret, "phase name: " + name, nullptr, nullptr, 0);
205 }
206 new FXMenuSeparator(ret);
207 buildShowParamsPopupEntry(ret, false);
208 buildPositionCopyEntry(ret, app);
209 return ret;
210}
211
212
213void
217 new FuncBinding_StringParam<MSTLLogicControl, std::pair<SUMOTime, MSPhaseDefinition> >
219 window->create();
220 window->show();
221}
222
223
224void
228 static_cast<MSSimpleTrafficLightLogic&>(myTLLogic).getPhases());
229 window->setBeginTime(0);
230 window->create();
231 window->show();
232}
233
234
239 ret->mkItem("tlLogic [id]", false, myTLLogic.getID());
240 ret->mkItem("type", false, toString(myTLLogic.getLogicType()));
241 ret->mkItem("program", false, myTLLogic.getProgramID());
252 MSRailSignal* rs = dynamic_cast<MSRailSignal*>(&myTLLogic);
253 if (rs != nullptr) {
258 }
259 // close building
261 return ret;
262}
263
264
267 Boundary ret;
269 for (MSTrafficLightLogic::LaneVectorVector::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
270 const MSTrafficLightLogic::LaneVector& lanes2 = (*i);
271 for (MSTrafficLightLogic::LaneVector::const_iterator j = lanes2.begin(); j != lanes2.end(); ++j) {
272 ret.add((*j)->getShape()[-1]);
273 }
274 }
275 ret.grow(20);
276 return ret;
277}
278
279const std::string
281 return myTLLogic.getParameter("name", "");
282}
283
284
285void
287 if (to == -1) {
290 } else {
292 std::vector<MSTrafficLightLogic*> logics = vars.getAllLogics();
293 myTLLogicControl.switchTo(myTLLogic.getID(), logics[to]->getProgramID());
294 }
295}
296
297
298int
300 return myTLLogic.getLinkIndex(link);
301}
302
303
304void
306 if (s.gaming) {
307 if (!MSNet::getInstance()->getTLSControl().isActive(&myTLLogic) || myTLLogic.getPhases().size() == 0) {
308 return;
309 }
310 const std::string& curState = myTLLogic.getCurrentPhaseDef().getState();
311 if (curState.find_first_of("gG") == std::string::npos) {
312 // no link is 'green' at the moment. find those that turn green next
314 int curPhaseIdx = myTLLogic.getCurrentPhaseIndex();
315 int phaseIdx = (curPhaseIdx + 1) % phases.size();
316 std::vector<int> nextGreen;
317 while (phaseIdx != curPhaseIdx) {
318 const std::string& state = phases[phaseIdx]->getState();
319 for (int linkIdx = 0; linkIdx < (int)state.size(); linkIdx++) {
320 if ((LinkState)state[linkIdx] == LINKSTATE_TL_GREEN_MINOR ||
321 (LinkState)state[linkIdx] == LINKSTATE_TL_GREEN_MAJOR) {
322 nextGreen.push_back(linkIdx);
323 }
324 }
325 if (nextGreen.size() > 0) {
326 break;
327 }
328 phaseIdx = (phaseIdx + 1) % phases.size();
329 }
330 // highlight nextGreen links
331 for (const int idx : nextGreen) {
332 for (const MSLane* const lane : myTLLogic.getLanesAt(idx)) {
334 // split circle in red and yellow
335 const Position& pos = lane->getShape().back();
336 glTranslated(pos.x(), pos.y(), GLO_MAX);
337 double rot = RAD2DEG(lane->getShape().angleAt2D((int)lane->getShape().size() - 2)) - 90;
338 glRotated(rot, 0, 0, 1);
340 GLHelper::drawFilledCircle(lane->getWidth() / 2., 8, -90, 90);
342 GLHelper::drawFilledCircle(lane->getWidth() / 2., 8, 90, 270);
344 }
345 }
346 }
347 }
348}
349
353}
354
355int
358}
359
360std::string
363}
364
365int
367 return (int)STEPS2TIME(getActiveTLLogic()->getCurrentPhaseDef().duration);
368}
369
370int
372 return (int)STEPS2TIME(getActiveTLLogic()->getMinDur());
373}
374
375int
377 return (int)STEPS2TIME(getActiveTLLogic()->getMaxDur());
378}
379
380int
382 const SUMOTime earliestEnd = getActiveTLLogic()->getEarliestEnd();
383 return earliestEnd == MSPhaseDefinition::UNSPECIFIED_DURATION ? -1 : (int)STEPS2TIME(earliestEnd);
384}
385
386int
388 const SUMOTime latestEnd = getActiveTLLogic()->getLatestEnd();
389 return latestEnd == MSPhaseDefinition::UNSPECIFIED_DURATION ? -1 : (int)STEPS2TIME(latestEnd);
390}
391
392int
394 return (int)STEPS2TIME(getActiveTLLogic()->getDefaultCycleTime());
395}
396
397int
399 return (int)STEPS2TIME(getActiveTLLogic()->getTimeInCycle());
400}
401
402int
404 return (int)(SIMTIME - STEPS2TIME(getActiveTLLogic()->getCurrentPhaseDef().myLastSwitch));
405}
406
407
408/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
@ MID_SWITCH_OFF
Show TLS phases - popup entry.
Definition: GUIAppEnum.h:468
@ MID_SHOWPHASES
Definition: GUIAppEnum.h:470
@ MID_TRACKPHASES
Begin to track phases - menu entry.
Definition: GUIAppEnum.h:472
@ MID_SHOW_DETECTORS
show/hide actuation detectors
Definition: GUIAppEnum.h:474
@ MID_SWITCH
Definition: GUIAppEnum.h:469
FXDEFMAP(GUIDialog_AppSettings) GUIDialog_AppSettingsMap[]
@ GLO_MAX
empty max
@ GLO_TLLOGIC
a tl-logic
GUIIcon
An enumeration of icons used by the gui applications.
Definition: GUIIcons.h:33
GUITrafficLightLogicWrapperPopupMenuMap[]
#define RAD2DEG(x)
Definition: GeomHelper.h:36
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define SIMTIME
Definition: SUMOTime.h:61
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
@ LINKSTATE_TL_YELLOW_MAJOR
The link has yellow light, may pass.
@ LINKSTATE_TL_GREEN_MAJOR
The link has green light, may pass.
@ LINKSTATE_TL_RED
The link has red light (must brake)
@ LINKSTATE_TL_GREEN_MINOR
The link has green light, has to brake.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:300
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:583
static void drawFilledCircle(double width, int steps=8)
Draws a filled circle around (0,0)
Definition: GLHelper.cpp:498
static void popMatrix()
pop matrix
Definition: GLHelper.cpp:130
static void pushMatrix()
push matrix
Definition: GLHelper.cpp:117
static FXMenuCommand * buildFXMenuCommand(FXComposite *p, const std::string &text, FXIcon *icon, FXObject *tgt, FXSelector sel)
build menu command
Definition: GUIDesigns.cpp:42
The popup menu of a globject.
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
void buildNameCopyPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds entries which allow to copy the name / typed name into the clipboard.
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
void buildSelectionPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to (de)select the object.
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, const GUIMainWindow &app) const
Builds an entry which allows to copy the cursor position if geo projection is used,...
static FXIcon * getIcon(const GUIIcon which)
returns a icon previously defined in the enum GUIIcon
void createTLWrapper(MSTrafficLightLogic *tll) override
creates a wrapper for the given logic
Definition: GUINet.cpp:156
static GUINet * getGUIInstance()
Returns the pointer to the unique instance of GUINet (singleton).
Definition: GUINet.cpp:571
A window containing a gl-object's parameter.
void mkItem(const char *name, bool dynamic, ValueSource< T > *src)
Adds a row which obtains its value from a ValueSource.
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
This window displays a phase diagram for a chosen tl-logic.
void setBeginTime(SUMOTime time)
Sets the time the display shall be shown as beginning at.
void create()
Creates the window (FOX-Toolkit)
long onCmdBegin2TrackPhases(FXObject *, FXSelector, void *)
Called if the phases shall be begun to track.
long onCmdShowPhases(FXObject *, FXSelector, void *)
Called if the phases shall be shown.
MSTLLogicControl & myTLLogicControl
Reference to the according tls.
MSTrafficLightLogic & myTLLogic
The wrapped tl-logic.
MSTrafficLightLogic & getTLLogic() const
GUIMainWindow * myApp
The main application.
void begin2TrackPhases()
Builds a GUITLLogicPhasesTrackerWindow which will receive new phases.
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
GUITrafficLightLogicWrapper(MSTLLogicControl &control, MSTrafficLightLogic &tll)
Constructor.
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
const std::string getOptionalName() const
Returns the value for generic parameter 'name' or ''.
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
MSTrafficLightLogic * getActiveTLLogic() const
void switchTLSLogic(int to)
Builds a GUITLLogicPhasesTrackerWindow which displays the phase diagram.
int getLinkIndex(const MSLink *const link) const
Returns the index of the given link within the according tls.
void showPhases()
Builds a GUITLLogicPhasesTrackerWindow which displays the phase diagram.
Stores the information about how to visualize structures.
bool gaming
whether the application is in gaming mode or not
static const RGBColor & getLinkColor(const LinkState &ls, bool realistic=false)
map from LinkState to color constants
An actuated (adaptive) traffic light logic.
An actuated traffic light logic based on time delay of approaching vehicles.
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
A traffic lights logic which represents a tls in an off-mode.
static const SUMOTime UNSPECIFIED_DURATION
const std::string & getName() const
const std::string & getState() const
Returns the state within this phase.
A signal for rails.
Definition: MSRailSignal.h:46
std::string getBlockingVehicleIDs() const
std::string getPriorityVehicleIDs() const
std::string getConstraintInfo() const
std::string getRivalVehicleIDs() const
A fixed traffic light logic.
Storage for all programs of a single tls.
std::vector< MSTrafficLightLogic * > getAllLogics() const
MSTrafficLightLogic * getActive() const
bool isActive(const MSTrafficLightLogic *tl) const
A class that stores and controls tls and switching of their programs.
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
The parent class for traffic light logics.
std::vector< LaneVector > LaneVectorVector
Definition of a list that holds lists of lanes that do have the same attribute.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
int getLinkIndex(const MSLink *const link) const
Returns the index of the given link.
virtual int getCurrentPhaseIndex() const =0
Returns the current index within the program.
const LaneVector & getLanesAt(int i) const
Returns the list of lanes that are controlled by the signals at the given position.
std::vector< MSLane * > LaneVector
Definition of the list of arrival lanes subjected to this tls.
virtual SUMOTime getLatestEnd(int step=-1) const
const std::string & getProgramID() const
Returns this tl-logic's id.
TrafficLightType getLogicType() const
Returns the type of the logic.
virtual SUMOTime getEarliestEnd(int step=-1) const
virtual const Phases & getPhases() const =0
Returns the phases of this tls program.
const LaneVectorVector & getLaneVectors() const
Returns the list of lists of all lanes controlled by this tls.
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
A NEMA (adaptive) traffic light logic based on E2Detector.
bool showDetectors() const
void setShowDetectors(bool show)
const std::string & getID() const
Returns the id.
Definition: Named.h:74
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
double x() const
Returns the x-position.
Definition: Position.h:55
double y() const
Returns the y-position.
Definition: Position.h:60