Neighbourhood.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
 
// Local
#include "CVMiscTools.h"
#include "GenericIndexedCloudPersist.h"
#include "SquareMatrix.h"
 
namespace cloudViewer {
 
class GenericIndexedMesh;
 
 
class CV_CORE_LIB_API Neighbourhood {
public:
    static constexpr int IGNORE_MAX_EDGE_LENGTH = 0;
 
    static constexpr bool DUPLICATE_VERTICES = true;
    static constexpr bool DO_NOT_DUPLICATE_VERTICES = false;
 
    enum GeomElement {
        FLAG_DEPRECATED = 0,
        FLAG_GRAVITY_CENTER = 1,
        FLAG_LS_PLANE = 2,
        FLAG_QUADRIC = 4
    };
 
    enum CurvatureType { GAUSSIAN_CURV = 1, MEAN_CURV, NORMAL_CHANGE_RATE };
 
 
    explicit Neighbourhood(GenericIndexedCloudPersist* associatedCloud);
 
    virtual ~Neighbourhood() = default;
 
    virtual void reset();
 
    GenericIndexedCloudPersist* associatedCloud() const {
        return m_associatedCloud;
    }
 
 
    GenericIndexedMesh* triangulateOnPlane(bool duplicateVertices,
                                           PointCoordinateType maxEdgeLength,
                                           std::string& outputErrorStr);
 
    GenericIndexedMesh* triangulateFromQuadric(unsigned stepsX,
                                               unsigned stepsY);
 
    enum InputVectorsUsage { UseOXYasBase, UseYAsUpDir, None };
 
 
    template <class Vec2D>
    bool projectPointsOn2DPlane(
            std::vector<Vec2D>& points2D,
            const PointCoordinateType* planeEquation = nullptr,
            CCVector3* O = nullptr,
            CCVector3* X = nullptr,
            CCVector3* Y = nullptr,
            InputVectorsUsage vectorsUsage = None) {
        // need at least one point ;)
        unsigned count = (m_associatedCloud ? m_associatedCloud->size() : 0);
        if (!count) return false;
 
        // if no custom plane equation is provided, get the default best LS one
        if (!planeEquation) {
            planeEquation = getLSPlane();
            if (!planeEquation) return false;
        }
 
        // reserve memory for output set
        try {
            points2D.resize(count);
        } catch (const std::bad_alloc&) {
            // out of memory
            return false;
        }
 
        // we construct the plane local base
        CCVector3 G(0, 0, 0), u(1, 0, 0), v(0, 1, 0);
        if ((vectorsUsage == UseOXYasBase) && O && X && Y) {
            G = *O;
            u = *X;
            v = *Y;
        } else {
            CCVector3 N(planeEquation);
            if ((vectorsUsage == UseYAsUpDir) && Y) {
                v = (*Y - Y->dot(N) * N);
                v.normalize();
                u = v.cross(N);
            } else {
                CCMiscTools::ComputeBaseVectors(N, u, v);
            }
            // get the barycenter
            const CCVector3* _G = getGravityCenter();
            assert(_G);
            G = *_G;
        }
 
        // project the points
        for (unsigned i = 0; i < count; ++i) {
            // we recenter current point
            const CCVector3 P = *m_associatedCloud->getPoint(i) - G;
 
            // then we project it on plane (with scalar prods)
            points2D[i] = Vec2D(P.dot(u), P.dot(v));
        }
 
        // output the local base if necessary
        if (vectorsUsage != UseOXYasBase) {
            if (O) *O = G;
            if (X) *X = u;
            if (Y) *Y = v;
        }
 
        return true;
    }
 
 
    enum GeomFeature {
        EigenValuesSum = 1,
        Omnivariance,
        EigenEntropy,
        Anisotropy,
        Planarity,
        Linearity,
        PCA1,
        PCA2,
        SurfaceVariation,
        Sphericity,
        Verticality,
        EigenValue1,
        EigenValue2,
        EigenValue3
    };
 
 
    double computeFeature(GeomFeature feature);
 
 
    ScalarType computeMomentOrder1(const CCVector3& P);
 
 
    ScalarType computeRoughness(const CCVector3& P,
                                const CCVector3* roughnessUpDir = nullptr);
 
 
    ScalarType computeCurvature(const CCVector3& P, CurvatureType cType);
 
    /**** GETTERS ****/
 
 
    const CCVector3* getGravityCenter();
 
 
    void setGravityCenter(const CCVector3& G);
 
 
    const PointCoordinateType* getLSPlane();
 
 
    void setLSPlane(const PointCoordinateType eq[4],
                    const CCVector3& X,
                    const CCVector3& Y,
                    const CCVector3& N);
 
 
    const CCVector3* getLSPlaneX();
 
    const CCVector3* getLSPlaneY();
 
    const CCVector3* getLSPlaneNormal();
 
 
    const PointCoordinateType* getQuadric(Tuple3ub* dims = nullptr);
 
 
    bool compute3DQuadric(double quadricEquation[10]);
 
    cloudViewer::SquareMatrixd computeCovarianceMatrix();
 
    PointCoordinateType computeLargestRadius();
 
protected:
 
    PointCoordinateType m_quadricEquation[6];
 
 
    Tuple3ub m_quadricEquationDirections;
 
 
    PointCoordinateType m_lsPlaneEquation[4];
 
 
    CCVector3 m_lsPlaneVectors[3];
 
 
    CCVector3 m_gravityCenter;
 
    unsigned char m_structuresValidity;
 
    void computeGravityCenter();
    bool computeLeastSquareBestFittingPlane();
    bool computeQuadric();
 
    GenericIndexedCloudPersist* m_associatedCloud;
};
 
}  // namespace cloudViewer