Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GUICalibrator.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/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/****************************************************************************/
20// Changes flow and speed on a set of lanes (gui version)
21/****************************************************************************/
22#include <config.h>
23
24#include <string>
27#include <utils/geom/Boundary.h>
31#include <microsim/MSNet.h>
32#include <microsim/MSLane.h>
33#include <microsim/MSEdge.h>
34#include <guisim/GUINet.h>
35#include <guisim/GUIEdge.h>
38#include <gui/GUIGlobals.h>
46
47#include "GUICalibrator.h"
48
49
50// ===========================================================================
51// FOX callback mapping
52// ===========================================================================
53/* -------------------------------------------------------------------------
54 * GUICalibrator::GUICalibratorPopupMenu - mapping
55 * ----------------------------------------------------------------------- */
61
62// Object implementation
64
65
66/* -------------------------------------------------------------------------
67 * GUICalibrator::GUIManip_Calibrator - mapping
68 * ----------------------------------------------------------------------- */
77
78FXIMPLEMENT(GUICalibrator::GUIManip_Calibrator, GUIManipulator, GUIManip_CalibratorMap, ARRAYNUMBER(GUIManip_CalibratorMap))
79
80
81// ===========================================================================
82// method definitions
83// ===========================================================================
84/* -------------------------------------------------------------------------
85 * GUICalibrator::GUIManip_Calibrator - methods
86 * ----------------------------------------------------------------------- */
88 GUIMainWindow& app,
89 const std::string& name, GUICalibrator& o,
90 int /*xpos*/, int /*ypos*/) :
91 GUIManipulator(app, name, 0, 0),
92 myParent(&app),
93 myChosenValue(0),
94 myChosenTarget(myChosenValue, nullptr, MID_OPTION),
95 //mySpeed(o.getDefaultSpeed()),
96 mySpeed(0),
97 mySpeedTarget(mySpeed),
98 myObject(&o) {
99 myChosenTarget.setTarget(this);
100 FXVerticalFrame* f1 =
101 new FXVerticalFrame(this, LAYOUT_FILL_X | LAYOUT_FILL_Y, 0, 0, 0, 0, 0, 0, 0, 0);
102
103 FXGroupBox* gp = new FXGroupBox(f1, "Change Speed",
104 GROUPBOX_TITLE_LEFT | FRAME_RIDGE,
105 0, 0, 0, 0, 4, 4, 1, 1, 2, 0);
106 {
107 // default
108 FXHorizontalFrame* gf1 =
109 new FXHorizontalFrame(gp, LAYOUT_TOP | LAYOUT_LEFT, 0, 0, 0, 0, 10, 10, 5, 5);
110 new FXRadioButton(gf1, "Default", &myChosenTarget, FXDataTarget::ID_OPTION + 0,
111 ICON_BEFORE_TEXT | LAYOUT_SIDE_TOP,
112 0, 0, 0, 0, 2, 2, 0, 0);
113 }
114 {
115 // loaded
116 FXHorizontalFrame* gf0 =
117 new FXHorizontalFrame(gp, LAYOUT_TOP | LAYOUT_LEFT, 0, 0, 0, 0, 10, 10, 5, 5);
118 new FXRadioButton(gf0, "Loaded", &myChosenTarget, FXDataTarget::ID_OPTION + 1,
119 ICON_BEFORE_TEXT | LAYOUT_SIDE_TOP,
120 0, 0, 0, 0, 2, 2, 0, 0);
121 }
122 {
123 // predefined
124 FXHorizontalFrame* gf2 =
125 new FXHorizontalFrame(gp, LAYOUT_TOP | LAYOUT_LEFT, 0, 0, 0, 0, 10, 10, 5, 5);
126 new FXRadioButton(gf2, "Predefined: ", &myChosenTarget, FXDataTarget::ID_OPTION + 2,
127 ICON_BEFORE_TEXT | LAYOUT_SIDE_TOP | LAYOUT_CENTER_Y,
128 0, 0, 0, 0, 2, 2, 0, 0);
129 myPredefinedValues =
130 new FXComboBox(gf2, 10, this, MID_PRE_DEF,
131 ICON_BEFORE_TEXT | LAYOUT_SIDE_TOP | LAYOUT_CENTER_Y | COMBOBOX_STATIC);
132 myPredefinedValues->appendItem("20 km/h");
133 myPredefinedValues->appendItem("40 km/h");
134 myPredefinedValues->appendItem("60 km/h");
135 myPredefinedValues->appendItem("80 km/h");
136 myPredefinedValues->appendItem("100 km/h");
137 myPredefinedValues->appendItem("120 km/h");
138 myPredefinedValues->appendItem("140 km/h");
139 myPredefinedValues->appendItem("160 km/h");
140 myPredefinedValues->appendItem("180 km/h");
141 myPredefinedValues->appendItem("200 km/h");
142 myPredefinedValues->setNumVisible(5);
143 }
144 {
145 // free
146 FXHorizontalFrame* gf12 =
147 new FXHorizontalFrame(gp, LAYOUT_TOP | LAYOUT_LEFT, 0, 0, 0, 0, 10, 10, 5, 5);
148 new FXRadioButton(gf12, "Free Entry: ", &myChosenTarget, FXDataTarget::ID_OPTION + 3,
149 ICON_BEFORE_TEXT | LAYOUT_SIDE_TOP | LAYOUT_CENTER_Y,
150 0, 0, 0, 0, 2, 2, 0, 0);
151 myUserDefinedSpeed =
152 new FXRealSpinner(gf12, 10, this, MID_USER_DEF,
153 LAYOUT_TOP | FRAME_SUNKEN | FRAME_THICK);
154 //myUserDefinedSpeed->setFormatString("%.0f km/h");
155 //myUserDefinedSpeed->setIncrements(1, 10, 10);
156 myUserDefinedSpeed->setIncrement(10);
157 myUserDefinedSpeed->setRange(0, 300);
158 myUserDefinedSpeed->setValue(0);
159 //static_cast<GUICalibrator*>(myObject)->getDefaultSpeed() * 3.6);
160 }
161 new FXButton(f1, "Close", nullptr, this, MID_CLOSE,
162 BUTTON_INITIAL | BUTTON_DEFAULT | FRAME_RAISED | FRAME_THICK | LAYOUT_TOP | LAYOUT_LEFT | LAYOUT_CENTER_X, 0, 0, 0, 0, 30, 30, 4, 4);
163 //static_cast<GUICalibrator*>(myObject)->setOverriding(true);
164}
165
166
168
169
170long
172 destroy();
173 return 1;
174}
175
176
177long
179 //mySpeed = (double)(myUserDefinedSpeed->getValue() / 3.6);
180 //static_cast<GUICalibrator*>(myObject)->setOverridingValue(mySpeed);
181 //myParent->updateChildren();
182 return 1;
183}
184
185
186long
187GUICalibrator::GUIManip_Calibrator::onUpdUserDef(FXObject* sender, FXSelector, void* ptr) {
188 sender->handle(this,
189 myChosenValue != 3 ? FXSEL(SEL_COMMAND, ID_DISABLE) : FXSEL(SEL_COMMAND, ID_ENABLE),
190 ptr);
191 myParent->updateChildren();
192 return 1;
193}
194
195
196long
198 //mySpeed = (double)(double)((myPredefinedValues->getCurrentItem() * 20 + 20) / 3.6);
199 //static_cast<GUICalibrator*>(myObject)->setOverridingValue(mySpeed);
200 //myParent->updateChildren();
201 return 1;
202}
203
204
205long
206GUICalibrator::GUIManip_Calibrator::onUpdPreDef(FXObject* sender, FXSelector, void* ptr) {
207 sender->handle(this,
208 myChosenValue != 2 ? FXSEL(SEL_COMMAND, ID_DISABLE) : FXSEL(SEL_COMMAND, ID_ENABLE),
209 ptr);
210 myParent->updateChildren();
211 return 1;
212}
213
214
215long
217 //static_cast<GUICalibrator*>(myObject)->setOverriding(true);
218 //switch (myChosenValue) {
219 // case 0:
220 // mySpeed = (double) static_cast<GUICalibrator*>(myObject)->getDefaultSpeed();
221 // break;
222 // case 1:
223 // mySpeed = (double) static_cast<GUICalibrator*>(myObject)->getLoadedSpeed();
224 // break;
225 // case 2:
226 // mySpeed = (double)((myPredefinedValues->getCurrentItem() * 20 + 20) / 3.6);
227 // break;
228 // case 3:
229 // mySpeed = (double)(myUserDefinedSpeed->getValue() / 3.6);
230 // break;
231 // default:
232 // // hmmm, should not happen
233 // break;
234 //}
235 //static_cast<GUICalibrator*>(myObject)->setOverridingValue(mySpeed);
236 //myParent->updateChildren();
237 //if (myChosenValue == 1) {
238 // // !!! lock in between
239 // static_cast<GUICalibrator*>(myObject)->setOverriding(false);
240 //}
241 return 1;
242}
243
244
245
246/* -------------------------------------------------------------------------
247 * GUICalibrator::GUICalibratorPopupMenu - methods
248 * ----------------------------------------------------------------------- */
253
254
256
257
258long
260 FXSelector,
261 void*) {
262 static_cast<GUICalibrator*>(myObject)->openManipulator(
263 *myApplication, *myParent);
264 return 1;
265}
266
267
268/* -------------------------------------------------------------------------
269 * GUICalibrator - methods
270 * ----------------------------------------------------------------------- */
273 myCalibrator(calibrator),
274 myShowAsKMH(true) {
275 const std::vector<MSLane*>& destLanes = calibrator->myEdge->getLanes();
276 const MSLane* lane = calibrator->myLane;
277 const double pos = calibrator->myPos;
278 for (std::vector<MSLane*>::const_iterator i = destLanes.begin(); i != destLanes.end(); ++i) {
279 if (lane == nullptr || (*i) == lane) {
280 const PositionVector& v = (*i)->getShape();
281 myFGPositions.push_back(v.positionAtOffset(pos));
283 myFGRotations.push_back(-v.rotationDegreeAtOffset(pos));
284 }
285 }
286}
287
288
290
291
294 GUISUMOAbstractView& parent) {
295 GUIGLObjectPopupMenu* ret = new GUICalibratorPopupMenu(app, parent, *this);
296 buildPopupHeader(ret, app);
298 //buildShowManipulatorPopupEntry(ret);
302 buildPositionCopyEntry(ret, app);
303 return ret;
304}
305
306
311 auto myCurrentStateInterval = myCalibrator->myCurrentStateInterval;
312 if (myCalibrator->isActive()) {
313 ret = new GUIParameterTableWindow(app, *this);
314 // add items
315 ret->mkItem("interval start", false, STEPS2TIME(myCurrentStateInterval->begin));
316 ret->mkItem("interval end", false, STEPS2TIME(myCurrentStateInterval->end));
317 ret->mkItem("aspired flow [veh/h]", false, myCurrentStateInterval->q);
318 ret->mkItem("aspired speed", false, myCurrentStateInterval->v);
321 ret->mkItem("default speed", false, myCalibrator->myDefaultSpeed);
327 } else {
328 ret = new GUIParameterTableWindow(app, *this);
329 const std::string nextStart =
330 (myCurrentStateInterval != myCalibrator->myIntervals.end() ?
331 time2string(myCurrentStateInterval->begin) :
332 "simulation end");
333 ret->mkItem("inactive until", false, nextStart);
334 }
335 // close building
336 ret->closeBuilding();
337 return ret;
338}
339
340
341void
343 const double exaggeration = getExaggeration(s);
345 std::string flow = "-";
346 std::string speed = "-";
347 if (myCalibrator->isActive()) {
348 auto myCurrentStateInterval = myCalibrator->myCurrentStateInterval;
349 if (myCurrentStateInterval->v >= 0) {
350 speed = toString(myCurrentStateInterval->v) + "m/s";
351 }
352 if (myCurrentStateInterval->q >= 0) {
353 flow = toString((int)myCurrentStateInterval->q) + "v/h";
354 }
355 }
356 for (int i = 0; i < (int)myFGPositions.size(); ++i) {
357 const Position& pos = myFGPositions[i];
358 double rot = myFGRotations[i];
360 glTranslated(pos.x(), pos.y(), getType());
361 glRotated(rot, 0, 0, 1);
362 glTranslated(0, 0, getType());
363 glScaled(exaggeration, exaggeration, 1);
364 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
365
366 glBegin(GL_TRIANGLES);
367 glColor3d(1, .8f, 0);
368 // base
369 glVertex2d(0 - 1.4, 0);
370 glVertex2d(0 - 1.4, 6);
371 glVertex2d(0 + 1.4, 6);
372 glVertex2d(0 + 1.4, 0);
373 glVertex2d(0 - 1.4, 0);
374 glVertex2d(0 + 1.4, 6);
375 glEnd();
376
377 // draw text
378 if (s.scale * exaggeration >= 1.) {
379 glTranslated(0, 0, .1);
380 GLHelper::drawText("C", Position(0, 2), 0.1, 3, RGBColor::BLACK, 180);
381 GLHelper::drawText(flow, Position(0, 4), 0.1, 0.7, RGBColor::BLACK, 180);
382 GLHelper::drawText(speed, Position(0, 5), 0.1, 0.7, RGBColor::BLACK, 180);
383 }
385 }
386 drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
388}
389
390
391double
395
396
400 b.grow(20);
401 return b;
402}
403
404
409 new GUIManip_Calibrator(app, getFullName(), *this, 0, 0);
410 gui->create();
411 gui->show();
412 return gui;
413}
414
415
416/****************************************************************************/
@ MID_MANIP
Open the object's manipulator.
Definition GUIAppEnum.h:482
FXDEFMAP(GUICalibrator::GUIManip_Calibrator) GUIManip_CalibratorMap[]
GUICalibratorPopupMenuMap[]
@ GLO_CALIBRATOR
a Calibrator
GUIIcon
An enumeration of icons used by the gui applications.
Definition GUIIcons.h:33
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:69
#define STEPS2TIME(x)
Definition SUMOTime.h:55
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 pushName(unsigned int name)
push Name
Definition GLHelper.cpp:139
static void popMatrix()
pop matrix
Definition GLHelper.cpp:130
static void popName()
pop Name
Definition GLHelper.cpp:148
static void pushMatrix()
push matrix
Definition GLHelper.cpp:117
static void drawText(const std::string &text, const Position &pos, const double layer, const double size, const RGBColor &col=RGBColor::BLACK, const double angle=0, const int align=0, double width=-1)
Definition GLHelper.cpp:685
long onCmdOpenManip(FXObject *, FXSelector, void *)
Called if the object's manipulator shall be shown.
long onCmdClose(FXObject *, FXSelector, void *)
long onCmdChangeOption(FXObject *, FXSelector, void *)
long onCmdUserDef(FXObject *, FXSelector, void *)
long onCmdPreDef(FXObject *, FXSelector, void *)
virtual ~GUIManip_Calibrator()
Destructor.
long onUpdUserDef(FXObject *, FXSelector, void *)
long onUpdPreDef(FXObject *, FXSelector, void *)
Changes the speed allowed on a set of lanes (gui version)
bool myShowAsKMH
The information whether the speed shall be shown in m/s or km/h.
MSCalibrator * myCalibrator
the calibrator being wrapped
double getExaggeration(const GUIVisualizationSettings &s) const
return exaggeration associated with this GLObject
RotCont myFGRotations
The rotations in full-geometry mode.
PosCont myFGPositions
The positions in full-geometry mode.
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
GUIManipulator * openManipulator(GUIMainWindow &app, GUISUMOAbstractView &parent)
Boundary myBoundary
The boundary of this rerouter.
GUICalibrator(MSCalibrator *calibrator)
Constructor.
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
The popup menu of a globject.
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
const std::string & getFullName() const
Definition GUIGlObject.h:92
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.
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
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,...
GUIGlID getGlID() const
Returns the numerical id of the object.
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0, bool forceShow=false) const
draw name of item
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.
Stores the information about how to visualize structures.
GUIVisualizationTextSettings addName
GUIVisualizationSizeSettings addSize
double scale
information about a lane's width (temporary, used for a single view)
Calibrates the flow on a segment to a specified one.
double currentSpeed() const
measured speed in the current interval
const MSEdge *const myEdge
the edge on which this calibrator lies
bool isActive() const
virtual int passed() const
std::vector< AspiredState >::const_iterator myCurrentStateInterval
Iterator pointing to the current interval.
int clearedInJam() const
double currentFlow() const
flow in the current interval in veh/h
std::vector< AspiredState > myIntervals
List of adaptation intervals.
const double myPos
the position on the edge where this calibrator lies
int totalWished() const
number of vehicles expected to pass this interval
double myDefaultSpeed
The default (maximum) speed on the segment.
MSLane *const myLane
the lane on which this calibrator lies (0 if the whole edge is covered at once)
int removed() const
int inserted() const
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition MSEdge.h:168
Representation of a lane in the micro simulation.
Definition MSLane.h:84
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
A list of positions.
double rotationDegreeAtOffset(double pos) const
Returns the rotation at the given length.
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
static const RGBColor BLACK
Definition RGBColor.h:193
Definition json.hpp:4471
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values