ecvNormalVectors.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
 
// cloudViewer
#include <GeometricalAnalysisTools.h>
 
// Local
#include "ecvGenericPointCloud.h"
 
// System
#include <vector>
 
class CV_DB_LIB_API ccNormalVectors {
public:
    static ccNormalVectors* GetUniqueInstance();
 
 
    static void ReleaseUniqueInstance();
 
    static inline unsigned GetNumberOfVectors() {
        return static_cast<unsigned>(
                GetUniqueInstance()->m_theNormalVectors.size());
    }
 
    static inline const CCVector3& GetNormal(unsigned normIndex) {
        return GetUniqueInstance()->getNormal(normIndex);
    }
    static inline CCVector3& GetNormalPtr(unsigned normIndex) {
        return GetUniqueInstance()->getNormal(normIndex);
    }
    static inline const std::vector<CCVector3>& GetNormals() {
        return GetUniqueInstance()->getNormals();
    }
    static inline std::vector<CCVector3>& GetNormalsPtr() {
        return GetUniqueInstance()->getNormals();
    }
 
    inline const CCVector3& getNormal(unsigned normIndex) const {
        return m_theNormalVectors[normIndex];
    }
    inline CCVector3& getNormal(unsigned normIndex) {
        return m_theNormalVectors[normIndex];
    }
    inline const std::vector<CCVector3>& getNormals() const {
        return m_theNormalVectors;
    }
    inline std::vector<CCVector3>& getNormals() { return m_theNormalVectors; }
 
    static CompressedNormType GetNormIndex(const PointCoordinateType N[]);
    static inline CompressedNormType GetNormIndex(const CCVector3& N) {
        return GetNormIndex(N.u);
    }
 
    enum Orientation {
        PLUS_X = 0,   
        MINUS_X = 1,  
        PLUS_Y = 2,   
        MINUS_Y = 3,  
        PLUS_Z = 4,   
        MINUS_Z = 5,  
        PLUS_BARYCENTER =
                6,  
        MINUS_BARYCENTER = 7,  
        PLUS_ORIGIN = 8,       
        MINUS_ORIGIN = 9,      
        PREVIOUS = 10,         
        PLUS_SENSOR_ORIGIN =
                11,  
        MINUS_SENSOR_ORIGIN =
                12,  
        UNDEFINED = 255  
    };
 
 
    static bool ComputeCloudNormals(
            ccGenericPointCloud* cloud,
            NormsIndexesTableType& theNormsCodes,
            CV_LOCAL_MODEL_TYPES localModel,
            PointCoordinateType localRadius,
            Orientation preferredOrientation = UNDEFINED,
            cloudViewer::GenericProgressCallback* progressCb = nullptr,
            cloudViewer::DgmOctree* inputOctree = nullptr);
 
 
    static PointCoordinateType GuessNaiveRadius(ccGenericPointCloud* cloud);
 
 
    static PointCoordinateType GuessBestRadius(
            ccGenericPointCloud* cloud,
            cloudViewer::DgmOctree* cloudOctree = nullptr,
            cloudViewer::GenericProgressCallback* progressCb = nullptr);
 
 
    static bool UpdateNormalOrientations(ccGenericPointCloud* theCloud,
                                         NormsIndexesTableType& theNormsCodes,
                                         Orientation preferredOrientation);
 
 
    static void ConvertNormalToStrikeAndDip(const CCVector3& N,
                                            PointCoordinateType& strike_deg,
                                            PointCoordinateType& dip_deg);
 
 
    static void ConvertNormalToDipAndDipDir(const CCVector3& N,
                                            PointCoordinateType& dip_deg,
                                            PointCoordinateType& dipDir_deg);
 
 
    static CCVector3 ConvertDipAndDipDirToNormal(PointCoordinateType dip_deg,
                                                 PointCoordinateType dipDir_deg,
                                                 bool upward = true);
 
 
    static QString ConvertStrikeAndDipToString(double& strike_deg,
                                               double& dip_deg);
 
 
    static QString ConvertDipAndDipDirToString(PointCoordinateType dip_deg,
                                               PointCoordinateType dipDir_deg);
 
 
    static void ConvertNormalToHSV(const CCVector3& N,
                                   float& H,
                                   float& S,
                                   float& V);
 
 
    static ecvColor::Rgb ConvertNormalToRGB(const CCVector3& N);
 
public:
    virtual ~ccNormalVectors();
 
 
    bool enableNormalHSVColorsArray();
 
    const ecvColor::Rgb& getNormalHSVColor(unsigned index) const;
 
    inline const std::vector<ecvColor::Rgb>& getNormalHSVColorArray() const {
        return m_theNormalHSVColors;
    }
 
    static bool ComputeNormalWithLS(
            cloudViewer::GenericIndexedCloudPersist* pointAndNeighbors,
            CCVector3& N);
 
 
    static bool ComputeNormalWithTri(
            cloudViewer::GenericIndexedCloudPersist* pointAndNeighbors,
            CCVector3& N);
 
 
    static bool ComputeNormalWithQuadric(
            cloudViewer::GenericIndexedCloudPersist* points,
            const CCVector3& P,
            CCVector3& N);
 
protected:
 
    ccNormalVectors();
 
    bool init();
 
    std::vector<CCVector3> m_theNormalVectors;
 
 
    std::vector<ecvColor::Rgb> m_theNormalHSVColors;
 
    static bool ComputeNormsAtLevelWithQuadric(
            const cloudViewer::DgmOctree::octreeCell& cell,
            void** additionalParameters,
            cloudViewer::NormalizedProgress* nProgress = nullptr);
    static bool ComputeNormsAtLevelWithLS(
            const cloudViewer::DgmOctree::octreeCell& cell,
            void** additionalParameters,
            cloudViewer::NormalizedProgress* nProgress = nullptr);
    static bool ComputeNormsAtLevelWithTri(
            const cloudViewer::DgmOctree::octreeCell& cell,
            void** additionalParameters,
            cloudViewer::NormalizedProgress* nProgress = nullptr);
};