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-2018 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
17 // Changes flow and speed on a set of lanes (gui version)
18 /****************************************************************************/
19 // ===========================================================================
20 // included modules
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);
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);
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(
264  return 1;
265 }
266 
267 
268 /* -------------------------------------------------------------------------
269  * GUICalibrator - methods
270  * ----------------------------------------------------------------------- */
271 GUICalibrator::GUICalibrator(const std::string& id,
272  MSEdge* edge,
273  MSLane* lane,
274  double pos,
275  const std::string& aXMLFilename,
276  const std::string& outputFilename,
277  const SUMOTime freq,
278  const MSRouteProbe* probe) :
279  MSCalibrator(id, edge, lane, pos, aXMLFilename, outputFilename, freq, edge->getLength(), probe),
281  myShowAsKMH(true) {
282  const std::vector<MSLane*>& destLanes = edge->getLanes();
283  for (std::vector<MSLane*>::const_iterator i = destLanes.begin(); i != destLanes.end(); ++i) {
284  if (lane == nullptr || (*i) == lane) {
285  const PositionVector& v = (*i)->getShape();
286  myFGPositions.push_back(v.positionAtOffset(pos));
288  myFGRotations.push_back(-v.rotationDegreeAtOffset(pos));
289  }
290  }
291 }
292 
293 
295 
296 
299  GUISUMOAbstractView& parent) {
300  GUIGLObjectPopupMenu* ret = new GUICalibratorPopupMenu(app, parent, *this);
301  buildPopupHeader(ret, app);
303  //buildShowManipulatorPopupEntry(ret);
307  buildPositionCopyEntry(ret, false);
308  return ret;
309 }
310 
311 
316  if (isActive()) {
317  ret = new GUIParameterTableWindow(app, *this, 12);
318  // add items
319  ret->mkItem("interval start", false, STEPS2TIME(myCurrentStateInterval->begin));
320  ret->mkItem("interval end", false, STEPS2TIME(myCurrentStateInterval->end));
321  ret->mkItem("aspired flow [veh/h]", false, myCurrentStateInterval->q);
322  ret->mkItem("aspired speed", false, myCurrentStateInterval->v);
323  ret->mkItem("current flow [veh/h]", true, new FunctionBinding<GUICalibrator, double>(this, &GUICalibrator::currentFlow));
324  ret->mkItem("current speed", true, new FunctionBinding<GUICalibrator, double>(this, &GUICalibrator::currentSpeed));
325  ret->mkItem("default speed", false, myDefaultSpeed);
326  ret->mkItem("required vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::totalWished));
327  ret->mkItem("passed vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::passed));
328  ret->mkItem("inserted vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::inserted));
329  ret->mkItem("removed vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::removed));
330  ret->mkItem("cleared in jam", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::clearedInJam));
331  } else {
332  ret = new GUIParameterTableWindow(app, *this, 1);
333  const std::string nextStart =
336  "simulation end");
337  ret->mkItem("inactive until", false, nextStart);
338  }
339  // close building
340  ret->closeBuilding();
341  return ret;
342 }
343 
344 
345 void
347  glPushName(getGlID());
348  std::string flow = "-";
349  std::string speed = "-";
350  if (isActive()) {
351  if (myCurrentStateInterval->v >= 0) {
352  speed = toString(myCurrentStateInterval->v) + "m/s";
353  }
354  if (myCurrentStateInterval->q >= 0) {
355  flow = toString((int)myCurrentStateInterval->q) + "v/h";
356  }
357  }
358  const double exaggeration = s.addSize.getExaggeration(s, this);
359  for (int i = 0; i < (int)myFGPositions.size(); ++i) {
360  const Position& pos = myFGPositions[i];
361  double rot = myFGRotations[i];
362  glPushMatrix();
363  glTranslated(pos.x(), pos.y(), getType());
364  glRotated(rot, 0, 0, 1);
365  glTranslated(0, 0, getType());
366  glScaled(exaggeration, exaggeration, 1);
367  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
368 
369  glBegin(GL_TRIANGLES);
370  glColor3d(1, .8f, 0);
371  // base
372  glVertex2d(0 - 1.4, 0);
373  glVertex2d(0 - 1.4, 6);
374  glVertex2d(0 + 1.4, 6);
375  glVertex2d(0 + 1.4, 0);
376  glVertex2d(0 - 1.4, 0);
377  glVertex2d(0 + 1.4, 6);
378  glEnd();
379 
380  // draw text
381  if (s.scale * exaggeration >= 1.) {
382  glTranslated(0, 0, .1);
383  GLHelper::drawText("C", Position(0, 2), 0.1, 3, RGBColor::BLACK, 180);
384  GLHelper::drawText(flow, Position(0, 4), 0.1, 0.7, RGBColor::BLACK, 180);
385  GLHelper::drawText(speed, Position(0, 5), 0.1, 0.7, RGBColor::BLACK, 180);
386  }
387  glPopMatrix();
388  }
389  drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
390  glPopName();
391 }
392 
393 
394 Boundary
396  Boundary b(myBoundary);
397  b.grow(20);
398  return b;
399 }
400 
401 
405  GUIManip_Calibrator* gui =
406  new GUIManip_Calibrator(app, getFullName(), *this, 0, 0);
407  gui->create();
408  gui->show();
409  return gui;
410 }
411 
412 
413 
414 /****************************************************************************/
415 
double rotationDegreeAtOffset(double pos) const
Returns the rotation at the given length.
long long int SUMOTime
Definition: SUMOTime.h:36
double scale
information about a lane&#39;s width (temporary, used for a single view)
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
Changes the speed allowed on a set of lanes (gui version)
Definition: GUICalibrator.h:45
GUIVisualizationTextSettings addName
void buildNameCopyPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds entries which allow to copy the name / typed name into the clipboard.
Open the object&#39;s manipulator.
Definition: GUIAppEnum.h:258
GUIManipulator * openManipulator(GUIMainWindow &app, GUISUMOAbstractView &parent)
virtual int passed() const
Definition: MSCalibrator.h:169
Writes routes of vehicles passing a certain edge.
Definition: MSRouteProbe.h:61
Stores the information about how to visualize structures.
double y() const
Returns the y-position.
Definition: Position.h:62
void mkItem(const char *name, bool dynamic, ValueSource< T > *src)
Adds a row which obtains its value from a ValueSource.
std::string time2string(SUMOTime t)
Definition: SUMOTime.cpp:65
double x() const
Returns the x-position.
Definition: Position.h:57
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
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, int align=0, double width=-1)
Definition: GLHelper.cpp:611
const std::vector< MSLane * > & getLanes() const
Returns this edge&#39;s lanes.
Definition: MSEdge.h:162
GUISUMOAbstractView * myParent
The parent window.
static const RGBColor BLACK
Definition: RGBColor.h:192
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
long onCmdChangeOption(FXObject *, FXSelector, void *)
double currentSpeed() const
measured speed in the current interval
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.
long onUpdPreDef(FXObject *, FXSelector, void *)
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:42
long onCmdOpenManip(FXObject *, FXSelector, void *)
Called if the object&#39;s manipulator shall be shown.
FXDEFMAP(GUICalibrator::GUIManip_Calibrator) GUIManip_CalibratorMap[]
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
int totalWished() const
number of vehicles expected to pass this interval
A road/street connecting two junctions.
Definition: MSEdge.h:75
GUICalibratorPopupMenuMap[]
GUIVisualizationSizeSettings addSize
virtual ~GUIManip_Calibrator()
Destructor.
GUIGlObjectType getType() const
Returns the type of the object as coded in GUIGlObjectType.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:49
std::vector< AspiredState >::const_iterator myCurrentStateInterval
Iterator pointing to the current interval.
Definition: MSCalibrator.h:241
Boundary myBoundary
The boundary of this rerouter.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
A list of positions.
long onCmdPreDef(FXObject *, FXSelector, void *)
#define STEPS2TIME(x)
Definition: SUMOTime.h:58
double myDefaultSpeed
The default (maximum) speed on the segment.
Definition: MSCalibrator.h:269
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0) const
draw name of item
RotCont myFGRotations
The rotations in full-geometry mode.
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:301
bool isActive() const
Definition: MSCalibrator.h:146
std::vector< AspiredState > myIntervals
List of adaptation intervals.
Definition: MSCalibrator.h:239
a Calibrator
long onCmdClose(FXObject *, FXSelector, void *)
bool myShowAsKMH
The information whether the speed shall be shown in m/s or km/h.
PosCont myFGPositions
The positions in full-geometry mode.
GUICalibrator(const std::string &id, MSEdge *edge, MSLane *lane, double pos, const std::string &aXMLFilename, const std::string &outputFilename, const SUMOTime freq, const MSRouteProbe *probe)
Constructor.
The popup menu of a globject.
void buildSelectionPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to (de)select the object.
int clearedInJam() const
Definition: MSCalibrator.h:198
GUIGlID getGlID() const
Returns the numerical id of the object.
Calibrates the flow on a segment to a specified one.
Definition: MSCalibrator.h:50
long onCmdUserDef(FXObject *, FXSelector, void *)
long onUpdUserDef(FXObject *, FXSelector, void *)
GUIMainWindow * myApplication
The main application.
const std::string & getFullName() const
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:79
int removed() const
Definition: MSCalibrator.h:195
GUIGlObject * myObject
The object that belongs to this popup-menu.
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
Representation of a lane in the micro simulation.
Definition: MSLane.h:78
A window containing a gl-object&#39;s parameter.
double currentFlow() const
flow in the current interval in veh/h
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
int inserted() const
Definition: MSCalibrator.h:192
Close simulation - ID.
Definition: GUIAppEnum.h:80