color.cpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "renderstack/color.hpp"
#include <math.h>

#ifdef  _MSC_VER
#   define isnan(x) _isnan(x)
#endif

namespace renderstack {

float srgb_to_linear(float cs)
{
    float cl = 0.0f;

    RS_ASSERT(cs >= 0.0f);
    RS_ASSERT(cs <= 1.0f);

    if(cs <= 0.04045f)
    {
        cl = cs / 12.92f;
    }
    else
    {
        cl = powf(
            (cs + 0.055f) / 1.055f, 
            2.4f
        );
    }

    return cl;
}

float linear_to_srgb(float cl)
{
    if(cl > 1.0f)
    {
        return 1.0f;
    }
    else if(cl < 0.0)
    {
        return 0.0f;
    }
    else if(cl < 0.0031308f)
    {
        return 12.92f * cl;
    }
    else
    {
        return 1.055f * powf(cl, 0.41666f) - 0.055f;
    }
}

/*
unsigned char rs_float_to_byte(float c)
{
    return (unsigned char)(floorf(255.0f * c + 0.5f));
}*/ 

float color::max_component() const
{
    float max;

    if(r > g)
    {
        max = r;
    }
    else
    {
        max = g;
    }
    if(b > max)
    {
        max = b;
    }
    return max;
}

float color::min_component() const
{
    float min;

    if(r < g)
    {
        min = r;
    }
    else
    {
        min = g;
    }
    if(b < min)
    {
        min = b;
    }
    return min;
}

vec3 color::hsv() const
{
    float h = 0;
    float s = 1.0f;
    float v = 1.0f;
    float max_v;
    float min_v;
    float diff;
    float r_dist;
    float g_dist;
    float b_dist;
    float undefined = 0;

    max_v = max_component();
    min_v = min_component();
    diff  = max_v - min_v;
    v     = max_v;

    if(RS_NEAR_ZERO(max_v))
    {
        s = 0;
    }
    else
    {
        s = diff / max_v;
    }
    if(s == 0)
    {
        h = undefined;
    }
    else
    {
        r_dist = (max_v - r) / diff;
        g_dist = (max_v - g) / diff;
        b_dist = (max_v - b) / diff;
        if(r == max_v)
        {
            h = b_dist - g_dist;
        }
        else
        {
            if(g == max_v)
            {
                h = 2.0f + r_dist - b_dist;
            }
            else
            {
                if(b == max_v)
                {
                    h = 4.0f + g_dist - r_dist;
                }
            }
        }
        h = h * 60.0f;
        if(h < 0)
        {
            h += 360.0f;
        }
    }
    return vec3(h, s, v);
}

color make_color_from_hsv(vec3 const &hsv)
{
    float h = hsv.x;
    float s = hsv.y;
    float v = hsv.z;
    float r = 0.0f;
    float g = 0.0f;
    float b = 0.0f;
    float f;
    float p;
    float q;
    float t;
    int   i;

    if(s == 0.0f)
    {
        r = v;
        g = v;
        b = v;
    }
    else
    {
        if(h == 360.0f)
        {
            h = 0.0;
        }
        h = h / 60.0f;
        i = (int)(h);
        f = h - i;
        p = v * (1.0f -  s             );
        q = v * (1.0f - (s *         f ));
        t = v * (1.0f - (s * (1.0f - f)));
        switch(i)
        {
            case 0:
            {
                r = v;
                g = t;
                b = p;
                break;
            }
            case 1:
            {
                r = q;
                g = v;
                b = p;
                break;
            }
            case 2:
            {
                r = p;
                g = v;
                b = t;
                break;
            }
            case 3:
            {
                r = p;
                g = q;
                b = v;
                break;
            }
            case 4:
            {
                r = t;
                g = p;
                b = v;
                break;
            }
            case 5:
            {
                r = v;
                g = p;
                b = q;
                break;
            }
            default:
            {
                r = 1.0f;
                b = 1.0f;
                b = 1.0f;
                break;
            }
        }
    }
    return color(r, g, b);
}

}