/************************************************************************/

/*                                                                      */

/*               Copyright 1998-2002 by Ullrich Koethe                  */

/*                                                                      */

/*    This file is part of the VIGRA computer vision library.           */

/*    The VIGRA Website is                                              */

/*        http://hci.iwr.uni-heidelberg.de/vigra/                       */

/*    Please direct questions, bug reports, and contributions to        */

/*        ullrich.koethe@iwr.uni-heidelberg.de    or                    */

/*        vigra@informatik.uni-hamburg.de                               */

/*                                                                      */

/*    Permission is hereby granted, free of charge, to any person       */

/*    obtaining a copy of this software and associated documentation    */

/*    files (the "Software"), to deal in the Software without           */

/*    restriction, including without limitation the rights to use,      */

/*    copy, modify, merge, publish, distribute, sublicense, and/or      */

/*    sell copies of the Software, and to permit persons to whom the    */

/*    Software is furnished to do so, subject to the following          */

/*    conditions:                                                       */

/*                                                                      */

/*    The above copyright notice and this permission notice shall be    */

/*    included in all copies or substantial portions of the             */

/*    Software.                                                         */

/*                                                                      */

/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */

/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */

/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */

/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */

/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */

/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */

/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */

/*    OTHER DEALINGS IN THE SOFTWARE.                                   */                

/*                                                                      */

/************************************************************************/

#ifndef VIGRA_COLORCONVERSIONS_HXX

#define VIGRA_COLORCONVERSIONS_HXX

#include <cmath>

#include "mathutil.hxx"

#include "rgbvalue.hxx"

#include "functortraits.hxx"

