color.h

#pragma once
 
#include <iostream>
#include <limits>
#include <cgv/defines/assert.h>
#include <cgv/type/func/promote.h>
#include <cgv/type/func/promote_const.h>
#include <cgv/type/traits/max.h>
#include <cgv/type/info/type_name.h>
#include <cgv/utils/scan.h>
#include "color_model.h"
#include <math.h>
 
namespace cgv {
namespace media {
 
template <typename T>
struct color_one
{
    static T value() { return type::traits::max<T>::value; }
};
template <>
struct color_one<float>
{
    static float value() { return 1.0f; }
};
template <>
struct color_one<double>
{
    static double value() { return 1.0; }
};
template <ColorModel cm>
struct color_model_traits {
    static const unsigned int nr_components = 3;
};
template <>
struct color_model_traits<LUM> {
    static const unsigned int nr_components = 1;
};
template <AlphaModel am>
struct alpha_model_traits {
    static const unsigned int nr_components = 1;
};
template <>
struct alpha_model_traits<NO_ALPHA> {
    static const unsigned int nr_components = 0;
};
 
template <typename T, ColorModel cm, AlphaModel am = NO_ALPHA>
class color_base
{
public:
    static const unsigned int nr_color_components = color_model_traits<cm>::nr_components;
    static const unsigned int nr_alpha_components = alpha_model_traits<am>::nr_components;
    static const unsigned int nr_components = nr_color_components + nr_alpha_components;
    typedef T component_type;
    color_base() { }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color_base(const color_base<T2, cm2, am2>& c2) {
        convert_color(c2, *this);
    }
    T& at(unsigned int i) { return components[i]; }
    const T& at(unsigned int i) const { return components[i]; }
    T& alpha() { return components[nr_color_components]; }
    const T& alpha() const { return components[nr_color_components]; }
protected:
    T components[nr_components];
};
 
// forward declaration of color class
template <typename T, ColorModel cm = RGB, AlphaModel = NO_ALPHA> 
class color;
 
template <typename T, AlphaModel am> 
struct alpha_reference
{
    T& alpha_ref;
    template <ColorModel cm>
    alpha_reference(color_base<T, cm, am>& c) : alpha_ref(c.alpha()) {}
};
template <typename T>
struct alpha_reference<T,NO_ALPHA>
{
    T& ref_dummy_alpha() { static T dummy_alpha = color_one<T>::value(); return dummy_alpha; }
    T& alpha_ref;
    template <ColorModel cm>
    alpha_reference(color_base<T,cm,NO_ALPHA>& c) : alpha_ref(ref_dummy_alpha()) {}
};
template <typename T, AlphaModel am> 
struct const_alpha_reference
{
    const T& alpha_ref;
    template <ColorModel cm>
    const_alpha_reference(const color_base<T, cm, am>& c) : alpha_ref(c.alpha()) {}
};
template <typename T>
struct const_alpha_reference<T,NO_ALPHA>
{
    const T& ref_dummy_alpha() { static T dummy_alpha = color_one<T>::value(); return dummy_alpha; }
    const T& alpha_ref;
    template <ColorModel cm>
    const_alpha_reference(const color_base<T,cm,NO_ALPHA>& c) : alpha_ref(ref_dummy_alpha()) {}
};
 
/*********************************************************************
**
** component type conversion
**
*********************************************************************/
 
template <typename T1, typename T2>
inline void convert_color_component(const T1& from, T2& to) {
    to = (T2)((typename type::func::promote<T1,T2>::type)(from)*color_one<T2>::value()/color_one<T1>::value());
}
template <>
inline void convert_color_component(const unsigned int& from, unsigned short& to) {
    to = from >> 16;
}
template <>
inline void convert_color_component(const unsigned int& from, unsigned char& to) {
    to = from >> 24;
}
template <>
inline void convert_color_component(const unsigned short& from, unsigned char& to) {
    to = from >> 8;
}
template <>
inline void convert_color_component(const unsigned short& from, unsigned int& to) {
    to = (unsigned int) from << 16;
}
template <>
inline void convert_color_component(const unsigned char& from, unsigned int& to) {
    to = (unsigned int)from << 24;
}
template <>
inline void convert_color_component(const unsigned char& from, unsigned short& to) {
    to = (unsigned short)from << 8;
}
 
/*********************************************************************
** alpha model conversion
*********************************************************************/
template <typename T1, AlphaModel am1, typename T2, AlphaModel am2>
inline void convert_alpha_model(const_alpha_reference<T1,am1> from, alpha_reference<T2,am2> to)
{
    color<typename type::func::promote<T1,T2>::type,LUM,OPACITY> tmp;
    alpha_reference<typename type::func::promote<T1, T2>::type, OPACITY> ref(tmp);
    convert_alpha_model(from,tmp);
    convert_alpha_model(tmp,to);
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, NO_ALPHA> from, alpha_reference<T2, OPACITY> to)
{
    to.alpha_ref = color_one<T2>::value();
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, NO_ALPHA> from, alpha_reference<T2, TRANSPARENCY> to)
{
    to.alpha_ref = T2(0);
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, NO_ALPHA> from, alpha_reference<T2, EXTINCTION> to)
{
    to.alpha_ref = color_one<T2>::value();
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, OPACITY> from, alpha_reference<T2, TRANSPARENCY> to)
{
    convert_color_component(from.alpha_ref, to.alpha_ref);
    to.alpha_ref = color_one<T2>::value() - to.alpha_ref;
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, TRANSPARENCY> from, alpha_reference<T2, OPACITY> to)
{
    convert_color_component(from.alpha_ref, to.alpha_ref);
    to.alpha_ref = color_one<T2>::value() - to.alpha_ref;
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, OPACITY> from, alpha_reference<T2, EXTINCTION> to)
{
    double tmp;
    convert_color_component(from.alpha_ref, tmp);
    tmp = -log(1 - tmp);
    convert_color_component(tmp, to.alpha_ref);
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, EXTINCTION> from, alpha_reference<T2, OPACITY> to)
{
    double tmp;
    convert_color_component(from.alpha_ref, tmp);
    tmp = 1 - exp(-tmp);
    convert_color_component(tmp, to.alpha_ref);
}
template <typename T1, AlphaModel am1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, am1> from, alpha_reference<T2, NO_ALPHA> to)
{
}
template <typename T1, typename T2>
void convert_alpha_model(const_alpha_reference<T1, NO_ALPHA> from, alpha_reference<T2, NO_ALPHA> to)
{
}
template <typename T1, AlphaModel am, typename T2>
void convert_alpha_model(const_alpha_reference<T1, am> from, alpha_reference<T2, am> to)
{
    convert_color_component(from.alpha_ref, to.alpha_ref);
}
 
/*********************************************************************
**
** color model conversions
**
*********************************************************************/
template <typename T1, ColorModel cm1, typename T2, ColorModel cm2>
inline void convert_color_model(const color_base<T1, cm1>& from, color_base<T2, cm2>& to)
{
    color_base<typename type::func::promote<T1, T2>::type, XYZ> tmp;
    convert_color_model(from, tmp);
    convert_color_model(tmp, to);
}
template <typename T1, ColorModel cm, typename T2>
void convert_color_model(const color_base<T1, cm>& from, color_base<T2, cm>& to)
{
    for (unsigned int i = 0; i < color_base<T1, cm>::nr_components; ++i)
        convert_color_component(from.at(i), to.at(i));
}
template <typename T1, ColorModel cm1, typename T2>
void convert_color_model(const color_base<T1, cm1>& from, color_base<T2, XYZ>& to)
{
    std::cerr << "conversion not implemented" << std::endl;
}
template <typename T1, ColorModel cm2, typename T2>
void convert_color_model(const color_base<T1, XYZ>& from, color_base<T2, cm2>& to)
{
    std::cerr << "conversion not implemented" << std::endl;
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, LUM>& c1, color_base<T2, XYZ>& c2) {
    c2.at(0) = 0;
    c2.at(2) = 0;
    convert_color_component(c1.at(0), c2.at(1));
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, XYZ>& c1, color_base<T2, LUM>& c2) {
    convert_color_component(c1.at(1), c2.at(0));
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, RGB>& _c1, color_base<T2, XYZ>& c2) {
    color_base<double, RGB> c1;
    convert_color_model(_c1,c1);
    convert_color_component(0.412453 * c1.at(0) + 0.357580 * c1.at(1) + 0.180423 * c1.at(2), c2.at(0));
    convert_color_component(0.212671 * c1.at(0) + 0.715160 * c1.at(1) + 0.072169 * c1.at(2), c2.at(1));
    convert_color_component(0.019334 * c1.at(0) + 0.119193 * c1.at(1) + 0.950227 * c1.at(2), c2.at(2));
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, XYZ>& _c1, color_base<T2, RGB>& c2) {
    color_base<double, XYZ> c1(_c1);
    convert_color_model(_c1, c1);
    convert_color_component(3.2404813432 * c1.at(0) - 1.5371515163 * c1.at(1) - 0.4985363262 * c1.at(2), c2.at(0));
    convert_color_component(-0.9692549500 * c1.at(0) + 1.8759900015 * c1.at(1) + 0.0415559266 * c1.at(2), c2.at(1));
    convert_color_component(0.0556466391 * c1.at(0) - 0.2040413384 * c1.at(1) + 1.0573110696 * c1.at(2), c2.at(2));
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, RGB>& rgb, color_base<T2, HLS>& hls) {
    double mx, mn;
    convert_color_component(std::max(rgb.at(0), std::max(rgb.at(1), rgb.at(2))), mx);
    convert_color_component(std::min(rgb.at(0), std::min(rgb.at(1), rgb.at(2))), mn);
    double LL = (mx + mn) / 2;
    if (mn == mx) {
        hls.at(0) = hls.at(2) = 0;
        convert_color_component(LL, hls.at(1));
    }
    else {
        double DM = mx - mn;
        double SM = mx + mn;
        double SS = (LL <= 0.5) ? DM / SM : DM / (2 - SM);
        color_base<double, RGB> c;
        convert_color_model(rgb, c);
        double HH;
        if (c.at(0) == mx) HH = (c.at(1) - c.at(2)) / DM;
        else if (c.at(1) == mx) HH = 2 + (c.at(2) - c.at(0)) / DM;
        else HH = 4 + (c.at(0) - c.at(1)) / DM;
        if (HH < 0) HH += 6;
        HH /= 6;
        convert_color_component(HH, hls.at(0));
        convert_color_component(LL, hls.at(1));
        convert_color_component(SS, hls.at(2));
    }
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, HLS>& hls, color_base<T2, RGB>& rgb) {
    double HH, LL, SS;
    convert_color_component(hls.at(0), HH); HH *= 6;
    convert_color_component(hls.at(1), LL);
    convert_color_component(hls.at(2), SS);
    int    I = (int)HH;
    double F = HH - I;
    while (I >= 6) I -= 6;
    double mx = (LL <= 0.5) ? LL * (1 + SS) : LL + SS - LL * SS;
    double mn = 2 * LL - mx;
    double DM = mx - mn;
    if (SS == 0) {
        T2 tmp;
        convert_color_component(LL, tmp);
        rgb.at(0) = rgb.at(1) = rgb.at(2) = tmp;
    }
    else {
        switch (I) {
        case 0:
            convert_color_component(mx, rgb.at(0));
            convert_color_component(mn + F * DM, rgb.at(1));
            convert_color_component(mn, rgb.at(2));
            break;
        case 1:
            convert_color_component(mn + (1 - F) * DM, rgb.at(0));
            convert_color_component(mx, rgb.at(1));
            convert_color_component(mn, rgb.at(2));
            break;
        case 2:
            convert_color_component(mn, rgb.at(0));
            convert_color_component(mx, rgb.at(1));
            convert_color_component(mn + F * DM, rgb.at(2));
            break;
        case 3:
            convert_color_component(mn, rgb.at(0));
            convert_color_component(mn + (1 - F) * DM, rgb.at(1));
            convert_color_component(mx, rgb.at(2));
            break;
        case 4:
            convert_color_component(mn + F * DM, rgb.at(0));
            convert_color_component(mn, rgb.at(1));
            convert_color_component(mx, rgb.at(2));
            break;
        case 5:
            convert_color_component(mx, rgb.at(0));
            convert_color_component(mn, rgb.at(1));
            convert_color_component(mn + (1 - F) * DM, rgb.at(2));
            break;
        }
    }
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, HLS>& c1, color_base<T2, XYZ>& c2) {
    color_base<typename type::func::promote<T1, T2>::type, RGB> tmp;
    convert_color_model(c1, tmp);
    convert_color_model(tmp, c2);
}
template <typename T1, typename T2>
void convert_color_model(const color_base<T1, XYZ>& c1, color_base<T2, HLS>& c2) {
    color_base<typename type::func::promote<T1, T2>::type, RGB> tmp;
    convert_color_model(c1, tmp);
    convert_color_model(tmp, c2);
}
 
template <typename T1, ColorModel cm1, AlphaModel am1, typename T2, ColorModel cm2, AlphaModel am2>
inline void convert_color(const color_base<T1,cm1,am1>& from, color_base<T2,cm2,am2>& to)
{
    convert_color_model(reinterpret_cast<const color_base<T1,cm1>&>(from),reinterpret_cast<color_base<T2,cm2>&>(to));
    convert_alpha_model(const_alpha_reference<T1,am1>(from),alpha_reference<T2,am2>(to));
}
 
template <typename ta_derived> struct rgb_color_interface {};
template <typename T, ColorModel cm, AlphaModel am> 
struct rgb_color_interface<color<T,cm,am> > : public color_base<T,cm,am>
{
    T R() const { return color_base<T,RGB>(*this).at(0); }
    T G() const { return color_base<T, RGB>(*this).at(1); }
    T B() const { return color_base<T, RGB>(*this).at(2); }
};
template <typename T, AlphaModel am>
struct rgb_color_interface<color<T,RGB,am> > : public color_base<T, RGB,am>
{
    T& R()             { return this->at(0); }
    const T& R() const { return this->at(0); }
    T& G()             { return this->at(1); }
    const T& G() const { return this->at(1); }
    T& B()             { return this->at(2); }
    const T& B() const { return this->at(2); }
};
 
template <typename ta_derived> struct hls_color_interface {};
template <typename T, ColorModel cm, AlphaModel am> 
struct hls_color_interface<color<T,cm,am> > : public rgb_color_interface<color<T, cm, am> >
{
    T H() const { return color_base<T, HLS>(*this).at(0); }
    T L() const { return color_base<T, HLS>(*this).at(1); }
    T S() const { return color_base<T, HLS>(*this).at(2); }
};
template <typename T, AlphaModel am>
struct hls_color_interface<color<T,HLS,am> > : public rgb_color_interface<color<T, HLS, am> >
{
    T& H()             { return this->at(0); }
    const T& H() const { return this->at(0); }
    T& L()             { return this->at(1); }
    const T& L() const { return this->at(1); }
    T& S()             { return this->at(2); }
    const T& S() const { return this->at(2); }
};
 
template <typename ta_derived> struct xyz_color_interface {};
template <typename T, ColorModel cm, AlphaModel am> 
struct xyz_color_interface<color<T,cm,am> > : public hls_color_interface<color<T, cm, am> >
{
    T X() const { return color_base<T,XYZ>(*this).at(0); }
    T Y() const { return color_base<T, XYZ>(*this).at(1); }
    T Z() const { return color_base<T, XYZ>(*this).at(2); }
};
template <typename T, AlphaModel am>
struct xyz_color_interface<color<T,XYZ,am> > : public hls_color_interface<color<T, XYZ, am> >
{
    T& X()             { return this->at(0); }
    const T& X() const { return this->at(0); }
    T& Y()             { return this->at(1); }
    const T& Y() const { return this->at(1); }
    T& Z()             { return this->at(2); }
    const T& Z() const { return this->at(2); }
};
 
template <typename ta_derived> struct opacity_alpha_interface {};
template <typename T, ColorModel cm, AlphaModel am> 
struct opacity_alpha_interface<color<T,cm,am> > : public xyz_color_interface<color<T, cm, am> >
{
    T opacity() const { 
        color<T,LUM,OPACITY> opa;
        alpha_reference<T, OPACITY> opa_ref(opa);
        convert_alpha_model(const_alpha_reference<T, am>(*this), opa_ref);
        return opa_ref.alpha_ref; 
    }
};
template <typename T, ColorModel cm>
struct opacity_alpha_interface<color<T,cm,OPACITY> > :public xyz_color_interface<color<T, cm, OPACITY> >
{
    T& opacity()       { return this->alpha(); }
    const T& opacity() const { return this->alpha(); }
};
 
template <typename ta_derived> struct transparency_alpha_interface{};
template <typename T, ColorModel cm, AlphaModel am> 
struct transparency_alpha_interface<color<T,cm,am> > : public opacity_alpha_interface<color<T, cm, am> >
{
    T transparency() const { 
        color<T, LUM, TRANSPARENCY> tra;
        alpha_reference<T, TRANSPARENCY> tra_ref(tra);
        convert_alpha_model(const_alpha_reference<T, am>(*this), tra_ref);
        return tra_ref.alpha_ref;
    }
};
template <typename T, ColorModel cm>
struct transparency_alpha_interface<color<T,cm,TRANSPARENCY> > : public opacity_alpha_interface<color<T, cm, TRANSPARENCY> >
{
    T& transparency()       { return this->alpha(); }
    const T& transparency() const { return this->alpha(); }
};
 
template <typename ta_derived> struct extinction_alpha_interface {};
template <typename T, ColorModel cm, AlphaModel am> 
struct extinction_alpha_interface<color<T,cm,am> > : public transparency_alpha_interface<color<T, cm, am> >
{
    T extinction() const { 
        color<T, LUM, EXTINCTION> ext;
        alpha_reference<T, EXTINCTION> ext_ref(ext);
        convert_alpha_model(const_alpha_reference<T, am>(*this), ext_ref);
        return ext_ref.alpha_ref;
    }
};
template <typename T, ColorModel cm>
struct extinction_alpha_interface<color<T,cm,EXTINCTION> > : public transparency_alpha_interface<color<T, cm, EXTINCTION> >
{
    T& extinction()       { return this->alpha(); }
    const T& extinction() const { return this->alpha(); }
};
 
template <typename T, ColorModel cm, AlphaModel am>
class color : public extinction_alpha_interface<color<T,cm,am> >
{
public:
    static const ColorModel clr_mod = cm;
    static const AlphaModel alp_mod = am;
    static const unsigned int nr_color_components = color_base<T,cm,am>::nr_color_components;
    static const unsigned int nr_alpha_components = color_base<T, cm, am>::nr_alpha_components;
    static const unsigned int nr_components = color_base<T, cm, am>::nr_components;
    typedef T component_type;
    color() { }
    color(const T& c) { *this = c; }
    color(const T& c0, const T& c1) { 
        this->components[0] = c0; 
        if (nr_components > 1)
            this->components[1] = c1;
    }
    color(const T& c0, const T& c1, const T& c2) { 
        this->components[0] = c0;
        if (nr_components > 1)
            this->components[1] = c1;
        if (nr_components > 2)
            this->components[2] = c2;
    }
    color(const T& c0, const T& c1, const T& c2, const T& c3) { 
        this->components[0] = c0;
        if (nr_components > 1)
            this->components[1] = c1;
        if (nr_components > 2)
            this->components[2] = c2;
        if (nr_components > 3)
            this->components[3] = c3;
    }
    color(const color<T, cm>& c, T a) {
        this->at(nr_components - 1) = a; // looks bit like a hack but avoids invalid access for NO_ALPHA
        for (unsigned i = 0; i < nr_color_components; ++i)
            this->at(i) = c[i];
    }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color(const color<T2,cm2,am2>& c2) {
        convert_color(c2, *this);
    }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color<T,cm,am>& operator = (const color<T2,cm2,am2>& c2) {
        convert_color(c2, *this);
        return *this;
    }
    color<T,cm,am>& operator = (const T& c) {
        std::fill(this->components, this->components+nr_components, c);
        return *this;
    }
          color<T,cm>& drop_alpha()       { return *((color<T,cm>*)this); }
    const color<T,cm>& drop_alpha() const { return *((const color<T,cm>*)this); }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color<T,cm,am>& operator *= (const color<T2,cm2,am2>& c2) {
        color<T,cm,am> tmp(c2);
        for (int i=0; i<nr_components; ++i)
            this->at(i) *= tmp[i];
        return *this;
    }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color<T,cm,am> operator * (const color<T2,cm2,am2>& c2) {
        color<T,cm,am> res(*this);
        res *= c2;
        return res;
    }
    color<T,cm,am>& operator *= (const T& c) {
        for (unsigned i=0; i<nr_components; ++i)
            this->at(i) *= c;
        return *this;
    }
    template <typename T2>
    color<typename type::func::promote<T,T2>::type,cm,am> operator * (const T2& c) const {
        color<typename type::func::promote<T,T2>::type,cm,am> res;
        for (unsigned i=0; i<nr_components; ++i)
            res[i] = this->at(i)*c;
        return res;
    }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color<T,cm,am>& operator += (const color<T2,cm2,am2>& c2) {
        color<T,cm,am> tmp(c2);
        for (unsigned i=0; i<nr_components; ++i)
            this->at(i) += tmp[i];
        return *this;
    }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color<T,cm,am> operator + (const color<T2,cm2,am2>& c2) {
        color<T,cm,am> res(*this);
        res += c2;
        return res;
    }
    color<T,cm,am>& operator += (const T& c) {
        for (unsigned i=0; i<nr_components; ++i)
            this->at(i) += c;
        return *this;
    }
    color<T,cm,am> operator + (const T& c) {
        color<T,cm,am> res(*this);
        res += c;
        return res;
    }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color<T, cm, am>& operator -= (const color<T2, cm2, am2>& c2) {
        color<T, cm, am> tmp(c2);
        for(unsigned i = 0; i < nr_components; ++i)
            this->at(i) -= tmp[i];
        return *this;
    }
    template <typename T2, ColorModel cm2, AlphaModel am2>
    color<T, cm, am> operator - (const color<T2, cm2, am2>& c2) {
        color<T, cm, am> res(*this);
        res -= c2;
        return res;
    }
    color<T, cm, am>& operator -= (const T& c) {
        for(unsigned i = 0; i < nr_components; ++i)
            this->at(i) -= c;
        return *this;
    }
    color<T, cm, am> operator - (const T& c) {
        color<T, cm, am> res(*this);
        res -= c;
        return res;
    }
    void clamp(const T& mn = 0, const T& mx = color_one<T>::value(), bool skip_alpha = false) {
        unsigned nr = skip_alpha ? nr_color_components : nr_components;
        for (unsigned i = 0; i < nr; ++i)
            if (this->at(i) < mn)
                this->at(i) = mn;
            else if (this->at(i) > mx)
                this->at(i) = mx;
    }
    T& operator [] (unsigned int i) { return this->at(i); }
    const T& operator [] (unsigned int i) const { return this->at(i);   }
};
 
#define CGV_MEDIA_COLOR_DECLARED
 
/*********************************************************************
**
** operators
**
*********************************************************************/
 
template <typename T, ColorModel cm, AlphaModel am>
bool operator == (const color<T,cm,am>& c1, const color<T,cm,am>& c2) {
    for (unsigned int i=0; i<color<T,cm,am>::nr_components; ++i)
        if (c1[i] != c2[i])
            return false;
    return true;
}
template <typename T1, ColorModel cm1, AlphaModel am1, typename T2, ColorModel cm2, AlphaModel am2>
color<typename type::func::promote<T1,T2>::type,cm1,am1> operator * (const color<T1,cm1,am1>& c1, const color<T2,cm2,am2>& c2) {
    color<typename type::func::promote<T1,T2>::type,cm1,am1> res(c1);
    res *= c2;
    return res;
}
template <typename T1, typename T2, ColorModel cm2, AlphaModel am2>
color<typename type::func::promote<T1,T2>::type,cm2,am2> operator * (const T1& c1, const color<T2,cm2,am2>& c2) {
    color<typename type::func::promote<T1,T2>::type,cm2,am2> res(c2);
    res *= c1;
    return res;
}
template <typename T1, ColorModel cm1, AlphaModel am1, typename T2, ColorModel cm2, AlphaModel am2>
color<typename type::func::promote<T1,T2>::type,cm1,am1> operator + (const color<T1,cm1,am1>& c1, const color<T2,cm2,am2>& c2) {
    color<typename type::func::promote<T1,T2>::type,cm1,am1> res(c1);
    res += c2;
    return res;
}
template <typename T1, ColorModel cm1, AlphaModel am1>
std::ostream& operator << (std::ostream& os, const color<T1,cm1,am1>& c) {
    os << c[0];
    for (unsigned int i=1; i<color<T1,cm1,am1>::nr_components; ++i)
        os << " " << c[i];
    return os;
}
template <typename T1, ColorModel cm1, AlphaModel am1>
std::istream& operator >> (std::istream& is, color<T1,cm1,am1>& c) {
    is >> c[0];
    for (unsigned int i=1; i<color<T1,cm1,am1>::nr_components; ++i)
        is >> c[i];
    return is;
}
template <ColorModel cm, AlphaModel am>
std::ostream& operator << (std::ostream& os, const color<unsigned char,cm,am>& c) {
    os << (int)c[0];
    for (unsigned int i=1; i<color<unsigned char,cm,am>::nr_components; ++i)
        os << " " << (int)c[i];
    return os;
}
template <ColorModel cm, AlphaModel am>
std::istream& operator >> (std::istream& is, color<unsigned char,cm,am>& c) {
    int tmp;
    is >> tmp; 
    c[0] = (unsigned char)tmp;
    for (unsigned int i=1; i<color<unsigned char,cm,am>::nr_components; ++i) {
        is >> tmp;
        c[i] = (unsigned char)tmp;
    }
    return is;
}
 
/*********************************************************************
**
** functions
**
*********************************************************************/
 
template <typename T, ColorModel cm, AlphaModel am>
const color<T,cm,am> lerp(const color<T,cm,am>& c1, const color<T,cm,am>& c2, T t) {
    return ((T)1 - t) * c1 + t * c2;
}
 
template<typename T1, typename T2, AlphaModel am>
const color<T1, RGB, am> pow(const color<T1, RGB, am>& c, T2 e) {
    color<T1, RGB, am> x = c;
    for(unsigned int i = 0; i < color<T1, RGB, am>::nr_color_components; ++i) {
        T2 v = T2(0);
        convert_color_component(x[i], v);
        convert_color_component(std::pow(v, e), x[i]);
    }
    return x;
}
 
template<typename T, AlphaModel am>
const color<T, RGB, am> inv(const color<T, RGB, am>& c) {
    color<T, RGB, am> x;
    for(unsigned int i = 0; i < color<T, RGB, am>::nr_components; ++i) {
        x[i] = color_one<T>::value() - c[i];
    }
    return x;
}
 
template<typename T, AlphaModel am>
std::string to_hex(const color<T, RGB, am>& c) {
    std::string res = "0x";
    res.resize(2 * static_cast<size_t>(color<T, RGB, am>::nr_components) + 2, '0');
    std::string buf = "00";
 
    for(size_t i = 0; i < static_cast<size_t>(color<T, RGB, am>::nr_components); ++i) {
        uint8_t v = 0;
        convert_color_component(c[i], v);
        buf = cgv::utils::to_hex(v);
        res[2 * i + 2] = buf[0];
        res[2 * i + 3] = buf[1];
    }
    return res;
}
 
template<typename T, AlphaModel am>
bool from_hex(const std::string& s, color<T, RGB, am>& c) {
    size_t off = 0;
    // skip the first parsed byte if the string has the typical hexadecimal prefix
    if(s.length() > 1 && s[0] == '0' && s[1] == 'x')
        off = 1;
 
    std::vector<uint8_t> parsed = cgv::utils::parse_hex_bytes(s);
    if(parsed.empty() || parsed.size() - off < static_cast<size_t>(color<T, RGB, am>::nr_components))
        return false;
    
    for(size_t i = 0; i < static_cast<size_t>(color<T, RGB, am>::nr_components); ++i) {
        uint8_t v = parsed[i + off];
        convert_color_component(v, c[i]);
    }
    return true;
}
 
} // namespace media
 
 
typedef cgv::media::color<float, cgv::media::RGB> rgb;
typedef cgv::media::color<float, cgv::media::RGB, cgv::media::OPACITY> rgba;
typedef cgv::media::color<cgv::type::uint8_type, cgv::media::RGB> rgb8;
typedef cgv::media::color<cgv::type::uint8_type, cgv::media::RGB, cgv::media::OPACITY> rgba8;
 
 
} // namespace cgv