ScalarField.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 "CVShareable.h"
 
// System
#include <vector>
 
namespace cloudViewer {
 
 
class ScalarField : public std::vector<ScalarType>, public CCShareable {
public:
 
    CV_CORE_LIB_API explicit ScalarField(const char* name = nullptr);
 
 
    CV_CORE_LIB_API ScalarField(const ScalarField& sf);
 
    CV_CORE_LIB_API void setName(const char* name);
 
    inline const char* getName() const { return m_name; }
 
    static inline ScalarType NaN() { return NAN_VALUE; }
 
 
    CV_CORE_LIB_API void computeMeanAndVariance(
            ScalarType& mean, ScalarType* variance = nullptr) const;
 
    CV_CORE_LIB_API virtual void computeMinAndMax();
 
    static inline bool ValidValue(ScalarType value) {
        return std::isfinite(value);
    }
 
    inline void flagValueAsInvalid(std::size_t index) { at(index) = NaN(); }
 
    CV_CORE_LIB_API std::size_t countValidValues() const;
 
    inline ScalarType getMin() const { return m_minVal; }
    inline ScalarType getMax() const { return m_maxVal; }
 
    inline void fill(ScalarType fillValue = 0) {
        if (empty())
            resize(capacity(), fillValue);
        else
            std::fill(begin(), end(), fillValue);
    }
 
    CV_CORE_LIB_API bool reserveSafe(std::size_t count);
    CV_CORE_LIB_API bool resizeSafe(std::size_t count,
                                    bool initNewElements = false,
                                    ScalarType valueForNewElements = 0);
 
    // Shortcuts (for backward compatibility)
    inline ScalarType& getValue(std::size_t index) { return at(index); }
    inline const ScalarType& getValue(std::size_t index) const {
        return at(index);
    }
    inline void setValue(std::size_t index, ScalarType value) {
        at(index) = value;
    }
    inline void addElement(ScalarType value) { push_back(value); }
    inline unsigned currentSize() const {
        return static_cast<unsigned>(size());
    }
    inline void swap(std::size_t i1, std::size_t i2) {
        std::swap(at(i1), at(i2));
    }
 
public:  // methods
 
    CV_CORE_LIB_API ~ScalarField() override = default;
 
protected:  // members
    char m_name[256];
 
    ScalarType m_minVal;
    ScalarType m_maxVal;
};
 
inline void ScalarField::computeMinAndMax() {
    ScalarType minVal = 0.0f;
    ScalarType maxVal = 0.0f;
 
    bool minMaxInitialized = false;
    for (std::size_t i = 0; i < size(); ++i) {
        const ScalarType& val = at(i);
        if (ValidValue(val)) {
            if (minMaxInitialized) {
                if (val < minVal)
                    minVal = val;
                else if (val > maxVal)
                    maxVal = val;
            } else {
                // first valid value is used to init min and max
                minVal = maxVal = val;
                minMaxInitialized = true;
            }
        }
    }
 
    if (minMaxInitialized) {
        m_minVal = minVal;
        m_maxVal = maxVal;
    } else  // particular case: zero valid values
    {
        m_minVal = m_maxVal = 0;
    }
}
 
}  // namespace cloudViewer