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-2020 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>
28 #include <utils/gui/div/GLHelper.h>
29 #include <utils/common/ToString.h>
30 #include <utils/common/Command.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>
44 #include <guisim/GUICalibrator.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  * ----------------------------------------------------------------------- */
69 FXDEFMAP(GUICalibrator::GUIManip_Calibrator) GUIManip_CalibratorMap[] = {
76 };
77 
78 FXIMPLEMENT(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 
170 long
171 GUICalibrator::GUIManip_Calibrator::onCmdClose(FXObject*, FXSelector, void*) {
172  destroy();
173  return 1;
174 }
175 
176 
177 long
179  //mySpeed = (double)(myUserDefinedSpeed->getValue() / 3.6);
180  //static_cast<GUICalibrator*>(myObject)->setOverridingValue(mySpeed);
181  //myParent->updateChildren();
182  return 1;
183 }
184 
185 
186 long
187 GUICalibrator::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 
196 long
197 GUICalibrator::GUIManip_Calibrator::onCmdPreDef(FXObject*, FXSelector, void*) {
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 
205 long
206 GUICalibrator::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 
215 long
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  * ----------------------------------------------------------------------- */
250  GUIMainWindow& app, GUISUMOAbstractView& parent,
251  GUIGlObject& o)
252  : GUIGLObjectPopupMenu(app, parent, o) {}
253 
254 
256 
257 
258 long
260  FXSelector,
261  void*) {
262  static_cast<GUICalibrator*>(myObject)->openManipulator(
263  *myApplication, *myParent);
264  return 1;
265 }
266 
267 
268 /* -------------------------------------------------------------------------
269  * GUICalibrator - methods
270  * ----------------------------------------------------------------------- */
272  GUIGlObject_AbstractAdd(GLO_CALIBRATOR, calibrator->getID()),
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, false);
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);
319  ret->mkItem("current flow [veh/h]", true, new FunctionBinding<MSCalibrator, double>(myCalibrator, &MSCalibrator::currentFlow));
321  ret->mkItem("default speed", false, myCalibrator->myDefaultSpeed);
323  ret->mkItem("passed vehicles", true, new FunctionBinding<MSCalibrator, int>(myCalibrator, &MSCalibrator::passed));
324  ret->mkItem("inserted vehicles", true, new FunctionBinding<MSCalibrator, int>(myCalibrator, &MSCalibrator::inserted));
325  ret->mkItem("removed vehicles", true, new FunctionBinding<MSCalibrator, int>(myCalibrator, &MSCalibrator::removed));
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 
341 void
343  glPushName(getGlID());
344  std::string flow = "-";
345  std::string speed = "-";
346  if (myCalibrator->isActive()) {
347  auto myCurrentStateInterval = myCalibrator->myCurrentStateInterval;
348  if (myCurrentStateInterval->v >= 0) {
349  speed = toString(myCurrentStateInterval->v) + "m/s";
350  }
351  if (myCurrentStateInterval->q >= 0) {
352  flow = toString((int)myCurrentStateInterval->q) + "v/h";
353  }
354  }
355  const double exaggeration = s.addSize.getExaggeration(s, this);
356  for (int i = 0; i < (int)myFGPositions.size(); ++i) {
357  const Position& pos = myFGPositions[i];
358  double rot = myFGRotations[i];
359  glPushMatrix();
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  }
384  glPopMatrix();
385  }
386  drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
387  glPopName();
388 }
389 
390 
391 Boundary
393  Boundary b(myBoundary);
394  b.grow(20);
395  return b;
396 }
397 
398 
402  GUIManip_Calibrator* gui =
403  new GUIManip_Calibrator(app, getFullName(), *this, 0, 0);
404  gui->create();
405  gui->show();
406  return gui;
407 }
408 
409 
410 /****************************************************************************/
@ MID_MANIP
Open the object's manipulator.
Definition: GUIAppEnum.h:431
FXDEFMAP(GUICalibrator::GUIManip_Calibrator) GUIManip_CalibratorMap[]
GUICalibratorPopupMenuMap[]
@ GLO_CALIBRATOR
a Calibrator
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
#define STEPS2TIME(x)
Definition: SUMOTime.h:53
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:44
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:77
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:299
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:498
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
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 buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used,...
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
const std::string & getFullName() const
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.
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) 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:48
double currentSpeed() const
measured speed in the current interval
const MSEdge *const myEdge
the edge on which this calibrator lies
Definition: MSCalibrator.h:280
bool isActive() const
Definition: MSCalibrator.h:214
virtual int passed() const
Definition: MSCalibrator.h:125
std::vector< AspiredState >::const_iterator myCurrentStateInterval
Iterator pointing to the current interval.
Definition: MSCalibrator.h:297
int clearedInJam() const
Definition: MSCalibrator.h:248
double currentFlow() const
flow in the current interval in veh/h
std::vector< AspiredState > myIntervals
List of adaptation intervals.
Definition: MSCalibrator.h:295
const double myPos
the position on the edge where this calibrator lies
Definition: MSCalibrator.h:284
int totalWished() const
number of vehicles expected to pass this interval
double myDefaultSpeed
The default (maximum) speed on the segment.
Definition: MSCalibrator.h:325
MSLane *const myLane
the lane on which this calibrator lies (0 if the whole edge is covered at once)
Definition: MSCalibrator.h:282
int removed() const
Definition: MSCalibrator.h:245
int inserted() const
Definition: MSCalibrator.h:242
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:166
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:36
double x() const
Returns the x-position.
Definition: Position.h:54
double y() const
Returns the y-position.
Definition: Position.h:59
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:188
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values