namespace vigra {

namespace detail

{

template<class ValueType>

inline ValueType gammaCorrection(double value, double gamma)

{

    typedef typename NumericTraits<ValueType>::RealPromote Promote;

    return NumericTraits<ValueType>::fromRealPromote(

              RequiresExplicitCast<Promote>::cast(

                (value < 0.0) 

                    ? -std::pow(-value, gamma) 

                    : std::pow(value, gamma)));

}

template<class ValueType>

inline ValueType gammaCorrection(double value, double gamma, double norm)

{

    typedef typename NumericTraits<ValueType>::RealPromote Promote;

    return NumericTraits<ValueType>::fromRealPromote(

              RequiresExplicitCast<Promote>::cast(

                (value < 0.0) 

                    ? -norm*std::pow(-value/norm, gamma)

                    : norm*std::pow(value/norm, gamma)));

}

template<class ValueType>

inline ValueType sRGBCorrection(double value, double norm)

{

    value /= norm;

    typedef typename NumericTraits<ValueType>::RealPromote Promote;

    return NumericTraits<ValueType>::fromRealPromote(

              RequiresExplicitCast<ValueType>::cast(

                (value <= 0.0031308) 

                    ? norm*12.92*value 

                    : norm*(1.055*std::pow(value, 0.41666666666666667) - 0.055)));

}

template<class ValueType>

inline ValueType inverse_sRGBCorrection(double value, double norm)

{

    value /= norm;

    typedef typename NumericTraits<ValueType>::RealPromote Promote;

    return NumericTraits<ValueType>::fromRealPromote(

             RequiresExplicitCast<ValueType>::cast(

                (value <= 0.04045) 

                    ? norm*value / 12.92

                    : norm*VIGRA_CSTD::pow((value + 0.055)/1.055, 2.4)));

}

} // namespace detail

/** \defgroup ColorConversions  Color Space Conversions

    Convert between RGB, sRGB, R'G'B', XYZ, L*a*b*, L*u*v*, Y'PbPr, Y'CbCr, Y'IQ, and Y'UV color spaces.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    <UL>

    <LI> <b>RGB/sRGB/R'G'B'</b><br>

        <em>linear and non-linear (gamma corrected) additive color</em>

        <p>

        <UL style="list-style-image:url(documents/bullet.gif)">

        <LI> \ref vigra::RGB2sRGBFunctor

        <LI> \ref vigra::sRGB2RGBFunctor

        <LI> \ref vigra::RGB2RGBPrimeFunctor

        <LI> \ref vigra::RGBPrime2RGBFunctor

        </UL><p>

    <LI> <b>XYZ</b><br>

        <em>device independent color representation 

               (according to Publication CIE  No  15.2 "Colorimetry"

                and ITU-R Recommendation BT.709)</em>

        <p>

        <UL style="list-style-image:url(documents/bullet.gif)">

        <LI> \ref vigra::RGB2XYZFunctor

        <LI> \ref vigra::RGBPrime2XYZFunctor

        <LI> \ref vigra::XYZ2RGBFunctor

        <LI> \ref vigra::XYZ2RGBPrimeFunctor

        </UL><p>

    <LI> <b>L*a*b* </b><br>

        <em>perceptually uniform color representation 

               (according to Publication CIE No 15.2 "Colorimetry" and

               ITU-R Recommendation BT.709)</em>

        <p>

        <UL style="list-style-image:url(documents/bullet.gif)">

        <LI> \ref vigra::RGB2LabFunctor

        <LI> \ref vigra::RGBPrime2LabFunctor

        <LI> \ref vigra::XYZ2LabFunctor

        <LI> \ref vigra::Lab2RGBFunctor

        <LI> \ref vigra::Lab2RGBPrimeFunctor

        <LI> \ref vigra::Lab2XYZFunctor

        <LI> \ref polar2Lab()

        <LI> \ref lab2Polar()

        </UL><p>

    <LI> <b>L*u*v* </b><br>

        <em>perceptually uniform color representation 

               (according to Publication CIE No 15.2 "Colorimetry" and

               ITU-R Recommendation BT.709)</em>

        <p>

        <UL style="list-style-image:url(documents/bullet.gif)">

        <LI> \ref vigra::RGB2LuvFunctor

        <LI> \ref vigra::RGBPrime2LuvFunctor

        <LI> \ref vigra::XYZ2LuvFunctor

        <LI> \ref vigra::Luv2RGBFunctor

        <LI> \ref vigra::Luv2RGBPrimeFunctor

        <LI> \ref vigra::Luv2XYZFunctor

        <LI> \ref polar2Luv()

        <LI> \ref luv2Polar()

        </UL><p>

    <LI> <b>Y'PbPr and Y'CbCr </b><br>

        <em>color difference coding

                (according to ITU-R Recommendation BT. 601)</em>

        <p>

        <UL style="list-style-image:url(documents/bullet.gif)">

        <LI> \ref vigra::RGBPrime2YPrimePbPrFunctor

        <LI> \ref vigra::YPrimePbPr2RGBPrimeFunctor

        <LI> \ref polar2YPrimePbPr()

        <LI> \ref yPrimePbPr2Polar()

        <LI> \ref vigra::RGBPrime2YPrimeCbCrFunctor

        <LI> \ref vigra::YPrimeCbCr2RGBPrimeFunctor

        <LI> \ref polar2YPrimeCbCr()

        <LI> \ref yPrimeCbCr2Polar()

        </UL><p>

    <LI> <b>Y'UV and Y'IQ </b><br>

        <em>analog video coding according to NTSC and PAL standards</em>

        <p>

        <UL style="list-style-image:url(documents/bullet.gif)">

        <LI> \ref vigra::RGBPrime2YPrimeUVFunctor

        <LI> \ref vigra::YPrimeUV2RGBPrimeFunctor

        <LI> \ref polar2YPrimeUV()

        <LI> \ref yPrimeUV2Polar()

        <LI> \ref vigra::RGBPrime2YPrimeIQFunctor

        <LI> \ref vigra::YPrimeIQ2RGBPrimeFunctor

        <LI> \ref polar2YPrimeIQ()

        <LI> \ref yPrimeIQ2Polar()

        </UL><p>

    </UL>

    \anchor _details

    This module provides conversion from RGB/R'G'B' into more perceptually uniform

    color spaces. In image analysis, colors are usually converted into another color space 

    in order to get good estimates of perceived color differences by just calculating 

    Euclidean distances between the transformed colors. The L*a*b* and L*u*v* were 

    designed with exactly this application in mind and thus give the best results. But these

    conversions are also the most computationally demanding. The Y'PbPr color difference

    space (designed for coding digital video) is computationally much cheaper, and 

    almost as good. Y'CbCr represents esentially the same transformation, but the color values 

    are scaled so that they can be stored with 8 bits per channel with minimal loss of 

    information. The other transformations are of lesser interest here: XYZ is a device independent

    (but not perceptually uniform) color representation, and Y'IQ and Y'UV are the color 

    spaces used by the PAL and NTSC analog video standards. Detailed information about

    these color spaces and their transformations can be found in 

    <a href="http://www.poynton.com/ColorFAQ.html">Charles Poynton's Color FAQ</a>

    When you want to perform a color conversion, you must first know in which

    color space the data are given. Although this sounds trivial, it is

    quite often done wrong, because the distinction between RGB and sRGB (still images) or R'G'B' 

    (digital video) is frequently overlooked: nowadays, most still images are stored in

    sRGB space, and treating them as RGB leads to wrong results (although the color primaries

    are named the same). RGB and R'G'B' are related by a so called <em>gamma correction</em>:

    \f[

        C' = C_{max} \left(\frac{C_{RGB}}{C_{max}} \right)^{0.45} \qquad

    \f]

    where C represents one of the color channels R, G, and B, and \f$ C_{max} \f$ usually equals 255. 

    The sRGB color space realizes a slight enhancement of this definition:

    \f[

        C_{sRGB} = \left\{\begin{array}{ll}

        12.92\,C_{RGB} & \textrm{ if }\frac{C_{RGB}}{C_{max}} \le 0.00304 \\

        C_{max}\left( 1.055 \left(\frac{C_{RGB}}{C_{max}}\right)^{1/2.4}-0.055\right) & \textrm{ otherwise}

        \end{array} \right.

    \f]

    sRGB has now become a widely accepted international standard (IEC 61966-2.1) which is used by most 

    consumer products (digital cameras, printers, and screens). In practice, you can 

    distinguish between linear and gamma-corrected red, green, and blue by displaying the images: if they look

    too dark, they are probably RGB, if they are OK, they are likely sRGB. (However, there are still a few older 

    graphics cards and display programs which silently apply an additional gamma correction to every image, 

    so that RGB appears correct and sRGB is too bright.) Whether or not the data are represented

    in the sRGB color space can also be seen in the color space tag of an image's EXIF data, if available.

    The distinction between RGB and R'G'B' is important because some conversions start at 

    RGB (XYZ, L*a*b*, L*u*v*), while others start at R'G'B' (Y'PbPr, Y'CbCr, Y'IQ, and Y'UV). 

    The names of VIGRA's color conversion functors always make clear to which color space 

    they must be applied.

    In addition VIGRA provides a <em>\ref PolarColors "polar coordinate interface"</em>

    to several color spaces (L*a*b*, L*u*v*, Y'PbPr, Y'CbCr, Y'IQ, and Y'UV). This

    interface makes use of the fact that these color spaces are conceptually similar:

    they represent colors by a "brightness" coordinate (L* or Y') and a pair of 

    "chromaticity" coordinates that span a plane of colors with equal brightness.

    The polar representation transforms chroma coordinates into a color "angle"

    (similar to hue in the HSV system) and a "saturation". The polar coordinates are 

    normalized so that a color angle of 0 degrees is always associated with red

    (green is at about 120 degrees, blue at about 240 degrees - exact values differ

    between color spaces). A saturation of 1 is the highest saturation that any RGB color 

    in the unit cube can have after transformation into the respective color space, 

    and saturation 0 corresponds to gray. Polar coordinates provide a more intuitive 

    interface to color specification by users and make different color spaces somewhat 

    comparable.

*/

//@{

/** \brief Convert linear (raw) RGB into non-linear (gamma corrected) R'G'B'.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    The functor realizes the transformation

    \f[

        R' = R_{max} \left(\frac{R}{R_{max}} \right)^{0.45} \qquad

        G' = G_{max} \left(\frac{G}{G_{max}} \right)^{0.45} \qquad

        B' = B_{max} \left(\frac{B}{B_{max}} \right)^{0.45}

    \f]

    By default, \f$ R_{max} = G_{max} = B_{max} = 255 \f$. This default can be overridden

    in the constructor. If both source and target colors components are stored 

    as <tt>unsigned char</tt>, a look-up-table will be used to speed up the transformation.

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

    */

template <class From, class To = From>

class RGB2RGBPrimeFunctor

{

