cvGenericSelectionTool.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
 
#include <vector>
 
#include "cvSelectionBase.h"
#include "cvSelectionData.h"
// cvSelectionTypes.h merged into cvSelectionData.h
 
// VTK includes (need full definitions for template instantiation)
#include <vtkCellPicker.h>  // Full definition needed for vtkSmartPointer<vtkCellPicker>
#include <vtkHardwareSelector.h>  // Full definition needed for vtkSmartPointer<vtkHardwareSelector>
#include <vtkPointPicker.h>  // Full definition needed for vtkSmartPointer<vtkPointPicker>
#include <vtkSmartPointer.h>  // For vtkSmartPointer template
#include <vtkType.h>          // For vtkIdType
 
// Forward declarations
class vtkRenderer;
class vtkSelection;
class vtkRenderWindowInteractor;
class cvViewSelectionManager;
class cvSelectionPipeline;
 
class QPCL_ENGINE_LIB_API cvGenericSelectionTool : public cvSelectionBase {
public:
    using SelectionMode = ::SelectionMode;
 
    using SelectionModifier = ::SelectionModifier;
 
    cvGenericSelectionTool()
        : cvSelectionBase(),
          m_manager(nullptr),
          m_useHardwareSelection(false),
          m_captureZValues(true),
          m_multipleSelectionMode(false),
          m_interactor(nullptr),
          m_renderer(nullptr) {}
 
    ~cvGenericSelectionTool() override = default;
 
    void setSelectionManager(cvViewSelectionManager* manager) {
        m_manager = manager;
    }
 
    cvViewSelectionManager* getSelectionManager() const { return m_manager; }
 
    cvSelectionPipeline* getSelectionPipeline() const;
 
    vtkPolyData* getPolyDataForSelection(
            const cvSelectionData* selectionData = nullptr) override;
 
protected:
    // Note: Visualizer access methods (setVisualizer, getVisualizer, getPCLVis,
    // hasValidPCLVis, getAllPolyDataFromVisualizer)
    // are inherited from cvSelectionBase
 
 
    cvSelectionData hardwareSelectAtPoint(
            int x,
            int y,
            SelectionMode mode = SelectionMode::SELECT_SURFACE_CELLS,
            SelectionModifier modifier = SelectionModifier::SELECTION_DEFAULT);
 
    cvSelectionData hardwareSelectInRegion(
            const int region[4],
            SelectionMode mode = SelectionMode::SELECT_SURFACE_CELLS,
            SelectionModifier modifier = SelectionModifier::SELECTION_DEFAULT);
 
    QVector<cvActorSelectionInfo> getActorsAtPoint(int x, int y);
 
 
 
    void setUseHardwareSelection(bool enable) {
        m_useHardwareSelection = enable;
    }
 
    bool useHardwareSelection() const { return m_useHardwareSelection; }
 
    void setCaptureZValues(bool capture) { m_captureZValues = capture; }
 
    void setMultipleSelectionMode(bool enable) {
        m_multipleSelectionMode = enable;
    }
 
    bool multipleSelectionMode() const { return m_multipleSelectionMode; }
 
 
 
    void initializePickers();
 
    vtkIdType pickAtPosition(int x, int y, bool selectCells);
 
    vtkIdType pickAtCursor(bool selectCells);
 
    void setInteractor(vtkRenderWindowInteractor* interactor) {
        m_interactor = interactor;
    }
 
    vtkRenderWindowInteractor* getInteractor() const { return m_interactor; }
 
    void setRenderer(vtkRenderer* renderer) { m_renderer = renderer; }
 
    vtkRenderer* getPickingRenderer() const { return m_renderer; }
 
    void setPickerTolerance(double cellTolerance, double pointTolerance);
 
    vtkActor* getPickedActor(bool selectCells);
 
    vtkPolyData* getPickedPolyData(bool selectCells);
 
    bool getPickedPosition(bool selectCells, double position[3]);
 
    cvSelectionData createSelectionFromPick(vtkIdType pickedId,
                                            bool selectCells);
 
    cvSelectionData applySelectionModifierUnified(
            const cvSelectionData& newSelection,
            const cvSelectionData& currentSelection,
            int modifier,
            int fieldAssociation);
 
 
private:
    vtkHardwareSelector* getHardwareSelector();
 
    vtkHardwareSelector* configureHardwareSelector(const int region[4],
                                                   int fieldAssociation);
 
    QVector<cvActorSelectionInfo> extractActorInfo(
            vtkHardwareSelector* selector, vtkSelection* vtkSel);
 
    cvSelectionData convertSelection(
            vtkSelection* vtkSel,
            const QVector<cvActorSelectionInfo>& actorInfos);
 
    cvSelectionData applyModifier(const cvSelectionData& newSelection,
                                  const cvSelectionData& currentSelection,
                                  SelectionModifier modifier);
 
    vtkRenderer* getRenderer();
 
protected:
    // Note: m_viewer is inherited from cvSelectionBase
 
    cvViewSelectionManager* m_manager;  
 
    vtkSmartPointer<vtkCellPicker> m_cellPicker;    
    vtkSmartPointer<vtkPointPicker> m_pointPicker;  
    vtkRenderWindowInteractor* m_interactor;  
    vtkRenderer* m_renderer;                  
 
    bool m_useHardwareSelection;         
    bool m_captureZValues;               
    bool m_multipleSelectionMode;        
    cvSelectionData m_currentSelection;  
    vtkSmartPointer<vtkHardwareSelector>
            m_hardwareSelector;  
};