cvSelectionPipeline.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 first for MOC to work correctly on Windows
#include <QtCore/QObject>
#include <QtCore/QHash>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QWidget>
// clang-format on
 
#include "cvSelectionData.h"
#include "qPCL.h"
 
// VTK
#include <vtkSmartPointer.h>
 
// Forward declarations
class cvHardwareSelector;
class vtkSelection;
class vtkIntArray;
class vtkIdTypeArray;
class vtkDataObject;
class vtkDataSet;
class vtkRenderer;
class vtkProp;
 
namespace PclUtils {
class PCLVis;
}
 
class QPCL_ENGINE_LIB_API cvSelectionPipeline : public QObject {
    Q_OBJECT
 
public:
    enum SelectionType {
        SURFACE_CELLS,   
        SURFACE_POINTS,  
        FRUSTUM_CELLS,   
        FRUSTUM_POINTS,  
        POLYGON_CELLS,   
        POLYGON_POINTS   
    };
 
    enum FieldAssociation {
        FIELD_ASSOCIATION_CELLS = 0,
        FIELD_ASSOCIATION_POINTS = 1
    };
 
    explicit cvSelectionPipeline(QObject* parent = nullptr);
    ~cvSelectionPipeline() override;
 
    //=========================================================================
    // Static Utility Methods (merged from cvSelectionToolHelper)
    //=========================================================================
 
    static bool promptUser(const QString& settingsKey,
                           const QString& title,
                           const QString& message,
                           QWidget* parent = nullptr);
 
    void setVisualizer(PclUtils::PCLVis* viewer);
 
    vtkSmartPointer<vtkSelection> executeRectangleSelection(int region[4],
                                                            SelectionType type);
 
    vtkSmartPointer<vtkSelection> executePolygonSelection(vtkIntArray* polygon,
                                                          SelectionType type);
 
    static vtkSmartPointer<vtkIdTypeArray> extractSelectionIds(
            vtkSelection* selection, FieldAssociation fieldAssociation);
 
    static QMap<vtkProp*, vtkDataSet*> extractDataFromSelection(
            vtkSelection* selection);
 
    static vtkDataSet* getPrimaryDataFromSelection(vtkSelection* selection);
 
    static cvSelectionData convertToCvSelectionData(
            vtkSelection* selection, FieldAssociation fieldAssociation);
 
    static bool pointInPolygon(const int point[2],
                               vtkIntArray* polygon,
                               vtkIdType numPoints);
 
    vtkSmartPointer<vtkSelection> refinePolygonSelection(
            vtkSelection* selection, vtkIntArray* polygon, vtkIdType numPoints);
 
    vtkSmartPointer<vtkSelection> getLastSelection() const {
        return m_lastSelection;
    }
 
    void setEnableCaching(bool enable);
 
    void clearCache();
 
    int getCacheSize() const;
    int getCacheHits() const;
    int getCacheMisses() const;
 
    void enterSelectionMode();
 
    void exitSelectionMode();
 
    bool isInSelectionMode() const { return m_inSelectionMode; }
 
    void invalidateCachedSelection();
 
 
    void setPointPickingRadius(unsigned int radius);
 
    unsigned int getPointPickingRadius() const { return m_pointPickingRadius; }
 
 
    struct PixelSelectionInfo {
        bool valid;             // Whether selection is valid
        vtkIdType attributeID;  // Element ID (point or cell) within the actor
        vtkProp* prop;          // The selected actor/prop
        vtkPolyData* polyData;  // PolyData from the selected actor
 
        PixelSelectionInfo()
            : valid(false), attributeID(-1), prop(nullptr), polyData(nullptr) {}
    };
 
    PixelSelectionInfo getPixelSelectionInfo(int x, int y, bool selectCells);
 
    vtkIdType fastPreSelectAt(int x, int y, bool selectCells);
 
    bool hasCachedBuffers() const;
 
    bool captureBuffersForFastPreSelection();
 
 
    cvSelectionData selectCellsOnSurface(const int region[4]);
 
    cvSelectionData selectPointsOnSurface(const int region[4]);
 
    cvSelectionData selectCellsInPolygon(vtkIntArray* polygon);
 
    cvSelectionData selectPointsInPolygon(vtkIntArray* polygon);
 
 
    enum CombineOperation {
        OPERATION_DEFAULT = 0,      
        OPERATION_ADDITION = 1,     
        OPERATION_SUBTRACTION = 2,  
        OPERATION_TOGGLE = 3        
    };
 
    static cvSelectionData combineSelections(const cvSelectionData& sel1,
                                             const cvSelectionData& sel2,
                                             CombineOperation operation);
 
signals:
    void selectionCompleted(vtkSelection* selection);
 
    void errorOccurred(const QString& message);
 
private:
    vtkSmartPointer<vtkSelection> performHardwareSelection(
            int region[4], FieldAssociation fieldAssociation);
 
    vtkSmartPointer<vtkSelection> getCachedSelection(const QString& key);
 
    void cacheSelection(const QString& key, vtkSelection* selection);
 
    QString generateCacheKey(int region[4], SelectionType type) const;
 
    FieldAssociation getFieldAssociation(SelectionType type) const;
 
    cvSelectionData convertSelectionToData(vtkSelection* vtkSel,
                                           FieldAssociation fieldAssoc,
                                           const QString& errorContext);
 
private:
    PclUtils::PCLVis* m_viewer;
    vtkRenderer* m_renderer;
 
    // Hardware selector (ParaView-style cvHardwareSelector)
    // Reference: ParaView uses vtkPVHardwareSelector for optimized selection
    vtkSmartPointer<cvHardwareSelector> m_hardwareSelector;
 
    // Last selection result (for getPolyData() operations)
    vtkSmartPointer<vtkSelection> m_lastSelection;
 
    // Selection cache
    bool m_cachingEnabled;
    QHash<QString, vtkSmartPointer<vtkSelection>> m_selectionCache;
 
    // Cache statistics
    int m_cacheHits;
    int m_cacheMisses;
 
    // Maximum cache size
    static const int MAX_CACHE_SIZE = 50;
 
    // Selection mode state (for cache optimization)
    bool m_inSelectionMode = false;
 
    // Flag to prevent concurrent access during invalidation
    // Set to true while invalidateCachedSelection() is running
    bool m_invalidating = false;
 
    // Point picking radius (ParaView-style)
    // When selecting a single point, search in this radius if no direct hit
    // ParaView code default is 0 (disabled), but settings XML sets it to 50
    // Range: 0-100, where 0 disables radius-based selection
    // We use 50 as default for better usability (ParaView settings default)
    unsigned int m_pointPickingRadius =
            50;  // ParaView settings default for usability
};