  public:

        /** the functor's argument type

        */

    typedef TinyVector<From, 3> argument_type;

        /** the functor's result type

        */

    typedef TinyVector<To, 3> result_type;

        /** \deprecated use argument_type and result_type

        */

    typedef TinyVector<To, 3> value_type;

        /** the result component's promote type

        */

    typedef typename NumericTraits<To>::RealPromote component_type;

        /** Default constructor.

            The maximum value for each RGB component defaults to 255

        */

    RGB2RGBPrimeFunctor()

    : max_(255.0)

    {}

        /** constructor

            \arg max - the maximum value for each RGB component

        */

    RGB2RGBPrimeFunctor(component_type max)

    : max_(max)

    {}

        /** apply the transformation

        */

    template <class V>

    result_type operator()(V const & rgb) const

    {

        return TinyVector<To, 3>(

            detail::gammaCorrection<To>(rgb[0], 0.45, max_),

            detail::gammaCorrection<To>(rgb[1], 0.45, max_),

            detail::gammaCorrection<To>(rgb[2], 0.45, max_));

    }

  private:

    component_type max_;    

};

template <>

class RGB2RGBPrimeFunctor<unsigned char, unsigned char>

{

    unsigned char lut_[256];

  public:

    typedef TinyVector<unsigned char, 3> argument_type;

