T:/Eigene Dateien/Visual Studio 2008/Projects/VisLuFramework/src/Colours.cpp

#include "Colours.h"

#include "math.h"

using namespace Colours;

namespace Colours
{

        float toX(GLubyte R, GLubyte G, GLubyte B)
        {
                return toX(R/255.f, G/255.f, B/255.f);
        }

        float toY(GLubyte R, GLubyte G, GLubyte B)
        {
                return toY(R/255.f, G/255.f, B/255.f);
        }

        float toZ(GLubyte R, GLubyte G, GLubyte B)
        {
                return toZ(R/255.f, G/255.f, B/255.f);
        }

        float toX(float R, float G, float B)
        {
                return (0.4124564f * R + 0.3575761f * G + 0.1804375f * B);
        }

        float toY(float R, float G, float B)
        {
                return (0.2126729f * R + 0.7151522f * G + 0.0721750f * B);
        }

        float toZ(float R, float G, float B)
        {
                return (0.0193339f * R + 0.1191920f * G + 0.9503041f * B);
        }

        float toL(float Y)
        {
                return (116.f * YNormCalc(Y) - 16.f);
        }
        float toA(float X, float Y)
        {
                return (500.f * (XNormCalc(X) - YNormCalc(Y)));
        }
        float toB(float Y, float Z)
        {
                return (200.f * (YNormCalc(Y) - ZNormCalc(Z)));
        }

        float XNormCalc(float X)
        {
                float div = (X / Xn);
                return normCalc(div);

        }
        float YNormCalc(float Y)
        {
                float div = (Y / Yn);
                return normCalc(div);
        }

        float ZNormCalc(float Z)
        {
                float div = (Z / Zn);
                return normCalc(div);
        }

        float normCalc( float div )
        {
                if(div < LAB_COMPARE_VALUE_CONST)
                        return ((24389.f / 27.f * div + 16.f) / 116.f);
                else
                        return pow(div, 1.f / 3.f);
        }


        RGB_Colour toRGB(Lab_Colour colour)
        {
                return toRGB(colour.L, colour.a, colour.b);
        }

        RGB_Colour toRGB(float L, float a, float b)
        {
                float vy = (L + 16.f) / 116.f;
                float vx = a / 500.f + vy;
                float vz = vy - b / 200.f;

                float vx3 = vx * vx * vx;
                float vy3 = vy * vy * vy;
                float vz3 = vz * vz * vz;

                if (vy3 > LAB_COMPARE_VALUE_CONST)
                        vy = vy3;
                else
                        vy = (vy - 16.f / 116.f) / 7.787f;

                if (vx3 > LAB_COMPARE_VALUE_CONST)
                        vx = vx3;
                else
                        vx = (vx - 16.f / 116.f) / 7.787f;

                if (vz3 > LAB_COMPARE_VALUE_CONST)
                        vz = vz3;
                else
                        vz = (vz - 16.f / 116.f) / 7.787f;

                vx *= Xn;
                vz *= Zn;

                float vr = vx *  3.2406f + vy * -1.5372f + vz * -0.4986f;
                float vg = vx * -0.9689f + vy *  1.8758f + vz *  0.0415f;
                float vb = vx *  0.0557f + vy * -0.2040f + vz *  1.0570f;

                clamp(vr, 0.f, 1.f);
                clamp(vg, 0.f, 1.f);
                clamp(vb, 0.f, 1.f);

                return RGB_Colour(GLubyte(255*vr), GLubyte(255*vg), GLubyte(255*vb));
        }

        RGB_Colour linearInterpolationRGB(float interPolBalance, RGB_Colour &start, RGB_Colour &end)
        {
                RGB_Colour colour = RGB_Colour();

                clampInterpolationValue(interPolBalance);

                colour.r = (GLubyte)((1 - interPolBalance) * start.r + (interPolBalance * end.r));
                colour.g = (GLubyte)((1 - interPolBalance) * start.g + (interPolBalance * end.g));
                colour.b = (GLubyte)((1 - interPolBalance) * start.b + (interPolBalance * end.b));

                return colour;
        }

        RGBA_Colour linearInterpolationRGBA(float interPolBalance, RGBA_Colour &start, RGBA_Colour &end)
        {
                RGBA_Colour colour = RGBA_Colour();

                clampInterpolationValue(interPolBalance);

                colour.r = (GLubyte)((1 - interPolBalance) * start.r + (interPolBalance * end.r));
                colour.g = (GLubyte)((1 - interPolBalance) * start.g + (interPolBalance * end.g));
                colour.b = (GLubyte)((1 - interPolBalance) * start.b + (interPolBalance * end.b));
                colour.a = (GLubyte)((1 - interPolBalance) * start.a + (interPolBalance * end.a));

                return colour;
        }


        Lab_Colour linearInterpolationLab(float interPolBalance, Lab_Colour &start, Lab_Colour &end)
        {
                Lab_Colour colour = Lab_Colour();

                clampInterpolationValue(interPolBalance);

                colour.L = (1 - interPolBalance) * start.L + (interPolBalance * end.L);
                colour.a = (1 - interPolBalance) * start.a + (interPolBalance * end.a);
                colour.b = (1 - interPolBalance) * start.b + (interPolBalance * end.b);

                return colour;
        }

        GLubyte linearInterpolationAlpha(float interPolBalance, GLubyte startAlpha, GLubyte endAlpha)
        {
                clampInterpolationValue(interPolBalance);

                return (GLubyte)( (1 - interPolBalance) * startAlpha + (interPolBalance * endAlpha));
        }


        void clampInterpolationValue(float& interPolBalance)
        {
                if(interPolBalance < 0.)
                {
                        interPolBalance = 0.;
                        //std::cout << "Warning - Interpolation value was below 0." << std::endl;
                }
                else if(interPolBalance > 1.)
                {
                        interPolBalance = 1.;
                        //std::cout << "Warning - Interpolation value was above 1." << std::endl;
                }
        }
}