Color.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

    typedef unsigned char byte;

namespace Imagine {


    template <typename T>
    class RGB : public FVector<T,3> {
    private:
        typedef FVector<T,3> Base;
    public:
        RGB() : Base() {}
        explicit RGB(T v) : Base(v) {}
        RGB(T r,T g,T b) : Base(r,g,b) {}
        explicit RGB(const T t[3]): Base(t) {}
        RGB(const Base& x) :  Base(x) {}
        template <typename T2> RGB(const FVector<T2,3>& x) : Base(x) {}
        template <typename T2> RGB(const  FArray<T2,4>& x) : Base(T(x[0]), T(x[1]), T(x[2])) {}
        const T& r() const { return (*this)[0]; }
        T& r() { return (*this)[0]; }
        const T& g() const { return (*this)[1]; }
        T& g() { return (*this)[1]; }
        const T& b() const { return (*this)[2]; }
        T& b() { return (*this)[2]; }
        operator T () const { return T(0.3*r()+0.59*g()+0.11*b()); }
    };

    template <typename T>
    class RGBA : public FVector<T,4> {
    private:
        typedef FVector<T,4> Base;
    public:
        RGBA() : Base() {}
        explicit RGBA(T x) : Base(x) { (*this)[3]=T(1); }
        RGBA(T r,T g,T b,T a){
            (*this)[0]=r;(*this)[1]=g;(*this)[2]=b;(*this)[3]=a;
        }
        RGBA(T r,T g, T b){
            (*this)[0]=r;(*this)[1]=g;(*this)[2]=b;(*this)[3]=T(255);
        }

        RGBA(const T t[4]): Base(t) {}
        RGBA(const Base& x) :  Base(x) {}
        template <typename T2> RGBA(const FArray<T2,4>& x) : Base(x) {}
        template <typename T2> RGBA(const FArray<T2,3>& x){
            (*this)[0]=T(x[0]);
            (*this)[1]=T(x[1]);
            (*this)[2]=T(x[2]);
            (*this)[3]=T(255);
        }
        const T& r() const { return (*this)[0]; }
        T& r() { return (*this)[0]; }
        const T& g() const { return (*this)[1]; }
        T& g() { return (*this)[1]; }
        const T& b() const { return (*this)[2]; }
        T& b() { return (*this)[2]; }
        const T& a() const { return (*this)[3]; }
        T& a() { return (*this)[3]; }
        operator T () const { return T(0.3*r()+0.59*g()+0.11*b()); }
    };
    typedef RGB<byte> Color;
    const Color WHITE=Color(255,255,255);
    const Color BLACK=Color(0,0,0);
    const Color BLUE=Color(0,0,255);
    const Color RED=Color(255,0,0);
    const Color GREEN=Color(0,255,0);
    const Color YELLOW=Color(255,255,0);
    const Color CYAN=Color(0,255,255);
    const Color MAGENTA=Color(255,0,255);
    const Color ORANGE=Color(255,128,0);
    const Color PURPLE=Color(128,0,255);

    inline std::ostream& operator<<(std::ostream& out, const Color& c) {
        return out << (int)c[0] << ' ' << (int)c[1] << ' ' << (int)c[2];
    }
    typedef RGBA<byte> AlphaColor;
    const AlphaColor AWHITE=AlphaColor(255,255,255);
    const AlphaColor ABLACK=AlphaColor(0,0,0);
    const AlphaColor ABLUE=AlphaColor(0,0,255);
    const AlphaColor ARED=AlphaColor(255,0,0);
    const AlphaColor AGREEN=AlphaColor(0,255,0);
    const AlphaColor AYELLOW=AlphaColor(255,255,0);
    const AlphaColor ACYAN=AlphaColor(0,255,255);
    const AlphaColor AMAGENTA=AlphaColor(255,0,255);

    template<typename T> inline FVector<double,3> RGB2YUV(const RGB<T>& rgb) {
        double y=.299*double(rgb[0])+.587*double(rgb[1])+.114*double(rgb[2]);
        return FVector<double,3>(y,.492*(double(rgb[2])-y),.877*(double(rgb[0])-y));
    }
    template<typename T> inline RGB<T> YUV2RGB(const FVector<double,3>& yuv) {
        double r(yuv[2]/.877+yuv[0]);
        double b(yuv[1]/.492+yuv[0]);
        double g((yuv[0]-.299*r-.114*b)/.587);
        return RGB<T>(T(r),T(g),T(b));
    }


}