---

glt/color.cpp

Go to the documentation of this file.

#include "color.h"

#include <string>

#include <cassert>
#include <cstdio>

using namespace std;

#include <glt/rgb.h>
#include <glt/error.h>
#include <glt/gl.h>

#include <misc/string.h>
#include <math/matrix4.h>

GltColor::GltColor()
: Vector(Vector0), _alpha(1.0)
{
}

GltColor::GltColor(const float red,const float green,const float blue,const float alpha)
: Vector(red,green,blue), _alpha(alpha)
{
}

GltColor::GltColor(const double red,const double green,const double blue,const double alpha)
: Vector(red,green,blue), _alpha(alpha)
{
}

GltColor::GltColor(const int red,const int green,const int blue,const int alpha)
: Vector(red,green,blue), _alpha(alpha)
{
}

GltColor::GltColor(const GltColor &col,const real alpha)
: Vector(col), _alpha(alpha)
{
}

GltColor::GltColor(const Vector &col)
: Vector(col), _alpha(1.0)
{
}

GltColor::GltColor(const GltColor &col)
: Vector(col), _alpha(col._alpha)
{
}

GltColor::GltColor(const string &name)
: _alpha(1.0)
{
    // Convert from HTML style color string

    if (name.size()>=7)
    {
        if (name[0]=='#')
        {
            const int r = fromHex4(name[1])<<4 | fromHex4(name[2]);
            const int g = fromHex4(name[3])<<4 | fromHex4(name[4]);
            const int b = fromHex4(name[5])<<4 | fromHex4(name[6]);

            red()   = real(r)/255.0;
            green() = real(g)/255.0;
            blue()  = real(b)/255.0;

            return;
        }
    }

    // Do a binary search through the list of names

    int i=0;
    int j=_rgbSize;

    for (;;)
    {
        int k = ((j-i)>>1)+i;
        const int res = strcmp(name.c_str(),_rgbName[k]);

        if (res<0)
            j = k;
        else
            if (res>0)
                i = k+1;
            else
            {
                operator=(*_rgbValue[k]);
                return;
            }

        if (i==k && j==k || i==_rgbSize)
        {
            assert(!"Color not found");
            operator=(::black);
            return;
        }
    }
}

GltColor::~GltColor()
{
}

GltColor &
GltColor::operator=(const GltColor &col)
{
    red()   = col.red();
    green() = col.green();
    blue()  = col.blue();
    alpha() = col.alpha();

    return *this;
}

void 
GltColor::glColor() const
{
    #ifdef GLT_FAST_FLOAT
    ::glColor4f(x(),y(),z(),_alpha);
    #else
    ::glColor4d(x(),y(),z(),_alpha);
    #endif
}

void 
GltColor::glColor(const GLdouble alpha) const
{
    #ifdef GLT_FAST_FLOAT
    ::glColor4f(x(),y(),z(),alpha);
    #else
    ::glColor4d(x(),y(),z(),alpha);
    #endif
}

void 
GltColor::glClearColor() const
{
    ::glClearColor(x(),y(),z(),_alpha);
}

void
GltColor::glFogColor() const
{
    const float col[4] = { x(), y(), z(), _alpha };
    ::glFogfv(GL_FOG_COLOR, col);
}

void 
GltColor::glMaterial(const GLenum face,const GLenum field) const
{
    assert(face==GL_FRONT_AND_BACK || face==GL_FRONT || face==GL_BACK);
    assert(field==GL_AMBIENT || field==GL_DIFFUSE || field==GL_SPECULAR || field==GL_EMISSION);

    GLERROR

    const GLfloat val[4] = { x(), y(), z(), _alpha };
    ::glMaterialfv(face,field,val);

    GLERROR
}

void 
GltColor::glGetMaterial(const GLenum face,const GLenum field)
{
    assert(face==GL_FRONT_AND_BACK || face==GL_FRONT || face==GL_BACK);
    assert(field==GL_AMBIENT || field==GL_DIFFUSE || field==GL_SPECULAR || field==GL_EMISSION);

    GLERROR

    GLfloat val[4];
    ::glGetMaterialfv(face,field,val);
    x() = val[0]; y() = val[1]; z() = val[2]; _alpha = val[3];

    GLERROR
}

void 
GltColor::glLight(const GLenum light,const GLenum field) const
{
    assert(light>=GL_LIGHT0 && light<=GL_LIGHT7);
    assert(field==GL_AMBIENT || field==GL_DIFFUSE || field==GL_SPECULAR || field==GL_POSITION || field==GL_SPOT_DIRECTION);

    GLERROR

    const GLfloat val[4] = { x(), y(), z(), _alpha };
    ::glLightfv(light,field,val);

    GLERROR
}

void 
GltColor::glGetLight(const GLenum light,const GLenum field)
{
    assert(light>=GL_LIGHT0 && light<=GL_LIGHT7);
    assert(field==GL_AMBIENT || field==GL_DIFFUSE || field==GL_SPECULAR || field==GL_POSITION || field==GL_SPOT_DIRECTION);

    GLERROR

    GLfloat val[4];
    ::glGetLightfv(light,field,val);
    x() = val[0]; y() = val[1]; z() = val[2]; _alpha = val[3];

    GLERROR
}

      real &GltColor::red()    { return x();    }
      real &GltColor::green()  { return y();    }
      real &GltColor::blue()   { return z();    }
      real &GltColor::alpha()  { return _alpha; }

