color.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2014> <EDF-R&D> <FRANCE>
 * This program 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 2 of the License, or
 * (at your option) any later version.
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef TY_COLOR
#define TY_COLOR
 
#include <vector>
#include <cmath>
#include <algorithm>
#include "Tympan/core/smartptr.h"
 
#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;
 
    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;
}
 
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