Eclipse SUMO - Simulation of Urban MObility
GUIViewTraffic.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-2019 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 /****************************************************************************/
18 // A view on the simulation; this view is a microscopic one
19 /****************************************************************************/
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #include <config.h>
26 
27 #ifdef HAVE_FFMPEG
29 #endif
30 
31 #include <iostream>
32 #include <utility>
33 #include <cmath>
34 #include <limits>
35 #include <guisim/GUINet.h>
36 #include <guisim/GUIEdge.h>
37 #include <guisim/GUILane.h>
38 #include <guisim/GUIVehicle.h>
40 #include <microsim/MSGlobals.h>
41 #include <microsim/MSEdge.h>
42 #include <microsim/MSLane.h>
46 #include <utils/common/RGBColor.h>
48 #include "GUISUMOViewParent.h"
49 #include "GUIViewTraffic.h"
61 #include <utils/gui/div/GLHelper.h>
64 
65 /* -------------------------------------------------------------------------
66  * GUIViewTraffic - FOX callback mapping
67  * ----------------------------------------------------------------------- */
68 FXDEFMAP(GUIViewTraffic) GUIViewTrafficMap[] = {
69  FXMAPFUNC(SEL_COMMAND, MID_CLOSE_LANE, GUIViewTraffic::onCmdCloseLane),
70  FXMAPFUNC(SEL_COMMAND, MID_CLOSE_EDGE, GUIViewTraffic::onCmdCloseEdge),
71  FXMAPFUNC(SEL_COMMAND, MID_ADD_REROUTER, GUIViewTraffic::onCmdAddRerouter),
73 };
74 
75 
76 FXIMPLEMENT_ABSTRACT(GUIViewTraffic, GUISUMOAbstractView, GUIViewTrafficMap, ARRAYNUMBER(GUIViewTrafficMap))
77 
78 
79 // ===========================================================================
80 // member method definitions
81 // ===========================================================================
83  FXComposite* p,
84  GUIMainWindow& app,
85  GUISUMOViewParent* parent,
86  GUINet& net, FXGLVisual* glVis,
87  FXGLCanvas* share) :
88  GUISUMOAbstractView(p, app, parent, net.getVisualisationSpeedUp(), glVis, share),
89  myTrackedID(GUIGlObject::INVALID_ID),
90  myTLSGame(OptionsCont::getOptions().getString("game.mode") == "tls")
91 #ifdef HAVE_FFMPEG
92  , myCurrentVideo(nullptr)
93 #endif
94 {}
95 
96 
98  endSnapshot();
99 }
100 
101 
102 void
104  // build coloring tools
105  {
106  const std::vector<std::string>& names = gSchemeStorage.getNames();
107  for (std::vector<std::string>::const_iterator i = names.begin(); i != names.end(); ++i) {
108  v.getColoringSchemesCombo()->appendItem(i->c_str());
109  if ((*i) == myVisualizationSettings->name) {
110  v.getColoringSchemesCombo()->setCurrentItem(v.getColoringSchemesCombo()->getNumItems() - 1);
111  }
112  }
113  v.getColoringSchemesCombo()->setNumVisible(MAX2(5, (int)names.size() + 1));
114  }
115  // for junctions
116  new FXButton(v.getLocatorPopup(),
117  "\tLocate Junction\tLocate a junction within the network.",
119  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
120  // for edges
121  new FXButton(v.getLocatorPopup(),
122  "\tLocate Street\tLocate a street within the network.",
124  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
125 
126  // for vehicles
127  new FXButton(v.getLocatorPopup(),
128  "\tLocate Vehicle\tLocate a vehicle within the network.",
130  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
131 
132  // for persons
133  if (!MSGlobals::gUseMesoSim) { // there are no persons in mesosim (yet)
134  new FXButton(v.getLocatorPopup(),
135  "\tLocate Vehicle\tLocate a person within the network.",
137  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
138  }
139 
140  // for tls
141  new FXButton(v.getLocatorPopup(),
142  "\tLocate TLS\tLocate a tls within the network.",
144  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
145  // for additional stuff
146  new FXButton(v.getLocatorPopup(),
147  "\tLocate Additional\tLocate an additional structure within the network.",
149  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
150  // for pois
151  new FXButton(v.getLocatorPopup(),
152  "\tLocate PoI\tLocate a PoI within the network.",
154  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
155  // for polygons
156  new FXButton(v.getLocatorPopup(),
157  "\tLocate Polygon\tLocate a Polygon within the network.",
159  ICON_ABOVE_TEXT | FRAME_THICK | FRAME_RAISED);
160 }
161 
162 
163 bool
164 GUIViewTraffic::setColorScheme(const std::string& name) {
165  if (!gSchemeStorage.contains(name)) {
166  return false;
167  }
168  if (myVisualizationChanger != nullptr) {
169  if (myVisualizationChanger->getCurrentScheme() != name) {
171  }
172  }
173  myVisualizationSettings = &gSchemeStorage.get(name.c_str());
175  update();
176  return true;
177 }
178 
179 
180 void
182  bool hide, double hideThreshold) {
183  assert(!scheme.isFixed());
184  double minValue = std::numeric_limits<double>::infinity();
185  double maxValue = -std::numeric_limits<double>::infinity();
186  // retrieve range
187  if (objectType == GLO_LANE) {
188  // XXX (see #3409) multi-colors are not currently handled. this is a quick hack
189  if (active == 22) {
190  active = 21; // segment height, fall back to start height
191  } else if (active == 24) {
192  active = 23; // segment incline, fall back to total incline
193  }
194  const MSEdgeVector& edges = MSEdge::getAllEdges();
195  for (MSEdgeVector::const_iterator it = edges.begin(); it != edges.end(); ++it) {
197  const double val = static_cast<GUIEdge*>(*it)->getColorValue(s, active);
198  minValue = MIN2(minValue, val);
199  maxValue = MAX2(maxValue, val);
200  } else {
201  const std::vector<MSLane*>& lanes = (*it)->getLanes();
202  for (std::vector<MSLane*>::const_iterator it_l = lanes.begin(); it_l != lanes.end(); it_l++) {
203  const double val = static_cast<GUILane*>(*it_l)->getColorValue(s, active);
204  minValue = MIN2(minValue, val);
205  maxValue = MAX2(maxValue, val);
206  }
207  }
208  }
209  } else if (objectType == GLO_JUNCTION) {
210  if (active == 3) {
211  std::set<const MSJunction*> junctions;
212  for (MSEdge* edge : MSEdge::getAllEdges()) {
213  junctions.insert(edge->getFromJunction());
214  junctions.insert(edge->getToJunction());
215  }
216  for (const MSJunction* junction : junctions) {
217  minValue = MIN2(minValue, junction->getPosition().z());
218  maxValue = MAX2(maxValue, junction->getPosition().z());
219  }
220  }
221  }
223  scheme.clear();
224  // add threshold for every distinct value
225  std::set<SVCPermissions> codes;
226  for (MSEdge* edge : MSEdge::getAllEdges()) {
227  for (MSLane* lane : edge->getLanes()) {
228  codes.insert(lane->getPermissions());
229  }
230  }
231  int step = MAX2(1, 360 / (int)codes.size());
232  int hue = 0;
233  for (SVCPermissions p : codes) {
234  scheme.addColor(RGBColor::fromHSV(hue, 1, 1), p);
235  hue = (hue + step) % 360;
236  }
237  return;
238  }
239 
240  if (minValue != std::numeric_limits<double>::infinity()) {
241  scheme.clear();
242  // add new thresholds
243  if (hide) {
244  minValue = MAX2(hideThreshold + 1, minValue);
245  scheme.addColor(RGBColor(204, 204, 204), hideThreshold);
246  }
247  double range = maxValue - minValue;
248  scheme.addColor(RGBColor::RED, (minValue));
249  scheme.addColor(RGBColor::ORANGE, (minValue + range * 1 / 6.0));
250  scheme.addColor(RGBColor::YELLOW, (minValue + range * 2 / 6.0));
251  scheme.addColor(RGBColor::GREEN, (minValue + range * 3 / 6.0));
252  scheme.addColor(RGBColor::CYAN, (minValue + range * 4 / 6.0));
253  scheme.addColor(RGBColor::BLUE, (minValue + range * 5 / 6.0));
254  scheme.addColor(RGBColor::MAGENTA, (maxValue));
255  }
256 }
257 
258 
259 std::vector<std::string>
261  if (GUINet::getGUIInstance() != nullptr) {
263  }
264  return std::vector<std::string>();
265 }
266 
267 
268 std::vector<std::string>
270  std::set<std::string> keys;
271  for (const MSEdge* e : MSEdge::getAllEdges()) {
272  if (edgeKeys) {
273  for (const auto& item : e->getParametersMap()) {
274  keys.insert(item.first);
275  }
276  } else {
277  for (const auto lane : e->getLanes()) {
278  for (const auto& item : lane->getParametersMap()) {
279  keys.insert(item.first);
280  }
281  }
282  }
283  }
284  return std::vector<std::string>(keys.begin(), keys.end());
285 }
286 
287 
288 std::vector<std::string>
289 GUIViewTraffic::getVehicleParamKeys(bool /*vTypeKeys*/) const {
290  std::set<std::string> keys;
292  vc->secureVehicles();
293  for (auto vehIt = vc->loadedVehBegin(); vehIt != vc->loadedVehEnd(); ++vehIt) {
294  for (auto kv : vehIt->second->getParameter().getParametersMap()) {
295  keys.insert(kv.first);
296  }
297  }
298  vc->releaseVehicles();
299  return std::vector<std::string>(keys.begin(), keys.end());
300 }
301 
302 
303 int
304 GUIViewTraffic::doPaintGL(int mode, const Boundary& bound) {
305  // (uncomment the next line to check select mode)
306  //myVisualizationSettings->drawForRectangleSelection = true;
307  // init view settings
308  glRenderMode(mode);
309  glMatrixMode(GL_MODELVIEW);
310  glPushMatrix();
311  glDisable(GL_TEXTURE_2D);
312  glDisable(GL_ALPHA_TEST);
313  glEnable(GL_BLEND);
314  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
315  glEnable(GL_DEPTH_TEST);
316 
317  // draw decals (if not in grabbing mode)
318  if (!myUseToolTips) {
319  drawDecals();
321  paintGLGrid();
322  }
323  }
324 
325  glLineWidth(1);
326  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
327  const float minB[2] = { (float)bound.xmin(), (float)bound.ymin() };
328  const float maxB[2] = { (float)bound.xmax(), (float)bound.ymax() };
330  glEnable(GL_POLYGON_OFFSET_FILL);
331  glEnable(GL_POLYGON_OFFSET_LINE);
332  int hits2 = myGrid->Search(minB, maxB, *myVisualizationSettings);
333  // Draw additional objects
334  if (myAdditionallyDrawn.size() > 0) {
335  glTranslated(0, 0, -.01);
337  for (auto i : myAdditionallyDrawn) {
338  i.first->drawGLAdditional(this, *myVisualizationSettings);
339  }
341  glTranslated(0, 0, .01);
342  }
343  glPopMatrix();
344  /*
345  // draw legends
346  glMatrixMode(GL_MODELVIEW);
347  glLoadIdentity();
348  glTranslated(1.-.2, 1.-.5, 0.);
349  glScaled(.2, .5, 1.);
350  GUIColoringSchemesMap<GUILane> &sm = GUIViewTraffic::getLaneSchemesMap(); //!!!
351  sm.getColorer(myVisualizationSettings->laneEdgeMode)->drawLegend();
352  */
353  return hits2;
354 }
355 
356 
357 void
359  myTrackedID = id;
360 }
361 
362 
363 void
366 }
367 
368 
369 GUIGlID
371  return myTrackedID;
372 }
373 
374 
375 void
377  if (myTLSGame) {
379  const MSTrafficLightLogic* minTll = nullptr;
380  double minDist = std::numeric_limits<double>::infinity();
381  for (const MSTrafficLightLogic* const tll : tlsControl.getAllLogics()) {
382  if (tlsControl.isActive(tll) && tll->getProgramID() != "off") {
383  // get the links
384  const MSTrafficLightLogic::LaneVector& lanes = tll->getLanesAt(0);
385  if (lanes.size() > 0) {
386  const Position& endPos = lanes[0]->getShape().back();
387  if (endPos.distanceTo(pos) < minDist) {
388  minDist = endPos.distanceTo(pos);
389  minTll = tll;
390  }
391  }
392  }
393  }
394  if (minTll != nullptr) {
395  const MSTLLogicControl::TLSLogicVariants& vars = tlsControl.get(minTll->getID());
396  const std::vector<MSTrafficLightLogic*> logics = vars.getAllLogics();
397  if (logics.size() > 1) {
399  for (int i = 0; i < (int)logics.size() - 1; ++i) {
400  if (minTll->getProgramID() == logics[i]->getProgramID()) {
401  l = (MSSimpleTrafficLightLogic*) logics[i + 1];
402  tlsControl.switchTo(minTll->getID(), l->getProgramID());
403  }
404  }
405  if (l == logics[0]) {
406  tlsControl.switchTo(minTll->getID(), l->getProgramID());
407  }
409  update();
410  }
411  }
412  } else {
413  // DRT game
415  return;
416  }
417  const std::set<GUIGlID>& sel = gSelected.getSelected(GLO_VEHICLE);
418  if (sel.size() == 0) {
419  // find closest pt vehicle
420  double minDist = std::numeric_limits<double>::infinity();
421  GUIVehicle* closest = nullptr;
425  for (it = vc.loadedVehBegin(); it != end; ++it) {
426  GUIVehicle* veh = dynamic_cast<GUIVehicle*>(it->second);
427  assert(veh != 0);
428  if (veh->getParameter().line != "") {
429  const double dist = veh->getPosition().distanceTo2D(pos);
430  if (dist < minDist) {
431  minDist = dist;
432  closest = veh;
433  }
434  }
435  }
436  if (closest != nullptr) {
437  gSelected.select(closest->getGlID());
439  }
440  } else {
441  // find closest pt stop
442  double minDist = std::numeric_limits<double>::infinity();
443  MSStoppingPlace* closestStop = nullptr;
445  for (auto it = stops.begin(); it != stops.end(); ++it) {
446  MSStoppingPlace* stop = it->second;
447  const double dist = pos.distanceTo2D(stop->getLane().geometryPositionAtOffset(stop->getEndLanePosition()));
448  if (dist < minDist) {
449  minDist = dist;
450  closestStop = stop;
451  }
452  }
453  if (closestStop != 0) {
454  GUIGlID id = *sel.begin();
455  GUIVehicle* veh = dynamic_cast<GUIVehicle*>(GUIGlObjectStorage::gIDStorage.getObjectBlocking(id));
456  assert(veh != 0);
457  MSLane* lane = veh->getLane();
458  lane->getVehiclesSecure();
459  veh->rerouteDRTStop(closestStop);
461  lane->releaseVehicles();
462  }
463  }
464  }
465 }
466 
467 
468 void
470  const std::set<GUIGlID>& sel = gSelected.getSelected(GLO_VEHICLE);
471  if (sel.size() > 0) {
472  GUIGlID id = *sel.begin();
473  GUIVehicle* veh = dynamic_cast<GUIVehicle*>(GUIGlObjectStorage::gIDStorage.getObjectBlocking(id));
474  if (veh != 0) {
476  }
478  }
479  gSelected.clear();
480 }
481 
482 
483 SUMOTime
486 }
487 
488 
489 GUILane*
491  if (makeCurrent()) {
492  int id = getObjectUnderCursor();
493  if (id != 0) {
495  if (o != nullptr) {
496  return dynamic_cast<GUILane*>(o);
497  }
498  }
499  makeNonCurrent();
500  }
501  return nullptr;
502 }
503 
504 long
505 GUIViewTraffic::onCmdCloseLane(FXObject*, FXSelector, void*) {
506  GUILane* lane = getLaneUnderCursor();
507  if (lane != nullptr) {
508  lane->closeTraffic();
510  update();
511  }
512  return 1;
513 }
514 
515 
516 long
517 GUIViewTraffic::onCmdCloseEdge(FXObject*, FXSelector, void*) {
518  GUILane* lane = getLaneUnderCursor();
519  if (lane != nullptr) {
520  dynamic_cast<GUIEdge*>(&lane->getEdge())->closeTraffic(lane);
522  update();
523  }
524  return 1;
525 }
526 
527 
528 long
529 GUIViewTraffic::onCmdAddRerouter(FXObject*, FXSelector, void*) {
530  GUILane* lane = getLaneUnderCursor();
531  if (lane != nullptr) {
532  dynamic_cast<GUIEdge*>(&lane->getEdge())->addRerouter();
534  update();
535  }
536  return 1;
537 }
538 
539 
540 long
541 GUIViewTraffic::onCmdShowReachability(FXObject* menu, FXSelector, void*) {
542  GUILane* lane = getLaneUnderCursor();
543  if (lane != nullptr) {
544  // reset
545  const double UNREACHABLE = -1;
546  gSelected.clear();
547  for (const MSEdge* const e : MSEdge::getAllEdges()) {
548  for (MSLane* const l : e->getLanes()) {
549  GUILane* gLane = dynamic_cast<GUILane*>(l);
551  }
552  }
553  // prepare
554  FXMenuCommand* mc = dynamic_cast<FXMenuCommand*>(menu);
555  const SUMOVehicleClass svc = SumoVehicleClassStrings.get(mc->getText().text());
556  const double defaultMaxSpeed = SUMOVTypeParameter::VClassDefaultValues(svc).maxSpeed;
557  // find reachable
558  std::map<MSEdge*, double> reachableEdges;
559  reachableEdges[&lane->getEdge()] = 0;
560  MSEdgeVector check;
561  check.push_back(&lane->getEdge());
562  while (check.size() > 0) {
563  MSEdge* e = check.front();
564  check.erase(check.begin());
565  double traveltime = reachableEdges[e];
566  for (MSLane* const l : e->getLanes()) {
567  if (l->allowsVehicleClass(svc)) {
568  GUILane* gLane = dynamic_cast<GUILane*>(l);
569  gSelected.select(gLane->getGlID());
570  gLane->setReachability(traveltime);
571  }
572  }
573  traveltime += e->getLength() / MIN2(e->getSpeedLimit(), defaultMaxSpeed);
574  for (MSEdge* const nextEdge : e->getSuccessors(svc)) {
575  if (reachableEdges.count(nextEdge) == 0 ||
576  // revisit edge via faster path
577  reachableEdges[nextEdge] > traveltime) {
578  reachableEdges[nextEdge] = traveltime;
579  check.push_back(nextEdge);
580  }
581  }
582  }
583  // switch to 'color by selection' unless coloring 'by reachability'
586  }
587  update();
588  }
589  return 1;
590 }
591 
592 
593 long
594 GUIViewTraffic::onDoubleClicked(FXObject*, FXSelector, void*) {
595  // leave fullscreen mode
596  if (myApp->isFullScreen()) {
597  myApp->onCmdFullScreen(nullptr, 0, nullptr);
598  } else {
599  stopTrack();
600  }
601  return 1;
602 }
603 
604 
605 
606 void
607 GUIViewTraffic::saveFrame(const std::string& destFile, FXColor* buf) {
608 #ifdef HAVE_FFMPEG
609  if (myCurrentVideo == nullptr) {
610  myCurrentVideo = new GUIVideoEncoder(destFile.c_str(), getWidth(), getHeight(), myApp->getDelay());
611  }
612  myCurrentVideo->writeFrame((uint8_t*)buf);
613 #else
614  UNUSED_PARAMETER(destFile);
615  UNUSED_PARAMETER(buf);
616 #endif
617 }
618 
619 
620 void
622 #ifdef HAVE_FFMPEG
623  if (myCurrentVideo != nullptr) {
624  delete myCurrentVideo;
625  myCurrentVideo = nullptr;
626  }
627 #endif
628 }
629 
630 
631 void
633 #ifdef HAVE_FFMPEG
634  if (myCurrentVideo != nullptr) {
636  }
637 #endif
639 }
640 
641 
642 const std::vector<SUMOTime>
644  return myApp->retrieveBreakpoints();
645 }
646 
647 
648 /****************************************************************************/
MSLane::releaseVehicles
virtual void releaseVehicles() const
Allows to use the container for microsimulation again.
Definition: MSLane.h:457
MID_LOCATEPOI
Locate poi - button.
Definition: GUIAppEnum.h:338
GUICompleteSchemeStorage.h
MSStoppingPlace::getLane
const MSLane & getLane() const
Returns the lane this stop is located at.
Definition: MSStoppingPlace.cpp:57
GUIViewTraffic.h
MID_LOCATETLS
Locate TLS - button.
Definition: GUIAppEnum.h:334
UNUSED_PARAMETER
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:31
GUIVisualizationSettings::name
std::string name
The name of this setting.
Definition: GUIVisualizationSettings.h:399
GUISUMOAbstractView::makeCurrent
FXbool makeCurrent()
A reimplementation due to some internal reasons.
Definition: GUISUMOAbstractView.cpp:841
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
GUIMainWindow::getDelay
virtual double getDelay() const
Returns the delay (should be overwritten by subclasses if applicable)
Definition: GUIMainWindow.h:106
MSLane::getVehiclesSecure
virtual const VehCont & getVehiclesSecure() const
Returns the vehicles container; locks it for microsimulation.
Definition: MSLane.h:427
GUIViewTraffic::endSnapshot
void endSnapshot()
Ends a video snapshot.
Definition: GUIViewTraffic.cpp:621
MID_CLOSE_EDGE
close edge
Definition: GUIAppEnum.h:561
MFXImageHelper.h
MSSimpleTrafficLightLogic::getPhase
const MSPhaseDefinition & getPhase(int givenstep) const
Returns the definition of the phase from the given position within the plan.
Definition: MSSimpleTrafficLightLogic.cpp:115
MSBaseVehicle::getParameter
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
Definition: MSBaseVehicle.cpp:144
MSStoppingPlace
A lane area vehicles can halt at.
Definition: MSStoppingPlace.h:59
MSEdge::getSuccessors
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition: MSEdge.cpp:959
MIN2
T MIN2(T a, T b)
Definition: StdDefs.h:73
MSEdge::getSpeedLimit
double getSpeedLimit() const
Returns the speed limit of the edge @caution The speed limit of the first lane is retured; should pro...
Definition: MSEdge.cpp:877
MID_LOCATEEDGE
Locate edge - button.
Definition: GUIAppEnum.h:324
GUIVehicle.h
MSTLLogicControl::isActive
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
Definition: MSTLLogicControl.cpp:653
GUISUMOAbstractView
Definition: GUISUMOAbstractView.h:72
MSTLLogicControl.h
MSLane
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
GUISUMOViewParent
A single child window which contains a view of the simulation area.
Definition: GUISUMOViewParent.h:58
GUIViewTraffic
Definition: GUIViewTraffic.h:54
GUISUMOAbstractView::myAdditionallyDrawn
std::map< GUIGlObject *, int > myAdditionallyDrawn
List of objects for which GUIGlObject::drawGLAdditional is called.
Definition: GUISUMOAbstractView.h:510
Boundary::ymin
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:130
MSJunction
The base class for an intersection.
Definition: MSJunction.h:60
MSStoppingPlace::getEndLanePosition
double getEndLanePosition() const
Returns the end position of this stop.
Definition: MSStoppingPlace.cpp:69
MSTrafficLightLogic::getProgramID
const std::string & getProgramID() const
Returns this tl-logic's id.
Definition: MSTrafficLightLogic.h:174
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:36
GUIVehicleControl.h
GUINet::getGUIInstance
static GUINet * getGUIInstance()
Returns the pointer to the unique instance of GUINet (singleton).
Definition: GUINet.cpp:515
GUIVisualizationSettings::drawForRectangleSelection
bool drawForRectangleSelection
whether drawing is performed for the purpose of selecting objects using a rectangle
Definition: GUIVisualizationSettings.h:647
GUIViewTraffic::stopTrack
void stopTrack()
Stops vehicle tracking.
Definition: GUIViewTraffic.cpp:364
GUIVideoEncoder
A simple video encoder from RGBA pics to anything ffmpeg can handle.
Definition: GUIVideoEncoder.h:70
GUISUMOAbstractView::m2p
double m2p(double meter) const
meter-to-pixels conversion method
Definition: GUISUMOAbstractView.cpp:771
GUIVisualizationSettings::SCHEME_NAME_PERMISSION_CODE
static const std::string SCHEME_NAME_PERMISSION_CODE
Definition: GUIVisualizationSettings.h:674
GUIVisualizationSettings::showGrid
bool showGrid
Information whether a grid shall be shown.
Definition: GUIVisualizationSettings.h:420
RGBColor::YELLOW
static const RGBColor YELLOW
Definition: RGBColor.h:192
GUISUMOAbstractView::getObjectUnderCursor
GUIGlID getObjectUnderCursor()
returns the id of the front object under the cursor using GL_SELECT
Definition: GUISUMOAbstractView.cpp:329
GUIGlobalSelection.h
GUIVehicle::rerouteDRTStop
void rerouteDRTStop(MSStoppingPlace *busStop)
handle route to accomodate to given stop
Definition: GUIVehicle.cpp:919
RGBColor::CYAN
static const RGBColor CYAN
Definition: RGBColor.h:193
MSTLLogicControl::getAllLogics
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
Definition: MSTLLogicControl.cpp:578
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
GUIViewTraffic::getEdgeDataAttrs
std::vector< std::string > getEdgeDataAttrs() const
return list of loaded edgeData attributes
Definition: GUIViewTraffic.cpp:260
GUIViewTraffic::onCmdCloseLane
long onCmdCloseLane(FXObject *, FXSelector, void *)
interaction with the simulation
Definition: GUIViewTraffic.cpp:505
Boundary::xmax
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:124
GUISUMOAbstractView::addSnapshot
void addSnapshot(SUMOTime time, const std::string &file, const int w=-1, const int h=-1)
Sets the snapshot time to file map.
Definition: GUISUMOAbstractView.cpp:1097
GUIViewTraffic::getLaneUnderCursor
GUILane * getLaneUnderCursor()
Definition: GUIViewTraffic.cpp:490
MID_REACHABILITY
show reachability from a given lane
Definition: GUIAppEnum.h:446
GUIMainWindow::isFullScreen
bool isFullScreen()
Definition: GUIMainWindow.h:133
MSJunctionControl.h
GUIVehicleControl::secureVehicles
void secureVehicles()
lock access to vehicle removal/additions for thread synchronization
Definition: GUIVehicleControl.cpp:102
ICON_LOCATEEDGE
Definition: GUIIcons.h:76
SUMO_const_laneWidth
const double SUMO_const_laneWidth
Definition: StdDefs.h:49
MSGlobals::gUseMesoSim
static bool gUseMesoSim
Definition: MSGlobals.h:90
GUISUMOAbstractView::checkSnapshots
virtual void checkSnapshots()
Checks whether it is time for a snapshot.
Definition: GUISUMOAbstractView.cpp:1273
GUIVehicleControl
The class responsible for building and deletion of vehicles (gui-version)
Definition: GUIVehicleControl.h:46
MID_LOCATEPERSON
Locate person - button.
Definition: GUIAppEnum.h:332
MSEdge.h
GLO_VEHICLE
Definition: GUIGlObjectTypes.h:141
GLHelper.h
ICON_LOCATETLS
Definition: GUIIcons.h:81
GUINet.h
GUIIconSubSys::getIcon
static FXIcon * getIcon(GUIIcon which)
returns a icon previously defined in the enum GUIIcon
Definition: GUIIconSubSys.cpp:609
MSEdge::getLength
double getLength() const
return the length of the edge
Definition: MSEdge.h:589
GUILane::closeTraffic
void closeTraffic(bool rebuildAllowed=true)
close this lane for traffic
Definition: GUILane.cpp:1302
MSVehicleControl::constVehIt
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
Definition: MSVehicleControl.h:74
MSSimpleTrafficLightLogic.h
GUIViewTraffic::onGamingClick
void onGamingClick(Position pos)
handle mouse click in gaming mode
Definition: GUIViewTraffic.cpp:376
RGBColor.h
GUIMainWindow::retrieveBreakpoints
virtual const std::vector< SUMOTime > retrieveBreakpoints() const
retrieve breakpoints if provided by the application
Definition: GUIMainWindow.h:138
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
GUIGlObjectStorage.h
GUIAppEnum.h
ICON_LOCATEADD
Definition: GUIIcons.h:82
GUIGlObjectType
GUIGlObjectType
Definition: GUIGlObjectTypes.h:39
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:79
GUICompleteSchemeStorage::getNames
const std::vector< std::string > & getNames() const
Returns a list of stored settings names.
Definition: GUICompleteSchemeStorage.cpp:99
SUMOVehicleParameter::line
std::string line
The vehicle's line (mainly for public transport)
Definition: SUMOVehicleParameter.h:561
GUISUMOAbstractView.h
RGBColor
Definition: RGBColor.h:39
GUIBaseVehicle::removeActiveAddVisualisation
void removeActiveAddVisualisation(GUISUMOAbstractView *const parent, int which)
Adds the named visualisation feature to the given view.
Definition: GUIBaseVehicle.cpp:711
MSTrafficLightLogic::LaneVector
std::vector< MSLane * > LaneVector
Definition of the list of arrival lanes subjected to this tls.
Definition: MSTrafficLightLogic.h:70
MSTLLogicControl::TLSLogicVariants::getAllLogics
std::vector< MSTrafficLightLogic * > getAllLogics() const
Definition: MSTLLogicControl.cpp:183
MSPhaseDefinition::duration
SUMOTime duration
The duration of the phase.
Definition: MSPhaseDefinition.h:70
RGBColor::MAGENTA
static const RGBColor MAGENTA
Definition: RGBColor.h:194
GUIGlObject::INVALID_ID
static const GUIGlID INVALID_ID
Definition: GUIGlObject.h:69
MSNet::getStoppingPlaces
const NamedObjectCont< MSStoppingPlace * > & getStoppingPlaces(SumoXMLTag category) const
Definition: MSNet.cpp:934
MSTLLogicControl::get
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
Definition: MSTLLogicControl.cpp:589
GUIMainWindow::isGaming
bool isGaming() const
return whether the gui is in gaming mode
Definition: GUIMainWindow.h:82
NamedObjectCont
A map of named object pointers.
Definition: NamedObjectCont.h:43
ICON_LOCATEJUNCTION
Definition: GUIIcons.h:75
Boundary::xmin
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:118
GUISelectedStorage::select
void select(GUIGlID id, bool update=true)
Adds the object with the given id.
Definition: GUISelectedStorage.cpp:113
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:218
GUIPerspectiveChanger.h
GUILane::setReachability
void setReachability(double value)
Definition: GUILane.h:238
RGBColor::ORANGE
static const RGBColor ORANGE
Definition: RGBColor.h:195
GUIPropertyScheme::clear
void clear()
Definition: GUIPropertyScheme.h:104
GUILane.h
Position::distanceTo
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:233
GUIPropertyScheme::isFixed
bool isFixed() const
Definition: GUIPropertyScheme.h:157
SUMORTree.h
GUIViewTraffic::getTrackedID
GUIGlID getTrackedID() const
Returns the id of the tracked vehicle (-1 if none)
Definition: GUIViewTraffic.cpp:370
MSNet::getCurrentTimeStep
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:283
GUIViewTraffic::onCmdShowReachability
long onCmdShowReachability(FXObject *, FXSelector, void *)
highlight edges according to reachability
Definition: GUIViewTraffic.cpp:541
GUIVehicle
A MSVehicle extended by some values for usage within the gui.
Definition: GUIVehicle.h:53
SUMOVTypeParameter::VClassDefaultValues::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:100
MSVehicleControl::loadedVehEnd
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
Definition: MSVehicleControl.h:185
NamedObjectCont::begin
IDMap::const_iterator begin() const
Returns a reference to the begin iterator for the internal map.
Definition: NamedObjectCont.h:144
ICON_LOCATEPOI
Definition: GUIIcons.h:83
GUIGlObject::getGlID
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.cpp:149
MID_ADD_REROUTER
add rerouter
Definition: GUIAppEnum.h:563
update
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:41
RGBColor::BLUE
static const RGBColor BLUE
Definition: RGBColor.h:191
GUIVisualizationSettings::scale
double scale
information about a lane's width (temporary, used for a single view)
Definition: GUIVisualizationSettings.h:632
ICON_LOCATEPOLY
Definition: GUIIcons.h:84
GUIApplicationWindow.h
GUISUMOViewParent.h
GUIViewTraffic::onDoubleClicked
long onDoubleClicked(FXObject *, FXSelector, void *)
Definition: GUIViewTraffic.cpp:594
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
gSchemeStorage
GUICompleteSchemeStorage gSchemeStorage
Definition: GUICompleteSchemeStorage.cpp:38
MSSimpleTrafficLightLogic
A fixed traffic light logic.
Definition: MSSimpleTrafficLightLogic.h:54
MSGlobals.h
GUIViewTraffic::retrieveBreakpoints
const std::vector< SUMOTime > retrieveBreakpoints() const
retrieve breakpoints from the current runThread
Definition: GUIViewTraffic.cpp:643
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:189
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
MSEdge
A road/street connecting two junctions.
Definition: MSEdge.h:78
GLO_LANE
a lane
Definition: GUIGlObjectTypes.h:48
GUIViewTraffic::buildColorRainbow
void buildColorRainbow(const GUIVisualizationSettings &s, GUIColorScheme &scheme, int active, GUIGlObjectType objectType, bool hide=false, double hideThreshold=0)
recalibrate color scheme according to the current value range
Definition: GUIViewTraffic.cpp:181
MSTrafficLightLogic
The parent class for traffic light logics.
Definition: MSTrafficLightLogic.h:55
GUISUMOAbstractView::myVisualizationSettings
GUIVisualizationSettings * myVisualizationSettings
visualization settings
Definition: GUISUMOAbstractView.h:471
GUISUMOAbstractView::drawDecals
void drawDecals()
Draws the stored decals.
Definition: GUISUMOAbstractView.cpp:1535
RGBColor::fromHSV
static RGBColor fromHSV(double h, double s, double v)
Converts the given hsv-triplet to rgb, inspired by http://alvyray.com/Papers/CG/hsv2rgb....
Definition: RGBColor.cpp:298
GUIGlObjectStorage::getObjectBlocking
GUIGlObject * getObjectBlocking(GUIGlID id)
Returns the object from the container locking it.
Definition: GUIGlObjectStorage.cpp:62
GUIViewTraffic::setColorScheme
bool setColorScheme(const std::string &name)
set color scheme
Definition: GUIViewTraffic.cpp:164
GUIGlObject
Definition: GUIGlObject.h:65
GUIDialog_ViewSettings.h
GUINet::lock
void lock()
grant exclusive access to the simulation state
Definition: GUINet.cpp:531
GUIViewTraffic::~GUIViewTraffic
virtual ~GUIViewTraffic()
destructor
Definition: GUIViewTraffic.cpp:97
ICON_LOCATEPERSON
Definition: GUIIcons.h:80
MSVehicle::getLane
MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:560
GUISelectedStorage::clear
void clear()
Clears the list of selected objects.
Definition: GUISelectedStorage.cpp:176
MSLane::getEdge
MSEdge & getEdge() const
Returns the lane's edge.
Definition: MSLane.h:669
GUIIconSubSys.h
Position::distanceTo2D
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:243
INVALID_ID
#define INVALID_ID
Definition: NWWriter_OpenDrive.cpp:40
GUIViewTraffic::getEdgeLaneParamKeys
std::vector< std::string > getEdgeLaneParamKeys(bool edgeKeys) const
return list of available edge parameters
Definition: GUIViewTraffic.cpp:269
GUIViewTraffic::checkSnapshots
void checkSnapshots()
Checks whether it is time for a snapshot.
Definition: GUIViewTraffic.cpp:632
ICON_LOCATEVEHICLE
Definition: GUIIcons.h:77
GLIncludes.h
GUIBaseVehicle::VO_SHOW_FUTURE_ROUTE
show vehicle's current continued from the current position
Definition: GUIBaseVehicle.h:299
GUIGlObjectStorage::unblockObject
void unblockObject(GUIGlID id)
Marks an object as unblocked.
Definition: GUIGlObjectStorage.cpp:119
MSNet::getTLSControl
MSTLLogicControl & getTLSControl()
Returns the tls logics control.
Definition: MSNet.h:409
GUILane
Representation of a lane in the micro simulation (gui-version)
Definition: GUILane.h:61
SUMO_TAG_BUS_STOP
A bus stop.
Definition: SUMOXMLDefinitions.h:97
GUIVideoEncoder.h
MSTLLogicControl::switchTo
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
Definition: MSTLLogicControl.cpp:673
MSNet::getInstance
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:167
GUIMainWindow
Definition: GUIMainWindow.h:46
GUIDialog_ViewSettings::setCurrentScheme
void setCurrentScheme(const std::string &)
Sets the named scheme as the current.
Definition: GUIDialog_ViewSettings.cpp:1791
MID_LOCATEJUNCTION
Locate junction - button.
Definition: GUIAppEnum.h:322
MID_CLOSE_LANE
close lane
Definition: GUIAppEnum.h:559
FXDEFMAP
FXDEFMAP(GUIViewTraffic) GUIViewTrafficMap[]
GUIViewTraffic::onCmdCloseEdge
long onCmdCloseEdge(FXObject *, FXSelector, void *)
Definition: GUIViewTraffic.cpp:517
MSSimpleTrafficLightLogic::changeStepAndDuration
void changeStepAndDuration(MSTLLogicControl &tlcontrol, SUMOTime simStep, int step, SUMOTime stepDuration)
Changes the current phase and her duration.
Definition: MSSimpleTrafficLightLogic.cpp:187
NamedObjectCont::end
IDMap::const_iterator end() const
Returns a reference to the end iterator for the internal map.
Definition: NamedObjectCont.h:149
GUIMainWindow::onCmdFullScreen
virtual long onCmdFullScreen(FXObject *, FXSelector, void *)
Toggle full screen mode.
Definition: GUIMainWindow.h:129
GUIGlID
unsigned int GUIGlID
Definition: GUIGlObject.h:42
SUMOVTypeParameter::VClassDefaultValues
struct for default values that depend of VClass
Definition: SUMOVTypeParameter.h:89
GUISUMOAbstractView::myApp
GUIMainWindow * myApp
The application.
Definition: GUISUMOAbstractView.h:447
GUIVehicleControl::releaseVehicles
void releaseVehicles()
unlock access to vehicle removal/additions for thread synchronization
Definition: GUIVehicleControl.cpp:108
GUIViewTraffic::myTrackedID
GUIGlID myTrackedID
Definition: GUIViewTraffic.h:137
GUIViewTraffic::doPaintGL
int doPaintGL(int mode, const Boundary &bound)
paint GL
Definition: GUIViewTraffic.cpp:304
GUIEdge.h
MSEdgeVector
std::vector< MSEdge * > MSEdgeVector
Definition: MSEdge.h:74
GUINet::unlock
void unlock()
release exclusive access to the simulation state
Definition: GUINet.cpp:537
GUIPropertyScheme::getName
const std::string & getName() const
Definition: GUIPropertyScheme.h:137
GUIViewTraffic::buildViewToolBars
virtual void buildViewToolBars(GUIGlChildWindow &)
builds the view toolbars
Definition: GUIViewTraffic.cpp:103
GUISUMOAbstractView::myGrid
SUMORTree * myGrid
The visualization speed-up.
Definition: GUISUMOAbstractView.h:453
GUIGlObjectStorage::gIDStorage
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
Definition: GUIGlObjectStorage.h:140
GUISUMOAbstractView::paintGLGrid
void paintGLGrid()
paints a grid
Definition: GUISUMOAbstractView.cpp:540
gSelected
GUISelectedStorage gSelected
A global holder of selected objects.
Definition: GUIGlobalSelection.cpp:33
GUIGlChildWindow::getColoringSchemesCombo
FXComboBox * getColoringSchemesCombo()
return combobox with the current coloring schemes (standard, fastest standard, real world....
Definition: GUIGlChildWindow.cpp:183
MSEdge::getLanes
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:167
MID_LOCATEVEHICLE
Locate vehicle - button.
Definition: GUIAppEnum.h:326
GUISUMOAbstractView::myUseToolTips
bool myUseToolTips
use tool tips
Definition: GUISUMOAbstractView.h:474
MSTLLogicControl::TLSLogicVariants
Storage for all programs of a single tls.
Definition: MSTLLogicControl.h:85
GUIPropertyScheme::addColor
int addColor(const T &color, const double threshold, const std::string &name="")
Definition: GUIPropertyScheme.h:80
GUIViewTraffic::getCurrentTimeStep
SUMOTime getCurrentTimeStep() const
get the current simulation time
Definition: GUIViewTraffic.cpp:484
config.h
SUMORTree::Search
virtual int Search(const float a_min[2], const float a_max[2], const GUIVisualizationSettings &c) const
Find all within search rectangle.
Definition: SUMORTree.h:118
MSVehicleControl
The class responsible for building and deletion of vehicles.
Definition: MSVehicleControl.h:71
GUIViewTraffic::saveFrame
void saveFrame(const std::string &destFile, FXColor *buf)
Adds a frame to a video snapshot which will be initialized if neccessary.
Definition: GUIViewTraffic.cpp:607
GUISUMOAbstractView::myVisualizationChanger
GUIDialog_ViewSettings * myVisualizationChanger
Visualization changer.
Definition: GUISUMOAbstractView.h:486
GUIVisualizationSettings::laneColorer
GUIColorer laneColorer
The lane colorer.
Definition: GUIVisualizationSettings.h:440
GLO_JUNCTION
a junction
Definition: GUIGlObjectTypes.h:50
MSLane::geometryPositionAtOffset
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition: MSLane.h:504
MSTLLogicControl
A class that stores and controls tls and switching of their programs.
Definition: MSTLLogicControl.h:59
RGBColor::GREEN
static const RGBColor GREEN
Definition: RGBColor.h:190
MSVehicleControl::loadedVehBegin
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
Definition: MSVehicleControl.h:177
MSLane.h
GUIGlChildWindow
Definition: GUIGlChildWindow.h:40
GUIViewTraffic::myTLSGame
bool myTLSGame
whether game mode was set to 'tls'
Definition: GUIViewTraffic.h:140
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:345
GUISelectedStorage::getSelected
const std::set< GUIGlID > & getSelected() const
Returns the set of ids of all selected objects.
Definition: GUISelectedStorage.cpp:164
UNREACHABLE
#define UNREACHABLE
Definition: AStarLookupTable.h:32
MID_LOCATEPOLY
Locate polygons - button.
Definition: GUIAppEnum.h:340
GUIViewTraffic::getVehicleParamKeys
std::vector< std::string > getVehicleParamKeys(bool vTypeKeys) const
return list of available vehicle parameters
Definition: GUIViewTraffic.cpp:289
GUINet
A MSNet extended by some values for usage within the gui.
Definition: GUINet.h:82
GUIVehicle::getPosition
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
Definition: GUIVehicle.h:73
GUINet::getEdgeDataAttrs
std::vector< std::string > getEdgeDataAttrs() const
return list of loaded edgeData attributes
Definition: GUINet.cpp:619
GUIViewTraffic::startTrack
void startTrack(int id)
Starts vehicle tracking.
Definition: GUIViewTraffic.cpp:358
MSEdge::getAllEdges
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
Definition: MSEdge.cpp:798
GUICompleteSchemeStorage::contains
bool contains(const std::string &name) const
Returns the information whether a setting with the given name is stored.
Definition: GUICompleteSchemeStorage.cpp:74
GUIVideoEncoder::writeFrame
void writeFrame(uint8_t *buffer)
Definition: GUIVideoEncoder.h:198
MID_LOCATEADD
Locate addtional structure - button.
Definition: GUIAppEnum.h:336
GUINet::getGUIVehicleControl
GUIVehicleControl * getGUIVehicleControl()
Returns the vehicle control.
Definition: GUINet.cpp:525
GUIVisualizationSettings::gaming
bool gaming
whether the application is in gaming mode or not
Definition: GUIVisualizationSettings.h:635
Named::getID
const std::string & getID() const
Returns the id.
Definition: Named.h:76
GUIViewTraffic::onCmdAddRerouter
long onCmdAddRerouter(FXObject *, FXSelector, void *)
Definition: GUIViewTraffic.cpp:529
GUIPropertySchemeStorage::setActive
void setActive(int scheme)
Definition: GUIPropertySchemeStorage.h:69
GUICompleteSchemeStorage::get
GUIVisualizationSettings & get(const std::string &name)
Returns the named scheme.
Definition: GUICompleteSchemeStorage.cpp:62
PositionVector.h
GUIGlChildWindow::getLocatorPopup
FXPopup * getLocatorPopup()
@ brief return a pointer to locator popup
Definition: GUIGlChildWindow.cpp:177
GUIDialog_ViewSettings::getCurrentScheme
std::string getCurrentScheme() const
Returns the name of the currently chosen scheme.
Definition: GUIDialog_ViewSettings.cpp:1785
MSNet::getVehicleControl
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:336
GUIPropertyScheme
Definition: GUIPropertyScheme.h:45
GUIPropertySchemeStorage::getActive
int getActive() const
Definition: GUIPropertySchemeStorage.h:75
GUIViewTraffic::onGamingRightClick
void onGamingRightClick(Position pos)
Definition: GUIViewTraffic.cpp:469
MFXCheckableButton.h
Boundary::ymax
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:136
GUIBaseVehicle::addActiveAddVisualisation
void addActiveAddVisualisation(GUISUMOAbstractView *const parent, int which)
Adds the named visualisation feature to the given view.
Definition: GUIBaseVehicle.cpp:701