|| || || || || || || ||

---

ColConvert.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Element_ColConvert_h
#define Impala_Core_Array_Element_ColConvert_h

#include "Core/Array/Element/ArithTypes.h"
#include "Core/Array/Element/E1Sum.h"
#include "Core/Array/Element/E1Min.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Element
{


// RGB - CMY

inline Vec3Real64
ColRGB2CMY(const Vec3Real64& v)
{
    return Vec3Real64(1, 1, 1) - v;
}

inline Vec3Real64
ColCMY2RGB(const Vec3Real64& v)
{
    return Vec3Real64(1, 1, 1) - v;
}

// RGB - XYZ 1931 through Rec709

inline Vec3Real64
ColRGB2XYZ(const Vec3Real64& v)
{
    // Using Rec709
    // X = 100 * (0.412452 R/255 + 0.357580 G/255 + 0.180423 B/255)
    // Y = 100 * (0.212671 R/255 + 0.715160 G/255 + 0.072169 B/255)
    // Z = 100 * (0.019334 R/255 + 0.119193 G/255 + 0.950227 B/255)

    double X = v.X() * 0.161746 + v.Y() * 0.140227 + v.Z() * 0.070754;
    double Y = v.X() * 0.083400 + v.Y() * 0.280455 + v.Z() * 0.028301;
    double Z = v.X() * 0.007582 + v.Y() * 0.046742 + v.Z() * 0.372638;
    
    return Vec3Real64(X, Y, Z);
}

inline Vec3Real64
ColXYZ2RGB(const Vec3Real64& v)
{
    // Using rec709
    // R = 255 * (3.240479 X/100 - 1.537150 * Y/100 - 0.498535 * Z/100)
    // G = 255 * (-0.969256 * X/100 + 1.875992 * Y/100 + 0.041556 * Z/100)
    // B = 255 * (0.055648 * Z/100 - 0.204043 * Y/100 + 1.057311 * Z/100)

    double R = v.X() * 8.25322145 + v.Y() * -3.9197325 + v.Z() * -1.27126425;
    double G = v.X() * -2.4716028 + v.Y() * 4.7837796 + v.Z() * 0.1059678;
    double B = v.X() * 0.1419024 + v.Y() * -0.52030965 + v.Z() * 2.69614305;

    return Vec3Real64(R, G, B);
}

// CMY - XYZ 1931 through Rec709

inline Vec3Real64
ColCMY2XYZ(const Vec3Real64& v)
{
    // Using rec709
    // R = 1-C, G = 1-M, B = 1-Y

    double X = 95.045385
        - v.X() * 0.161746 - v.Y() * 0.140227 - v.Z() * 0.070754;
    double Y = 100.0
        - v.X() * 0.083400 - v.Y() * 0.280455 - v.Z() * 0.028301;
    double Z = 108.87531
        - v.X() * 0.007582 - v.Y() * 0.046742 - v.Z() * 0.372638;

    return Vec3Real64(X, Y, Z);
}

inline Vec3Real64
ColXYZ2CMY(const Vec3Real64& v)
{
    // Using rec709
    // C = 1-R, M = 1-G, Y = 1-B

    double C = 255.0
        - v.X() * 8.25322145 - v.Y() * -3.9197325 - v.Z() * -1.27126425;
    double M = 255.0
        - v.X() * -2.4716028 - v.Y() * 4.7837796 - v.Z() * 0.1059678;
    double Y = 255.0
        - v.X() * 0.1419024 - v.Y() * -0.52030965 - v.Z() * 2.69614305;

    return Vec3Real64(C, M, Y);
}

// Lab - XYZ 1931
// Using D65 (95.0, 100.0, 108.9) as ref white
const double Xn = 95.0;
const double Yn = 100.0;
const double Zn = 108.9;

static inline double
Y2L(double YYn)
{
    return (YYn > 0.008856) ? 116.0 * pow(YYn , 1.0 / 3.0) - 16.0
                            : 903.3 * YYn;
}

static inline double
L2Y(double L)
{
    return (L > 7.999625) ? Yn * pow((L + 16.0) / 116.0, 3.0)
                          : Yn * (L / 903.3);
}

static inline double
f4ab(double r)
{
    return (r > 0.008856) ? pow(r, 1.0 / 3.0) 
                          : 7.787 * r + (16.0 / 116.0);
}

static inline double
fInv4ab(double r, double Ltmp)
{
    return (Ltmp > 0.206893) ? pow(r, 3.0)
                             : (r - 16.0 / 116.0) / 7.787;
}

inline Vec3Real64
ColLab2XYZ(const Vec3Real64& v)
{
    double Y = L2Y(v.X());

    double Ltmp = (v.X() + 16.0) / 116.0; // == f(Y / Yn)
    double atmp = Ltmp + v.Y() / 500.0;
    double X = Xn * fInv4ab(atmp, Ltmp);
    double btmp = Ltmp - v.Z() / 200.0;
    double Z = Zn * fInv4ab(btmp, Ltmp);
    return Vec3Real64(X, Y, Z);
}

inline Vec3Real64
ColXYZ2Lab(const Vec3Real64& v)
{
    Vec3Real64 n = v / Vec3Real64(Xn, Yn, Zn);

    double L = Y2L(n.Y());

    double fnX = f4ab(n.X());
    double fnY = f4ab(n.Y());
    double fnZ = f4ab(n.Z());
        
    double a = 500.0 * (fnX - fnY);
    double b = 200.0 * (fnY - fnZ);
    return Vec3Real64(L, a, b);
}


// Luv - XYZ 1931
// Using D65 (95.0, 100.0, 108.9) as ref white

inline Vec3Real64
ColLuv2XYZ(const Vec3Real64& v)
{
    double Y = L2Y(v.X());
    double tmp = Xn + 15 * Yn + 3 * Zn;
    double unp = 4 * Xn / tmp;
    double vnp = 9 * Yn / tmp;
    double Q = v.Y() / (13 * v.X()) + unp;
    double R = v.Z() / (13 * v.X()) + vnp;
    double A = 3 * Y * (5 * R - 3);
    double Z = ((Q - 4) * A - 15 * Q * R * Y) / (12 * R);
    double X = -(A / R + 3 * Z);
    return Vec3Real64(X, Y, Z);
}

inline Vec3Real64
ColXYZ2Luv(const Vec3Real64& v)
{
    double L = Y2L(v.Y() / Yn);
    double tmp = Xn + 15 * Yn + 3 * Zn;
    double unp = 4 * Xn / tmp;
    double vnp = 9 * Yn / tmp;
    tmp = v.X() + 15 * v.Y() + 3 * v.Z();
    double up = 4 * v.X() / tmp;
    double vp = 9 * v.Y() / tmp;
    double us = 13 * L * (up - unp);
    double vs = 13 * L * (vp - vnp);
    return Vec3Real64(L, us, vs);
}


// RGB - HSI
#ifdef PI
#undef PI
#endif
#define PI          3.1415926536
#define TWO_PI      6.2831853072     /* PI * 2   */
#define PI_3        1.0471975512     /* PI/3     */
#define TWO_PI_3    2.0943951024     /* 2 * PI/3 */
#define FOUR_PI_3   4.1887902048     /* 4 * PI/3 */
#define FIVE_PI_3   5.2359877560     /* 5 * PI/3 */

inline Vec3Real64
ColRGB2HSI(const Vec3Real64& v)
{
    double I = E1Sum(v) / 3.0;
    double S = (I == 0.0) ? 1.0 : 1.0 - (E1Min(v) / I);
    double H;
    if (v.X() == v.Y() && v.Y() == v.Z())
        H = 0.0;
    else {
        double tmp = acos((0.5*(v.X()-v.Y()+v.X()-v.Z())) / 
                sqrt((v.X()-v.Y())*(v.X()-v.Y())+(v.X()-v.Z())*(v.Y()-v.Z())));
        H = (v.Y() > v.Z()) ? tmp : TWO_PI - tmp;
    }
    return Vec3Real64(H, S, I);
}

//michiel: huh? the range of this function seems tot be [0..3] for R, G and B... what does that mean?
// does convert to normalised RGB? in that case why isn't RGB2rgb in chorus?
inline Vec3Real64
ColHSI2RGB(const Vec3Real64& v)
{
    double H = v.X();
    double S = v.Y();
    double I = v.Z();
    double Htmp;
    double R,B,G;
    
    if (H == 0.0)
        R = G = B = I;
    else if (H > 0.0 && H < TWO_PI_3 ) {
        Htmp = 1 / sqrt(3.0) * tan(H - PI_3);
        B = (1.0 - S) * I;
        G = (1.5 + 1.5*Htmp ) * I - ((0.5 + 1.5*Htmp) * B);
        R = 3.0 * I - G - B;
    }
    else if (H >= TWO_PI_3 && H < FOUR_PI_3) {
        Htmp = 1 / sqrt(3.0) * tan(H - PI);
        R = (1.0 - S) * I;
        B = (1.5 + 1.5*Htmp ) * I - ((0.5 + 1.5*Htmp) * R);
        G = 3.0 * I - B - R;
    }
    else { 
        Htmp = 1 / sqrt(3.0) * tan(H - FIVE_PI_3);
        G = (1.0 - S) * I;
        R = (1.5 + 1.5*Htmp ) * I - ((0.5 + 1.5*Htmp) * G);
        B = 3.0 * I - R - G;
    }
    return Vec3Real64(R, G, B);
}

#undef PI
#undef TWO_PI
#undef PI_3
#undef TWO_PI_3
#undef FOUR_PI_3
#undef FIVE_PI_3

// XYZ 1931 - OOO (Geusebroek Thesis)

inline Vec3Real64
ColXYZ2OOO(const Vec3Real64& v)
{
    double E   = v.X() *-0.004362 + v.Y() * 0.010954 + v.Z() * 0.003408;
    double El  = v.X() * 0.004055 + v.Y() * 0.001220 + v.Z() *-0.004120;
    double Ell = v.X() * 0.011328 + v.Y() *-0.011755 + v.Z() *-0.000664;

    return Vec3Real64(E, El, Ell);
}

// OOO - XYZ 1931 (Geusebroek Thesis)

inline Vec3Real64
ColOOO2XYZ(const Vec3Real64& v)
{
    double X = v.X() * 103.337 + v.Y() * 68.824 + v.Z() * 103.435;
    double Y = v.X() * 92.297  + v.Y() * 74.949 + v.Z() * 8.714;
    double Z = v.X() * 129.034 + v.Y() * -152.804 + v.Z() * 104.383;

    return Vec3Real64(X, Y, Z);
}

// RGB - OOO through Rec709

inline Vec3Real64
ColRGB2OOO(const Vec3Real64& v)
{
    double E   = v.X() * 0.000233846 + v.Y() * 0.00261968 + v.Z() * 0.00127135;
    double El  = v.X() * 0.000726333 + v.Y() * 0.000718106+ v.Z() * -0.00121377;
    double Ell = v.X() * 0.000846833 + v.Y() * -0.00173932+ v.Z() * 0.000221515;

    return Vec3Real64(E, El, Ell);
}

// OOO - RGB through Rec709

inline Vec3Real64
ColOOO2RGB(const Vec3Real64& v)
{
    double R = v.X() * 328.084 + v.Y() * 469.182 + v.Z() * 687.853;
    double G = v.X() * 199.794 + v.Y() * 172.242 + v.Z() * -202.904;
    double B = v.X() * 314.533 + v.Y() * -441.212 + v.Z() * 291.574;

    return Vec3Real64(R, G, B);
}


// RGB - 24bit

inline int
ColRGB2int(const Vec3Real64& v)
{
    int x = (int) (v.X());
    if (x < 0)
        x = 0;
    else {
        if (x > 255)
            x = 255;
    }
    int y = (int) (v.Y());
    if (y < 0)
        y = 0;
    else {
        if (y > 255)
            y = 255;
    }
    int z = (int) (v.Z());
    if (z < 0)
        z = 0;
    else {
        if (z > 255)
            z = 255;
    }
    return (255 << 24) | (x << 16) | (y << 8) | z;
}

inline int
ColRGB2int(const Vec3Int32& v)
{
    int x = v.X();
    if (x < 0)
        x = 0;
    else {
        if (x > 255)
            x = 255;
    }
    int y = v.Y();
    if (y < 0)
        y = 0;
    else {
        if (y > 255)
            y = 255;
    }
    int z = v.Z();
    if (z < 0)
        z = 0;
    else {
        if (z > 255)
            z = 255;
    }
    return (255 << 24) | (x << 16) | (y << 8) | z;
}

} // namespace Element
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---