---

Colour.cc

Go to the documentation of this file.

/*
    File:           Colour.cc

    Function:       Implements Colour.h

    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott

    Notes:          Useful info on colour (Gamma & Colour FAQs):                    
                        http://www.inforamp.net/~poynton/notes/colour_and_gamma
                    Useful info on colour transforms:
                        http://www.sgi.com/grafica/matrix/index.html
                        http://www.sgi.com/grafica/interp/index.html
*/

#include "gcl/Colour.h"
#include "gcl/Geometry.h"

Colour &ClipColour(Colour &c)
{
    if (c[0] > 1.0) c[0] = 1.0;
    if (c[0] < 0.0) c[0] = 0.0;
    if (c[1] > 1.0) c[1] = 1.0;
    if (c[1] < 0.0) c[1] = 0.0;
    if (c[2] > 1.0) c[2] = 1.0;
    if (c[2] < 0.0) c[2] = 0.0;

    return(c);
}

Colour &ClipColourZero(Colour &c)
{
    if (c[0] < 0.0) c[0] = 0.0;
    if (c[1] < 0.0) c[1] = 0.0;
    if (c[2] < 0.0) c[2] = 0.0;

    return(c);
}

Colour HSVCol(ClrReal hue, ClrReal saturation, ClrReal value)
// Convert HSV to RGB...
{
    hue =       hue - 360 * floor(hue / 360);
    Int         face = (Int) floor(hue / 120);
    ClrReal     d = (hue - 120 * face) / 60;
    Colour      result;

    if (face == 3)
        face--;
    
    result[face] = value;
    
    if (d > 1)
    {
        result[(face + 1) % 3] = value * (1 - saturation * (2 - d));
        result[(face + 2) % 3] = value * (1 - saturation);
    }
    else
    {
        result[(face + 1) % 3] = value * (1 - saturation);
        result[(face + 2) % 3] = value * (1 - saturation * d);
    }

    return(result);
}

// --- Colour transformations ----------------

ClrTrans RGBScale(ClrReal rscale, ClrReal gscale, ClrReal bscale)
{
    return(HScale4f(Colour(rscale, gscale, bscale)));
}

ClrTrans RGBToLum()
{
    ClrTrans result;
    
    result[0] = Vec4f(cRGBToLum, 0.0);
    result[1] = Vec4f(cRGBToLum, 0.0);
    result[2] = Vec4f(cRGBToLum, 0.0);
    result[3] = vl_w;
    
    return(result);
}

ClrTrans RGBSaturate(ClrReal sat)
{
    // saturate by interpolating with greyscale pixel
    return(Mix(RGBToLum(), ClrTrans(vl_I), sat));
}

ClrTrans RGBReplace(const Colour &c)
// replace with colour c
{
    ClrTrans result = vl_0;

    result[0][3] = c[0];
    result[1][3] = c[1];
    result[2][3] = c[2];
    result[3][3] = 1.0;

    return(result);
}

ClrTrans RGBPixelMix(ClrReal mix, const Colour &c)
// If you use c = cBlack, mix < 1.0 will darken the image,
// and mix > 1.0 will lighten it.
// If you use the average colour of an image, c = img.AverageColour(),
// mix < 1.0 will lower contrast, mix > 1.0 raise it.
{
    return(Mix(RGBReplace(c), ClrTrans(vl_I), mix));
}

ClrTrans RGBOffset(const Colour &c)
{
    return(HTrans4f(c));
}

ClrTrans RGBHueRotate(ClrReal degrees)
{
    ClrTrans    trans, shear;
    Colour      newLum;
    
    // align grey vector with z axis (vl_z)
    trans = HRot4f(norm(Colour(1, -1, 0)), DegsToRads(45));

    // what is the luminance vector in the new space?
    newLum = xform(trans, cRGBToLum);
    // shear so plane parallel to this vector is now horizontal (x-y)
    // if dot(x, newLum) = c, (shear * x)[2] * newLum[2] = c,
    // i.e. is constant
    shear = vl_I;
    shear[2][0] = newLum[0] / newLum[2];
    shear[2][1] = newLum[1] / newLum[2];
    trans = xform(trans, shear);

    // rotate the hue!
    trans = xform(trans, HRot4f(vl_z, DegsToRads(degrees))); 

    // unshear
    shear[2][0] = -shear[2][0];
    shear[2][1] = -shear[2][1];
    trans = xform(trans, shear);
    // unrotate
    trans = xform(trans, HRot4f(norm(Colour(1, -1, 0)), DegsToRads(-45)));

    return(trans);
}

Colour YUVToRGB(const Colour &yuv)
{
    Colour  rgb;

    rgb[0] = yuv[0] + 1.4075 * (yuv[2] - 0.5);
    rgb[1] = yuv[0] - 0.3455 * (yuv[1] - 0.5) - 0.7169 * (yuv[2] - 0.5);
    rgb[2] = yuv[0] + 1.7790 * (yuv[1] - 0.5);

    return(rgb);
}

Colour RGBToYUV(const Colour &rgb)
{
    Colour  yuv;

    yuv[0] = rgb[0] *   0.299 + rgb[1] *   0.587 + rgb[2] *  0.114;
    yuv[1] = rgb[0] * -0.1687 + rgb[1] * -0.3313 + rgb[2] *  0.500 + 0.5;
    yuv[2] = rgb[0] *   0.500 + rgb[1] * -0.4187 + rgb[2] * -0.0813 + 0.5;

    return(yuv);
}

#ifdef CL_TMPL_INST
template class Array<Colour>;
#endif

---