const real &GltColor::red()    const { return x();    }
const real &GltColor::green()  const { return y();    }
const real &GltColor::blue()   const { return z();    }
const real &GltColor::alpha()  const { return _alpha; }

const real 
GltColor::brightness() const
{
    // (from Colorspace FAQ)
    //  Y = 0.212671 * R + 0.715160 * G + 0.072169 * B;
  
    return 0.212671*red() + 0.715160*green() + 0.072169*blue();
}

void
GltColor::toHSV(real &h,real &s,real &v) const
{
    // Based on http://www.cs.rit.edu/~ncs/color/t_convert.html

    const real min = MIN(red(),MIN(green(),blue()));
    const real max = MAX(red(),MAX(green(),blue()));

    v = max;
    
    const real delta = max-min;

    if (max!=0.0)
        s = delta/max;
    else 
    {
        // Black
        h = 0.0;
        s = 0.0;
        return;
    }

    if (delta==0.0) 
    {
        h = 0.0;
        s = 0.0;
    }
    else
        if (red()==max)
            h = (green()-blue()) / delta;           // between yellow & magenta
        else 
            if(green()==max)
                h = 2.0 + (blue()-red())/delta;     // between cyan & yellow
            else
                h = 4.0 + (red()-green())/delta;    // between magenta & cyan

    // Scale h to degrees
    
    h *= 60;

    if (h<0.0)
        h += 360.0;
}

void
GltColor::fromHSV(const real h,const real s,const real v)
{
    // Based on http://www.cs.rit.edu/~ncs/color/t_convert.html

    // Achromatic case (grey)

    if (s==0.0) 
    {
        red() = green() = blue() = v;
        return;
    }

        
    const real hue = h/60.0;    // sector 0 to 5
    const int  i   = int(floor(hue));
    const real f   = hue-i;     // factorial part of h
    const real p = v*(1-s);
    const real q = v*(1-s*f);
    const real t = v*(1-s*(1-f));

    switch (i) 
    {
    case 0:
        red()   = v;
        green() = t;
        blue()  = p;
        break;
    case 1:
        red()   = q;
        green() = v;
        blue()  = p;
        break;
    case 2:
        red()   = p;
        green() = v;
        blue()  = t;
        break;
    case 3:
        red()   = p;
        green() = q;
        blue()  = v;
        break;
    case 4:
        red()   = t;
        green() = p;
        blue()  = v;
        break;
    default:        // case 5:
        red()   = v;
        green() = p;
        blue()  = q;
        break;
    }
}

//

const bool 
GltColor::isGrey() const
{
    return red()==green() && green()==blue();
}

std::string 
GltColor::html() const
{
    const int r = CLAMP(int(red()  *255.0+0.5),0,255);
    const int g = CLAMP(int(green()*255.0+0.5),0,255);
    const int b = CLAMP(int(blue() *255.0+0.5),0,255);

    char buffer[8];
    sprintf(buffer,"#%02X%02X%02X",r,g,b);
    return buffer;
}

bool GltColor::operator< (const GltColor &c) const
{
    if (red()!=c.red())     return red()<c.red();
    if (green()!=c.green()) return green()<c.green();
    return blue()<c.blue();
}

bool GltColor::operator> (const GltColor &c) const
{
    if (red()!=c.red())     return red()>c.red();
    if (green()!=c.green()) return green()>c.green();
    return blue()>c.blue();
}

bool GltColor::operator==(const GltColor &c) const
{
    return red()==c.red() && green()==c.green() && blue()==c.blue();
}

GltColor operator*(const GltColor  &c, const real x)
{
    return GltColor(c.red()*x,c.green()*x,c.blue()*x,c.alpha()*x);
}

GltColor operator/(const GltColor  &c, const real x)
{
    const double s = 1.0/x;
    return GltColor(c.red()*s,c.green()*s,c.blue()*s,c.alpha()*s);
}

GltColor operator*(const real      x, const GltColor &c)
{
    return GltColor(c.red()*x,c.green()*x,c.blue()*x,c.alpha()*x);
}

GltColor operator+(const GltColor &c1, const GltColor &c2)
{
    return GltColor(c1.red()+c2.red(),c1.green()+c2.green(),c1.blue()+c2.blue(),c1.alpha()+c2.alpha());
}

GltColor operator-(const GltColor &c1, const GltColor &c2)
{
    return GltColor(c1.red()-c2.red(),c1.green()-c2.green(),c1.blue()-c2.blue(),c1.alpha()-c2.alpha());
}


GltClearColor::GltClearColor(bool getIt)
{
    if (getIt)
        get();
}

GltClearColor::~GltClearColor()
{
}

void 
GltClearColor::get()
{
    GLdouble tmp[4];
    glGetDoublev(GL_COLOR_CLEAR_VALUE,tmp);
    x() = tmp[0];
    y() = tmp[1];
    z() = tmp[2];
}
    
void 
GltClearColor::set() const
{
    GltColor::glClearColor();
}

void 
GltClearColor::set(const GltColor &col)
{
    x() = col.x();
    y() = col.y();
    z() = col.z();
    GltColor::glClearColor();
}

---