ecvScalarField.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
 
// cloudViewer
#include <ScalarField.h>
 
// CV_DB_LIB
#include "ecvColorScale.h"
 
 
class CV_DB_LIB_API ccScalarField : public cloudViewer::ScalarField,
                                    public ccSerializableObject {
public:
 
    explicit ccScalarField(const char* name = nullptr);
 
 
    ccScalarField(const ccScalarField& sf);
 
    /*** Scalar values display handling ***/
 
    class CV_DB_LIB_API Range {
    public:
        Range() : m_min(0), m_start(0), m_stop(0), m_max(0), m_range(1) {}
 
        // getters
        inline ScalarType min() const { return m_min; }
        inline ScalarType start() const { return m_start; }
        inline ScalarType stop() const { return m_stop; }
        inline ScalarType max() const { return m_max; }
        inline ScalarType range() const { return m_range; }
        inline ScalarType maxRange() const { return m_max - m_min; }
 
        // setters
        void setBounds(ScalarType minVal,
                       ScalarType maxVal,
                       bool resetStartStop = true) {
            assert(minVal <= maxVal);
            m_min = minVal;
            m_max = maxVal;
            if (resetStartStop) {
                m_start = m_min;
                m_stop = m_max;
            } else {
                m_start = inbound(m_start);
                m_stop = inbound(m_stop);
            }
            updateRange();
        }
 
        inline void setStart(ScalarType value) {
            m_start = inbound(value);
            if (m_stop < m_start) m_stop = m_start;
            updateRange();
        }
        inline void setStop(ScalarType value) {
            m_stop = inbound(value);
            if (m_stop < m_start) m_start = m_stop;
            updateRange();
        }
 
        inline ScalarType inbound(ScalarType val) const {
            return (val < m_min ? m_min : (val > m_max ? m_max : val));
        }
        inline bool isInbound(ScalarType val) const {
            return (val >= m_min && val <= m_max);
        }
        inline bool isInRange(ScalarType val) const {
            return (val >= m_start && val <= m_stop);
        }
 
    protected:
        inline void updateRange() {
            m_range = std::max(m_stop - m_start, ZERO_TOLERANCE_SCALAR);
        }
 
        ScalarType m_min;   
        ScalarType m_start; 
        ScalarType m_stop;  
        ScalarType m_max;   
        ScalarType
                m_range; 
    };
 
 
    inline const Range& displayRange() const { return m_displayRange; }
 
 
    inline const Range& saturationRange() const {
        return m_logScale ? m_logSaturationRange : m_saturationRange;
    }
 
 
    inline const Range& logSaturationRange() const {
        return m_logSaturationRange;
    }
 
    void setMinDisplayed(ScalarType val);
    void setMaxDisplayed(ScalarType val);
    void setSaturationStart(ScalarType val);
    void setSaturationStop(ScalarType val);
 
 
    inline const ecvColor::Rgb* getColor(ScalarType value) const {
        assert(m_colorScale);
        return m_colorScale->getColorByRelativePos(
                normalize(value), m_colorRampSteps,
                m_showNaNValuesInGrey ? &ecvColor::lightGrey : nullptr);
    }
 
    inline const ecvColor::Rgb* getValueColor(unsigned index) const {
        return getColor(getValue(index));
    }
 
    void showNaNValuesInGrey(bool state);
 
    inline bool areNaNValuesShownInGrey() const {
        return m_showNaNValuesInGrey;
    }
 
    void alwaysShowZero(bool state);
 
    inline bool isZeroAlwaysShown() const { return m_alwaysShowZero; }
 
 
    void setSymmetricalScale(bool state);
 
 
    inline bool symmetricalScale() const { return m_symmetricalScale; }
 
    void setLogScale(bool state);
 
    inline bool logScale() const { return m_logScale; }
 
    // inherited
    void computeMinAndMax() override;
 
    inline const ccColorScale::Shared& getColorScale() const {
        return m_colorScale;
    }
 
    void setColorScale(ccColorScale::Shared scale);
 
    inline unsigned getColorRampSteps() const { return m_colorRampSteps; }
 
    void setColorRampSteps(unsigned steps);
 
    struct Histogram : std::vector<unsigned> {
        unsigned maxValue = 0;
    };
 
    inline const Histogram& getHistogram() const { return m_histogram; }
 
 
    bool mayHaveHiddenValues() const;
 
    inline void setModificationFlag(bool state) { m_modified = state; }
    inline bool getModificationFlag() const { return m_modified; }
 
    void importParametersFrom(const ccScalarField* sf);
 
    // inherited from ccSerializableObject
    inline bool isSerializable() const override { return true; }
    bool toFile(QFile& out, short dataVersion) const override;
    short minimumFileVersion() const override;
    bool fromFile(QFile& in,
                  short dataVersion,
                  int flags,
                  LoadedIDMap& oldToNewIDMap) override;
 
    inline double getGlobalShift() const { return m_globalShift; }
    inline void setGlobalShift(double shift) { m_globalShift = shift; }
 
protected:  // methods
 
    ~ccScalarField() override = default;
 
    void updateSaturationBounds();
 
 
    ScalarType normalize(ScalarType val) const;
 
protected:  // members
    Range m_displayRange;
 
 
    Range m_saturationRange;
 
 
    Range m_logSaturationRange;
 
    bool m_showNaNValuesInGrey;
 
 
    bool m_symmetricalScale;
 
    bool m_logScale;
 
    bool m_alwaysShowZero;
 
    ccColorScale::Shared m_colorScale;
 
    unsigned m_colorRampSteps;
 
    Histogram m_histogram;
 
 
    bool m_modified;
 
    double m_globalShift;
};