GUISUMOAbstractView.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// The base class for a view
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <map>
#include <utils/foxtools/fxheader.h>
// fx3d includes windows.h so we need to guard against macro pollution
#ifdef WIN32
#define NOMINMAX
#endif
#include <fx3d.h>
#ifdef WIN32
#undef NOMINMAX
#endif
 
#include <utils/geom/Boundary.h>
#include <utils/geom/Position.h>
#include <utils/common/RGBColor.h>
#include <utils/common/SUMOTime.h>
#include <utils/gui/globjects/GUIGlObjectTypes.h>
#include <foreign/rtree/SUMORTree.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class GUIGlChildWindow;
class GUIVehicle;
class GUIPerspectiveChanger;
class GUIMainWindow;
class GUIGLObjectPopupMenu;
class GUIGlObject;
class GUIDialog_EditViewport;
class GUIDialog_ViewSettings;
class GUIVisualizationSettings;
class GUILane;
 
struct ComparatorClickPriority {
    bool operator()(const GUIGlObject* const a, const GUIGlObject* const b) const {
        if (a->getClickPriority() == b->getClickPriority()) {
            // sorty by GUIGlID as second criterion to simplify
            // duplicate removal
            return a->getGlID() > b->getGlID();
        } else {
            return a->getClickPriority() > b->getClickPriority();
        }
    }
};
 
// ===========================================================================
// class definitions
// ===========================================================================
class GUISUMOAbstractView : public FXGLCanvas {
    FXDECLARE(GUISUMOAbstractView)
 
public:
    GUISUMOAbstractView(FXComposite* p, GUIMainWindow& app, GUIGlChildWindow* parent, const SUMORTree& grid, FXGLVisual* glVis, FXGLCanvas* share);
 
    virtual ~GUISUMOAbstractView();
 
    virtual void recalculateBoundaries() { };
 
    virtual void buildViewToolBars(GUIGlChildWindow*) { }
 
    virtual void recenterView();
 
    virtual void centerTo(GUIGlID id, bool applyZoom, double zoomDist = 20);
 
    virtual void centerTo(const Position& pos, bool applyZoom, double zoomDist = 20);
 
    void centerTo(const Boundary& bound);
 
    virtual void setViewportFromToRot(const Position& lookFrom, const Position& lookAt, double rotation);
 
    virtual void copyViewportTo(GUISUMOAbstractView* view);
 
    double m2p(double meter) const;
 
    double p2m(double pixel) const;
 
    GUIMainWindow* getMainWindow() const;
 
    Position getWindowCursorPosition() const;
 
    void setWindowCursorPosition(FXint x, FXint y);
 
    FXbool makeCurrent();
 
    bool isInEditMode();
 
    GUIPerspectiveChanger& getChanger() const;
 
    Boundary getVisibleBoundary() const;
 
    virtual bool is3DView() const;
 
    virtual void zoom2Pos(Position& camera, Position& lookAt, double zoom);
 
 
    virtual long onConfigure(FXObject*, FXSelector, void*);
    virtual long onPaint(FXObject*, FXSelector, void*);
    virtual long onLeftBtnPress(FXObject*, FXSelector, void*);
    virtual long onLeftBtnRelease(FXObject*, FXSelector, void*);
    virtual long onMiddleBtnPress(FXObject*, FXSelector, void*);
    virtual long onMiddleBtnRelease(FXObject*, FXSelector, void*);
    virtual long onRightBtnPress(FXObject*, FXSelector, void*);
    virtual long onRightBtnRelease(FXObject*, FXSelector, void*);
    virtual long onDoubleClicked(FXObject*, FXSelector, void*);
    virtual long onMouseWheel(FXObject*, FXSelector, void*);
    virtual long onMouseMove(FXObject*, FXSelector, void*);
    virtual long onMouseLeft(FXObject*, FXSelector, void*);
 
 
    virtual long onKeyPress(FXObject* o, FXSelector sel, void* data);
    virtual long onKeyRelease(FXObject* o, FXSelector sel, void* data);
 
    virtual long onCmdCloseLane(FXObject*, FXSelector, void*);
    virtual long onCmdCloseEdge(FXObject*, FXSelector, void*);
    virtual long onCmdAddRerouter(FXObject*, FXSelector, void*);
 
    virtual long onCmdShowReachability(FXObject*, FXSelector, void*);
 
