Eclipse SUMO - Simulation of Urban MObility
GUICalibrator.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/****************************************************************************/
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 * ----------------------------------------------------------------------- */
59
60};
61
62// Object implementation
64
65
66/* -------------------------------------------------------------------------
67 * GUICalibrator::GUIManip_Calibrator - mapping
68 * ----------------------------------------------------------------------- */
69FXDEFMAP(GUICalibrator::GUIManip_Calibrator) GUIManip_CalibratorMap[] = {
76};
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 * ----------------------------------------------------------------------- */
251 GUIGlObject& o)
252 : GUIGLObjectPopupMenu(app, parent, o) {}
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
393 return s.addSize.getExaggeration(s, this);
394}
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:480
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)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
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)
Definition: GUICalibrator.h:42
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.
Definition: GUIGlObject.h:154
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.
Definition: GUIGlObject.h:102
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.
Definition: MSCalibrator.h:47
double currentSpeed() const
measured speed in the current interval
const MSEdge *const myEdge
the edge on which this calibrator lies
Definition: MSCalibrator.h:287
bool isActive() const
Definition: MSCalibrator.h:221
virtual int passed() const
Definition: MSCalibrator.h:119
std::vector< AspiredState >::const_iterator myCurrentStateInterval
Iterator pointing to the current interval.
Definition: MSCalibrator.h:304
int clearedInJam() const
Definition: MSCalibrator.h:255
double currentFlow() const
flow in the current interval in veh/h
std::vector< AspiredState > myIntervals
List of adaptation intervals.
Definition: MSCalibrator.h:302
const double myPos
the position on the edge where this calibrator lies
Definition: MSCalibrator.h:291
int totalWished() const
number of vehicles expected to pass this interval
double myDefaultSpeed
The default (maximum) speed on the segment.
Definition: MSCalibrator.h:332
MSLane *const myLane
the lane on which this calibrator lies (0 if the whole edge is covered at once)
Definition: MSCalibrator.h:289
int removed() const
Definition: MSCalibrator.h:252
int inserted() const
Definition: MSCalibrator.h:249
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