    typedef TinyVector<unsigned char, 3> result_type;

    typedef TinyVector<unsigned char, 3> value_type;

    RGB2RGBPrimeFunctor()

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::gammaCorrection<unsigned char>(i, 0.45, 255.0);

        }

    }

    RGB2RGBPrimeFunctor(double max)

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::gammaCorrection<unsigned char>(i, 0.45, max);

        }

    }

    template <class V>

    TinyVector<unsigned char, 3> operator()(V const & rgb) const

    {

        return TinyVector<unsigned char, 3>(lut_[rgb[0]], lut_[rgb[1]], lut_[rgb[2]]);

    }

};

template <class From, class To>

class FunctorTraits<RGB2RGBPrimeFunctor<From, To> >

: public FunctorTraitsBase<RGB2RGBPrimeFunctor<From, To> >

{

  public:

    typedef VigraTrueType isUnaryFunctor;

};

/** \brief Convert linear (raw) RGB into standardized sRGB.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    The sRGB color space is a slight improvement over the R'G'B' space. It is now a widely accepted 

    international standard (IEC 61966-2.1) which is used by most consumer products

    (digital cameras, printers, and screens). The functor realizes the transformation

    \f[

        C_{sRGB} = \left\{ \begin{array}{ll}

        12.92\,C_{RGB} & \textrm{ if }\frac{C_{RGB}}{C_{max}} \le 0.0031308 \\

        C_{max}\left( 1.055 \left(\frac{C_{RGB}}{C_{max}}\right)^{1/2.4}-0.055\right) & \textrm{ otherwise}

        \end{array}  \right.

    \f]

    where C is any of the primaries R, G, and B. By default, \f$ C_{max} = 255 \f$ (this default can be

    overridden in the constructor). If both source and target color components are stored

    as <tt>unsigned char</tt>, a look-up-table will be used to speed up the transformation.

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

    */

template <class From, class To = From>

class RGB2sRGBFunctor

{

  public:

        /** the functor's argument type

        */

    typedef TinyVector<From, 3> argument_type;

        /** the functor's result type

        */

    typedef TinyVector<To, 3> result_type;

        /** \deprecated use argument_type and result_type

        */

    typedef TinyVector<To, 3> value_type;

        /** the result component's promote type

        */

    typedef typename NumericTraits<To>::RealPromote component_type;

        /** Default constructor.

            The maximum value for each RGB component defaults to 255

        */

    RGB2sRGBFunctor()

    : max_(255.0)

    {}

        /** constructor

            \arg max - the maximum value for each RGB component

        */

    RGB2sRGBFunctor(component_type max)