    virtual long  onVisualizationChange(FXObject*, FXSelector, void*);
 
    std::vector<GUIGlObject*> filterContextObjects(const std::vector<GUIGlObject*>& objects);
 
    virtual void openObjectDialogAtCursor(const FXEvent* ev);
 
    void openObjectDialog(const std::vector<GUIGlObject*>& objects, const bool filter = true);
 
    void updateToolTip();
 
 
    void addSnapshot(SUMOTime time, const std::string& file, const int w = -1, const int h = -1);
 
    std::string makeSnapshot(const std::string& destFile, const int w = -1, const int h = -1);
 
    virtual void saveFrame(const std::string& destFile, FXColor* buf);
 
    virtual void endSnapshot() {}
 
    virtual void checkSnapshots();
 
    void waitForSnapshots(const SUMOTime snapshotTime);
 
    virtual SUMOTime getCurrentTimeStep() const;
 
 
    GUIDialog_EditViewport* getViewportEditor();
 
    virtual void updateViewportValues();
 
    virtual void showViewportEditor();
 
    void showViewschemeEditor();
 
    virtual bool setColorScheme(const std::string&);
 
    const GUIVisualizationSettings& getVisualisationSettings() const;
 
    GUIVisualizationSettings* editVisualisationSettings() const;
 
    virtual void buildColorRainbow(const GUIVisualizationSettings& /*s*/, GUIColorScheme& /*scheme*/, int /*active*/, GUIGlObjectType /*objectType*/,
                                   bool hide = false, double hideThreshold = 0,
                                   bool hide2 = false, double hideThreshold2 = 0) {
        UNUSED_PARAMETER(hide);
        UNUSED_PARAMETER(hideThreshold);
        UNUSED_PARAMETER(hide2);
        UNUSED_PARAMETER(hideThreshold2);
    }
 
    virtual std::vector<std::string> getEdgeDataAttrs() const {
        return std::vector<std::string>();
    }
 
    virtual std::vector<std::string> getMeanDataIDs() const {
        return std::vector<std::string>();
    }
 
    virtual std::vector<std::string> getMeanDataAttrs(const std::string& meanDataID) const {
        UNUSED_PARAMETER(meanDataID);
        return std::vector<std::string>();
    }
 
    virtual std::vector<std::string> getRelDataAttrs() const {
        return std::vector<std::string>();
    }
 
    virtual std::vector<std::string> getEdgeLaneParamKeys(bool /*edgeKeys*/) const {
        return std::vector<std::string>();
    }
 
    virtual std::vector<std::string> getVehicleParamKeys(bool /*vTypeKeys*/) const {
        return std::vector<std::string>();
    }
 
    virtual std::vector<std::string> getPOIParamKeys() const {
        return std::vector<std::string>();
    }
 
    void remove(GUIDialog_EditViewport*);
 
    void remove(GUIDialog_ViewSettings*);
 
    // @todo: check why this is here
    double getGridWidth() const;
 
    // @todo: check why this is here
    double getGridHeight() const;
 
    virtual void startTrack(int /*id*/);
 
    virtual void stopTrack();
 
    virtual GUIGlID getTrackedID() const;
 
    virtual void onGamingClick(Position /*pos*/);
    virtual void onGamingRightClick(Position /*pos*/);
 
 
    bool addAdditionalGLVisualisation(GUIGlObject* const which);
 
    bool removeAdditionalGLVisualisation(GUIGlObject* const which);
 
    bool isAdditionalGLVisualisationEnabled(GUIGlObject* const which) const;
 
 
    const Position& getPopupPosition() const;
 
    void destroyPopup();
 
    void replacePopup(GUIGLObjectPopupMenu* popUp);
 
    struct Decal {
 
        Decal() {};
 
        std::string filename;
 
        double centerX = 0;
 
        double centerY = 0;
 
        double centerZ = 0;
 
        double width = 0;
 
        double height = 0;
 
        double altitude = 0;
 
        double rot = 0;
 
        double tilt = 0;
 
        double roll = 0;
 
        double layer = 0;
 
        bool initialised = false;
 
        bool skip2D = false;
 
        bool screenRelative = false;
 
        int glID = -1;
 
        FXImage* image = nullptr;
    };
 
    std::vector<Decal>& getDecals();
 
    FXMutex& getDecalsLockMutex();
 
    MFXComboBoxIcon* getColoringSchemesCombo();
 
    virtual Position getPositionInformation() const;
 
