DistanceComputationTools.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 "CVConst.h"
#include "CVToolbox.h"
#include "DgmOctree.h"
#include "Polyline.h"
#include "SquareMatrix.h"
 
namespace cloudViewer {
 
class GenericTriangle;
class GenericIndexedMesh;
class GenericCloud;
class GenericIndexedCloudPersist;
class ReferenceCloud;
class PointCloud;
class GenericProgressCallback;
struct OctreeAndMeshIntersection;
class ScalarField;
 
class CV_CORE_LIB_API DistanceComputationTools : public CVToolbox {
public:  // distance to clouds or meshes
    struct Cloud2CloudDistancesComputationParams {
 
        unsigned char octreeLevel;
 
 
        ScalarType maxSearchDist;
 
 
        bool multiThread;
 
        int maxThreadCount;
 
 
        CV_LOCAL_MODEL_TYPES localModel;
 
 
        bool useSphericalSearchForLocalModel;
 
 
        unsigned kNNForLocalModel;
 
 
        ScalarType radiusForLocalModel;
 
 
        bool reuseExistingLocalModels;
 
 
        ReferenceCloud* CPSet;
 
        ScalarField* splitDistances[3];
 
 
        bool resetFormerDistances;
 
        Cloud2CloudDistancesComputationParams()
            : octreeLevel(0),
              maxSearchDist(0),
              multiThread(true),
              maxThreadCount(0),
              localModel(NO_MODEL),
              useSphericalSearchForLocalModel(false),
              kNNForLocalModel(0),
              radiusForLocalModel(0),
              reuseExistingLocalModels(false),
              CPSet(nullptr),
              resetFormerDistances(true) {
            splitDistances[0] = splitDistances[1] = splitDistances[2] = nullptr;
        }
    };
 
 
    static int computeCloud2CloudDistances(
            GenericIndexedCloudPersist* comparedCloud,
            GenericIndexedCloudPersist* referenceCloud,
            Cloud2CloudDistancesComputationParams& params,
            GenericProgressCallback* progressCb = nullptr,
            DgmOctree* compOctree = nullptr,
            DgmOctree* refOctree = nullptr);
 
    struct Cloud2MeshDistancesComputationParams {
        unsigned char octreeLevel;
 
 
        ScalarType maxSearchDist;
 
 
        bool useDistanceMap;
 
 
        bool signedDistances;
 
        bool flipNormals;
 
        bool multiThread;
 
        int maxThreadCount;
 
 
        PointCloud* CPSet;
 
        Cloud2MeshDistancesComputationParams()
            : octreeLevel(0),
              maxSearchDist(0),
              useDistanceMap(false),
              signedDistances(false),
              flipNormals(false),
              multiThread(true),
              maxThreadCount(0),
              CPSet(nullptr) {}
    };
 
 
    static int computeCloud2MeshDistances(
            GenericIndexedCloudPersist* pointCloud,
            GenericIndexedMesh* mesh,
            Cloud2MeshDistancesComputationParams& params,
            GenericProgressCallback* progressCb = nullptr,
            DgmOctree* cloudOctree = nullptr);
 
public:  // approximate distances to clouds or meshes
 
    static int computeApproxCloud2CloudDistance(
            GenericIndexedCloudPersist* comparedCloud,
            GenericIndexedCloudPersist* referenceCloud,
            unsigned char octreeLevel,
            PointCoordinateType maxSearchDist = 0,
            GenericProgressCallback* progressCb = nullptr,
            DgmOctree* compOctree = nullptr,
            DgmOctree* refOctree = nullptr);
 
public:  // distance to simple entities (triangles, planes, etc.)
 