    : max_(max)

    {}

        /** apply the transformation

        */

    template <class V>

    result_type operator()(V const & rgb) const

    {

        return TinyVector<To, 3>(

            detail::sRGBCorrection<To>(rgb[0], max_),

            detail::sRGBCorrection<To>(rgb[1], max_),

            detail::sRGBCorrection<To>(rgb[2], max_));

    }

  private:

    component_type max_;    

};

template <>

class RGB2sRGBFunctor<unsigned char, unsigned char>

{

    unsigned char lut_[256];

  public:

    typedef TinyVector<unsigned char, 3> argument_type;

    typedef TinyVector<unsigned char, 3> result_type;

    typedef TinyVector<unsigned char, 3> value_type;

    RGB2sRGBFunctor()

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::sRGBCorrection<unsigned char>(i, 255.0);

        }

    }

    RGB2sRGBFunctor(double max)

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::sRGBCorrection<unsigned char>(i, max);

        }

    }

    template <class V>

    TinyVector<unsigned char, 3> operator()(V const & rgb) const

    {

        return TinyVector<unsigned char, 3>(lut_[rgb[0]], lut_[rgb[1]], lut_[rgb[2]]);

    }

};

template <class From, class To>

class FunctorTraits<RGB2sRGBFunctor<From, To> >

: public FunctorTraitsBase<RGB2sRGBFunctor<From, To> >

{

  public:

    typedef VigraTrueType isUnaryFunctor;

};

/** \brief Convert non-linear (gamma corrected) R'G'B' into non-linear (raw) RGB.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    The functor realizes the transformation

    \f[

        R = R_{max} \left(\frac{R'}{R_{max}} \right)^{1/0.45} \qquad

        G = G_{max} \left(\frac{G'}{G_{max}} \right)^{1/0.45} \qquad

        B = B_{max} \left(\frac{B'}{B_{max}} \right)^{1/0.45}

    \f]

    By default, \f$ R_{max} = G_{max} = B_{max} = 255 \f$. This default can be overridden

    in the constructor. If both source and target color components are stored 

    as <tt>unsigned char</tt>, a look-up-table will be used to speed up the transformation.

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

*/

template <class From, class To = From>

class RGBPrime2RGBFunctor

{

  public:

        /** the functor's argument type

        */

    typedef TinyVector<From, 3> argument_type;

        /** the functor's result type

        */

    typedef TinyVector<To, 3> result_type;

        /** \deprecated use argument_type and result_type

        */

    typedef TinyVector<To, 3> value_type;

        /** the result component's promote type

        */

    typedef typename NumericTraits<To>::RealPromote component_type;

        /** Default constructor.

            The maximum value for each RGB component defaults to 255.

        */

    RGBPrime2RGBFunctor()

    : max_(255.0), gamma_(1.0/0.45)

    {}

        /** constructor

            \arg max - the maximum value for each RGB component

        */

    RGBPrime2RGBFunctor(component_type max)

    : max_(max), gamma_(1.0/0.45)

    {}

        /** apply the transformation

        */

    result_type operator()(argument_type const & rgb) const

    {

        return TinyVector<To, 3>(

            detail::gammaCorrection<To>(rgb[0], gamma_, max_),

            detail::gammaCorrection<To>(rgb[1], gamma_, max_),

            detail::gammaCorrection<To>(rgb[2], gamma_, max_));

    }

  private:

    component_type max_;

    double gamma_;

};

template <>

class RGBPrime2RGBFunctor<unsigned char, unsigned char>

{    

    unsigned char lut_[256];

  public:

    typedef TinyVector<unsigned char, 3> argument_type;

    typedef TinyVector<unsigned char, 3> result_type;

    typedef TinyVector<unsigned char, 3> value_type;

    RGBPrime2RGBFunctor()

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::gammaCorrection<unsigned char>(i, 1.0/0.45, 255.0);

        }

    }

    RGBPrime2RGBFunctor(double max)

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::gammaCorrection<unsigned char>(i, 1.0/0.45, max);

        }

    }

    template <class V>

    TinyVector<unsigned char, 3> operator()(V const & rgb) const

    {

        return TinyVector<unsigned char, 3>(lut_[rgb[0]], lut_[rgb[1]], lut_[rgb[2]]);

    }

};