    Position snapToActiveGrid(const Position& pos, bool snapXY = true) const;
 
    Position screenPos2NetPos(int x, int y) const;
 
    void addDecals(const std::vector<Decal>& decals);
 
    double getDelay() const;
 
    void setDelay(double delay);
 
    void setBreakpoints(const std::vector<SUMOTime>& breakpoints);
 
    virtual const std::vector<SUMOTime> retrieveBreakpoints() const {
        return std::vector<SUMOTime>();
    }
 
    double getFPS() const;
 
    GUIGlChildWindow* getGUIGlChildWindow();
 
    virtual void drawPedestrianNetwork(const GUIVisualizationSettings& /*s*/) const { };
 
    virtual void changePedestrianNetworkColor(const GUIVisualizationSettings& /*s*/) const { };
 
protected:
    FOX_CONSTRUCTOR(GUISUMOAbstractView)
 
    
    void paintGL();
 
    virtual void updatePositionInformationLabel() const;
 
    virtual int doPaintGL(int /*mode*/, const Boundary& /*boundary*/);
 
    virtual void doInit();
 
    void paintGLGrid() const;
 
    void displayLegend();
 
    void displayLegends();
 
    void displayColorLegend(const GUIColorScheme& scheme, bool leftSide);
 
    void drawFPS();
 
    virtual GUILane* getLaneUnderCursor();
 
    virtual GUIGlID getToolTipID();
 
    GUIGlID getObjectUnderCursor();
 
    std::vector<GUIGlID> getObjectsUnderCursor();
 
    std::vector<GUIGlObject*> getGUIGlObjectsUnderCursor();
 
    std::vector<GUIGlObject*> getGUIGlObjectsUnderSnappedCursor();
 
    GUIGlID getObjectAtPosition(Position pos);
 
    std::vector<GUIGlID> getObjectsAtPosition(Position pos, double radius);
 
    std::vector<GUIGlObject*> getGUIGlObjectsAtPosition(Position pos, double radius);
 
    std::vector<GUIGlID> getObjectsInBoundary(Boundary bound);
 
    std::vector<GUIGlObject*> filterInternalLanes(const std::vector<GUIGlObject*>& objects) const;
 
    bool showToolTipFor(const GUIGlID idToolTip);
 
    void drawDecals();
 
    void openPopupDialog();
 
    Boundary applyGLTransform(bool fixRatio = true);
 
    FXImage* checkGDALImage(Decal& d);
 
    GUIMainWindow* myApp;
 
    GUIGlChildWindow* myGlChildWindowParent;
 
    const SUMORTree* myGrid;
 
    GUIPerspectiveChanger* myChanger = nullptr;
 
    bool myPanning = false;
 
    bool myInEditMode = false;
 
    int myMouseHotspotX, myMouseHotspotY;
 
    GUIGLObjectPopupMenu* myPopup = nullptr;
 
    Position myClickedPopupPosition = Position::INVALID;
 
    Position myPopupPosition = Position(0, 0);
 
    std::vector<GUIGlObject*> myCurrentObjectsDialog;
 
    GUIVisualizationSettings* myVisualizationSettings;
 
    bool myAmInitialised = false;
 
    GUIDialog_EditViewport* myGUIDialogEditViewport = nullptr;
 
    FXint myWindowCursorPositionX, myWindowCursorPositionY;
 
    GUIDialog_ViewSettings* myGUIDialogViewSettings = nullptr;
 
 
    std::vector<Decal> myDecals;
 
    FXMutex myDecalsLockMutex;
 
 
    std::map<SUMOTime, std::vector<std::tuple<std::string, int, int> > > mySnapshots;
 
    FXMutex mySnapshotsMutex;
 
    FXCondition mySnapshotCondition;
 
    mutable FXMutex myPolyDrawLock;
 
    std::map<GUIGlObject*, int> myAdditionallyDrawn;
 
    long myFrameDrawTime = 0;
 
private:
    struct LayerObject : public std::pair<double, std::pair<GUIGlObjectType, std::string> > {
 
    public:
        LayerObject(double layer, GUIGlObject* object);
 
        LayerObject(GUIGlObject* object);
 
        GUIGlObject* getGLObject() const;
 
    private:
        GUIGlObject* myGLObject;
    };
 
    // @brief sensitivity for "<>AtPosition(...) functions
    static const double SENSITIVITY;
};