vee_color.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef VEE_COLOR_H
#define VEE_COLOR_H

class VEE_Rgba
{
public:

  VEE_Rgba() {}

  VEE_Rgba(float r, float g, float b, float a = 1.0, float t = 0.5)
    : m_r(r), m_g(g), m_b(b), m_a(a), m_t(t) {}

  ~VEE_Rgba() {}
  
  void set(float r, float g, float b, float a = 1.0, float t = 0.5)
  { m_r = r; m_g = g; m_b = b; m_a = a; m_t = t; }

  template <class S>
  void copy(const S * c, int n) 
  { for(int i=0; i < n; i++) data()[i] = c[i]; }

  float red()   const { return m_r; }
  float green() const { return m_g; }
  float blue()  const { return m_b; }
  float alpha() const { return m_a; }
  float theta() const { return m_t; }

  unsigned getARGB() const;

  void setRed(float r) { m_r = r; }
  void setGreen(float g) { m_g = g; }
  void setBlue(float b) { m_b = b; }
  void setAlpha(float a) { m_a = a; }
  void setTheta(float t) { m_t = t; }

  float *data() { return & m_r; } 
  const float *data() const { return & m_r; } 

  void clampNth(unsigned index, float minVal, float maxVal)
  {
    float &v = data()[index];

    if(v < minVal) v = minVal;
    else if(v > maxVal) v = maxVal;
  }

  void clampRgb(float minVal, float maxVal);
  void clampRgba(float minVal, float maxVal);

  VEE_Rgba farColor() const
  {
    VEE_Rgba c = *this;
    for(int i = 0; i < 3; i++)
      c[i] = (c[i] > 0.5f) ? 0.0f : 1.0f;
    return c;
  }
  
  void normalize()
  { clampRgba(0.0, 1.0); }

  VEE_Rgba mulRgba (float mul) const
  { return VEE_Rgba(m_r * mul, m_g * mul, m_b * mul, m_a * mul, m_t); }

  VEE_Rgba mulRgb (float mul) const
  { return VEE_Rgba(m_r * mul, m_g * mul, m_b * mul, m_a, m_t); }

  VEE_Rgba addRgba (const VEE_Rgba& rgb) const
  { return VEE_Rgba(m_r + rgb.m_r, m_g + rgb.m_g, m_b + rgb.m_b, 
        m_a + rgb.m_a); }

  VEE_Rgba operator * (float mul) const
  { return VEE_Rgba(m_r * mul, m_g * mul, m_b * mul, m_a * mul, m_t * mul); }

  VEE_Rgba operator + (const VEE_Rgba& rgb) const
  { return VEE_Rgba(m_r + rgb.m_r, m_g + rgb.m_g, m_b + rgb.m_b, 
        m_a + rgb.m_a, m_t + rgb.m_t); }
  
  VEE_Rgba operator - (const VEE_Rgba& rgb) const
  { return VEE_Rgba(m_r - rgb.m_r, m_g - rgb.m_g, m_b - rgb.m_b, 
        m_a - rgb.m_a, m_t - rgb.m_t); }
  
  float & operator [] (int n) { return (&m_r)[n]; }
  const float & operator [] (int n) const { return (&m_r)[n]; }

  static const VEE_Rgba White;
  static const VEE_Rgba Gray;
  static const VEE_Rgba Black;
  static const VEE_Rgba BlackTransparent;

  static const VEE_Rgba Red;
  static const VEE_Rgba Green;
  static const VEE_Rgba Blue;

  static const VEE_Rgba Cyan;
  static const VEE_Rgba Magenta;
  static const VEE_Rgba Yellow;

protected:

  float m_r, m_g, m_b, m_a, m_t;
};


class VEE_Hsva
{
public:
  VEE_Hsva(float h = 0.0, float s = 0.0, float v = 0.0, 
     float a = 1.0, float t = 0.5)
    : m_h(h), m_s(s), m_v(v), m_a(a), m_t(t) {}

  ~VEE_Hsva() {}

  float hue() const { return m_h; }
  float saturation() const { return m_s; }
  float value() const { return m_v; }
  float alpha() const { return m_a; }
  float theta() const { return m_t; }

  void setHue(float h) { m_h = h; }
  void setSaturation(float s) { m_s = s; }
  void setValue(float v) { m_v = v; }
  void setAlpha(float a) { m_a = a; }
  void setTheta(float t) { m_t = t; }

  void set(float h, float s, float v, float a = 1.0, float t = 0.5)
  { m_h = h; m_s = s; m_v = v; m_a = a; m_t = t; }

  inline VEE_Rgba rgba() const;

  float * data() { return & m_h; }
  const float * data() const { return & m_h; }

  void normalize(int c) 
  { 
    float tmp = data()[c]; 
    if(tmp < 0.0) tmp = 0.0; 
    else if(tmp > 1.0) tmp = 1.0; 
    data()[c] = tmp;
  }
  void normalize() 
  { 
    for(int i = 0; i < 5; i++) 
      normalize(i); 
  }

  VEE_Rgba operator * (float mul) const
  { return VEE_Rgba(m_h * mul, m_s * mul, m_v * mul, m_a * mul, m_t * mul); }

  VEE_Hsva & operator = (const VEE_Rgba &);

  static const VEE_Hsva Gray;
  static const VEE_Hsva White;
  static const VEE_Hsva Black;

  static const VEE_Hsva Red;
  static const VEE_Hsva Green;
  static const VEE_Hsva Blue;

  static const VEE_Hsva Cyan;
  static const VEE_Hsva Magenta;
  static const VEE_Hsva Yellow;

protected:
  float m_h, m_s, m_v, m_a, m_t;
};

inline VEE_Rgba VEE_Hsva::rgba() const
{
  // void HSVtoRGB( float *r, float *g, float *b, float h, float s, float v )
  
  int i;
  float f, p, q, t;

  float h = m_h, s = m_s, v = m_v;
  float r, g, b;
  
  if( s == 0 ) {
    // achromatic (grey)
    return VEE_Rgba(v, v, v, m_a);
  }

  h *= 6.0f;                        // sector 0 to 5
  i = (int) h; // floor(h);
  f = h - i;                      // factorial part of h
  p = v * ( 1 - s );
  q = v * ( 1 - s * f );
  t = v * ( 1 - s * ( 1 - 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: // = case 0:
    r = v;
    g = t;
    b = p;
    break;    
  }
  
  return VEE_Rgba(r, g, b, m_a, m_t);
}

#endif

---