template <class From, class To>

class FunctorTraits<RGBPrime2RGBFunctor<From, To> >

: public FunctorTraitsBase<RGBPrime2RGBFunctor<From, To> >

{

  public:

    typedef VigraTrueType isUnaryFunctor;

};

/** \brief Convert standardized sRGB into non-linear (raw) RGB.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    The sRGB color space is a slight improvement over the R'G'B' space. Is is now a widely accepted 

    international standard (IEC 61966-2.1) which is used by most consumer products

    (digital cameras, printers, and screens). The functor realizes the transformation

    \f[

        C_{RGB} = \left\{\begin{array}{ll}

        C_{sRGB} / 12.92 & \textrm{if }\frac{C_{sRGB}}{C_{max}} \le 0.04045 \\

        C_{max}\left( \frac{C_{sRGB}/C_{max}+0.055}{1.055}\right)^{2.4} & \textrm{otherwise}

        \end{array}\right.

    \f]

    where C is one of the color channels R, G, or B, and \f$ C_{max}\f$ equals 255 by default (This default 

    can be overridden in the constructor). If both source and target color components are stored 

    as <tt>unsigned char</tt>, a look-up-table will be used to speed up the transformation.

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

*/

template <class From, class To = From>

class sRGB2RGBFunctor

{

  public:

        /** the functor's argument type

        */

    typedef TinyVector<From, 3> argument_type;

        /** the functor's result type

        */

    typedef TinyVector<To, 3> result_type;

        /** \deprecated use argument_type and result_type

        */

    typedef TinyVector<To, 3> value_type;

        /** the result component's promote type

        */

    typedef typename NumericTraits<To>::RealPromote component_type;

        /** Default constructor.

            The maximum value for each RGB component defaults to 255.

        */

    sRGB2RGBFunctor()

    : max_(255.0)

    {}

        /** constructor

            \arg max - the maximum value for each RGB component

        */

    sRGB2RGBFunctor(component_type max)

    : max_(max)

    {}

        /** apply the transformation

        */

    result_type operator()(argument_type const & rgb) const

    {

        return TinyVector<To, 3>(

            detail::inverse_sRGBCorrection<To>(rgb[0], max_),

            detail::inverse_sRGBCorrection<To>(rgb[1], max_),

            detail::inverse_sRGBCorrection<To>(rgb[2], max_));

    }

  private:

    component_type max_;

};

template <>

class sRGB2RGBFunctor<unsigned char, unsigned char>

{    

    unsigned char lut_[256];

  public:

    typedef TinyVector<unsigned char, 3> argument_type;

    typedef TinyVector<unsigned char, 3> result_type;

    typedef TinyVector<unsigned char, 3> value_type;

    sRGB2RGBFunctor()

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::inverse_sRGBCorrection<unsigned char>(i, 255.0);

        }

    }

    sRGB2RGBFunctor(double max)

    {

        for(int i=0; i<256; ++i)

        {

            lut_[i] = detail::inverse_sRGBCorrection<unsigned char>(i, max);

        }

    }

    template <class V>

    TinyVector<unsigned char, 3> operator()(V const & rgb) const

    {

        return TinyVector<unsigned char, 3>(lut_[rgb[0]], lut_[rgb[1]], lut_[rgb[2]]);

    }

};

template <class From, class To>

class FunctorTraits<sRGB2RGBFunctor<From, To> >

: public FunctorTraitsBase<sRGB2RGBFunctor<From, To> >

{

  public:

    typedef VigraTrueType isUnaryFunctor;

};

