ecvDisplayTools.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// Local
#include "ecvGLMatrix.h"
#include "ecvGenericDisplayTools.h"
#include "ecvGuiParameters.h"
#include "ecvHObject.h"
#include "ecvViewportParameters.h"
 
// QT
#include <QApplication>  // Added for QApplication::primaryScreen()
#include <QElapsedTimer>
#include <QMainWindow>
#include <QObject>
#include <QRect>
#include <QScreen>  // Added for QScreen
#include <QTimer>
 
// System
#include <list>
#include <unordered_set>
#include <vector>
 
namespace cloudViewer {
namespace geometry {
class LineSet;
}
}  // namespace cloudViewer
 
class ccPolyline;
class ccInteractor;
class ccGenericMesh;
class ecvOrientedBBox;
 
class ecvGenericVisualizer;
class ecvGenericVisualizer2D;
class ecvGenericVisualizer3D;
 
// ============================================================================
// Axes Grid Properties Structure (ParaView-compatible)
// ============================================================================
 
struct CV_DB_LIB_API AxesGridProperties {
    // Basic properties
    bool visible = false;
    CCVector3 color = CCVector3(255, 255, 255);  // White (RGB 0-255)
    double lineWidth = 1.0;
    double spacing = 1.0;
    int subdivisions = 10;
    bool showLabels = true;
    double opacity = 1.0;
 
    // Extended properties (ParaView-style)
    bool showGrid = false;  // Show grid lines (default OFF like ParaView)
    QString xTitle = "X-Axis";
    QString yTitle = "Y-Axis";
    QString zTitle = "Z-Axis";
    bool xUseCustomLabels = false;
    bool yUseCustomLabels = false;
    bool zUseCustomLabels = false;
    bool useCustomBounds = false;
 
    // Custom labels (ParaView-style: value -> label string)
    QList<QPair<double, QString>> xCustomLabels;
    QList<QPair<double, QString>> yCustomLabels;
    QList<QPair<double, QString>> zCustomLabels;
 
    // Custom bounds (ParaView-style: explicit min/max for each axis)
    double xMin = 0.0, xMax = 1.0;
    double yMin = 0.0, yMax = 1.0;
    double zMin = 0.0, zMax = 1.0;
 
    // Constructor with defaults
    AxesGridProperties() = default;
};
 
