cvSelectionAlgebra.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
 
// Protect against Windows macro conflicts - must be before any includes
// Note: Windows headers may define DIFFERENCE as a macro
#ifdef DIFFERENCE
#undef DIFFERENCE
#endif
 
// clang-format off
// Qt - must be included before qPCL.h and cvSelectionData.h for MOC to work correctly
// QObject must be fully defined before Q_ENUM macro
#include <QtCore/QObject>
#include <QtCore/QSet>
#include <QtCore/QString>
// clang-format on
 
// LOCAL
// Note: cvSelectionData.h includes qPCL.h, so we include it after Qt headers
#include "cvSelectionData.h"
 
// VTK
#include <vtkType.h>
 
// Forward declarations
class vtkPolyData;
 
class QPCL_ENGINE_LIB_API cvSelectionAlgebra : public QObject {
    Q_OBJECT
 
public:
    enum class Operation {
        UNION,
        INTERSECTION,
        DIFFERENCE,
        SYMMETRIC_DIFF,
        COMPLEMENT
    };
    Q_ENUM(Operation)
 
    explicit cvSelectionAlgebra(QObject* parent = nullptr);
 
    static cvSelectionData unionOf(const cvSelectionData& a,
                                   const cvSelectionData& b);
 
    static cvSelectionData intersectionOf(const cvSelectionData& a,
                                          const cvSelectionData& b);
 
    static cvSelectionData differenceOf(const cvSelectionData& a,
                                        const cvSelectionData& b);
 
    static cvSelectionData symmetricDifferenceOf(const cvSelectionData& a,
                                                 const cvSelectionData& b);
 
    static cvSelectionData complementOf(vtkPolyData* polyData,
                                        const cvSelectionData& input);
 
    static cvSelectionData performOperation(Operation op,
                                            const cvSelectionData& a,
                                            const cvSelectionData& b,
                                            vtkPolyData* polyData = nullptr);
 
    static cvSelectionData growSelection(vtkPolyData* polyData,
                                         const cvSelectionData& input,
                                         int layers = 1,
                                         bool removeSeed = false,
                                         bool removeIntermediateLayers = false);
 
    static cvSelectionData shrinkSelection(vtkPolyData* polyData,
                                           const cvSelectionData& input,
                                           int iterations = 1);
 
    static cvSelectionData expandSelection(
            vtkPolyData* polyData,
            const cvSelectionData& input,
            int layers,
            bool removeSeed = false,
            bool removeIntermediateLayers = false);
 
    static cvSelectionData extractBoundary(vtkPolyData* polyData,
                                           const cvSelectionData& input);
 
    static bool areCompatible(const cvSelectionData& a,
                              const cvSelectionData& b);
 
    static cvSelectionData growPointSelection(
            vtkPolyData* polyData,
            const cvSelectionData& input,
            int layers = 1,
            bool removeSeed = false,
            bool removeIntermediateLayers = false);
 
    static cvSelectionData shrinkPointSelection(vtkPolyData* polyData,
                                                const cvSelectionData& input,
                                                int iterations = 1);
 
signals:
    void operationComplete(const cvSelectionData& result);
 
    void progressChanged(int percentage);
 
    void filteringComplete(const cvSelectionData& result);
 
private:
    static QSet<vtkIdType> getCellNeighbors(vtkPolyData* polyData,
                                            vtkIdType cellId);
    static QSet<vtkIdType> getPointNeighbors(vtkPolyData* polyData,
                                             vtkIdType pointId);
    static bool isBoundaryCell(vtkPolyData* polyData,
                               vtkIdType cellId,
                               const QSet<vtkIdType>& selectedSet);
    static bool isBoundaryPoint(vtkPolyData* polyData,
                                vtkIdType pointId,
                                const QSet<vtkIdType>& selectedSet);
    double computeCellArea(vtkPolyData* polyData, vtkIdType cellId);
    double computeAngleBetweenNormals(const double n1[3], const double n2[3]);
    bool isPointInBounds(const double point[3], const double bounds[6]);
    double computeDistance(const double p1[3], const double p2[3]);
    int countCellNeighbors(vtkPolyData* polyData, vtkIdType cellId);
};
 
//=============================================================================
// Selection Filter (merged from cvSelectionFilter.h)
//=============================================================================
 
class QPCL_ENGINE_LIB_API cvSelectionFilter : public QObject {
    Q_OBJECT
 
public:
    enum FilterType {
        ATTRIBUTE_RANGE,    
        GEOMETRIC_AREA,     
        GEOMETRIC_ANGLE,    
        SPATIAL_BBOX,       
        SPATIAL_DISTANCE,   
        TOPOLOGY_NEIGHBORS  
    };
 
    enum ComparisonOp {
        EQUAL,
        NOT_EQUAL,
        LESS_THAN,
        LESS_EQUAL,
        GREATER_THAN,
        GREATER_EQUAL,
        BETWEEN,
        OUTSIDE
    };
 
    explicit cvSelectionFilter(QObject* parent = nullptr);
    ~cvSelectionFilter() override;
 
    cvSelectionData filterByAttributeRange(vtkPolyData* polyData,
                                           const cvSelectionData& input,
                                           const QString& attributeName,
                                           double minValue,
                                           double maxValue);
 
    cvSelectionData filterByAttributeComparison(vtkPolyData* polyData,
                                                const cvSelectionData& input,
                                                const QString& attributeName,
                                                ComparisonOp op,
                                                double value);
 
    cvSelectionData filterByArea(vtkPolyData* polyData,
                                 const cvSelectionData& input,
                                 double minArea,
                                 double maxArea);
 
    cvSelectionData filterByNormalAngle(vtkPolyData* polyData,
                                        const cvSelectionData& input,
                                        double refX,
                                        double refY,
                                        double refZ,
                                        double minAngleDeg,
                                        double maxAngleDeg);
 
    cvSelectionData filterByBoundingBox(vtkPolyData* polyData,
                                        const cvSelectionData& input,
                                        const double bounds[6]);
 
    cvSelectionData filterByDistanceFromPoint(vtkPolyData* polyData,
                                              const cvSelectionData& input,
                                              double x,
                                              double y,
                                              double z,
                                              double minDistance,
                                              double maxDistance);
 
    cvSelectionData filterByNeighborCount(vtkPolyData* polyData,
                                          const cvSelectionData& input,
                                          int minNeighbors,
                                          int maxNeighbors);
 
    static cvSelectionData combineAND(const cvSelectionData& a,
                                      const cvSelectionData& b);
 
    static cvSelectionData combineOR(const cvSelectionData& a,
                                     const cvSelectionData& b);
 
    static cvSelectionData invert(vtkPolyData* polyData,
                                  const cvSelectionData& input);
 
    static QStringList getAttributeNames(vtkPolyData* polyData,
                                         bool pointData = true);
 
signals:
    void progressChanged(int percentage);
 
    void filteringComplete(const cvSelectionData& result);
 
private:
    double computeCellArea(vtkPolyData* polyData, vtkIdType cellId);
    double computeAngleBetweenNormals(const double n1[3], const double n2[3]);
    bool isPointInBounds(const double point[3], const double bounds[6]);
    double computeDistance(const double p1[3], const double p2[3]);
    int countCellNeighbors(vtkPolyData* polyData, vtkIdType cellId);
};