/** \brief Convert linear (raw) RGB into standardized tri-stimulus XYZ.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    According to ITU-R Recommendation BT.709, the functor realizes the transformation

    \f[

        \begin{array}{rcl}

        X & = & 0.412453\enspace R / R_{max} + 0.357580\enspace G / G_{max} + 0.180423\enspace B / B_{max}\\

        Y & = & 0.212671\enspace R / R_{max} + 0.715160\enspace G / G_{max} + 0.072169\enspace B / B_{max} \\

        Z & = & 0.019334\enspace R / R_{max} + 0.119193\enspace G / G_{max} + 0.950227\enspace B / B_{max}

        \end{array}

    \f]

    By default, \f$ R_{max} = G_{max} = B_{max} = 255 \f$. This default can be overridden

    in the constructor. X, Y, and Z are always positive and reach their maximum for white. 

    The white point is obtained by transforming RGB(255, 255, 255). It corresponds to the 

    D65 illuminant. Y represents the <em>luminance</em> ("brightness") of the color. The above

    transformation is officially defined in connection with the sRGB color space (i.e. when the RGB values

    are obtained by inverse gamma correction of sRGB), other color spaces use slightly different numbers

    or another standard illuminant (which gives raise to significantly different numbers).

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

*/

template <class T>

class RGB2XYZFunctor

{

  public:

        /** the result's component type

        */

    typedef typename NumericTraits<T>::RealPromote component_type;

        /** the functor's argument type

        */

    typedef TinyVector<T, 3> argument_type;

        /** the functor's result type

        */

    typedef TinyVector<component_type, 3> result_type;

        /** \deprecated use argument_type and result_type

        */

    typedef TinyVector<component_type, 3> value_type;

        /** default constructor.

            The maximum value for each RGB component defaults to 255.

        */

    RGB2XYZFunctor()

    : max_(255.0)

    {}

        /** constructor

            \arg max - the maximum value for each RGB component

        */

    RGB2XYZFunctor(component_type max)

    : max_(max)

    {}

        /** apply the transformation

        */

    result_type operator()(argument_type const & rgb) const

    {

        typedef detail::RequiresExplicitCast<component_type> Convert;

        component_type red = rgb[0] / max_;

        component_type green = rgb[1] / max_;

        component_type blue = rgb[2] / max_;

        result_type result;

        result[0] = Convert::cast(0.412453*red + 0.357580*green + 0.180423*blue);

        result[1] = Convert::cast(0.212671*red + 0.715160*green + 0.072169*blue);

        result[2] = Convert::cast(0.019334*red + 0.119193*green + 0.950227*blue);

        return result;

    }

  private:

    component_type max_;

};

template <class T>

class FunctorTraits<RGB2XYZFunctor<T> >

: public FunctorTraitsBase<RGB2XYZFunctor<T> >

{

  public:

    typedef VigraTrueType isUnaryFunctor;

};

/** \brief Convert non-linear (gamma corrected) R'G'B' into standardized tri-stimulus XYZ.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    The functor realizes the transformation

    \f[

        R'G'B' \Rightarrow RGB \Rightarrow XYZ

    \f]

    See vigra::RGBPrime2RGBFunctor and vigra::RGB2XYZFunctor for a description of the two 

    steps.

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

*/

template <class T>

class RGBPrime2XYZFunctor

{

  public:

        /** the result's component type

        */

    typedef typename NumericTraits<T>::RealPromote component_type;

        /** the functor's argument type

        */

    typedef TinyVector<T, 3> argument_type;

        /** the functor's result type

        */

    typedef TinyVector<component_type, 3> result_type;

        /** \deprecated use argument_type and result_type

        */

    typedef TinyVector<component_type, 3> value_type;

        /** default constructor

            The maximum value for each RGB component defaults to 255.

        */

    RGBPrime2XYZFunctor()

	: gamma_(1.0/ 0.45), max_(component_type(255.0))

    {}

        /** constructor

            \arg max - the maximum value for each RGB component

        */

    RGBPrime2XYZFunctor(component_type max)

	: gamma_(1.0/ 0.45), max_(max)

    {}

        /** apply the transformation

        */

    result_type operator()(argument_type const & rgb) const

    {

        typedef detail::RequiresExplicitCast<component_type> Convert;

        component_type red = detail::gammaCorrection<component_type>(rgb[0]/max_, gamma_);

        component_type green = detail::gammaCorrection<component_type>(rgb[1]/max_, gamma_);

        component_type blue = detail::gammaCorrection<component_type>(rgb[2]/max_, gamma_);

        result_type result;

        result[0] = Convert::cast(0.412453*red + 0.357580*green + 0.180423*blue);

        result[1] = Convert::cast(0.212671*red + 0.715160*green + 0.072169*blue);

        result[2] = Convert::cast(0.019334*red + 0.119193*green + 0.950227*blue);

        return result;

    }

