cvRenderViewSelectionReaction.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
 
// clang-format off
// Qt - must be included before other headers for MOC to work correctly
#include <QtGlobal>
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
#include <QAction>
#include <QCursor>
#include <QObject>
#include <QPointer>
#include <QShortcut>
#include <QTimer>
#else
#include <QtWidgets/QAction>
#include <QtGui/QCursor>
#include <QtCore/QObject>
#include <QtCore/QPointer>
#include <QtWidgets/QShortcut>
#include <QtCore/QTimer>
#endif
// clang-format on
 
#include "cvSelectionData.h"
#include "cvSelectionData.h"  // Contains SelectionMode, SelectionModifier enums
#include "qPCL.h"
 
// VTK
#include <vtkSmartPointer.h>
#include <vtkWeakPointer.h>
 
// Forward declarations
class QActionGroup;
class ecvGenericVisualizer3D;
class cvSelectionPipeline;
class cvSelectionHighlighter;
class vtkObject;
class vtkRenderWindowInteractor;
class vtkRenderer;
class vtkInteractorStyle;
class vtkIntArray;
class vtkPolyData;
 
namespace PclUtils {
class PCLVis;
}
 
class QPCL_ENGINE_LIB_API cvRenderViewSelectionReaction : public QObject {
    Q_OBJECT
 
public:
    using SelectionMode = ::SelectionMode;
    using SelectionModifier = ::SelectionModifier;
 
    cvRenderViewSelectionReaction(QAction* parentAction,
                                  SelectionMode mode,
                                  QActionGroup* modifierGroup = nullptr);
 
    ~cvRenderViewSelectionReaction() override;
 
    QAction* parentAction() const { return m_parentAction; }
 
    SelectionMode mode() const { return m_mode; }
 
    void setVisualizer(ecvGenericVisualizer3D* viewer);
 
    ecvGenericVisualizer3D* getVisualizer() const { return m_viewer; }
 
    bool isActive() const;
 
    static cvRenderViewSelectionReaction* activeReaction() {
        return ActiveReaction;
    }
 
    static void endActiveSelection();
 
    //-------------------------------------------------------------------------
    // Public event handlers (called by VTK callbacks)
    //-------------------------------------------------------------------------
 
    void handleSelectionChanged(vtkObject* caller,
                                unsigned long eventId,
                                void* callData);
 
    Q_INVOKABLE void handleMouseMove();
 
    Q_INVOKABLE void handleLeftButtonPress();
 
    Q_INVOKABLE void handleLeftButtonRelease();
 
    Q_INVOKABLE void handleWheelRotate();
 
    Q_INVOKABLE void handleRightButtonPressed();
 
    Q_INVOKABLE void handleRightButtonRelease();
 
protected:
 
    void vtkOnSelectionChanged(vtkObject* caller,
                               unsigned long eventId,
                               void* callData);
    void vtkOnMouseMove(vtkObject* caller,
                        unsigned long eventId,
                        void* callData);
    void vtkOnLeftButtonPress(vtkObject* caller,
                              unsigned long eventId,
                              void* callData);
    void vtkOnLeftButtonRelease(vtkObject* caller,
                                unsigned long eventId,
                                void* callData);
    void vtkOnWheelRotate(vtkObject* caller,
                          unsigned long eventId,
                          void* callData);
    void vtkOnRightButtonPressed(vtkObject* caller,
                                 unsigned long eventId,
                                 void* callData);
    void vtkOnRightButtonRelease(vtkObject* caller,
                                 unsigned long eventId,
                                 void* callData);
    void vtkOnMiddleButtonPressed(vtkObject* caller,
                                  unsigned long eventId,
                                  void* callData);
    void vtkOnMiddleButtonRelease(vtkObject* caller,
                                  unsigned long eventId,
                                  void* callData);
 
signals:
    void selectionFinished(const cvSelectionData& selectionData);
 
    void selectedCustomBox(int xmin, int ymin, int xmax, int ymax);
    void selectedCustomBox(const int region[4]);
 
    void selectedCustomPolygon(vtkIntArray* polygon);
 
    void zoomToBoxCompleted(int xmin, int ymin, int xmax, int ymax);
 
public slots:
    virtual void actionTriggered(bool val);
 
    virtual void updateEnableState();
 
protected slots:
    virtual void beginSelection();
 
    virtual void endSelection();
 
    virtual void onMouseStop();
 
    virtual void clearSelectionCache();
 
protected:
    virtual void selectionChanged(vtkObject* caller,
                                  unsigned long eventId,
                                  void* callData);
 
