qCanupoTools.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 "classifier.h"
 
// cloudViewer
#include <DgmOctree.h>
#include <GenericIndexedCloud.h>
#include <GenericProgressCallback.h>
 
// Qt
#include <QString>
 
// system
#include <vector>
 
class ccGenericPointCloud;
class ccPointCloud;
class ecvMainAppInterface;
class ccHObject;
class QComboBox;
class ccScalarField;
 
template <unsigned Count>
struct CosSinTable {
    float cosines[Count];
    float sines[Count];
 
    CosSinTable() {
        for (int i = 0; i < Count; ++i) {
            cosines[i] = static_cast<float>(cos(M_PI * i / Count));
            sines[i] = static_cast<float>(sin(M_PI * i / Count));
        }
    }
};
 
class qCanupoTools {
public:
    template <typename T>
    static bool Fpeq(T a, T b, T epsilon = static_cast<T>(1.0e-6)) {
        if (b == 0) return fabs(a) < epsilon;
 
        return fabs(a / b - 1) <= epsilon;
    }
 
 
    static bool CompareVectors(const std::vector<float>& first,
                               const std::vector<float>& second);
 
 
    static size_t TestVectorsOverlap(const std::vector<float>& first,
                                     const std::vector<float>& second);
 
    static bool ComputeCorePointsDescriptors(
            cloudViewer::GenericIndexedCloud* corePoints,
            CorePointDescSet& corePointsDescriptors,
            ccGenericPointCloud* sourceCloud,
            const std::vector<float>& sortedScales,
            bool& invalidDescriptors,
            QString& error,  // if any
            unsigned descriptorID = DESC_DIMENSIONALITY,
            int maxThreadCount = 0,
            cloudViewer::GenericProgressCallback* progressCb = 0,
            cloudViewer::DgmOctree* inputOctree = 0,
            std::vector<ccScalarField*>* roughnessSFs = 0 /*for tests*/);
 
    static QString GetEntityName(ccHObject* obj);
 
 
    static ccPointCloud* GetCloudFromCombo(QComboBox* comboBox,
                                           ccHObject* dbRoot);
 
    static bool TrainClassifier(
            Classifier& classifier,
            const CorePointDescSet& descriptors1,
            const CorePointDescSet& descriptors2,
            const std::vector<float>& scales,
            ccPointCloud* mscCloud,
            const CorePointDescSet* evaluationDescriptors = 0,
            ecvMainAppInterface* app = 0);
 
 
    struct EvalParameters {
        EvalParameters()
            : false1(0),
              false2(0),
              true1(0),
              true2(0),
              mu1(0),
              mu2(0),
              var1(0),
              var2(0) {}
        unsigned false1, false2;
        unsigned true1, true2;
        double ba() const {
            unsigned n1 = true1 + false1;
            unsigned n2 = true2 + false2;
            double a1 =
                    (n1 ? static_cast<double>(true1) / static_cast<double>(n1)
                        : 0);
            double a2 =
                    (n2 ? static_cast<double>(true2) / static_cast<double>(n2)
                        : 0);
            return (a1 + a2) / 2;
        }
 
        double mu1, mu2;
        double var1, var2;
        double fdr() const {
            double v = var1 + var2;
            return v != 0 ? (mu1 - mu2) * (mu1 - mu2) / v : 0;
        }
    };
 
    static bool EvaluateClassifier(const Classifier& classifier,
                                   const CorePointDescSet& descriptors1,
                                   const CorePointDescSet& descriptors2,
                                   const std::vector<float>& scales,
                                   EvalParameters& params);
};