    static ScalarType computePoint2TriangleDistance(
            const CCVector3* P,
            const GenericTriangle* theTriangle,
            bool signedDist,
            CCVector3* nearestP = nullptr);
 
 
    static ScalarType computePoint2PlaneDistance(
            const CCVector3* P, const PointCoordinateType* planeEquation);
 
 
    static ScalarType computePoint2LineSegmentDistSquared(
            const CCVector3* point,
            const CCVector3* start,
            const CCVector3* end);
 
 
    static int computeCloud2ConeEquation(GenericIndexedCloudPersist* cloud,
                                         const CCVector3& coneP1,
                                         const CCVector3& coneP2,
                                         const PointCoordinateType coneR1,
                                         const PointCoordinateType coneR2,
                                         bool signedDistances = true,
                                         bool solutionType = false,
                                         double* rms = nullptr);
 
 
    static int computeCloud2CylinderEquation(
            GenericIndexedCloudPersist* cloud,
            const CCVector3& cylinderP1,
            const CCVector3& cylinderP2,
            const PointCoordinateType cylinderRadius,
            bool signedDistances = true,
            bool solutionType = false,
            double* rms = nullptr);
 
 
    static int computeCloud2SphereEquation(
            GenericIndexedCloudPersist* cloud,
            const CCVector3& sphereCenter,
            const PointCoordinateType sphereRadius,
            bool signedDistances = true,
            double* rms = nullptr);
 
 
    static int computeCloud2DiscEquation(GenericIndexedCloudPersist* cloud,
                                         const CCVector3& discCenter,
                                         const PointCoordinateType discRadius,
                                         const SquareMatrix& rotationTransform,
                                         bool signedDistances = true,
                                         double* rms = nullptr);
 
 
    static int computeCloud2PlaneEquation(
            GenericIndexedCloudPersist* cloud,
            const PointCoordinateType* planeEquation,
            bool signedDistances = true,
            double* rms = nullptr);
 
    static int computeCloud2RectangleEquation(
            GenericIndexedCloudPersist* cloud,
            PointCoordinateType widthX,
            PointCoordinateType widthY,
            const SquareMatrix& rotationTransform,
            const CCVector3& center,
            bool signedDist = true,
            double* rms = nullptr);
 
    static int computeCloud2BoxEquation(GenericIndexedCloudPersist* cloud,
                                        const CCVector3& boxDimensions,
                                        const SquareMatrix& rotationTransform,
                                        const CCVector3& boxCenter,
                                        bool signedDist = true,
                                        double* rms = nullptr);
 
 
    static int computeCloud2PolylineEquation(GenericIndexedCloudPersist* cloud,
                                             const Polyline* polyline,
                                             double* rms = nullptr);
 
    enum ERROR_MEASURES {
        RMS,                 
        MAX_DIST_68_PERCENT, 
        MAX_DIST_95_PERCENT, 
        MAX_DIST_99_PERCENT, 
        MAX_DIST,            
    };
 
    enum DISTANCE_COMPUTATION_RESULTS {
        CANCELED_BY_USER = -1000,
        ERROR_NULL_COMPAREDCLOUD,
        ERROR_NULL_COMPAREDOCTREE,
        ERROR_OUT_OF_MEMORY,
        ERROR_ENABLE_SCALAR_FIELD_FAILURE,
        ERROR_EMPTY_COMPAREDCLOUD,
        ERROR_NULL_REFERENCECLOUD,
        ERROR_EMPTY_REFERENCECLOUD,
        ERROR_NULL_REFERENCEMESH,
        ERROR_EMPTY_REFERENCEMESH,
        ERROR_NULL_REFERENCEPOLYLINE,
        ERROR_TOOSMALL_REFERENCEPOLYLINE,
        NULL_PLANE_EQUATION,
        ERROR_NULL_OCTREE,
        ERROR_INVALID_OCTREE_AND_MESH_INTERSECTION,
        ERROR_OCTREE_AND_MESH_INTERSECTION_MISMATCH,
        ERROR_CANT_USE_MAX_SEARCH_DIST_AND_CLOSEST_POINT_SET,
        ERROR_EXECUTE_FUNCTION_FOR_ALL_CELLS_AT_LEVEL_FAILURE,
        ERROR_EXECUTE_GET_POINTS_IN_CELL_BY_INDEX_FAILURE,
        ERROR_EXECUTE_CLOUD_MESH_DIST_CELL_FUNC_MT_FAILURE,
        ERROR_GET_CELL_CODES_FAILURE,
        ERROR_GET_CELL_CODES_AND_INDEXES_FAILURE,
        ERROR_GET_CELL_INDEXES_FAILURE,
        ERROR_PROPAGATE_DISTANCE_FAILURE,
        ERROR_SEED_POINT_INDEX_GREATER_THAN_COMPAREDCLOUD_SIZE,
        ERROR_INIT_DISTANCE_TRANSFORM_GRID_FAILURE,
        ERROR_INIT_PER_CELL_TRIANGLE_LIST_FAILURE,
        ERROR_INTERSECT_MESH_WITH_OCTREE_FAILURE,
        ERROR_COMPUTE_CLOUD2_MESH_DISTANCE_WITH_OCTREE_FAILURE,
        ERROR_COMPUTE_CLOUD2_CLOUD_DISTANCE_FAILURE,
        ERROR_OCTREE_LEVEL_LT_ONE,
        ERROR_OCTREE_LEVEL_GT_MAX_OCTREE_LEVEL,
        ERROR_SYNCHRONIZE_OCTREES_FAILURE,
        ERROR_PLANE_NORMAL_LT_ZERO,
        ERROR_INVALID_PRIMITIVE_DIMENSIONS,
        ERROR_CONE_R1_LT_CONE_R2,
        ERROR_CONELENGTH_ZERO,
        ERROR_COULDNOT_SYNCRONIZE_OCTREES,
        ERROR_BUILD_OCTREE_FAILURE,
        ERROR_BUILD_FAST_MARCHING_FAILURE,
        ERROR_UNKOWN_ERRORMEASURES_TYPE,
        ERROR_INTERNAL,
        INVALID_INPUT,
        SUCCESS = 1,
    };
 
 
    static ScalarType ComputeCloud2PlaneDistance(
            cloudViewer::GenericCloud* cloud,
            const PointCoordinateType* planeEquation,
            ERROR_MEASURES measureType);
 
 
    static ScalarType ComputeCloud2PlaneRobustMax(
            GenericCloud* cloud,
            const PointCoordinateType* planeEquation,
            float percent);
 
 
    static ScalarType ComputeCloud2PlaneMaxDistance(
            GenericCloud* cloud, const PointCoordinateType* planeEquation);
 
 
    static ScalarType computeCloud2PlaneDistanceRMS(
            GenericCloud* cloud, const PointCoordinateType* planeEquation);
 
 
    static PointCoordinateType ComputeSquareDistToSegment(
            const CCVector2& P,
            const CCVector2& A,
            const CCVector2& B,
            bool onlyOrthogonal = false);
 
public:  // other methods
 