    virtual void onMouseMove();
 
    virtual void onLeftButtonPress();
 
    virtual void onLeftButtonRelease();
 
    virtual void onWheelRotate();
 
    virtual void onRightButtonPressed();
 
    virtual void onRightButtonRelease();
 
    virtual void onMiddleButtonPressed();
 
    virtual void onMiddleButtonRelease();
 
    virtual void preSelection();
 
    virtual void fastPreSelection();
 
    virtual void updateTooltip();
 
    virtual int getSelectionModifier();
 
    virtual bool isCompatible(SelectionMode mode);
 
    virtual void cleanupObservers();
 
    void uncheckSelectionModifiers();
 
    //-------------------------------------------------------------------------
    // Selection execution methods
    //-------------------------------------------------------------------------
 
    void selectCellsOnSurface(int region[4], int selectionModifier);
 
    void selectPointsOnSurface(int region[4], int selectionModifier);
 
    void selectFrustumCells(int region[4], int selectionModifier);
 
    void selectFrustumPoints(int region[4], int selectionModifier);
 
    void finalizeSelection(const cvSelectionData& newSelection,
                           int selectionModifier,
                           const QString& description);
 
    void selectPolygonCells(vtkIntArray* polygon, int selectionModifier);
 
    void selectPolygonPoints(vtkIntArray* polygon, int selectionModifier);
 
    void selectBlock(int region[4], int selectionModifier);
 
    //-------------------------------------------------------------------------
    // Internal helpers
    //-------------------------------------------------------------------------
 
    PclUtils::PCLVis* getPCLVis() const;
 
    cvSelectionPipeline* getSelectionPipeline() const;
 
    cvSelectionHighlighter* getSelectionHighlighter() const;
 
    bool isSelectingCells() const;
 
    bool isInteractiveMode() const;
 
    bool isTooltipMode() const;
 
    void setCursor(const QCursor& cursor);
 
    void unsetCursor();
 
    void storeCurrentStyle();
 
    void restoreStyle();
 
    void setupInteractorStyle();
 
    void setupObservers();
 
    void addCameraMovementObservers(int startIndex);
 
    void setRubberBand3DStyle(bool renderOnMouseMove);
 
    void showInstructionDialog();
 
private:
    // Qt objects
    QPointer<QAction> m_parentAction;
    QPointer<QActionGroup> m_modifierGroup;
 
    // Selection mode
    SelectionMode m_mode;
 
    // Visualizer reference (not owned)
    ecvGenericVisualizer3D* m_viewer = nullptr;
 
    // VTK objects
    vtkRenderWindowInteractor* m_interactor = nullptr;
    vtkRenderer* m_renderer = nullptr;
    vtkSmartPointer<vtkInteractorStyle> m_previousStyle;
    vtkSmartPointer<vtkInteractorStyle> m_selectionStyle;
 
    // Previous render view mode (for restoration)
    int m_previousRenderViewMode = -1;
 
    // Event observer IDs for interactor events (increased to 8 for pan/zoom)
    unsigned long m_observerIds[8] = {0, 0, 0, 0, 0, 0, 0, 0};
    vtkWeakPointer<vtkObject> m_observedObject;
 
    // Separate observer ID for selection style (SelectionChangedEvent)
    unsigned long m_styleObserverId = 0;
 
    // Cursor
    QCursor m_zoomCursor;
 
    // Mouse move state (for tooltip timing)
    QTimer m_mouseMovingTimer;
    bool m_mouseMoving = false;
    int m_mousePosition[2] = {0, 0};
 
    // Zoom box tracking (for zoomToBoxCompleted signal)
    int m_zoomStartPosition[2] = {0, 0};
    bool m_zoomTracking = false;
 
    // Pre-selection state
    bool m_disablePreSelection = false;
 
    // Tooltip state
    QString m_plainTooltipText;
    QShortcut* m_copyTooltipShortcut = nullptr;
 
    // Current highlight state (for interactive modes)
    vtkIdType m_hoveredId = -1;
    vtkPolyData* m_currentPolyData = nullptr;
 
    // Current selection data
    cvSelectionData m_currentSelection;
 
    // Static: only one reaction can be active at a time
    // Reference: pqRenderViewSelectionReaction::ActiveReaction
    static QPointer<cvRenderViewSelectionReaction> ActiveReaction;
 
    // Tooltip display wait time (ms)
    static const int TOOLTIP_WAITING_TIME = 400;
};