rgba.h

#ifndef CVD_RGBA_H
#define CVD_RGBA_H

#include <iostream>

namespace CVD
{

// CVD::Rgba
// Template class to represent red, green, blue and alpha components
//
template <typename T>
class Rgba
{
    public:
    Rgba() = default;
    Rgba(const Rgba&) = default;
    Rgba& operator=(const Rgba&) = default;

    inline explicit Rgba(T r, T g, T b, T a)
        : red(r)
        , green(g)
        , blue(b)
        , alpha(a)
    {
    }
    template <class S>
    inline explicit Rgba(const Rgba<S>& rgba)
        : red(static_cast<T>(rgba.red))
        , green(static_cast<T>(rgba.green))
        , blue(static_cast<T>(rgba.blue))
        , alpha(static_cast<T>(rgba.alpha))
    {
    }

    T red; 
    T green; 
    T blue; 
    T alpha; 

    template <typename T2>
    Rgba<T>& operator=(const Rgba<T2>& c)
    {
        red = static_cast<T>(c.red);
        green = static_cast<T>(c.green);
        blue = static_cast<T>(c.blue);
        alpha = static_cast<T>(c.alpha);
        return *this;
    }

    bool operator==(const Rgba<T>& c) const
    {
        return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha;
    }

    bool operator!=(const Rgba<T>& c) const
    {
        return red != c.red || green != c.green || blue != c.blue || alpha != c.alpha;
    }

    //   T to_grey() const {return 0.3*red + 0.6*green + 0.1*blue;}
};

template <typename T>
std::ostream& operator<<(std::ostream& os, const Rgba<T>& x)
{
    return os << "(" << x.red << "," << x.green << ","
              << x.blue << "," << x.alpha << ")";
}

inline std::ostream& operator<<(std::ostream& os, const Rgba<unsigned char>& x)
{
    return os << "(" << static_cast<unsigned int>(x.red) << ","
              << static_cast<unsigned int>(x.green) << ","
              << static_cast<unsigned int>(x.blue) << ","
              << static_cast<unsigned int>(x.alpha) << ")";
}

} // end namespace
#endif