  private:

    double gamma_;

    component_type max_;

};

template <class T>

class FunctorTraits<RGBPrime2XYZFunctor<T> >

: public FunctorTraitsBase<RGBPrime2XYZFunctor<T> >

{

  public:

    typedef VigraTrueType isUnaryFunctor;

};

/** \brief Convert standardized tri-stimulus XYZ into linear (raw) RGB.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    According to ITU-R Recommendation BT.709, the functor realizes the transformation

    \f[

        \begin{array}{rcl}

        R & = & R_{max} (3.2404813432\enspace X - 1.5371515163\enspace Y - 0.4985363262\enspace Z) \\

        G & = & G_{max} (-0.9692549500\enspace X + 1.8759900015\enspace Y + 0.0415559266\enspace Z) \\

        B & = & B_{max} (0.0556466391\enspace X - 0.2040413384\enspace Y + 1.0573110696\enspace Z)

        \end{array}

    \f]

    By default, \f$ R_{max} = G_{max} = B_{max} = 255 \f$. This default can be overridden

    in the constructor. This is the inverse transform of vigra::RGB2XYZFunctor.

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

*/

template <class T>

class XYZ2RGBFunctor

{

    typedef typename NumericTraits<T>::RealPromote component_type;

    component_type max_;

  public:

        /** the functor's argument type. (Actually, the argument type

            is more general: <TT>V</TT> with arbitrary

            <TT>V</TT>. But this cannot be expressed in a typedef.)

        */

    typedef TinyVector<T, 3> argument_type;

        /** the functor's result type

        */

    typedef TinyVector<T, 3> result_type;

        /** \deprecated use argument_type and result_type

        */

    typedef TinyVector<T, 3> value_type;

        /** default constructor.

            The maximum value for each RGB component defaults to 255.

        */

    XYZ2RGBFunctor()

    : max_(255.0)

    {}

        /** constructor

            \arg max - the maximum value for each RGB component

        */

    XYZ2RGBFunctor(component_type max)

    : max_(max)

    {}

        /** apply the transformation

        */

    template <class V>

    result_type operator()(V const & xyz) const

    {

        typedef detail::RequiresExplicitCast<component_type> Convert;

        component_type red   = Convert::cast( 3.2404813432*xyz[0] - 1.5371515163*xyz[1] - 0.4985363262*xyz[2]);

        component_type green = Convert::cast(-0.9692549500*xyz[0] + 1.8759900015*xyz[1] + 0.0415559266*xyz[2]);

        component_type blue  = Convert::cast( 0.0556466391*xyz[0] - 0.2040413384*xyz[1] + 1.0573110696*xyz[2]);

        return value_type(NumericTraits<T>::fromRealPromote(red * max_),

                          NumericTraits<T>::fromRealPromote(green * max_),

                          NumericTraits<T>::fromRealPromote(blue * max_));

    }

};

template <class T>

class FunctorTraits<XYZ2RGBFunctor<T> >

: public FunctorTraitsBase<XYZ2RGBFunctor<T> >

{

  public:

    typedef VigraTrueType isUnaryFunctor;

};

/** \brief Convert standardized tri-stimulus XYZ into non-linear (gamma corrected) R'G'B'.

    <b>\#include</b> \<<a href="colorconversions_8hxx-source.html">vigra/colorconversions.hxx</a>\><br>

    Namespace: vigra

    The functor realizes the transformation

    \f[

        XYZ \Rightarrow RGB \Rightarrow R'G'B'

    \f]

    See vigra::XYZ2RGBFunctor and vigra::RGB2RGBPrimeFunctor for a description of the two 

    steps.

    <b> Traits defined:</b>

    <tt>FunctorTraits::isUnaryFunctor</tt> is true (<tt>VigraTrueType</tt>)

*/

template <class T>

class XYZ2RGBPrimeFunctor

{

    typedef typename NumericTraits<T>::RealPromote component_type;

    double gamma_;

    component_type max_;