RegistrationTools.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 "PointProjectionTools.h"
 
namespace cloudViewer {
 
class GenericProgressCallback;
class GenericCloud;
class GenericIndexedMesh;
class GenericIndexedCloud;
class KDTree;
class ScalarField;
 
class CV_CORE_LIB_API RegistrationTools : public CVToolbox {
public:
    using ScaledTransformation = PointProjectionTools::Transformation;
 
    enum TRANSFORMATION_FILTERS {
        SKIP_NONE = 0,
        SKIP_RXY = 1,
        SKIP_RYZ = 2,
        SKIP_RXZ = 4,
        SKIP_ROTATION = 7,
        SKIP_TX = 8,
        SKIP_TY = 16,
        SKIP_TZ = 32,
        SKIP_TRANSLATION = 56,
    };
 
 
    static void FilterTransformation(const ScaledTransformation& inTrans,
                                     int transformationFilters,
                                     const CCVector3& toBeAlignedGravityCenter,
                                     const CCVector3& referenceGravityCenter,
                                     ScaledTransformation& outTrans);
 
protected:
 
    static bool RegistrationProcedure(GenericCloud* P,
                                      GenericCloud* X,
                                      ScaledTransformation& trans,
                                      bool adjustScale = false,
                                      ScalarField* coupleWeights = nullptr,
                                      PointCoordinateType aPrioriScale = 1.0f,
                                      CCVector3* Gp = nullptr,
                                      CCVector3* Gx = nullptr);
};
 
 
class CV_CORE_LIB_API HornRegistrationTools : public RegistrationTools {
public:
 
    static bool FindAbsoluteOrientation(GenericCloud* lCloud,
                                        GenericCloud* rCloud,
                                        ScaledTransformation& trans,
                                        bool fixedScale = false);
 
 
    static double ComputeRMS(GenericCloud* lCloud,
                             GenericCloud* rCloud,
                             const ScaledTransformation& trans);
};
 
class CV_CORE_LIB_API ICPRegistrationTools : public RegistrationTools {
public:
    enum CONVERGENCE_TYPE {
        MAX_ERROR_CONVERGENCE = 0,
        MAX_ITER_CONVERGENCE = 1,
    };
 
    enum RESULT_TYPE {
        ICP_NOTHING_TO_DO = 0,
        ICP_APPLY_TRANSFO = 1,
        ICP_ERROR = 100,
        // all errors should be greater than ICP_ERROR
        ICP_ERROR_REGISTRATION_STEP = 101,
        ICP_ERROR_DIST_COMPUTATION = 102,
        ICP_ERROR_NOT_ENOUGH_MEMORY = 103,
        ICP_ERROR_CANCELED_BY_USER = 104,
        ICP_ERROR_INVALID_INPUT = 105,
    };
 
    enum NORMALS_MATCHING {
        NO_NORMAL = 0,
        OPPOSITE_NORMALS = 1,
        SAME_SIDE_NORMALS = 2,
        DOUBLE_SIDED_NORMALS = 3
    };
 
    struct Parameters {
        Parameters()
            : convType(MAX_ERROR_CONVERGENCE),
              minRMSDecrease(1.0e-5),
              nbMaxIterations(20),
              adjustScale(false),
              filterOutFarthestPoints(false),
              samplingLimit(50000),
              finalOverlapRatio(1.0),
              modelWeights(nullptr),
              dataWeights(nullptr),
              transformationFilters(SKIP_NONE),
              maxThreadCount(0),
              useC2MSignedDistances(false),
              normalsMatching(NO_NORMAL) {}
 
        CONVERGENCE_TYPE convType;
 
        double minRMSDecrease;
 
        unsigned nbMaxIterations;
 
        bool adjustScale;
 
        bool filterOutFarthestPoints;
 
        unsigned samplingLimit;
 
        double finalOverlapRatio;
 
        ScalarField* modelWeights;
 
        ScalarField* dataWeights;
 
        int transformationFilters;
 
        int maxThreadCount;
 
 
        bool useC2MSignedDistances;
 
        NORMALS_MATCHING normalsMatching;
    };
 
 
    static RESULT_TYPE Register(GenericIndexedCloudPersist* modelCloud,
                                GenericIndexedMesh* modelMesh,
                                GenericIndexedCloudPersist* dataCloud,
                                const Parameters& params,
                                ScaledTransformation& totalTrans,
                                double& finalRMS,
                                unsigned& finalPointCount,
                                GenericProgressCallback* progressCb = nullptr);
};
 
class CV_CORE_LIB_API FPCSRegistrationTools : public RegistrationTools {
public:
 
    static bool RegisterClouds(GenericIndexedCloud* modelCloud,
                               GenericIndexedCloud* dataCloud,
                               ScaledTransformation& transform,
                               ScalarType delta,
                               ScalarType beta,
                               PointCoordinateType overlap,
                               unsigned nbBases,
                               unsigned nbTries,
                               GenericProgressCallback* progressCb = nullptr,
                               unsigned nbMaxCandidates = 0);
 
protected:
    struct Base {
        unsigned a, b, c, d;
        void init(unsigned _a, unsigned _b, unsigned _c, unsigned _d) {
            a = _a;
            b = _b;
            c = _c;
            d = _d;
        }
        void copy(const struct Base& b) { init(b.a, b.b, b.c, b.d); }
        unsigned getIndex(unsigned i) {
            if (i == 0) return a;
            if (i == 1) return b;
            if (i == 2) return c;
            if (i == 3) return d;
            return 0;
        }
    };
 
 
    static bool FindBase(GenericIndexedCloud* cloud,
                         PointCoordinateType overlap,
                         unsigned nbTries,
                         Base& base);
 
    static int FindCongruentBases(KDTree* tree,
                                  ScalarType delta,
                                  const CCVector3* base[4],
                                  std::vector<Base>& results);
 
 
    static unsigned ComputeRegistrationScore(
            KDTree* modelTree,
            GenericIndexedCloud* dataCloud,
            ScalarType delta,
            const ScaledTransformation& dataToModel);
 
 
    static bool LinesIntersections(const CCVector3& p0,
                                   const CCVector3& p1,
                                   const CCVector3& p2,
                                   const CCVector3& p3,
                                   CCVector3& inter,
                                   PointCoordinateType& lambda,
                                   PointCoordinateType& mu);
 
    static bool FilterCandidates(GenericIndexedCloud* modelCloud,
                                 GenericIndexedCloud* dataCloud,
                                 Base& reference,
                                 std::vector<Base>& candidates,
                                 unsigned nbMaxCandidates,
                                 std::vector<ScaledTransformation>& transforms);
};
 
}  // namespace cloudViewer