class CV_DB_LIB_API ecvDisplayTools : public QObject,
                                      public ecvGenericDisplayTools {
    Q_OBJECT
public:
    static void Init(ecvDisplayTools* displayTools,
                     QMainWindow* win,
                     bool stereoMode = false);
    static ecvDisplayTools* TheInstance();
 
    static void ReleaseInstance();
 
    virtual ~ecvDisplayTools() override;
 
 
    void scheduleFullRedraw(unsigned maxDelay_ms);
 
    void cancelScheduledRedraw();
 
public:
    enum PICKING_MODE {
        NO_PICKING,
        ENTITY_PICKING,
        ENTITY_RECT_PICKING,
        FAST_PICKING,
        POINT_PICKING,
        TRIANGLE_PICKING,
        POINT_OR_TRIANGLE_PICKING,
        POINT_OR_TRIANGLE_OR_LABEL_PICKING,
        LABEL_PICKING,
        DEFAULT_PICKING,
    };
 
    enum INTERACTION_FLAG {
 
        // no interaction
        INTERACT_NONE = 0,
 
        // camera interactions
        INTERACT_ROTATE = 1,
        INTERACT_PAN = 2,
        INTERACT_CTRL_PAN = 4,
        INTERACT_ZOOM_CAMERA = 8,
        INTERACT_2D_ITEMS = 16,         // labels, etc.
        INTERACT_CLICKABLE_ITEMS = 32,  // hot zone
 
        // options / modifiers
        INTERACT_TRANSFORM_ENTITIES = 64,
 
        // signals
        INTERACT_SIG_RB_CLICKED = 128,  // right button clicked
        INTERACT_SIG_LB_CLICKED = 256,  // left button clicked
        INTERACT_SIG_MOUSE_MOVED =
                512,  // mouse moved (only if a button is clicked)
        INTERACT_SIG_BUTTON_RELEASED = 1024,  // mouse button released
        INTERACT_SIG_MB_CLICKED = 2048,       // middle button clicked
        INTERACT_SEND_ALL_SIGNALS =
                INTERACT_SIG_RB_CLICKED | INTERACT_SIG_LB_CLICKED |
                INTERACT_SIG_MB_CLICKED | INTERACT_SIG_MOUSE_MOVED |
                INTERACT_SIG_BUTTON_RELEASED,
 
        // default modes
        MODE_PAN_ONLY = INTERACT_PAN | INTERACT_ZOOM_CAMERA |
                        INTERACT_2D_ITEMS | INTERACT_CLICKABLE_ITEMS,
        MODE_TRANSFORM_CAMERA = INTERACT_ROTATE | MODE_PAN_ONLY,
        MODE_TRANSFORM_ENTITIES =
                INTERACT_ROTATE | INTERACT_PAN | INTERACT_ZOOM_CAMERA |
                INTERACT_TRANSFORM_ENTITIES | INTERACT_CLICKABLE_ITEMS,
    };
    Q_DECLARE_FLAGS(INTERACTION_FLAGS, INTERACTION_FLAG)
 
    // Default interaction modes (with the mouse!)
    static INTERACTION_FLAGS PAN_ONLY();
    static INTERACTION_FLAGS TRANSFORM_CAMERA();
    static INTERACTION_FLAGS TRANSFORM_ENTITIES();
 
    enum MessagePosition {
        LOWER_LEFT_MESSAGE,
        UPPER_CENTER_MESSAGE,
        SCREEN_CENTER_MESSAGE,
    };
 
    enum MessageType {
        CUSTOM_MESSAGE,
        SCREEN_SIZE_MESSAGE,
        PERSPECTIVE_STATE_MESSAGE,
        SUN_LIGHT_STATE_MESSAGE,
        CUSTOM_LIGHT_STATE_MESSAGE,
        MANUAL_TRANSFORMATION_MESSAGE,
        MANUAL_SEGMENTATION_MESSAGE,
        ROTAION_LOCK_MESSAGE,
        FULL_SCREEN_MESSAGE,
    };
 
    enum PivotVisibility {
        PIVOT_HIDE,
        PIVOT_SHOW_ON_MOVE,
        PIVOT_ALWAYS_SHOW,
    };
 
    struct CV_DB_LIB_API MessageToDisplay {
        MessageToDisplay()
            : messageValidity_sec(0),
              position(LOWER_LEFT_MESSAGE),
              type(CUSTOM_MESSAGE) {}
 
        QString message;
        qint64 messageValidity_sec;
        MessagePosition position;
        MessageType type;
    };
 
    std::list<MessageToDisplay> m_messagesToDisplay;
 
    struct CV_DB_LIB_API ProjectionMetrics {
        ProjectionMetrics()
            : zNear(0.0),
              zFar(0.0),
              cameraToBBCenterDist(0.0),
              bbHalfDiag(0.0) {}
 
        double zNear;
        double zFar;
        double cameraToBBCenterDist;
        double bbHalfDiag;
    };
 
    struct CV_DB_LIB_API HotZone {
        // display font
        QFont font;
        // text height
        int textHeight;
        // text shift
        int yTextBottomLineShift;
        // default color
        unsigned char color[3];
 
        // bubble-view label rect.
        QString bbv_label;
        // bubble-view label rect.
        QRect bbv_labelRect;
        // bubble-view row width
        int bbv_totalWidth;
 
        // fullscreen label rect.
        QString fs_label;
        // fullscreen label rect.
        QRect fs_labelRect;
        // fullscreen row width
        int fs_totalWidth;
 
        // point size label
        QString psi_label;
        // point size label rect.
        QRect psi_labelRect;
        // point size row width
        int psi_totalWidth;
 
        // line size label
        QString lsi_label;
        // line size label rect.
        QRect lsi_labelRect;
        // line size row width
        int lsi_totalWidth;
 
        int margin;
        int iconSize;
        QPoint topCorner;
        qreal pixelDeviceRatio;
 
        explicit HotZone(QWidget* win)
            : textHeight(0),
              yTextBottomLineShift(0),
              bbv_label("bubble-view mode"),
              fs_label("fullscreen mode"),
              psi_label("default point size"),
              lsi_label("default line width"),
              margin(16)  // 16|10
              ,
              iconSize(16)  // 16
              ,
              topCorner(0, 0),
              pixelDeviceRatio(1.0) {
            color[0] = ecvColor::defaultLabelBkgColor.r;
            color[1] = ecvColor::defaultLabelBkgColor.g;
            color[2] = ecvColor::defaultLabelBkgColor.b;
 
            updateInternalVariables(win);
        }
 
        void updateInternalVariables(QWidget* win) {
            if (win) {
                font = win->font();
                pixelDeviceRatio = GetPlatformAwareDPIScale();
                int fontSize = GetOptimizedFontSize(12);
                if (fontSize != pixelDeviceRatio) {
                    font.setPointSize(fontSize);
                } else {
                    font.setPointSize(12 * pixelDeviceRatio);
                }
                CVLog::Print(QString("pixelDeviceRatio: %1 and fontSize %2")
                                     .arg(pixelDeviceRatio)
                                     .arg(fontSize));
                margin *= pixelDeviceRatio;
                iconSize *= pixelDeviceRatio;
                font.setBold(true);
            }
 
            QFontMetrics metrics(font);
            bbv_labelRect = metrics.boundingRect(bbv_label);
            fs_labelRect = metrics.boundingRect(fs_label);
            psi_labelRect = metrics.boundingRect(psi_label);
            lsi_labelRect = metrics.boundingRect(lsi_label);
 
            psi_totalWidth = /*margin() + */ psi_labelRect.width() + margin +
                             iconSize + margin + iconSize /* + margin*/;
            lsi_totalWidth = /*margin() + */ lsi_labelRect.width() + margin +
                             iconSize + margin + iconSize /* + margin*/;
            bbv_totalWidth = /*margin() + */ bbv_labelRect.width() + margin +
                             iconSize /* + margin*/;
            fs_totalWidth = /*margin() + */ fs_labelRect.width() + margin +
                            iconSize /* + margin*/;
 
            textHeight =
                    std::max(psi_labelRect.height(), bbv_labelRect.height());
            textHeight = std::max(lsi_labelRect.height(), textHeight);
            textHeight = std::max(fs_labelRect.height(), textHeight);
            textHeight = (3 * textHeight) /
                         4;  // --> factor: to recenter the baseline a little
            yTextBottomLineShift = (iconSize / 2) + (textHeight / 2);
        }
 
        QRect rect(bool clickableItemsVisible,
                   bool bubbleViewModeEnabled,
                   bool fullScreenEnabled) const {
            // total hot zone area size (without margin)
            int totalWidth = 0;
            if (clickableItemsVisible)
                totalWidth = std::max(psi_totalWidth, lsi_totalWidth);
            if (bubbleViewModeEnabled)
                totalWidth = std::max(totalWidth, bbv_totalWidth);
            if (fullScreenEnabled)
                totalWidth = std::max(totalWidth, fs_totalWidth);
 
#ifdef Q_OS_MAC
            // fix the hot zone width on mac
            totalWidth = totalWidth + 3 * (margin + iconSize);
#endif
            QPoint minAreaCorner(
                    0, std::min(0, yTextBottomLineShift - textHeight));
            QPoint maxAreaCorner(totalWidth,
                                 std::max(iconSize, yTextBottomLineShift));
            int rowCount = clickableItemsVisible ? 2 : 0;
            rowCount += bubbleViewModeEnabled ? 1 : 0;
            rowCount += fullScreenEnabled ? 1 : 0;
            maxAreaCorner.setY(maxAreaCorner.y() +
                               (iconSize + margin) * (rowCount - 1));
 
            QRect areaRect(minAreaCorner - QPoint(margin, margin) / 2,
                           maxAreaCorner + QPoint(margin, margin) / 2);
 
            return areaRect;
        }
    };
 
 
    static void DisplayText(const QString& text,
                            int x,
                            int y,
                            unsigned char align = ALIGN_DEFAULT,
                            float bkgAlpha = 0.0f,
                            const unsigned char* rgbColor = nullptr,
                            const QFont* font = nullptr,
                            const QString& id = "");
 
    static void DisplayText(const CC_DRAW_CONTEXT& CONTEXT) {
        TheInstance()->displayText(CONTEXT);
    }
    inline virtual void displayText(
            const CC_DRAW_CONTEXT& CONTEXT) { /* do nothing */ }
 
 
    static void Display3DLabel(const QString& str,
                               const CCVector3& pos3D,
                               const ecvColor::Rgbub* color = nullptr,
                               const QFont& font = QFont());
 
public:  
    static void SetFocusToScreen();
    static void ToBeRefreshed();
    static void RefreshDisplay(bool only2D = false, bool forceRedraw = true);
    static void RedrawDisplay(bool only2D = false, bool forceRedraw = true);
    static void CheckIfRemove();
    inline static void Draw(const CC_DRAW_CONTEXT& context,
                            const ccHObject* obj) {
        TheInstance()->draw(context, obj);
    }
    inline virtual void draw(const CC_DRAW_CONTEXT& context,
                             const ccHObject* obj) { /* do nothing */ }
 
    inline static void UpdateMeshTextures(const CC_DRAW_CONTEXT& context,
                                          const ccGenericMesh* mesh) {
        TheInstance()->updateMeshTextures(context, mesh);
    }
    inline virtual void updateMeshTextures(
            const CC_DRAW_CONTEXT& context,
            const ccGenericMesh* mesh) { /* do nothing */ }
 
    inline static void DrawBBox(const CC_DRAW_CONTEXT& context,
                                const ccBBox* bbox) {
        TheInstance()->drawBBox(context, bbox);
    }
    inline virtual void drawBBox(const CC_DRAW_CONTEXT& context,
                                 const ccBBox* bbox) { /* do nothing */ }
 
    inline static void DrawOrientedBBox(const CC_DRAW_CONTEXT& context,
                                        const ecvOrientedBBox* obb) {
        TheInstance()->drawOrientedBBox(context, obb);
    }
    inline virtual void drawOrientedBBox(
            const CC_DRAW_CONTEXT& context,
            const ecvOrientedBBox* obb) { /* do nothing */ }
 
    static void RemoveBB(CC_DRAW_CONTEXT context);
    static void RemoveBB(const QString& viewId);
    static void ChangeEntityProperties(PROPERTY_PARAM& propertyParam,
                                       bool autoUpdate = true);
    inline virtual void changeEntityProperties(
            PROPERTY_PARAM& propertyParam) { /* do nothing */ }
    static void DrawWidgets(const WIDGETS_PARAMETER& param,
                            bool update = false);
    inline virtual void drawWidgets(
            const WIDGETS_PARAMETER& param) { /* do nothing */ }
    static void RemoveWidgets(const WIDGETS_PARAMETER& param,
                              bool update = false);
    static void RemoveAllWidgets(bool update = true);
    static void Remove3DLabel(const QString& view_id);
 
    inline static void DrawCoordinates(double scale = 1.0,
                                       const std::string& id = "reference",
                                       int viewport = 0) {
        TheInstance()->drawCoordinates(scale, id, viewport);
    }
 
    inline virtual void drawCoordinates(double scale = 1.0,
                                        const std::string& id = "reference",
                                        int viewport = 0) { /* do nothing */ }
 
    inline static void RotateWithAxis(const CCVector2i& pos,
                                      const CCVector3d& axis,
                                      double angle,
                                      int viewport = 0) {
        TheInstance()->rotateWithAxis(pos, axis, angle, viewport);
    }
 
    inline virtual void rotateWithAxis(const CCVector2i& pos,
                                       const CCVector3d& axis,
                                       double angle,
                                       int viewport = 0) { /* do nothing */ }
 
    inline static void ToggleOrientationMarker(bool state = true) {
        TheInstance()->toggleOrientationMarker(state);
        UpdateScreen();
    }
    inline virtual void toggleOrientationMarker(
            bool state = true) { /* do nothing */ }
 
    inline static bool OrientationMarkerShown() {
        return TheInstance()->orientationMarkerShown();
    }
    inline virtual bool orientationMarkerShown() {
        return false; /* do nothing */
    }
 
    // ========================================================================
    // ParaView-style Axes Grid Support (Unified Interface with
    // AxesGridProperties)
    // ========================================================================
 
    inline static void SetDataAxesGridProperties(
            const QString& viewID,
            const AxesGridProperties& props,
            int viewport = 0) {
        TheInstance()->setDataAxesGridProperties(viewID, props, viewport);
        UpdateScreen();
    }
 
    inline virtual void setDataAxesGridProperties(
            const QString& viewID,
            const AxesGridProperties& props,
            int viewport = 0) { /* do nothing */ }
 
    inline static void GetDataAxesGridProperties(const QString& viewID,
                                                 AxesGridProperties& props,
                                                 int viewport = 0) {
        TheInstance()->getDataAxesGridProperties(viewID, props, viewport);
    }
 
    inline virtual void getDataAxesGridProperties(const QString& viewID,
                                                  AxesGridProperties& props,
                                                  int viewport = 0) const {
        // Default implementation
        props = AxesGridProperties();
    }
 
    inline static void SetViewAxesGridVisible(bool visible, int viewport = 0) {
        TheInstance()->setViewAxesGridVisible(visible, viewport);
        UpdateScreen();
    }
    inline virtual void setViewAxesGridVisible(
            bool visible, int viewport = 0) { /* do nothing */ }
 
    inline static void SetViewAxesGridProperties(bool visible,
                                                 const CCVector3& color,
                                                 double lineWidth,
                                                 double spacing,
                                                 int subdivisions,
                                                 bool showLabels,
                                                 double opacity,
                                                 int viewport = 0) {
        TheInstance()->setViewAxesGridProperties(visible, color, lineWidth,
                                                 spacing, subdivisions,
                                                 showLabels, opacity, viewport);
        UpdateScreen();
    }
    inline virtual void setViewAxesGridProperties(
            bool visible,
            const CCVector3& color,
            double lineWidth,
            double spacing,
            int subdivisions,
            bool showLabels,
            double opacity,
            int viewport = 0) { /* do nothing */ }
 
    inline virtual void getViewAxesGridProperties(bool& visible,
                                                  CCVector3& color,
                                                  double& lineWidth,
                                                  double& spacing,
                                                  int& subdivisions,
                                                  bool& showLabels,
                                                  double& opacity,
                                                  int viewport = 0) const {
        // Default values
        visible = false;
        color = CCVector3(179, 179, 179);
        lineWidth = 1.0;
        spacing = 1.0;
        subdivisions = 10;
        showLabels = true;
        opacity = 0.3;
    }
 
    inline static void SetCenterAxesVisible(bool visible, int viewport = 0) {
        TheInstance()->setCenterAxesVisible(visible, viewport);
        UpdateScreen();
    }
    inline virtual void setCenterAxesVisible(
            bool visible, int viewport = 0) { /* do nothing */ }
 
    inline static void ToggleCameraOrientationWidget(bool show) {
        TheInstance()->toggleCameraOrientationWidget(show);
        UpdateScreen();
    }
    inline virtual void toggleCameraOrientationWidget(
            bool show) { /* do nothing */ }
 
    inline static bool IsCameraOrientationWidgetShown() {
        return TheInstance()->isCameraOrientationWidgetShown();
    }
    inline virtual bool isCameraOrientationWidgetShown() const { return false; }
 
    inline static void SetLightIntensity(double intensity) {
        TheInstance()->setLightIntensity(intensity);
        UpdateScreen();
    }
    inline virtual void setLightIntensity(double intensity) { /* do nothing */ }
 
    inline static double GetLightIntensity() {
        return TheInstance()->getLightIntensity();
    }
    inline virtual double getLightIntensity() const { return 1.0; }
 
private:
    static void Draw3D(CC_DRAW_CONTEXT& CONTEXT);
 
public:  // main interface
    inline static ecvGenericVisualizer3D* GetVisualizer3D() {
        return TheInstance()->getVisualizer3D();
    }
    inline virtual ecvGenericVisualizer3D* getVisualizer3D() {
        return nullptr; /* do nothing */
    }
    inline static ecvGenericVisualizer2D* GetVisualizer2D() {
        return TheInstance()->getVisualizer2D();
    }
    inline virtual ecvGenericVisualizer2D* getVisualizer2D() {
        return nullptr; /* do nothing */
    }
 
    inline static QWidget* GetCurrentScreen() {
        if (!TheInstance()) return nullptr;
        return TheInstance()->m_currentScreen;
    }
    static void SetCurrentScreen(QWidget* widget);
    inline static QWidget* GetMainScreen() {
        if (!TheInstance()) return nullptr;
        return TheInstance()->m_mainScreen;
    }
    inline static void SetMainScreen(QWidget* widget) {
        TheInstance()->m_mainScreen = widget;
    }
 
    inline static QMainWindow* GetMainWindow() { return TheInstance()->m_win; }
    inline static void SetMainWindow(QMainWindow* win) {
        TheInstance()->m_win = win;
    }
 
    static QPointF ToCenteredGLCoordinates(int x, int y);
    static CCVector3d ToVtkCoordinates(int x, int y, int z = 0);
    static void ToVtkCoordinates(CCVector3d& sP);
    static void ToVtkCoordinates(CCVector2i& sP);
 
    inline static ccHObject* GetOwnDB() { return TheInstance()->m_winDBRoot; }
 
    static void AddToOwnDB(ccHObject* obj, bool noDependency = true);
 
    static void RemoveFromOwnDB(ccHObject* obj);
 
    static void SetSceneDB(ccHObject* root);
    inline static ccHObject* GetSceneDB() {
        return TheInstance()->m_globalDBRoot;
    }
 
    static void UpdateNamePoseRecursive();
 
    static void SetRedrawRecursive(bool redraw = false);
    static void SetRedrawRecursive(ccHObject* obj, bool redraw = false);
 
    static void GetVisibleObjectsBB(ccBBox& box);
 
 
    static void RotateBaseViewMat(const ccGLMatrixd& rotMat);
 
    inline static ccGLMatrixd& GetBaseViewMat() {
        return TheInstance()->m_viewportParams.viewMat;
    }
    static void SetBaseViewMat(ccGLMatrixd& mat);
 
    static void SetRemoveViewIDs(std::vector<removeInfo>& removeinfos);
    inline static void SetRemoveAllFlag(bool state) {
        TheInstance()->m_removeAllFlag = state;
    }
 
    inline static void TransformCameraView(const ccGLMatrixd& viewMat) {
        TheInstance()->transformCameraView(viewMat);
    }
    inline virtual void transformCameraView(
            const ccGLMatrixd& viewMat) { /* do nothing */ }
    inline static void TransformCameraProjection(const ccGLMatrixd& projMat) {
        TheInstance()->transformCameraProjection(projMat);
    }
    inline virtual void transformCameraProjection(
            const ccGLMatrixd& projMat) { /* do nothing */ }
 
    static inline int GetDevicePixelRatio() {
        // return TheInstance()->getDevicePixelRatio();
        return GetMainWindow()->devicePixelRatio();
    }
 
    // New: Cross-platform font size optimization function
    static inline int GetOptimizedFontSize(int baseFontSize = 12) {
        QWidget* win = GetMainWindow();
        if (!win) {
            return baseFontSize;
        }
 
        int dpiScale = win->devicePixelRatio();
        QScreen* screen = QApplication::primaryScreen();
        if (!screen) {
            return baseFontSize;
        }
 
        // Get screen resolution information
        QSize screenSize = screen->size();
        int screenWidth = screenSize.width();
        int screenHeight = screenSize.height();
        int screenDPI = screen->physicalDotsPerInch();
 
        // Platform-specific base font size adjustment
        int platformBaseSize = baseFontSize;
#ifdef Q_OS_MAC
        // macOS: Default font is slightly larger, but need to consider Retina
        // display over-scaling
        platformBaseSize = baseFontSize;
        if (dpiScale > 1) {
            // Retina display: Use smaller font to avoid over-scaling
            platformBaseSize = std::max(8, baseFontSize - (dpiScale - 1) * 2);
        }
#elif defined(Q_OS_WIN)
        // Windows: Adjust font size according to DPI
        if (screenDPI > 120) {
            // High DPI display
            platformBaseSize = std::max(8, baseFontSize - 1);
        } else if (screenDPI < 96) {
            // Low DPI display
            platformBaseSize = baseFontSize + 1;
        }
#elif defined(Q_OS_LINUX)
        // Linux: Adjust according to screen resolution
        if (screenWidth >= 1920 && screenHeight >= 1080) {
            // High resolution display
            platformBaseSize = std::max(8, baseFontSize - 1);
        } else if (screenWidth < 1366) {
            // Low resolution display
            platformBaseSize = baseFontSize + 1;
        }
#endif
 
        // Resolution-specific adjustment
        int resolutionFactor = 1;
        if (screenWidth >= 2560 && screenHeight >= 1440) {
            // 2K and above resolution
            resolutionFactor = 0;
        } else if (screenWidth >= 1920 && screenHeight >= 1080) {
            // 1080p resolution
            resolutionFactor = 0;
        } else if (screenWidth < 1366) {
            // Low resolution
            resolutionFactor = 1;
        }
 
        // Final font size calculation
        int finalSize = platformBaseSize + resolutionFactor;
 
        // Ensure font size is within reasonable range
        finalSize = std::max(6, std::min(24, finalSize));
 
        return finalSize;
    }
 
    // New: Cross-platform DPI scaling handling function
    static inline double GetPlatformAwareDPIScale() {
        QWidget* win = GetMainWindow();
        if (!win) {
            return 1.0;
        }
 
        int dpiScale = win->devicePixelRatio();
        QScreen* screen = QApplication::primaryScreen();
        if (!screen) {
            return static_cast<double>(dpiScale);
        }
 
        // Get screen information
        QSize screenSize = screen->size();
        int screenWidth = screenSize.width();
        int screenHeight = screenSize.height();
        int screenDPI = screen->physicalDotsPerInch();
 
        // Platform-specific DPI scaling adjustment
        double adjustedScale = static_cast<double>(dpiScale);
 
#ifdef Q_OS_MAC
        // macOS: Retina displays need special handling
        if (dpiScale > 1) {
            // For UI elements, use smaller scaling to avoid over-scaling
            adjustedScale = 1.0 + (dpiScale - 1.0) * 0.5;
        }
#elif defined(Q_OS_WIN)
        // Windows: Adjust according to DPI settings
        if (screenDPI > 120) {
            // High DPI display, appropriately reduce scaling
            adjustedScale = std::min(adjustedScale, 1.5);
        } else if (screenDPI < 96) {
            // Low DPI display, appropriately increase scaling
            adjustedScale = std::max(adjustedScale, 1.0);
        }
#elif defined(Q_OS_LINUX)
        // Linux: Adjust according to resolution
        if (screenWidth >= 2560 && screenHeight >= 1440) {
            // Ultra-high resolution, reduce scaling
            adjustedScale = std::min(adjustedScale, 1.3);
        } else if (screenWidth < 1366) {
            // Low resolution, increase scaling
            adjustedScale = std::max(adjustedScale, 1.0);
        }
#endif
 
        // Ensure scaling is within reasonable range
        adjustedScale = std::max(0.5, std::min(2.0, adjustedScale));
 
        return adjustedScale;
    }
 
    inline static QRect GetScreenRect() {
        QRect screenRect = GetCurrentScreen()->geometry();
        QPoint globalPosition =
                GetCurrentScreen()->mapToGlobal(screenRect.topLeft());
        screenRect.setTopLeft(globalPosition);
        return screenRect;
    }
    inline static void SetScreenSize(int xw, int yw) {
        GetCurrentScreen()->resize(QSize(xw, yw));
    }
    inline static void DoResize(int xw, int yw) { SetScreenSize(xw, yw); }
    inline static void DoResize(const QSize& size) {
        SetScreenSize(size.width(), size.height());
    }
    inline static QSize GetScreenSize() { return GetCurrentScreen()->size(); }
 
    inline static void SetRenderWindowSize(int xw, int yw) {
        TheInstance()->setRenderWindowSize(xw, yw);
    }
    inline virtual void setRenderWindowSize(int xw, int yw) { /* do nothing */ }
 
    inline static void FullScreen(bool state) {
        TheInstance()->fullScreen(state);
    }
    inline virtual void fullScreen(bool state) { /* do nothing */ }
 
    static void ZoomCamera(double zoomFactor, int viewport = 0);
    inline virtual void zoomCamera(double zoomFactor, int viewport = 0) {}
    inline static double GetCameraFocalDistance(int viewport = 0) {
        return TheInstance()->getCameraFocalDistance(viewport);
    }
    inline virtual double getCameraFocalDistance(int viewport = 0) {
        return 100.0; /* do nothing */
    }
 
    inline static void SetCameraFocalDistance(double focal_distance,
                                              int viewport = 0) {
        TheInstance()->setCameraFocalDistance(focal_distance, viewport);
    }
    inline virtual void setCameraFocalDistance(
            double focal_distance, int viewport = 0) { /* do nothing */ }
 
    inline static void GetCameraPos(double* pos, int viewport = 0) {
        TheInstance()->getCameraPos(pos, viewport);
    }
    inline virtual void getCameraPos(double* pos,
                                     int viewport = 0) { /* do nothing */ }
    inline static void GetCameraFocal(double* focal, int viewport = 0) {
        TheInstance()->getCameraFocal(focal, viewport);
    }
    inline virtual void getCameraFocal(double* focal,
                                       int viewport = 0) { /* do nothing */ }
    inline static void GetCameraUp(double* up, int viewport = 0) {
        TheInstance()->getCameraUp(up, viewport);
    }
    virtual void getCameraUp(double* up, int viewport = 0) { /* do nothing */ }
 
    inline static void SetCameraPosition(const CCVector3d& pos,
                                         int viewport = 0) {
        TheInstance()->setCameraPosition(pos, viewport);
    }
    inline virtual void setCameraPosition(const CCVector3d& pos,
                                          int viewport = 0) { /* do nothing */ }
    inline static void SetCameraPosition(const double* pos,
                                         const double* focal,
                                         const double* up,
                                         int viewport = 0) {
        TheInstance()->setCameraPosition(pos, focal, up, viewport);
    }
    inline virtual void setCameraPosition(const double* pos,
                                          const double* focal,
                                          const double* up,
                                          int viewport = 0) { /* do nothing */ }
    inline static void SetCameraPosition(const double* pos,
                                         const double* up,
                                         int viewport = 0) {
        TheInstance()->setCameraPosition(pos, up, viewport);
    }
    inline virtual void setCameraPosition(const double* pos,
                                          const double* up,
                                          int viewport = 0) { /* do nothing */ }
    inline static void SetCameraPosition(double pos_x,
                                         double pos_y,
                                         double pos_z,
                                         double view_x,
                                         double view_y,
                                         double view_z,
                                         double up_x,
                                         double up_y,
                                         double up_z,
                                         int viewport = 0) {
        TheInstance()->setCameraPosition(pos_x, pos_y, pos_z, view_x, view_y,
                                         view_z, up_x, up_y, up_z, viewport);
    }
    inline virtual void setCameraPosition(double pos_x,
                                          double pos_y,
                                          double pos_z,
                                          double view_x,
                                          double view_y,
                                          double view_z,
                                          double up_x,
                                          double up_y,
                                          double up_z,
                                          int viewport = 0) { /* do nothing */ }
 
    // set and get clip distances (near and far)
    inline static void GetCameraClip(double* clipPlanes, int viewport = 0) {
        TheInstance()->getCameraClip(clipPlanes, viewport);
    }
    virtual void getCameraClip(double* clipPlanes,
                               int viewport = 0) { /* do nothing */ }
    inline static void SetCameraClip(double znear,
                                     double zfar,
                                     int viewport = 0) {
        TheInstance()->m_viewportParams.zNear = znear;
        TheInstance()->m_viewportParams.zFar = zfar;
        TheInstance()->setCameraClip(znear, zfar, viewport);
    }
    virtual void setCameraClip(double znear,
                               double zfar,
                               int viewport = 0) { /* do nothing */ }
 
    inline static void ResetCameraClippingRange(int viewport = 0) {
        TheInstance()->resetCameraClippingRange(viewport);
    }
    inline virtual void resetCameraClippingRange(
            int viewport = 0) { /* do nothing */ }
 
    // set and get view angle in y direction
    inline static double GetCameraFovy(int viewport = 0) {
        return TheInstance()->getCameraFovy(viewport);
    }
    inline virtual double getCameraFovy(int viewport = 0) {
        return 0; /* do nothing */
    }
    inline static void SetCameraFovy(double fovy, int viewport = 0) {
        TheInstance()->m_viewportParams.fov_deg = static_cast<float>(fovy);
        TheInstance()->setCameraFovy(cloudViewer::DegreesToRadians(fovy),
                                     viewport);
    }
    inline virtual void setCameraFovy(double fovy,
                                      int viewport = 0) { /* do nothing */ }
 
    inline static void GetViewerPos(int* viewPos, int viewport = 0) {
        viewPos[0] = 0;
        viewPos[1] = 0;
        viewPos[2] = Width();
        viewPos[3] = Height();
    }
 
    inline static void SaveScreenshot(const std::string& file) {
        TheInstance()->saveScreenshot(file);
    }
    inline virtual void saveScreenshot(
            const std::string& file) { /* do nothing */ }
 
    inline static void SaveCameraParameters(const std::string& file) {
        TheInstance()->saveCameraParameters(file);
    }
    inline virtual void saveCameraParameters(
            const std::string& file) { /* do nothing */ }
 
    inline static void LoadCameraParameters(const std::string& file) {
        TheInstance()->loadCameraParameters(file);
    }
    inline virtual void loadCameraParameters(
            const std::string& file) { /* do nothing */ }
 
    inline static void ShowOrientationMarker() {
        TheInstance()->showOrientationMarker();
        UpdateScreen();
    }
    inline virtual void showOrientationMarker() { /* do nothing */ }
 
    inline static void SetOrthoProjection(int viewport = 0) {
        TheInstance()->setOrthoProjection(viewport);
        UpdateScreen();
    }
    inline virtual void setOrthoProjection(int viewport = 0) { /* do nothing */
    }
    inline static void SetPerspectiveProjection(int viewport = 0) {
        TheInstance()->setPerspectiveProjection(viewport);
        UpdateScreen();
    }
    inline virtual void setPerspectiveProjection(
            int viewport = 0) { /* do nothing */ }
 
    inline static void SetUseVbos(bool useVbos) {
        TheInstance()->setUseVbos(useVbos);
    }
    inline virtual void setUseVbos(bool useVbos) { /* do nothing */ }
 
    inline static void SetLookUpTableID(const std::string& viewID) {
        TheInstance()->setLookUpTableID(viewID);
    }
    inline virtual void setLookUpTableID(
            const std::string& viewID) { /* do nothing */ }
 
    inline static void GetProjectionMatrix(double* projArray,
                                           int viewport = 0) {
        TheInstance()->getProjectionMatrix(projArray, viewport);
    }
    inline virtual void getProjectionMatrix(double* projArray,
                                            int viewport = 0) { /* do nothing */
    }
    inline static void GetViewMatrix(double* viewArray, int viewport = 0) {
        TheInstance()->getViewMatrix(viewArray, viewport);
    }
    inline virtual void getViewMatrix(double* viewArray,
                                      int viewport = 0) { /* do nothing */ }
 
    inline static void SetViewMatrix(const ccGLMatrixd& viewMat,
                                     int viewport = 0) {
        TheInstance()->setViewMatrix(viewMat, viewport);
    }
    inline virtual void setViewMatrix(const ccGLMatrixd& viewMat,
                                      int viewport = 0) { /* do nothing */ }
 
    static bool HideShowEntities(const ccHObject* obj, bool visible);
    inline static bool HideShowEntities(const CC_DRAW_CONTEXT& CONTEXT) {
        return TheInstance()->hideShowEntities(CONTEXT);
    }
    inline virtual bool hideShowEntities(const CC_DRAW_CONTEXT& CONTEXT) {
        return true; /* do nothing */
    }
    static void HideShowEntities(const QStringList& viewIDs,
                                 ENTITY_TYPE hideShowEntityType,
                                 bool visibility = false);
 
    static void RemoveEntities(const ccHObject* obj);
    static void RemoveEntities(const QStringList& viewIDs,
                               ENTITY_TYPE removeEntityType);
    inline static void RemoveEntities(const CC_DRAW_CONTEXT& CONTEXT) {
        TheInstance()->removeEntities(CONTEXT);
    }
    inline virtual void removeEntities(
            const CC_DRAW_CONTEXT& CONTEXT) { /* do nothing */ }
 
    static void DrawBackground(CC_DRAW_CONTEXT& CONTEXT);
    static void DrawForeground(CC_DRAW_CONTEXT& CONTEXT);
    static void Update2DLabel(bool immediateUpdate = false);
    static void Pick2DLabel(int x, int y);
    virtual QString pick2DLabel(int x, int y) {
        return QString(); /* do nothing */
    }
    static void Redraw2DLabel();
 
    static QString Pick3DItem(int x = -1, int y = -1) {
        return TheInstance()->pick3DItem(x, y);
    }
    virtual QString pick3DItem(int x = -1, int y = -1) {
        return QString(); /* do nothing */
    }
    static QString PickObject(double x = -1, double y = -1) {
        return TheInstance()->pickObject(x, y);
    }
    virtual QString pickObject(double x = -1, double y = -1) {
        return QString(); /* do nothing */
    }
 
    static void FilterByEntityType(ccHObject::Container& labels,
                                   CV_CLASS_ENUM type);
 
    inline virtual void setBackgroundColor(
            const CC_DRAW_CONTEXT& CONTEXT) { /* do nothing */ }
 
    inline static void CreateViewPort(
            double xmin, double ymin, double xmax, double ymax, int& viewport) {
        TheInstance()->createViewPort(xmin, ymin, xmax, ymax, viewport);
    }
    inline virtual void createViewPort(double xmin,
                                       double ymin,
                                       double xmax,
                                       double ymax,
                                       int& viewport) { /* do nothing */ }
 
    inline static void ResetCameraViewpoint(const std::string& viewID) {
        TheInstance()->resetCameraViewpoint(viewID);
    }
    inline virtual void resetCameraViewpoint(
            const std::string& viewID) { /* do nothing */ }
 
    static void SetPointSize(float size, bool silent = false, int viewport = 0);
    static void SetPointSizeRecursive(int size);
 
 
    static void SetLineWidth(float width,
                             bool silent = false,
                             int viewport = 0);
    static void SetLineWithRecursive(PointCoordinateType with);
 
    inline static void Toggle2Dviewer(bool state) {
        TheInstance()->toggle2Dviewer(state);
    }
    inline virtual void toggle2Dviewer(bool state) { /* do nothing */ }
 
public:  // visualization matrix transformation
 
    static void DisplayNewMessage(const QString& message,
                                  MessagePosition pos,
                                  bool append = false,
                                  int displayMaxDelay_sec = 2,
                                  MessageType type = CUSTOM_MESSAGE);
 
 
    static const ecvGui::ParamStruct& GetDisplayParameters();
 
    static void SetDisplayParameters(const ecvGui::ParamStruct& params);
 
    static void UpdateDisplayParameters();
 
    static void SetupProjectiveViewport(const ccGLMatrixd& cameraMatrix,
                                        float fov_deg = 0.0f,
                                        float ar = 1.0f,
                                        bool viewerBasedPerspective = true,
                                        bool bubbleViewMode = false);
 
 
    static void SetAspectRatio(float ar);
 
 
    static void ResizeGL(int w, int h);
    static void UpdateScreenSize();
    inline static void Update() {
        GetCurrentScreen()->update();
        UpdateCamera();
    }
    inline static void UpdateScreen() {
        GetCurrentScreen()->update();
        UpdateScene();
    }
    inline static void ResetCamera(const ccBBox* bbox) {
        TheInstance()->resetCamera(bbox);
        UpdateScreen();
    }
    inline virtual void resetCamera(const ccBBox* bbox) { /* do nothing */ }
    inline static void ResetCamera() {
        TheInstance()->resetCamera();
        UpdateScreen();
    }
    inline virtual void resetCamera() { /* do nothing */ }
    inline static void UpdateCamera() {
        TheInstance()->updateCamera();
        UpdateScreen();
    }
    inline virtual void updateCamera() { /* do nothing */ }
 
    inline static void UpdateScene() { TheInstance()->updateScene(); }
    inline virtual void updateScene() { /* do nothing */ }
 
    inline static void SetAutoUpateCameraPos(bool state) {
        TheInstance()->setAutoUpateCameraPos(state);
    }
    inline virtual void setAutoUpateCameraPos(bool state) { /* do nothing */ }
 
    inline static void GetCenterOfRotation(double center[3]) {
        TheInstance()->getCenterOfRotation(center);
    }
    inline static void GetCenterOfRotation(CCVector3d& center) {
        TheInstance()->getCenterOfRotation(center.u);
    }
    inline virtual void getCenterOfRotation(double center[3]) { /* do nothing */
    }
 
    inline static void ResetCenterOfRotation(int viewport = 0) {
        TheInstance()->resetCenterOfRotation(viewport);
        UpdateScreen();
    }
    inline virtual void resetCenterOfRotation(
            int viewport = 0) { /* do nothing */ }
 
    inline static void SetCenterOfRotation(double x, double y, double z) {
        TheInstance()->setCenterOfRotation(x, y, z);
    }
    inline virtual void setCenterOfRotation(double x,
                                            double y,
                                            double z) { /* do nothing */ }
 
    inline static void SetCenterOfRotation(const double xyz[3]) {
        SetCenterOfRotation(xyz[0], xyz[1], xyz[2]);
    }
 
    inline static void SetCenterOfRotation(const CCVector3d& center) {
        SetCenterOfRotation(center.u);
    }
 
    inline static double GetGLDepth(int x, int y) {
        return TheInstance()->getGLDepth(x, y);
    }
    inline virtual double getGLDepth(int x, int y) {
        return 1.0; /* do nothing */
    }
 
    inline static void ChangeOpacity(double opacity,
                                     const std::string& viewID,
                                     int viewport = 0) {
        TheInstance()->changeOpacity(opacity, viewID, viewport);
        UpdateScreen();
    }
    inline virtual void changeOpacity(double opacity,
                                      const std::string& viewID,
                                      int viewport = 0) {
        /* do nothing */
    }
 
 
    static CCVector3d ConvertMousePositionToOrientation(int x, int y);
 
 
    static void UpdateActiveItemsList(int x,
                                      int y,
                                      bool extendToSelectedLabels = false);
 
    inline static void SetGLViewport(int x, int y, int w, int h) {
        SetGLViewport(QRect(x, y, w, h));
    }
    static void SetGLViewport(const QRect& rect);
 
    // Graphical features controls
    static void drawCross();
    static void drawTrihedron();
 
    static bool RenderToFile(QString filename,
                             float zoomFactor = 1.0f,
                             bool dontScaleFeatures = false,
                             bool renderOverlayItems = false);
 
    inline static QImage RenderToImage(int zoomFactor = 1,
                                       bool renderOverlayItems = false,
                                       bool silent = false,
                                       int viewport = 0) {
        return TheInstance()->renderToImage(zoomFactor, renderOverlayItems,
                                            silent, viewport);
    }
    inline virtual QImage renderToImage(int zoomFactor = 1,
                                        bool renderOverlayItems = false,
                                        bool silent = false,
                                        int viewport = 0) {
        return QImage(); /* do nothing */
    }
 
    inline static void SetScaleBarVisible(bool visible) {
        return TheInstance()->setScaleBarVisible(visible);
    }
    inline virtual void setScaleBarVisible(bool visible) { /* do nothing */ }
 
    static void DisplayTexture2DPosition(QImage image,
                                         const QString& id,
                                         int x,
                                         int y,
                                         int w,
                                         int h,
                                         unsigned char alpha = 255);
    static void DrawClickableItems(int xStart, int& yStart);
    static void RenderText(
            int x,
            int y,
            const QString& str,
            const QFont& font = QFont(),
            const ecvColor::Rgbub& color = ecvColor::defaultLabelBkgColor,
            const QString& id = "");
    static void RenderText(
            double x,
            double y,
            double z,
            const QString& str,
            const QFont& font = QFont(),
            const ecvColor::Rgbub& color = ecvColor::defaultLabelBkgColor,
            const QString& id = "");
 
    inline static void ToggleExclusiveFullScreen(bool state) {
        TheInstance()->toggleExclusiveFullScreen(state);
    }
    inline virtual void toggleExclusiveFullScreen(
            bool state) { /* in this do nothing */ }
 
    inline static bool ExclusiveFullScreen() {
        return TheInstance()->m_exclusiveFullscreen;
    }
    inline static void SetExclusiveFullScreenFlage(bool state) {
        TheInstance()->m_exclusiveFullscreen = state;
    }
 
 
    static void SetPixelSize(float pixelSize);
 
 
    static void UpdateConstellationCenterAndZoom(const ccBBox* aBox = nullptr,
                                                 bool redraw = true);
 
    static void GetContext(CC_DRAW_CONTEXT& CONTEXT);
 
    static void GetGLCameraParameters(ccGLCameraParameters& params);
 
    static void SetInteractionMode(INTERACTION_FLAGS flags);
    static INTERACTION_FLAGS GetInteractionMode();
 
    static void SetView(CC_VIEW_ORIENTATION orientation, ccBBox* bbox);
    static void SetView(CC_VIEW_ORIENTATION orientation,
                        bool forceRedraw = false);
 
 
    static ccGLMatrixd GenerateViewMat(CC_VIEW_ORIENTATION orientation);
 
 
    static void SetPerspectiveState(bool state, bool objectCenteredView);
 
    static bool GetPerspectiveState(int viewport = 0) {
        return TheInstance()->getPerspectiveState(viewport);
    }
    inline virtual bool getPerspectiveState(int viewport = 0) const override {
        return TheInstance()->m_viewportParams.perspectiveView;
    }
 
    static bool ObjectPerspectiveEnabled();
    static bool ViewerPerspectiveEnabled();
 
    static float ComputePerspectiveZoom();
 
 
    static void SetFov(float fov);
    static float GetFov();
 
    inline static void ZoomGlobal() { UpdateConstellationCenterAndZoom(); }
 
 
    static CCVector3d GetCurrentViewDir();
 
 
    static CCVector3d GetCurrentUpDir();
 
 
    static void SetCameraPos(const CCVector3d& P);
 
 
    static void MoveCamera(float dx, float dy, float dz);
 
    inline static void MoveCamera(const CCVector3d& v) {
        MoveCamera(v.x, v.y, v.z);
    }
 
    static void SetPickingMode(PICKING_MODE mode = DEFAULT_PICKING);
    static PICKING_MODE GetPickingMode();
 
 
    static void LockPickingMode(bool state);
 
    static bool IsPickingModeLocked();
 
 
    static void SetZoom(float value);
 
 
    static void UpdateZoom(float zoomFactor);
 
 
    static void SetPivotPoint(const CCVector3d& P,
                              bool autoUpdateCameraPos = false,
                              bool verbose = false);
 
    static void SetPivotVisibility(PivotVisibility vis);
    static void SetPivotVisibility(bool state) {
        TheInstance()->setPivotVisibility(state);
    }
    virtual void setPivotVisibility(bool state) { /*do nothing here*/ }
 
    inline static PivotVisibility GetPivotVisibility() {
        return TheInstance()->m_pivotVisibility;
    }
 
 
    static void ShowPivotSymbol(bool state);
 
    static void SetViewportParameters(const ecvViewportParameters& params);
    static const ecvViewportParameters& GetViewportParameters();
 
    // return value (in rad)
    inline static double GetParallelScale(int viewport = 0) {
        return TheInstance()->getParallelScale(viewport);
    }
    inline virtual double getParallelScale(int viewport = 0) { return -1.0; }
 
    // scale (in rad)
    inline static void SetParallelScale(double scale, int viewport = 0) {
        TheInstance()->setParallelScale(scale, viewport);
    }
    inline virtual void setParallelScale(double scale,
                                         int viewport = 0) { /*do nothing here*/
    }
 
    static ccGLMatrixd& GetModelViewMatrix();
    static ccGLMatrixd& GetProjectionMatrix();
 
    static void UpdateModelViewMatrix();
    static void UpdateProjectionMatrix();
 
    static ccGLMatrixd ComputeModelViewMatrix();
 
    static ccGLMatrixd ComputeProjectionMatrix(
            bool withGLfeatures,
            ProjectionMetrics* metrics = nullptr,
            double* eyeOffset = nullptr);
 
    inline static void Deprecate3DLayer() { TheInstance()->m_updateFBO = true; }
    inline static void InvalidateViewport() {
        TheInstance()->m_validProjectionMatrix = false;
    }
    inline static void InvalidateVisualization() {
        TheInstance()->m_validModelviewMatrix = false;
    }
 
    static CCVector3d GetRealCameraCenter();
 
 
    static double ComputeActualPixelSize();
 
    static bool IsRectangularPickingAllowed();
 
    static void SetRectangularPickingAllowed(bool state);
 
 
    static void SetBubbleViewMode(bool state);
    inline static bool BubbleViewModeEnabled() {
        return TheInstance()->m_bubbleViewModeEnabled;
    }
    static void SetBubbleViewFov(float fov_deg);
 
    inline static void ShowCursorCoordinates(bool state) {
        TheInstance()->m_showCursorCoordinates = state;
    }
    inline static bool CursorCoordinatesShown() {
        return TheInstance()->m_showCursorCoordinates;
    }
 
    static void SetAutoPickPivotAtCenter(bool state);
    static void SendAutoPickPivotAtCenter(bool state) {
        emit TheInstance() -> autoPickPivot(state);
    }
    inline static bool AutoPickPivotAtCenter() {
        return TheInstance()->m_autoPickPivotAtCenter;
    }
 
    static void LockRotationAxis(bool state, const CCVector3d& axis);
 
    inline static bool IsRotationAxisLocked() {
        return TheInstance()->m_rotationAxisLocked;
    }
 
    static bool GetClick3DPos(int x, int y, CCVector3d& P3D);
 
    static void DrawPivot();
 
    // debug traces on screen
    inline static void EnableDebugTrace(bool state) {
        TheInstance()->m_showDebugTraces = state;
    }
 
    inline static void ToggleDebugTrace() {
        TheInstance()->m_showDebugTraces = !TheInstance()->m_showDebugTraces;
    }
 
    struct PickingParameters {
        PickingParameters(PICKING_MODE _mode = NO_PICKING,
                          int _centerX = 0,
                          int _centerY = 0,
                          int _pickWidth = 5,
                          int _pickHeight = 5,
                          bool _pickInSceneDB = true,
                          bool _pickInLocalDB = true)
            : mode(_mode),
              centerX(_centerX),
              centerY(_centerY),
              pickWidth(_pickWidth),
              pickHeight(_pickHeight),
              pickInSceneDB(_pickInSceneDB),
              pickInLocalDB(_pickInLocalDB) {}
 
        PICKING_MODE mode;
        int centerX;
        int centerY;
        int pickWidth;
        int pickHeight;
        bool pickInSceneDB;
        bool pickInLocalDB;
    };
 
 
    static bool ProcessClickableItems(int x, int y);
 
 
    static void SetZNearCoef(double coef);
 
 
    static void StartPicking(PickingParameters& params);
 
    static ccHObject* GetPickedEntity(const PickingParameters& params);
 
    static void StartOpenGLPicking(const PickingParameters& params);
 
    static void StartCPUBasedPointPicking(const PickingParameters& params);
 
    static void ProcessPickingResult(
            const PickingParameters& params,
            ccHObject* pickedEntity,
            int pickedItemIndex,
            const CCVector3* nearestPoint = nullptr,
            const std::unordered_set<int>* selectedIDs = nullptr);
 
 
    inline static void SetFontPointSize(int pixelSize) {
        TheInstance()->m_font.setPointSize(pixelSize);
    }
    static int GetFontPointSize();
    static int GetLabelFontPointSize();
 
    static void SetClickableItemsVisible(bool state) {
        TheInstance()->m_clickableItemsVisible = state;
    }
    static bool GetClickableItemsVisible() {
        return TheInstance()->m_clickableItemsVisible;
    }
 
    // takes rendering zoom into account!
    static QFont GetLabelDisplayFont();
    // takes rendering zoom into account!
    inline static QFont GetTextDisplayFont() { return TheInstance()->m_font; }
 
    static ENTITY_TYPE ConvertToEntityType(const CV_CLASS_ENUM& type);
 
    static const int DefaultPickRadius = 5;
 
    inline static void SetPickingRadius(int radius) {
        TheInstance()->m_pickRadius = radius;
    }
    inline static int GetPickingRadius() { return TheInstance()->m_pickRadius; }
 
    static void DisplayOverlayEntities(bool state);
 
    inline static bool OverlayEntitiesAreDisplayed() {
        return TheInstance()->m_displayOverlayEntities;
    }
 
 
    std::list<ccInteractor*> m_activeItems;
 
protected:
    ecvDisplayTools() = default;
    virtual void registerVisualizer(QMainWindow* win,
                                    bool stereoMode = false) = 0;
 
    QWidget* m_currentScreen;
    QWidget* m_mainScreen;
    QMainWindow* m_win;
 
public:
    ecvViewportParameters m_viewportParams;
 
    struct ClickableItem {
        enum Role {
            NO_ROLE,
            INCREASE_POINT_SIZE,
            DECREASE_POINT_SIZE,
            INCREASE_LINE_WIDTH,
            DECREASE_LINE_WIDTH,
            LEAVE_BUBBLE_VIEW_MODE,
            LEAVE_FULLSCREEN_MODE,
        };
 
        ClickableItem() : role(NO_ROLE) {}
        ClickableItem(Role _role, QRect _area) : role(_role), area(_area) {}
 
        Role role;
        QRect area;
    };
 
    std::vector<ClickableItem> m_clickableItems;
 
    bool m_clickableItemsVisible;
 
    INTERACTION_FLAGS m_interactionFlags;
 
    PICKING_MODE m_pickingMode;
    bool m_pickingModeLocked;
 
    QElapsedTimer m_timer;
 
    bool m_touchInProgress;
    qreal m_touchBaseDist;
 
    QTimer m_scheduleTimer;
    qint64 m_scheduledFullRedrawTime;
 
    ecvGui::ParamStruct m_overridenDisplayParameters;
 
    bool m_displayOverlayEntities;
 
    bool m_overridenDisplayParametersEnabled;
 
    bool m_exclusiveFullscreen;
 
    bool m_showCursorCoordinates;
 
    bool m_autoPickPivotAtCenter;
 
    bool m_shouldBeRefreshed;
 
    CCVector3d m_autoPivotCandidate;
 
    QRect m_glViewport;
 
    bool m_showDebugTraces;
 
    int m_pickRadius;
 
    bool m_autoRefresh;
 
    bool m_rotationAxisLocked;
    CCVector3d m_lockedRotationAxis;
 
    ccGLMatrixd m_viewMatd;
    bool m_validModelviewMatrix;
    ccGLMatrixd m_projMatd;
    bool m_validProjectionMatrix;
    double m_cameraToBBCenterDist;
    double m_bbHalfDiag;
 
    PivotVisibility m_pivotVisibility;
 
    bool m_pivotSymbolShown;
 
    bool m_allowRectangularEntityPicking;
 
    ccPolyline* m_rectPickingPoly;
 
    cloudViewer::geometry::LineSet* m_scale_lineset;
 
    ccHObject* m_winDBRoot;
 
    ccHObject* m_globalDBRoot;
 
    bool m_removeFlag;
    bool m_removeAllFlag;
    std::vector<removeInfo> m_removeInfos;
 
    bool m_alwaysUseFBO;
 
    bool m_updateFBO;
 
 
    float m_sunLightPos[4];
 
    bool m_sunLightEnabled;
 
 
    float m_customLightPos[4];
 
    bool m_customLightEnabled;
 
    bool m_bubbleViewModeEnabled;
 
    float m_bubbleViewFov_deg;
 
    ecvViewportParameters m_preBubbleViewParameters;
 
    int m_uniqueID;
 
    QFont m_font;
 
    struct CaptureModeOptions {
        CaptureModeOptions()
            : enabled(false), zoomFactor(1.0f), renderOverlayItems(false) {}
 
        bool enabled;
        float zoomFactor;
        bool renderOverlayItems;
    };
 
    CaptureModeOptions m_captureMode;
 
    QTimer m_deferredPickingTimer;
 
public:  // event representation
    static bool USE_2D;
    static bool USE_VTK_PICK;
 
    CCVector3 m_last_picked_point;
    int m_last_point_index = -1;
    QString m_last_picked_id = QString();
 
    qint64 m_lastClickTime_ticks;
 
    HotZone* m_hotZone;
 
    QPoint m_lastMousePos;
 
    QPoint m_lastMouseMovePos;
 
    QStringList m_diagStrings;
 
    bool m_mouseMoved;
    bool m_mouseButtonPressed;
 
    bool m_ignoreMouseReleaseEvent;
 
    bool m_widgetClicked;
 
    static int Width() { return size().width(); }
    static int Height() { return size().height(); }
    static QSize size() { return GetScreenSize(); }
 
    static int GlWidth() { return TheInstance()->m_glViewport.width(); }
    static int GlHeight() { return TheInstance()->m_glViewport.height(); }
    static QSize GlSize() { return TheInstance()->m_glViewport.size(); }
 
    static void ClearBubbleView();
 
public slots:
 
    void onItemPickedFast(ccHObject* pickedEntity,
                          int pickedItemIndex,
                          int x,
                          int y);
 
    void onPointPicking(const CCVector3& p, int index, const std::string& id);
 
    void checkScheduledRedraw();
 
    void doPicking();
 
    // called when receiving mouse wheel is rotated
    void onWheelEvent(float wheelDelta_deg);
 
signals:
 
    void entitySelectionChanged(ccHObject* entity);
    void entitiesSelectionChanged(std::unordered_set<int> entIDs);
 
 
    void itemPicked(ccHObject* entity,
                    unsigned subEntityID,
                    int x,
                    int y,
                    const CCVector3& P);
 
 
    void itemPickedFast(ccHObject* entity, int subEntityID, int x, int y);
 
    void fastPickingFinished();
 
    /*** Camera link mode (interactive modifications of the view/camera are
     * echoed to other windows) ***/
 
    void viewMatRotated(const ccGLMatrixd& rotMat);
    void cameraDisplaced(float ddx, float ddy);
    void mouseWheelRotated(float wheelDelta_deg);
    void mouseWheelChanged(QWheelEvent* event);
 
    void perspectiveStateChanged();
 
    void baseViewMatChanged(const ccGLMatrixd& newViewMat);
 
    void pixelSizeChanged(float pixelSize);
 
    void fovChanged(float fov);
 
    void zNearCoefChanged(float coef);
 
    void pivotPointChanged(const CCVector3d&);
 
    void cameraPosChanged(const CCVector3d&);
 
    void translation(const CCVector3d& t);
 
 
    void rotation(const ccGLMatrixd& rotMat);
 
 
    void leftButtonClicked(int x, int y);
 
 
    void rightButtonClicked(int x, int y);
 
 
    void doubleButtonClicked(int x, int y);
 
 
    void mouseMoved(int x, int y, Qt::MouseButtons buttons);
 
 
    void buttonReleased();
 
 
    void drawing3D();
 
    void filesDropped(const QStringList& filenames, bool displayDialog);
 
    void newLabel(ccHObject* obj);
 
    void exclusiveFullScreenToggled(bool exclusive);
    void autoPickPivot(bool state);
 
    void labelmove2D(int x, int y, int dx, int dy);
 
    void mousePosChanged(const QPoint& pos);
 
    void pointPicked(double x, double y, double z);
 
    void cameraParamChanged();
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(ecvDisplayTools::INTERACTION_FLAGS);