ecvColorScale.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 "ecvColorTypes.h"
#include "ecvSerializableObject.h"
 
// Qt
#include <QList>
#include <QSharedPointer>
 
// System
#include <set>
 
class ccColorScaleElement {
public:
    ccColorScaleElement() : m_relativePos(0.0), m_color(Qt::black) {}
 
    ccColorScaleElement(double relativePos, QColor color)
        : m_relativePos(relativePos), m_color(color) {}
 
 
    inline void setRelativePos(double pos) { m_relativePos = pos; }
 
    inline double getRelativePos() const { return m_relativePos; }
 
    inline void setColor(QColor color) { m_color = color; }
    inline const QColor& getColor() const { return m_color; }
 
    inline static bool IsSmaller(const ccColorScaleElement& e1,
                                 const ccColorScaleElement& e2) {
        return e1.getRelativePos() < e2.getRelativePos();
    }
 
protected:
 
    double m_relativePos;
    QColor m_color;
};
 
 
class CV_DB_LIB_API ccColorScale : public ccSerializableObject {
public:
    typedef QSharedPointer<ccColorScale> Shared;
 
 
    static ccColorScale::Shared Create(const QString& name);
 
 
    ccColorScale(const QString& name, const QString& uuid = QString());
 
    virtual ~ccColorScale();
 
    ccColorScale::Shared copy(const QString& uuid = QString()) const;
 
 
    static const unsigned MIN_STEPS = 2;
 
 
    static const unsigned DEFAULT_STEPS = 256;
 
 
    static const unsigned MAX_STEPS = 1024;
 
    inline const QString& getName() const { return m_name; }
    void setName(const QString& name) { m_name = name; }
 
    QString getUuid() const { return m_uuid; }
    void setUuid(QString uuid) { m_uuid = uuid; }
    void generateNewUuid();
 
 
    inline bool isRelative() const { return m_relative; }
 
    inline void setRelative() { m_relative = true; }
 
    void setAbsolute(double minVal, double maxVal);
 
 
    void getAbsoluteBoundaries(double& minVal, double& maxVal) const;
 
    inline bool isLocked() const { return m_locked; }
 
    inline void setLocked(bool state) { m_locked = state; }
 
    struct Label {
        Label(double v) : value(v) {}
 
        Label(double v, const QString& t) : value(v), text(t) {}
 
        double value = 0.0;
        QString text;
 
        bool operator<(const Label& otherLabel) const {
            return value < otherLabel.value;
        }
    };
 
    using LabelSet = std::set<Label>;
 
    inline LabelSet& customLabels() { return m_customLabels; }
    inline const LabelSet& customLabels() const { return m_customLabels; }
 
 
    inline void setCustomLabels(const LabelSet& labels) {
        m_customLabels = labels;
    }
 
 
    inline int stepCount() const { return m_steps.size(); }
 
    inline ccColorScaleElement& step(int index) { return m_steps[index]; }
 
    inline const ccColorScaleElement& step(int index) const {
        return m_steps[index];
    }
 
 
    void insert(const ccColorScaleElement& step, bool autoUpdate = true);
 
 
    void remove(int index, bool autoUpdate = true);
 
 
    void clear();
 
 
    void update();
 
 
    inline double getRelativePosition(double value) const {
        assert(m_updated && !m_relative);
        return (value - m_absoluteMinValue) / m_absoluteRange;
    }
 
 
    inline const ecvColor::Rgb* getColorByValue(
            double value,
            const ecvColor::Rgb* outOfRangeColor = nullptr) const {
        assert(m_updated && !m_relative);
        double relativePos = getRelativePosition(value);
        return (relativePos >= 0.0 && relativePos <= 1.0
                        ? getColorByRelativePos(relativePos)
                        : outOfRangeColor);
    }
 
 
    inline const ecvColor::Rgb* getColorByRelativePos(
            double relativePos,
            const ecvColor::Rgb* outOfRangeColor = nullptr) const {
        assert(m_updated);
        if (relativePos >= 0.0 && relativePos <= 1.0)
            return &getColorByIndex(
                    static_cast<unsigned>(relativePos * (MAX_STEPS - 1)));
        else
            return outOfRangeColor;
    }
 
 
    inline const ecvColor::Rgb* getColorByRelativePos(
            double relativePos,
            unsigned steps,
            const ecvColor::Rgb* outOfRangeColor = nullptr) const {
        assert(m_updated);
        if (relativePos >= 0.0 && relativePos <= 1.0) {
            // quantized (16 bits) version --> much faster than floor!
            unsigned index =
                    (static_cast<unsigned>((relativePos * steps) * 65535.0)) >>
                    16;
            return &getColorByIndex((index * (MAX_STEPS - 1)) / steps);
        } else {
            return outOfRangeColor;
        }
    }
 
 
    inline const ecvColor::Rgb& getColorByIndex(unsigned index) const {
        assert(m_updated && index < MAX_STEPS);
        return m_rgbaScale[index];
    }
 
    bool saveAsXML(QString filename) const;
    static Shared LoadFromXML(QString filename);
 
    // inherited from ccSerializableObject
    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;
 
protected:
    void sort();
 
    QString m_name;
 
    QString m_uuid;
 
    QList<ccColorScaleElement> m_steps;
 
    ecvColor::Rgb m_rgbaScale[MAX_STEPS];
 
    bool m_updated;
 
    bool m_relative;
 
    bool m_locked;
 
 
    double m_absoluteMinValue;
 
 
    double m_absoluteRange;
 
    LabelSet m_customLabels;
};