    static bool computeGeodesicDistances(
            GenericIndexedCloudPersist* cloud,
            unsigned seedPointIndex,
            unsigned char octreeLevel,
            GenericProgressCallback* progressCb = nullptr);
 
 
    static int diff(GenericIndexedCloudPersist* comparedCloud,
                    GenericIndexedCloudPersist* referenceCloud,
                    GenericProgressCallback* progressCb = nullptr);
 
    enum SOReturnCode { EMPTY_CLOUD, SYNCHRONIZED, DISJOINT, OUT_OF_MEMORY };
 
 
    static SOReturnCode synchronizeOctrees(
            GenericIndexedCloudPersist* comparedCloud,
            GenericIndexedCloudPersist* referenceCloud,
            DgmOctree*& comparedOctree,
            DgmOctree*& referenceOctree,
            PointCoordinateType maxSearchDist = 0,
            GenericProgressCallback* progressCb = nullptr);
 
    static bool MultiThreadSupport();
 
protected:
 
    static int intersectMeshWithOctree(
            OctreeAndMeshIntersection* theIntersection,
            unsigned char octreeLevel,
            GenericProgressCallback* progressCb = nullptr);
 
 
    static int computeCloud2MeshDistanceWithOctree(
            OctreeAndMeshIntersection* theIntersection,
            Cloud2MeshDistancesComputationParams& params,
            GenericProgressCallback* progressCb = nullptr);
 
 
    static int computeCloud2MeshDistancesWithOctree(
            const DgmOctree* octree,
            OctreeAndMeshIntersection* intersection,
            Cloud2MeshDistancesComputationParams& params,
            GenericProgressCallback* progressCb = nullptr);
 
 
    static int computePoint2MeshDistancesWithOctree(
            const CCVector3& P,
            ScalarType& distance,
            OctreeAndMeshIntersection* intersection,
            Cloud2MeshDistancesComputationParams& params);
 
 
    static bool computeCellHausdorffDistance(
            const DgmOctree::octreeCell& cell,
            void** additionalParameters,
            NormalizedProgress* nProgress = nullptr);
 
 
    static bool computeCellHausdorffDistanceWithLocalModel(
            const DgmOctree::octreeCell& cell,
            void** additionalParameters,
            NormalizedProgress* nProgress = nullptr);
};
 
}  // namespace cloudViewer