color.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef TY_COLOR
#define TY_COLOR
 
#include <qcolor.h>
#include <vector>
#include <cmath>
#include <algorithm>
#include "Tympan/core/smartptr.h"
 
#ifdef TY_USE_IHM
    #include <QColor>
#endif // TY_USE_IHM
 
#undef min
#undef max
 
class OColor
{
public:
    float r, g, b, a;
 
public:
    OColor();
    OColor(const OColor& c);
    OColor(float* c);
    OColor(float red, float green, float blue, float alpha = 1.0f);
 
    void operator=(const OColor& c);
 
    operator float*();
    operator const float*() const;
#ifdef TY_USE_IHM
    operator QColor() const;
#endif // TY_USE_IHM
 
    unsigned int getAsRGBA() const;
 
    void setAsRGBA(const unsigned int val);
 
    void getAsHSB(float& hue, float& saturation, float& brightness) const;
 
    void setAsHSB(const float hue, const float saturation, const float brightness);
 
    void clamp();
    OColor clampCopy() const;
 
    bool operator==(const OColor& other) const;
 
    static const OColor BLACK;
    static const OColor BLUE;
    static const OColor GREEN;
    static const OColor CYAN;
    static const OColor RED;
    static const OColor MAGENTA;
    static const OColor YELLOW;
    static const OColor WHITE;
 
protected:
    static const float equality_threshold;
 
    static bool float_eq(float a, float b, float epsilon = equality_threshold)
    {
        return (std::fabs(a - b) <= epsilon * std::max(std::fabs(a), std::fabs(b)));
    }
};
 
typedef std::vector<OColor> OLookupTable;
 
inline OColor::OColor() : r(1.0f), g(1.0f), b(1.0f), a(1.0f) {}
 
inline OColor::OColor(const OColor& c) : r(c.r), g(c.g), b(c.b), a(c.a) {}
 
inline OColor::OColor(float red, float green, float blue, float alpha) : r(red), g(green), b(blue), a(alpha)
{
}
 
inline OColor::OColor(float* c)
{
    r = c[0];
    g = c[1];
    b = c[2];
    a = c[3];
}
 
inline void OColor::operator=(const OColor& c)
{
    r = c.r;
    g = c.g;
    b = c.b;
    a = c.a;
}
 
inline OColor::operator float*()
{
    return &r;
}
 
inline OColor::operator const float*() const
{
    return &r;
}
 
#if TY_USE_IHM
inline OColor::operator QColor() const
{
    return QColor::fromRgbF(r, g, b, a);
}
#endif // TY_USE_IHM
 
class TYColorManager
{
public:
    static void getSCurveColorTable(const unsigned int& nbColors, const float* hueRange,
                                    const float* saturationRange, const float* valueRange,
                                    OLookupTable& outColors);
 
    static void getLinearColorTable(const unsigned int& nbColors, const float* hueRange,
                                    const float* saturationRange, const float* valueRange,
                                    OLookupTable& outColors);
 
    static void getSqrtColorTable(const unsigned int& nbColors, const float* hueRange,
                                  const float* saturationRange, const float* valueRange,
                                  OLookupTable& outColors);
 
    static void getGaussColorTable(const unsigned int& nbColors, const float& alpha1, const float& alpha2,
                                   OLookupTable& outColors);
};
 
#endif // TY_COLOR