GUISUMOAbstractView.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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*/,
                                   const GUIVisualizationRainbowSettings& /*rs*/) {
    }

    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;


    GUIGLObjectPopupMenu* getPopup() 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, const std::string& key);

    void drawFPS();

    virtual GUILane* getLaneUnderCursor();

    virtual GUIGlID getToolTipID();

    GUIGlID getObjectUnderCursor(double sensitivity = SENSITIVITY);

    std::vector<GUIGlID> getObjectsUnderCursor();

    std::vector<GUIGlObject*> getGUIGlObjectsUnderCursor();

    std::vector<GUIGlObject*> getGUIGlObjectsUnderSnappedCursor();

    GUIGlID getObjectAtPosition(Position pos, double sensitivity = SENSITIVITY);

    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();

    void buildMinMaxRainbow(const GUIVisualizationSettings& s, GUIColorScheme& scheme, const GUIVisualizationRainbowSettings& rs, double minValue, double maxValue, bool hasMissingData);

    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;
 
    // @brief sensitivity for "<>AtPosition(...) functions
    static const double SENSITIVITY;
 
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;
    };
 
};