Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GUISUMOAbstractView.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
21// The base class for a view
22/****************************************************************************/
23#pragma once
24#include <config.h>
25
26#include <string>
27#include <vector>
28#include <map>
30// fx3d includes windows.h so we need to guard against macro pollution
31#ifdef WIN32
32#define NOMINMAX
33#endif
34#include <fx3d.h>
35#ifdef WIN32
36#undef NOMINMAX
37#endif
38
39#include <utils/geom/Boundary.h>
40#include <utils/geom/Position.h>
45
46
47// ===========================================================================
48// class declarations
49// ===========================================================================
51class GUIVehicle;
53class GUIMainWindow;
55class GUIGlObject;
59class GUILane;
60
61// ===========================================================================
62// class definitions
63// ===========================================================================
70class GUISUMOAbstractView : public FXGLCanvas {
71 FXDECLARE(GUISUMOAbstractView)
72
73public:
75 GUISUMOAbstractView(FXComposite* p, GUIMainWindow& app, GUIGlChildWindow* parent, const SUMORTree& grid, FXGLVisual* glVis, FXGLCanvas* share);
76
78 virtual ~GUISUMOAbstractView();
79
81 virtual void recalculateBoundaries() = 0;
82
85
87 virtual void recenterView();
88
95 virtual void centerTo(GUIGlID id, bool applyZoom, double zoomDist = 20);
96
103 virtual void centerTo(const Position& pos, bool applyZoom, double zoomDist = 20);
104
106 void centerTo(const Boundary& bound);
107
109 virtual void setViewportFromToRot(const Position& lookFrom, const Position& lookAt, double rotation);
110
112 virtual void copyViewportTo(GUISUMOAbstractView* view);
113
115 double m2p(double meter) const;
116
118 double p2m(double pixel) const;
119
122
125
127 void setWindowCursorPosition(FXint x, FXint y);
128
130 FXbool makeCurrent();
131
133 bool isInEditMode();
134
137
140
142 virtual bool is3DView() const;
143
145 virtual void zoom2Pos(Position& camera, Position& lookAt, double zoom);
146
148
149 virtual long onConfigure(FXObject*, FXSelector, void*);
150 virtual long onPaint(FXObject*, FXSelector, void*);
151 virtual long onLeftBtnPress(FXObject*, FXSelector, void*);
152 virtual long onLeftBtnRelease(FXObject*, FXSelector, void*);
153 virtual long onMiddleBtnPress(FXObject*, FXSelector, void*);
154 virtual long onMiddleBtnRelease(FXObject*, FXSelector, void*);
155 virtual long onRightBtnPress(FXObject*, FXSelector, void*);
156 virtual long onRightBtnRelease(FXObject*, FXSelector, void*);
157 virtual long onDoubleClicked(FXObject*, FXSelector, void*);
158 virtual long onMouseWheel(FXObject*, FXSelector, void*);
159 virtual long onMouseMove(FXObject*, FXSelector, void*);
160 virtual long onMouseLeft(FXObject*, FXSelector, void*);
162
164
165 virtual long onKeyPress(FXObject* o, FXSelector sel, void* data);
166 virtual long onKeyRelease(FXObject* o, FXSelector sel, void* data);
168
170 virtual long onCmdCloseLane(FXObject*, FXSelector, void*);
171 virtual long onCmdCloseEdge(FXObject*, FXSelector, void*);
172 virtual long onCmdAddRerouter(FXObject*, FXSelector, void*);
173
175 virtual long onCmdShowReachability(FXObject*, FXSelector, void*);
176
178 virtual long onVisualizationChange(FXObject*, FXSelector, void*);
179
181 virtual void openObjectDialogAtCursor(const FXEvent* ev);
182
184 void openObjectDialog(const std::vector<GUIGlObject*>& objects, const bool filter = true);
185
187 void updateToolTip();
188
191
197 void addSnapshot(SUMOTime time, const std::string& file, const int w = -1, const int h = -1);
198
208 std::string makeSnapshot(const std::string& destFile, const int w = -1, const int h = -1);
209
211 virtual void saveFrame(const std::string& destFile, FXColor* buf);
212
214 virtual void endSnapshot() {}
215
217 virtual void checkSnapshots();
218
219 void waitForSnapshots(const SUMOTime snapshotTime);
220
222 virtual SUMOTime getCurrentTimeStep() const;
223
225
228
230 virtual void updateViewportValues();
231
233 virtual void showViewportEditor();
234
237
239 virtual bool setColorScheme(const std::string&);
240
243
246
248 virtual void buildColorRainbow(const GUIVisualizationSettings& /*s*/, GUIColorScheme& /*scheme*/, int /*active*/, GUIGlObjectType /*objectType*/,
249 bool hide = false, double hideThreshold = 0,
250 bool hide2 = false, double hideThreshold2 = 0) {
251 UNUSED_PARAMETER(hide);
252 UNUSED_PARAMETER(hideThreshold);
253 UNUSED_PARAMETER(hide2);
254 UNUSED_PARAMETER(hideThreshold2);
255 }
256
258 virtual std::vector<std::string> getEdgeDataAttrs() const {
259 return std::vector<std::string>();
260 }
261
263 virtual std::vector<std::string> getMeanDataIDs() const {
264 return std::vector<std::string>();
265 }
266
268 virtual std::vector<std::string> getMeanDataAttrs(const std::string& meanDataID) const {
269 UNUSED_PARAMETER(meanDataID);
270 return std::vector<std::string>();
271 }
272
274 virtual std::vector<std::string> getRelDataAttrs() const {
275 return std::vector<std::string>();
276 }
277
279 virtual std::vector<std::string> getEdgeLaneParamKeys(bool /*edgeKeys*/) const {
280 return std::vector<std::string>();
281 }
282
284 virtual std::vector<std::string> getVehicleParamKeys(bool /*vTypeKeys*/) const {
285 return std::vector<std::string>();
286 }
287
289 virtual std::vector<std::string> getPOIParamKeys() const {
290 return std::vector<std::string>();
291 }
292
295
298
300 // @todo: check why this is here
301 double getGridWidth() const;
302
304 // @todo: check why this is here
305 double getGridHeight() const;
306
308 virtual void startTrack(int /*id*/);
309
311 virtual void stopTrack();
312
314 virtual GUIGlID getTrackedID() const;
315
317 virtual void onGamingClick(Position /*pos*/);
318 virtual void onGamingRightClick(Position /*pos*/);
319
322
328 bool addAdditionalGLVisualisation(GUIGlObject* const which);
329
336
341 bool isAdditionalGLVisualisationEnabled(GUIGlObject* const which) const;
342
344
346 const Position& getPopupPosition() const;
347
349 void destroyPopup();
350
353
356 struct Decal {
357
359 Decal() {};
360
362 std::string filename;
363
365 double centerX = 0;
366
368 double centerY = 0;
369
371 double centerZ = 0;
372
374 double width = 0;
375
377 double height = 0;
378
380 double altitude = 0;
381
383 double rot = 0;
384
386 double tilt = 0;
387
389 double roll = 0;
390
392 double layer = 0;
393
395 bool initialised = false;
396
398 bool skip2D = false;
399
401 bool screenRelative = false;
402
404 int glID = -1;
405
407 FXImage* image = nullptr;
408 };
409
411 std::vector<Decal>& getDecals();
412
414 FXMutex& getDecalsLockMutex();
415
417 FXComboBox* getColoringSchemesCombo();
418
420 virtual Position getPositionInformation() const;
421
425 Position snapToActiveGrid(const Position& pos, bool snapXY = true) const;
426
428 Position screenPos2NetPos(int x, int y) const;
429
431 void addDecals(const std::vector<Decal>& decals);
432
434 double getDelay() const;
435
437 void setDelay(double delay);
438
440 void setBreakpoints(const std::vector<SUMOTime>& breakpoints);
441
443 virtual const std::vector<SUMOTime> retrieveBreakpoints() const {
444 return std::vector<SUMOTime>();
445 }
446
448 double getFPS() const;
449
452
453protected:
455 FOX_CONSTRUCTOR(GUISUMOAbstractView)
456
457
458 void paintGL();
459
461 virtual void updatePositionInformationLabel() const;
462
464 virtual int doPaintGL(int /*mode*/, const Boundary& /*boundary*/);
465
467 virtual void doInit();
468
470 void paintGLGrid();
471
473 void displayLegend();
474
476 void displayLegends();
477
479 void displayColorLegend(const GUIColorScheme& scheme, bool leftSide);
480
482 void drawFPS();
483
485 virtual GUILane* getLaneUnderCursor();
486
489
491 std::vector<GUIGlID> getObjectsUnderCursor();
492
494 std::vector<GUIGlObject*> getGUIGlObjectsUnderCursor();
495
497 std::vector<GUIGlObject*> getGUIGlObjectsUnderSnappedCursor();
498
501
503 std::vector<GUIGlID> getObjectsAtPosition(Position pos, double radius);
504
506 std::vector<GUIGlObject*> getGUIGlObjectsAtPosition(Position pos, double radius);
507
509 std::vector<GUIGlID> getObjectsInBoundary(Boundary bound, bool singlePosition);
510
512 std::vector<GUIGlObject*> filterInernalLanes(const std::vector<GUIGlObject*>& objects) const;
513
515 bool showToolTipFor(const GUIGlID idToolTip);
516
518 void drawDecals();
519
521 void openPopupDialog();
522
526 Boundary applyGLTransform(bool fixRatio = true);
527
529 FXImage* checkGDALImage(Decal& d);
530
533
536
539
542
544 bool myPanning = false;
545
547 bool myInEditMode = false;
548
551
554
557
560
562 std::vector<GUIGlObject*> myCurrentObjectsDialog;
563
566
568 bool myAmInitialised = false;
569
572
575
578
581
583 std::vector<Decal> myDecals;
584
587
589
591 std::map<SUMOTime, std::vector<std::tuple<std::string, int, int> > > mySnapshots;
592
595
598
600 mutable FXMutex myPolyDrawLock;
601
603 std::map<GUIGlObject*, int> myAdditionallyDrawn;
604
607
608private:
610 struct LayerObject : public std::pair<double, std::pair<GUIGlObjectType, std::string> > {
611
612 public:
614 LayerObject(double layer, GUIGlObject* object);
615
617 LayerObject(GUIGlObject* object);
618
620 GUIGlObject* getGLObject() const;
621
622 private:
625 };
626
628 std::vector<GUIGlObject*> filterGUIGLObjectsByLayer(const std::vector<GUIGlObject*>& objects) const;
629
630 // @brief sensitivity for "<>AtPosition(...) functions
631 static const double SENSITIVITY;
632};
long long int SUMOTime
Definition GUI.h:36
unsigned int GUIGlID
Definition GUIGlObject.h:43
GUIGlObjectType
#define UNUSED_PARAMETER(x)
Definition StdDefs.h:30
A class that stores a 2D geometrical boundary.
Definition Boundary.h:39
A dialog to change the viewport.
The dialog to change the view (gui) settings.
The popup menu of a globject.
Representation of a lane in the micro simulation (gui-version)
Definition GUILane.h:60
void paintGLGrid()
paints a grid
bool myAmInitialised
Internal information whether doInit() was called.
Position snapToActiveGrid(const Position &pos, bool snapXY=true) const
Returns a position that is mapped to the closest grid point if the grid is active.
std::vector< GUIGlObject * > myCurrentObjectsDialog
vector with current objects dialog
std::string makeSnapshot(const std::string &destFile, const int w=-1, const int h=-1)
Takes a snapshots and writes it into the given file.
void updateToolTip()
A method that updates the tooltip.
void addDecals(const std::vector< Decal > &decals)
add decals
virtual void checkSnapshots()
Checks whether it is time for a snapshot.
void showViewschemeEditor()
show viewsscheme editor
static const double SENSITIVITY
virtual long onLeftBtnRelease(FXObject *, FXSelector, void *)
void displayLegend()
Draws a line with ticks, and the length information.
virtual long onVisualizationChange(FXObject *, FXSelector, void *)
hook to react on change in visualization settings
std::vector< GUIGlObject * > getGUIGlObjectsUnderCursor()
returns the GUIGlObject under the cursor using GL_SELECT (including overlapped objects)
long myFrameDrawTime
counter for measuring rendering time
void replacePopup(GUIGLObjectPopupMenu *popUp)
replace PopUp
std::vector< GUIGlID > getObjectsAtPosition(Position pos, double radius)
returns the ids of the object at position within the given (rectangular) radius using GL_SELECT
virtual void endSnapshot()
Ends a video snapshot.
const SUMORTree * myGrid
The visualization speed-up.
void openObjectDialog(const std::vector< GUIGlObject * > &objects, const bool filter=true)
open object dialog for the given object
virtual void saveFrame(const std::string &destFile, FXColor *buf)
Adds a frame to a video snapshot which will be initialized if necessary.
virtual void recenterView()
recenters the view
virtual SUMOTime getCurrentTimeStep() const
get the current simulation time
std::vector< GUIGlID > getObjectsInBoundary(Boundary bound, bool singlePosition)
returns the ids of all objects in the given boundary
FXbool makeCurrent()
A reimplementation due to some internal reasons.
Position myClickedPopupPosition
clicked poup position
int myMouseHotspotX
Offset to the mouse-hotspot from the mouse position.
std::vector< GUIGlObject * > filterInernalLanes(const std::vector< GUIGlObject * > &objects) const
filter internal lanes in Objects under cursor
GUIMainWindow * getMainWindow() const
get main window
bool isInEditMode()
returns true, if the edit button was pressed
virtual long onMiddleBtnRelease(FXObject *, FXSelector, void *)
virtual long onMouseMove(FXObject *, FXSelector, void *)
bool myPanning
Panning flag.
bool isAdditionalGLVisualisationEnabled(GUIGlObject *const which) const
Check if an object is added in the additional GL visualitation.
FXMutex myDecalsLockMutex
The mutex to use before accessing the decals list in order to avoid thread conflicts.
FXCondition mySnapshotCondition
the semaphore when waiting for snapshots to finish
Position myPopupPosition
The current popup-menu position.
virtual void doInit()
doInit
virtual long onCmdCloseEdge(FXObject *, FXSelector, void *)
virtual int doPaintGL(int, const Boundary &)
paint GL
virtual void buildViewToolBars(GUIGlChildWindow *)
builds the view toolbars
virtual void showViewportEditor()
show viewport editor
const GUIVisualizationSettings & getVisualisationSettings() const
get visualization settings (read only)
virtual std::vector< std::string > getMeanDataAttrs(const std::string &meanDataID) const
return list of available attributes for the given meanData id
void setDelay(double delay)
Sets the delay of the parent application.
Boundary getVisibleBoundary() const
get visible boundary
FXMutex myPolyDrawLock
poly draw lock
Position screenPos2NetPos(int x, int y) const
Translate screen position to network position.
void addSnapshot(SUMOTime time, const std::string &file, const int w=-1, const int h=-1)
Sets the snapshot time to file map.
GUIGlID getObjectUnderCursor()
returns the id of the front object under the cursor using GL_SELECT
GUIPerspectiveChanger & getChanger() const
get changer
virtual void centerTo(GUIGlID id, bool applyZoom, double zoomDist=20)
centers to the chosen artifact
GUIMainWindow * myApp
The application.
GUIDialog_EditViewport * getViewportEditor()
get the viewport and create it on first access
virtual void zoom2Pos(Position &camera, Position &lookAt, double zoom)
zoom interface for 3D view
virtual long onCmdCloseLane(FXObject *, FXSelector, void *)
interaction with the simulation
void drawFPS()
Draws frames-per-second indicator.
virtual long onMouseWheel(FXObject *, FXSelector, void *)
double getGridWidth() const
get grid width
std::vector< Decal > & getDecals()
The list of decals to show.
std::vector< GUIGlObject * > filterGUIGLObjectsByLayer(const std::vector< GUIGlObject * > &objects) const
@fbrief filter elements by layer
bool removeAdditionalGLVisualisation(GUIGlObject *const which)
Removes an object from the list of objects that show additional things.
GUIGlChildWindow * myGlChildWindowParent
The parent window.
GUIGlChildWindow * getGUIGlChildWindow()
get GUIGlChildWindow
double getDelay() const
Returns the delay of the parent application.
virtual void updatePositionInformationLabel() const
update position information labels
std::vector< GUIGlObject * > getGUIGlObjectsAtPosition(Position pos, double radius)
returns the GUIGlObjects at position within the given (rectangular) radius using GL_SELECT
virtual long onLeftBtnPress(FXObject *, FXSelector, void *)
virtual void setViewportFromToRot(const Position &lookFrom, const Position &lookAt, double rotation)
applies the given viewport settings
double p2m(double pixel) const
pixels-to-meters conversion method
std::vector< Decal > myDecals
The list of decals to show.
const Position & getPopupPosition() const
get position of current popup
double m2p(double meter) const
meter-to-pixels conversion method
virtual GUILane * getLaneUnderCursor()
returns the GUILane at cursor position (implementation depends on view)
virtual void openObjectDialogAtCursor(const FXEvent *ev)
open object dialog at the cursor position
virtual std::vector< std::string > getEdgeLaneParamKeys(bool) const
return list of available edge parameters
virtual void onGamingClick(Position)
on gaming click
bool myInEditMode
Information whether too-tip informations shall be generated.
GUIVisualizationSettings * editVisualisationSettings() const
edit visualization settings (allow modify VisualizationSetings, use carefully)
GUIVisualizationSettings * myVisualizationSettings
visualization settings
void destroyPopup()
destroys the popup
virtual void buildColorRainbow(const GUIVisualizationSettings &, GUIColorScheme &, int, GUIGlObjectType, bool hide=false, double hideThreshold=0, bool hide2=false, double hideThreshold2=0)
recalibrate color scheme according to the current value range
Position getWindowCursorPosition() const
return windows cursor position
virtual long onKeyPress(FXObject *o, FXSelector sel, void *data)
keyboard functions
GUIDialog_EditViewport * myGUIDialogEditViewport
viewport chooser
virtual long onMiddleBtnPress(FXObject *, FXSelector, void *)
virtual std::vector< std::string > getVehicleParamKeys(bool) const
return list of available vehicle parameters
void paintGL()
FOX needs this.
virtual void stopTrack()
stop track
virtual Position getPositionInformation() const
Returns the cursor's x/y position within the network.
virtual std::vector< std::string > getMeanDataIDs() const
return list of loaded edgeData ids (being computed in the current simulation)
GUIGlID getObjectAtPosition(Position pos)
returns the id of the object at position using GL_SELECT
std::vector< GUIGlObject * > getGUIGlObjectsUnderSnappedCursor()
returns the GUIGlObject under the gripped cursor using GL_SELECT (including overlapped objects)
bool showToolTipFor(const GUIGlID idToolTip)
invokes the tooltip for the given object
virtual long onKeyRelease(FXObject *o, FXSelector sel, void *data)
GUIDialog_ViewSettings * myGUIDialogViewSettings
Visualization changer.
virtual void onGamingRightClick(Position)
void setWindowCursorPosition(FXint x, FXint y)
Returns the gl-id of the object under the given coordinates.
double getFPS() const
retrieve FPS
virtual long onCmdShowReachability(FXObject *, FXSelector, void *)
highlight edges according to reachability
std::map< GUIGlObject *, int > myAdditionallyDrawn
List of objects for which GUIGlObject::drawGLAdditional is called.
void drawDecals()
Draws the stored decals.
std::vector< GUIGlID > getObjectsUnderCursor()
returns the id of the objects under the cursor using GL_SELECT (including overlapped objects)
virtual void recalculateBoundaries()=0
recalculate boundaries
Boundary applyGLTransform(bool fixRatio=true)
applies gl-transformations to fit the Boundary given by myChanger onto the canvas....
virtual void updateViewportValues()
update the viewport chooser with the current view values
FXImage * checkGDALImage(Decal &d)
check whether we can read image data or position with gdal
double getGridHeight() const
get grid height
virtual void startTrack(int)
star track
virtual long onDoubleClicked(FXObject *, FXSelector, void *)
FXMutex & getDecalsLockMutex()
The mutex to use before accessing the decals list in order to avoid thread conflicts.
virtual bool is3DView() const
return whether this is a 3D view
virtual std::vector< std::string > getPOIParamKeys() const
return list of available vehicle parameters
void displayLegends()
Draws the configured legends.
void displayColorLegend(const GUIColorScheme &scheme, bool leftSide)
Draws a legend for the given scheme.
FXMutex mySnapshotsMutex
The mutex to use before accessing the decals list in order to avoid thread conflicts.
virtual long onMouseLeft(FXObject *, FXSelector, void *)
virtual long onRightBtnRelease(FXObject *, FXSelector, void *)
FXint myWindowCursorPositionX
Position of the cursor relative to the window.
GUIPerspectiveChanger * myChanger
The perspective changer.
GUIGLObjectPopupMenu * myPopup
The current popup-menu.
virtual void copyViewportTo(GUISUMOAbstractView *view)
copy the viewport to the given view
void setBreakpoints(const std::vector< SUMOTime > &breakpoints)
Sets the breakpoints of the parent application.
FXComboBox * getColoringSchemesCombo()
get coloring schemes combo
void waitForSnapshots(const SUMOTime snapshotTime)
bool addAdditionalGLVisualisation(GUIGlObject *const which)
Adds an object to call its additional visualisation method.
virtual bool setColorScheme(const std::string &)
set color scheme
virtual long onCmdAddRerouter(FXObject *, FXSelector, void *)
virtual std::vector< std::string > getRelDataAttrs() const
return list of loaded edgeRelation and tazRelation attributes
virtual long onPaint(FXObject *, FXSelector, void *)
virtual long onRightBtnPress(FXObject *, FXSelector, void *)
virtual ~GUISUMOAbstractView()
destructor
virtual long onConfigure(FXObject *, FXSelector, void *)
mouse functions
std::map< SUMOTime, std::vector< std::tuple< std::string, int, int > > > mySnapshots
Snapshots.
virtual const std::vector< SUMOTime > retrieveBreakpoints() const
retrieve breakpoints if provided by the application
void remove(GUIDialog_EditViewport *)
remove viewport
virtual GUIGlID getTrackedID() const
get tracked id
void openPopupDialog()
open popup dialog
virtual std::vector< std::string > getEdgeDataAttrs() const
return list of loaded edgeData attributes
A MSVehicle extended by some values for usage within the gui.
Definition GUIVehicle.h:51
Stores the information about how to visualize structures.
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
static const Position INVALID
used to indicate that a position is valid
Definition Position.h:300
A RT-tree for efficient storing of SUMO's GL-objects.
Definition SUMORTree.h:66
A decal (an image) that can be shown.
double tilt
The tilt of the image to the ground plane (in degrees)
double centerX
The center of the image in x-direction (net coordinates, in m)
double height
The height of the image (net coordinates in y-direction, in m)
bool skip2D
Whether this image should be skipped in 2D-views.
double width
The width of the image (net coordinates in x-direction, in m)
bool initialised
Whether this image was initialised (inserted as a texture)
FXImage * image
The image pointer for later cleanup.
double rot
The rotation of the image in the ground plane (in degrees)
double layer
The layer of the image.
double altitude
The altitude of the image (net coordinates in z-direction, in m)
double centerY
The center of the image in y-direction (net coordinates, in m)
double centerZ
The center of the image in z-direction (net coordinates, in m)
std::string filename
The path to the file the image is located at.
int glID
whether the decal shall be drawn in screen coordinates, rather than network coordinates
double roll
The roll of the image to the ground plane (in degrees)
bool screenRelative
Whether this image should be skipped in 2D-views.
struct used for sorting objects by layer
GUIGlObject * getGLObject() const
get GLObject