ccPointDescriptor.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
 
// Qt
#include <QByteArray>
#include <QString>
 
// cloudViewer
#include <ReferenceCloud.h>
 
// system
#include <math.h>
 
#include <vector>
 
// Descriptors' ID must be declared here and then implemented in
// 'ccPointDescriptor.cpp'.
//
// WARNING: the ID must be unique and must not be changed once set!
//
// Once declared (and implemented) in ccPointDescriptor.cpp, the descriptor must
// be added to the static 'vault' (see ScaleParamsComputerVault's constructor).
 
static const unsigned DESC_INVALID = 0;  // Unknown descritpr
static const unsigned DESC_DIMENSIONALITY =
        1;  // Original CANUPO's "Dimensionality" descriptor
static const unsigned DESC_DIMENSIONALITY_SF =
        2;  // "Dimensionality" + scalar field descriptor
static const unsigned DESC_CURVATURE =
        3;  // Test: Gaussian curvature descriptor
// static const unsigned DESC_CUSTOM                =   ?;
// // Example of custom descriptor (to be reimplemented)
 
 
class ScaleParamsComputer {
public:
    static ScaleParamsComputer* GetByID(unsigned descID);
 
public:
    static unsigned AvailableCount();
 
    static ScaleParamsComputer* GetByIndex(unsigned index);
 
public:
    virtual ~ScaleParamsComputer() = default;
 
    virtual unsigned getID() const = 0;
 
    virtual QString getName() const = 0;
 
    virtual unsigned dimPerScale() const = 0;
 
    virtual bool needSF() const { return false; }
 
    virtual void reset() = 0;
 
 
    virtual bool computeScaleParams(cloudViewer::ReferenceCloud& neighbors,
                                    double radius,
                                    float params[],
                                    bool& invalidScale) = 0;
 
protected:
};
 
 
struct CorePointDesc {
    std::vector<float> params;
};
 
class ccPointCloud;
 
class CorePointDescSet : public std::vector<CorePointDesc> {
public:
    CorePointDescSet() : m_descriptorID(0), m_dimPerScale(0) {}
    CorePointDescSet(size_t sz)
        : std::vector<CorePointDesc>(sz), m_descriptorID(0), m_dimPerScale(0) {}
    CorePointDescSet(size_t sz, const CorePointDesc& defaultVal)
        : std::vector<CorePointDesc>(sz, defaultVal),
          m_descriptorID(0),
          m_dimPerScale(0) {}
    CorePointDescSet(const CorePointDescSet& descSet)
        : std::vector<CorePointDesc>(descSet),
          m_descriptorID(descSet.m_descriptorID),
          m_dimPerScale(descSet.m_dimPerScale) {}
 
    QByteArray toByteArray() const;
    bool fromByteArray(const QByteArray& data);
 
    bool loadFromMSC(QString filename,
                     QString& error,
                     ccPointCloud* corePoints = 0);
 
    inline const std::vector<float>& scales() const { return m_scales; }
 
 
    bool setScales(const std::vector<float>& scales);
 
    inline const unsigned descriptorID() const { return m_descriptorID; }
    inline void setDescriptorID(unsigned ID) { m_descriptorID = ID; }
 
    inline const unsigned dimPerScale() const { return m_dimPerScale; }
    inline void setDimPerScale(unsigned dim) { m_dimPerScale = dim; }
 
protected:
    std::vector<float> m_scales;
 
    unsigned m_descriptorID;
 
    unsigned m_dimPerScale;
};