Merge lp:~unity-team/nux/nux.color-class into lp:nux/2.0

[Jay Taoko]

* nux::Color is now a class rather than a struct
* Added support for pre-multiplied color
* Added tests for Color class
* Cleanup obsolete function calls

[lp:~unity-team/nux/nux.color-class]

557. By Gord Allott on 2012-02-07

Adds very basic completion support to nux,
Essentially just adds text to the end of the TextEntry widget without any real logic as the logic we want for unity is
different from what we want for a toolkit

Basically just a visual change to allow hud to offer completion. Fixes: . Approved by Tim Penhey.

558. By Thomi Richards on 2012-02-08

Moved keycode definitions from unity into nux, where they belong.. Fixes: . Approved by Jay Taoko.

559. By Jason Smith on 2012-02-09

Improves dash startup times dramatically.. Fixes: . Approved by Thomi Richards.

[Tim Penhey (thumper)]

If you are changing the copyright, use
  2010-2012
to extend the date not replace.

I don't think that SetPremultiplied should take any params.

void Color::Premultiply()
{
  if (premultiplied_) return;

  red *= alpha;
  blue *= alpha;
  green *= alpha;
  premultiplied_ = true;
}

Then inside GetPremultiplied, then use:

  Color c(*this);
  c.Premultiply();
  return c;

Should the assignment operator also check operator ==?

What about the operators, do they care?

Re: tests,

perhaps we should have some conversion functions tested for well known HSV, RGB, and HLS values.

review: Needs Fixing

[Jay Taoko (jaytaoko)]

> If you are changing the copyright, use
> 2010-2012
> to extend the date not replace.
>
> I don't think that SetPremultiplied should take any params.
>

Why? GetPremultiply do not take parameters. I don't see the issue with SetPremultiply. You don't have to use it; it is there if you need it.

> void Color::Premultiply()
> {
> if (premultiplied_) return;
>
> red *= alpha;
> blue *= alpha;
> green *= alpha;
> premultiplied_ = true;
> }
>
> Then inside GetPremultiplied, then use:
>
> Color c(*this);
> c.Premultiply();
> return c;
>
> Should the assignment operator also check operator ==?

The implicit assignment operator and copy constructor will work fine.
Yes, operator == has been fixed.

> What about the operators, do they care?

Other operators are left to perform as usual.

> Re: tests,
>
> perhaps we should have some conversion functions tested for well known HSV,
> RGB, and HLS values.

I have taken random reference values from generally accepted tools such as Photoshop and used Nux's internal conversion routines to match them closely. It is enough to start. More can be added later.

[lp:~unity-team/nux/nux.color-class]

560. By Jason Smith on 2012-02-09

Makes nux lazy load some of its less frequently use, yet more expensive objects. Fixes: . Approved by Jay Taoko, Thomi Richards.

561. By Jay Taoko on 2012-02-09

* Expose the StaticText device texture
* Code style fixes. Fixes: . Approved by Jason Smith.

[Jay Taoko (jaytaoko)]

review: Approve

[lp:~unity-team/nux/nux.color-class]

562. By Jay Taoko on 2012-02-10

* Merged with Nux trunk
* Updated ABI version

[Jay Taoko (jaytaoko)]

review: Needs Fixing

[Jay Taoko (jaytaoko)]

review: Approve

=== modified file 'Nux/ColorEditor.cpp'
--- Nux/ColorEditor.cpp	2011-12-29 18:06:53 +0000
+++ Nux/ColorEditor.cpp	2012-02-10 04:48:18 +0000
@@ -504,7 +504,10 @@
       Geometry basepickermarker = Geometry(channel_area_->GetBaseX(), channel_area_->GetBaseY() + m_VertMarkerPosition.y, 5, 5);
 
       Color color(rgb_.red, rgb_.green, rgb_.blue);
-      GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, OneMinusLuminance(rgb_));
+      float luma = color::LumaRed * rgb_.red + color::LumaGreen * rgb_.green + color::LumaBlue * rgb_.blue;
+      Color one_minus_luma(1.0f - luma, 1.0f - luma, 1.0f - luma);
+
+      GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, one_minus_luma);
 
       GetPainter().Paint2DQuadColor(graphics_engine, channel_area_->GetGeometry(), BaseChannelTop, BaseChannelBottom, BaseChannelBottom, BaseChannelTop);
       // Draw Marker on Base Chanel Area
@@ -556,7 +559,10 @@
         GetPainter().Paint2DQuadVGradient(graphics_engine, p, Color(1.0f * v, 1.0f * v, s * v), Color(1.0f * v, s * v, s * v));
 
         Geometry pickermarker = Geometry(GetBaseX() + m_MarkerPosition.x - 2, GetBaseY() + m_MarkerPosition.y - 2, 5, 5);
-        GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, OneMinusLuminance(rgb_));
+
+        float luma = color::LumaRed * rgb_.red + color::LumaGreen * rgb_.green + color::LumaBlue * rgb_.blue;
+        Color one_minus_luma(1.0f - luma, 1.0f - luma, 1.0f - luma);
+        GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, one_minus_luma);
       }
       else if (color_channel_ == color::SATURATION)
       {
@@ -578,7 +584,11 @@
 
         //Geometry pickermarker = Geometry(GetX() + x - 2, GetY() + y -2, 5, 5);
         Geometry pickermarker = Geometry(GetBaseX() + m_MarkerPosition.x - 2, GetBaseY() + m_MarkerPosition.y - 2, 5, 5);
-        GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, OneMinusLuminance(rgb_));
+
+        float luma = color::LumaRed * rgb_.red + color::LumaGreen * rgb_.green + color::LumaBlue * rgb_.blue;
+        Color one_minus_luma(1.0f - luma, 1.0f - luma, 1.0f - luma);
+
+        GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, one_minus_luma);
         GetPainter().Paint2DQuadColor(graphics_engine, channel_area_->GetGeometry(), BaseChannelTop, BaseChannelBottom, BaseChannelBottom, BaseChannelTop);
       }
       else if (color_channel_ == color::VALUE)
@@ -598,7 +608,11 @@
 
         //Geometry pickermarker = Geometry(GetX() + x - 2, GetY() + y -2, 5, 5);
         Geometry pickermarker = Geometry(GetBaseX() + m_MarkerPosition.x - 2, GetBaseY() + m_MarkerPosition.y - 2, 5, 5);
-        GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, OneMinusLuminance(rgb_));
+
+        float luma = color::LumaRed * rgb_.red + color::LumaGreen * rgb_.green + color::LumaBlue * rgb_.blue;
+        Color one_minus_luma(1.0f - luma, 1.0f - luma, 1.0f - luma);
+
+        GetPainter().Paint2DQuadWireframe(graphics_engine, pickermarker, one_minus_luma);
         GetPainter().Paint2DQuadColor(graphics_engine, channel_area_->GetGeometry(), BaseChannelTop, BaseChannelBottom, BaseChannelBottom, BaseChannelTop);
       }
 

=== modified file 'NuxCore/Color.cpp'
--- NuxCore/Color.cpp	2011-10-21 22:06:35 +0000
+++ NuxCore/Color.cpp	2012-02-10 04:48:18 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010 Inalogic® Inc.
+ * Copyright 2010-2012 Inalogic® Inc.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License, as
@@ -35,186 +35,188 @@
 {
 namespace color
 {
-
   Color::Color()
-    : red(0)
-    , green(0)
-    , blue(0)
-    , alpha(1)
-  {
-  }
+  : red(0.0f)
+  , green(0.0f)
+  , blue(0.0f)
+  , alpha(1.0f)
+  , premultiplied_(false)
+  {}
 
-Color::Color(RedGreenBlue const& rgb, float a)
-    : red(rgb.red)
-    , green(rgb.green)
-    , blue(rgb.blue)
-    , alpha(a)
-{}
+  Color::Color(RedGreenBlue const& rgb, float a)
+  : red(rgb.red)
+  , green(rgb.green)
+  , blue(rgb.blue)
+  , alpha(a)
+  , premultiplied_(false)
+  {}
 
   Color::Color (unsigned int c)
-    : red(NUX_RGBA_GET_RED(c) / 255.f)
-    , green(NUX_RGBA_GET_GREEN(c) / 255.f)
-    , blue(NUX_RGBA_GET_BLUE(c) / 255.f)
-    , alpha(NUX_RGBA_GET_ALPHA(c) / 255.f)
-  {
-  }
+  : red(NUX_RGBA_GET_RED(c) / 255.0f)
+  , green(NUX_RGBA_GET_GREEN(c) / 255.0f)
+  , blue(NUX_RGBA_GET_BLUE(c) / 255.0f)
+  , alpha(NUX_RGBA_GET_ALPHA(c) / 255.0f)
+  , premultiplied_(false)
+  {}
 
   Color::Color(int r, int g, int b)
-    : red(r / 255.f)
-    , green(g / 255.f)
-    , blue(b / 255.f)
-    , alpha(1)
-  {
-  }
-
-  Color::Color (float r, float g, float b, float a)
-    : red(r)
-    , green(g)
-    , blue(b)
-    , alpha(a)
-  {
-  }
-
-bool operator == (const Color &lhs, const Color &rhs)
-{
-  return (lhs.red == rhs.red &&
-          lhs.green == rhs.green &&
-          lhs.blue == rhs.blue &&
-          lhs.alpha == rhs.alpha);
-}
-
-bool operator != (const Color &lhs, const Color &rhs)
-{
-  return !(lhs == rhs);
-}
-
-Color ClampVal(Color const& c)
-{
-  return Color(std::max(0.0f, std::min(1.0f, c.red)),
-               std::max(0.0f, std::min(1.0f, c.green)),
-               std::max(0.0f, std::min(1.0f, c.blue)),
-               std::max(0.0f, std::min(1.0f, c.alpha)));
-}
-
-Color Luminance(Color const& c)
-{
-  float L = 0.30f * c.red + 0.59f * c.green + 0.11f * c.blue;
-  return Color(L, L, L);
-}
-
-Color OneMinusLuminance(Color const& c)
-{
-  float L = 1.0f - (0.30f * c.red + 0.59f * c.green + 0.11f * c.blue);
-  return Color(L, L, L);
-}
-
-Color RandomColor()
-{
-  return Color(RandomColorINT());
-}
-
-Color MakeOpaque(Color const& c)
-{
-  return Color(c.red, c.green, c.blue, 1.0f);
-}
-
-unsigned int RandomColorINT()
-{
-  // std::rand isn't defined to be more random than 2^15, so we need
-  // to generate the full unsigned in chunks.
-  return (((std::rand() % 255) << 24) |
-          ((std::rand() % 255) << 16) |
-          ((std::rand() % 255) << 8) |
-          (std::rand() % 255));
-}
-
-Color operator + (Color const& lhs, Color const& rhs)
-{
-  return Color(lhs.red + rhs.red,
-               lhs.green + rhs.green,
-               lhs.blue + rhs.blue,
-               lhs.alpha + rhs.alpha);
-}
-
-Color operator - (Color const& lhs, Color const& rhs)
-{
-  return Color(lhs.red - rhs.red,
-               lhs.green - rhs.green,
-               lhs.blue - rhs.blue,
-               lhs.alpha - rhs.alpha);
-}
-
-Color operator + (float scalar, Color const& c)
-{
-  return Color(c.red + scalar,
-               c.green + scalar,
-               c.blue + scalar,
-               c.alpha + scalar);
-}
-
-Color operator + (Color const& c, float scalar)
-{
-  return scalar + c;
-}
-
-Color operator - (float scalar, Color const& c)
-{
-  return Color(scalar - c.red,
-               scalar - c.green,
-               scalar - c.blue,
-               scalar - c.alpha);
-}
-
-
-Color operator - (Color const& c, float scalar)
-{
-  return Color(c.red - scalar,
-               c.green - scalar,
-               c.blue - scalar,
-               c.alpha - scalar);
-}
-
-Color operator * (float scalar, Color const& c)
-{
-  return Color(c.red * scalar,
-               c.green * scalar,
-               c.blue * scalar,
-               c.alpha * scalar);
-}
-
-Color operator * (Color const& c, float scalar)
-{
-  return scalar * c;
-}
-
-// The Hue/Saturation/Value model was created by A. R. Smith in 1978. It is
-// based on such intuitive color characteristics as tint, shade and tone (or
-// family, purety and intensity). The coordinate system is cylindrical, and
-// the colors are defined inside a hexcone.  The hue value H runs from 0 to
-// 360º. The saturation S is the degree of strength or purity and is from 0 to
-// 1. Purity is how much white is added to the color, so S=1 makes the purest
-// color (no white). Brightness V also ranges from 0 to 1, where 0 is the
-// black.  There is no transformation matrix for RGB/HSV conversion, but the
-// algorithm follows:
-
-// r,g,b values are from 0 to 1
-// h = [0,360], s = [0,1], v = [0,1]
-//		if s == 0, then h = -1 (undefined)
-
-  void RGBtoHSV ( float r, float g, float b, float &h, float &s, float &v )
+  : red(r / 255.0f)
+  , green(g / 255.0f)
+  , blue(b / 255.0f)
+  , alpha(1.0f)
+  , premultiplied_(false)
+  {}
+
+  Color::Color(float r, float g, float b, float a)
+  : red(r)
+  , green(g)
+  , blue(b)
+  , alpha(a)
+  , premultiplied_(false)
+  {}
+
+  Color Color::GetPremultiplied()
+  {
+    if (premultiplied_)
+    {
+      // Already pre-multiplied. Return *this;
+      return *this;
+    }
+
+    Color c;
+    c.SetPremultiplied(red, green, blue, alpha);
+    return c;
+  }
+
+  void Color::SetPremultiplied(float r, float g, float b, float a)
+  {
+    red   = r * a;
+    green = g * a;
+    blue  = b * a;
+    alpha = a;
+    premultiplied_ = true;
+  }
+
+  bool Color::IsPremultiplied()
+  {
+    return premultiplied_;
+  }
+
+  bool operator == (const Color& lhs, const Color& rhs)
+  {
+    return (lhs.red == rhs.red &&
+            lhs.green == rhs.green &&
+            lhs.blue == rhs.blue &&
+            lhs.alpha == rhs.alpha &&
+            lhs.premultiplied_ == rhs.premultiplied_);
+  }
+
+  bool operator != (const Color& lhs, const Color& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  Color RandomColor()
+  {
+    return Color(RandomColorINT());
+  }
+
+  unsigned int RandomColorINT()
+  {
+    // std::rand isn't defined to be more random than 2^15, so we need
+    // to generate the full unsigned in chunks.
+    return (((std::rand() % 255) << 24) |
+            ((std::rand() % 255) << 16) |
+            ((std::rand() % 255) << 8) |
+            (std::rand() % 255));
+  }
+
+  Color operator + (Color const& lhs, Color const& rhs)
+  {
+    return Color(lhs.red + rhs.red,
+                 lhs.green + rhs.green,
+                 lhs.blue + rhs.blue,
+                 lhs.alpha + rhs.alpha);
+  }
+
+  Color operator - (Color const& lhs, Color const& rhs)
+  {
+    return Color(lhs.red - rhs.red,
+                 lhs.green - rhs.green,
+                 lhs.blue - rhs.blue,
+                 lhs.alpha - rhs.alpha);
+  }
+
+  Color operator + (float scalar, Color const& c)
+  {
+    return Color(c.red + scalar,
+                 c.green + scalar,
+                 c.blue + scalar,
+                 c.alpha + scalar);
+  }
+
+  Color operator + (Color const& c, float scalar)
+  {
+    return scalar + c;
+  }
+
+  Color operator - (float scalar, Color const& c)
+  {
+    return Color(scalar - c.red,
+                 scalar - c.green,
+                 scalar - c.blue,
+                 scalar - c.alpha);
+  }
+
+
+  Color operator - (Color const& c, float scalar)
+  {
+    return Color(c.red - scalar,
+                 c.green - scalar,
+                 c.blue - scalar,
+                 c.alpha - scalar);
+  }
+
+  Color operator * (float scalar, Color const& c)
+  {
+    return Color(c.red * scalar,
+                 c.green * scalar,
+                 c.blue * scalar,
+                 c.alpha * scalar);
+  }
+
+  Color operator * (Color const& c, float scalar)
+  {
+    return scalar * c;
+  }
+
+  // The Hue/Saturation/Value model was created by A. R. Smith in 1978. It is
+  // based on such intuitive color characteristics as tint, shade and tone (or
+  // family, purety and intensity). The coordinate system is cylindrical, and
+  // the colors are defined inside a hexcone.  The hue value H runs from 0 to
+  // 360º. The saturation S is the degree of strength or purity and is from 0 to
+  // 1. Purity is how much white is added to the color, so S=1 makes the purest
+  // color (no white). Brightness V also ranges from 0 to 1, where 0 is the
+  // black.  There is no transformation matrix for RGB/HSV conversion, but the
+  // algorithm follows:
+
+  // r,g,b values are from 0 to 1
+  // h = [0,360], s = [0,1], v = [0,1]
+  //    if s == 0, then h = -1 (undefined)
+  void RGBtoHSV(float r, float g, float b, float& h, float& s, float& v)
   {
     float mini, maxi, delta;
 
     mini = std::min(std::min(r, g), b);
     maxi = std::max(std::max(r, g), b);
-    v = maxi;   // v
+    v = maxi;
 
     delta = maxi - mini;
 
 
-    if ( maxi != 0 )
+    if (maxi != 0)
     {
-      s = delta / maxi; // s
+      s = delta / maxi;
     }
     else
     {
@@ -231,24 +233,24 @@
       return;
     }
 
-    if ( r == maxi)
-      h = ( g - b ) / delta;      // between yellow & magenta
-    else if ( g == maxi)
-      h = 2 + ( b - r ) / delta;  // between cyan & yellow
+    if (r == maxi)
+      h = (g - b) / delta;      // between yellow & magenta
+    else if (g == maxi)
+      h = 2 + (b - r) / delta;  // between cyan & yellow
     else
-      h = 4 + ( r - g ) / delta;  // between magenta & cyan
+      h = 4 + (r - g) / delta;  // between magenta & cyan
 
     h *= 60;  // degrees
 
-    if ( h < 0 )
+    if (h < 0)
       h += 360;
 
     // convert h from [0, 360] to [0, 1]
-    h = (h) / 360.0f;
+    h = h / 360.0f;
 
   }
 
-  void HSVtoRGB ( float &r, float &g, float &b, float h, float s, float v )
+  void HSVtoRGB(float& r, float& g, float& b, float h, float s, float v )
   {
     int i;
     float f, p, q, t;
@@ -256,19 +258,19 @@
     // convert h from [0, 1] to [0, 360]
     h = h * 360.0f;
 
-    if ( s == 0 )
+    if (s == 0)
     {
       // achromatic (grey)
       r = g = b = v;
       return;
     }
 
-    h /= 60;        // sector 0 to 5
-    i = (int) std::floor ( h );
-    f = h - i;      // factorial part of h
-    p = v * ( 1 - s );
-    q = v * ( 1 - s * f );
-    t = v * ( 1 - s * ( 1 - f ) );
+    h /= 60.0f;         // sector 0 to 5
+    i = (int) std::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 )
     {
@@ -297,7 +299,7 @@
         g = p;
         b = v;
         break;
-      default:		// case 5:
+      default:    // case 5:
         r = v;
         g = p;
         b = q;
@@ -305,30 +307,34 @@
     }
   }
 
-/////////////////////////
-// HLS-RGB Conversions //
-/////////////////////////
+  /////////////////////////
+  // HLS-RGB Conversions //
+  /////////////////////////
 
-  float HLStoRGB1 (float rn1, float rn2, float huei)
+  // Static function. Auxiliary to HLS2RGB().
+  static float HLStoRGB_(float rn1, float rn2, float huei)
   {
-    // Static method. Auxiliary to HLS2RGB().
-
     float hue = huei;
 
-    if (hue > 360) hue = hue - 360;
-
-    if (hue < 0)   hue = hue + 360;
-
-    if (hue < 60 ) return rn1 + (rn2 - rn1) * hue / 60;
-
-    if (hue < 180) return rn2;
-
-    if (hue < 240) return rn1 + (rn2 - rn1) * (240 - hue) / 60;
+    if (hue > 360.0f)
+      hue = hue - 360.0f;
+
+    if (hue < 0.0f)
+      hue = hue + 360.0f;
+
+    if (hue < 60.0f )
+      return rn1 + (rn2 - rn1) * hue / 60.0f;
+
+    if (hue < 180.0f)
+      return rn2;
+
+    if (hue < 240.0f)
+      return rn1 + (rn2 - rn1) * (240.0f - hue) / 60.0f;
 
     return rn1;
   }
 
-  void HLStoRGB (float &r, float &g, float &b, float hue, float light, float satur)
+  void HLStoRGB(float& r, float& g, float& b, float hue, float light, float satur)
   {
     // Static method to compute RGB from HLS. The l and s are between [0,1]
     // and h is between [0, 1]. The returned r,g,b triplet is between [0,1].
@@ -337,17 +343,23 @@
     float rh, rl, rs, rm1, rm2;
     rh = rl = rs = 0;
 
-    if (hue   > 0) rh = hue;
-
-    if (rh > 360) rh = 360;
-
-    if (light > 0) rl = light;
-
-    if (rl > 1)   rl = 1;
-
-    if (satur > 0) rs = satur;
-
-    if (rs > 1)   rs = 1;
+    if (hue   > 0)
+      rh = hue;
+
+    if (rh > 360.0f)
+      rh = 360.0f;
+
+    if (light > 0)
+      rl = light;
+
+    if (rl > 1)
+      rl = 1;
+
+    if (satur > 0)
+      rs = satur;
+
+    if (rs > 1)
+      rs = 1.0f;
 
     if (rl <= 0.5f)
       rm2 = rl * (1.0f + rs);
@@ -364,34 +376,13 @@
       return;
     }
 
-    r = HLStoRGB1 (rm1, rm2, rh + 120);
-    g = HLStoRGB1 (rm1, rm2, rh);
-    b = HLStoRGB1 (rm1, rm2, rh - 120);
-  }
-
-  void HLStoRGBi (int h, int l, int s, int &r, int &g, int &b)
-  {
-    // Static method to compute RGB from HLS. The h,l,s are between [0,255].
-    // The returned r,g,b triplet is between [0,255].
-
-    float hh, ll, ss;
-    float rr, gg, bb;
-    hh = ll = ss = 0;
-    rr = gg = bb = 0;
-
-    hh = float (h) * 360 / 255;
-    ll = float (l) / 255;
-    ss = float (s) / 255;
-
-    HLStoRGB (hh, ll, ss, rr, gg, bb);
-
-    r = (int) (rr * 255);
-    g = (int) (gg * 255);
-    b = (int) (bb * 255);
-  }
-
-  void RGBtoHLS (float rr, float gg, float bb,
-                 float &hue, float &light, float &satur)
+    r = HLStoRGB_(rm1, rm2, rh + 120);
+    g = HLStoRGB_(rm1, rm2, rh);
+    b = HLStoRGB_(rm1, rm2, rh - 120);
+  }
+
+  void RGBtoHLS(float rr, float gg, float bb,
+                float& hue, float& light, float& satur)
   {
     // Static method to compute HLS from RGB. The r,g,b triplet is between
     // [0,1], hue is between [0,1], light and satur are [0,1].
@@ -399,29 +390,39 @@
     float rnorm, gnorm, bnorm, minval, maxval, msum, mdiff, r, g, b;
     r = g = b = 0;
 
-    if (rr > 0) r = rr;
-
-    if (r > 1) r = 1;
-
-    if (gg > 0) g = gg;
-
-    if (g > 1) g = 1;
-
-    if (bb > 0) b = bb;
-
-    if (b > 1) b = 1;
+    if (rr > 0)
+      r = rr;
+
+    if (r > 1)
+      r = 1;
+
+    if (gg > 0)
+      g = gg;
+
+    if (g > 1)
+      g = 1;
+
+    if (bb > 0)
+      b = bb;
+
+    if (b > 1)
+      b = 1;
 
     minval = r;
 
-    if (g < minval) minval = g;
+    if (g < minval)
+      minval = g;
 
-    if (b < minval) minval = b;
+    if (b < minval)
+      minval = b;
 
     maxval = r;
 
-    if (g > maxval) maxval = g;
+    if (g > maxval)
+      maxval = g;
 
-    if (b > maxval) maxval = b;
+    if (b > maxval)
+      maxval = b;
 
     rnorm = gnorm = bnorm = 0;
     mdiff = maxval - minval;
@@ -458,74 +459,52 @@
     hue = hue / 360.0f;
   }
 
-
-  void RGBtoHLSi (int r, int g, int b, int &h, int &l, int &s)
-  {
-    // Static method to compute HLS from RGB. The r,g,b triplet is between
-    // [0,255], hue, light and satur are between [0,255].
-
-    float rr, gg, bb, hue, light, satur;
-
-    rr = float (r) / 255;
-    gg = float (g) / 255;
-    bb = float (b) / 255;
-
-    RGBtoHLS (rr, gg, bb, hue, light, satur);
-
-    h = (int) (hue / 360 * 255);
-    l = (int) (light * 255);
-    s = (int) (satur * 255);
-  }
-
-
-RedGreenBlue::RedGreenBlue(float r, float g, float b)
+  RedGreenBlue::RedGreenBlue(float r, float g, float b)
   : red(r)
   , green(g)
   , blue(b)
-{}
-
-RedGreenBlue::RedGreenBlue(HueSaturationValue const& hsv)
-{
-  HSVtoRGB(red, green, blue, hsv.hue, hsv.saturation, hsv.value);
-}
-
-RedGreenBlue::RedGreenBlue(HueLightnessSaturation const& hls)
-{
-  HLStoRGB(red, green, blue, hls.hue, hls.lightness, hls.saturation);
-}
-
-HueSaturationValue::HueSaturationValue(float h, float s, float v)
+  {}
+
+  RedGreenBlue::RedGreenBlue(HueSaturationValue const& hsv)
+  {
+    HSVtoRGB(red, green, blue, hsv.hue, hsv.saturation, hsv.value);
+  }
+
+  RedGreenBlue::RedGreenBlue(HueLightnessSaturation const& hls)
+  {
+    HLStoRGB(red, green, blue, hls.hue, hls.lightness, hls.saturation);
+  }
+
+  HueSaturationValue::HueSaturationValue(float h, float s, float v)
   : hue(h)
   , saturation(s)
   , value(v)
-{}
-
-HueSaturationValue::HueSaturationValue(RedGreenBlue const& rgb)
-{
-  RGBtoHSV(rgb.red, rgb.green, rgb.blue, hue, saturation, value);
-}
-
-HueSaturationValue::HueSaturationValue(Color const& c)
-{
-  RGBtoHSV(c.red, c.green, c.blue, hue, saturation, value);
-}
-
-HueLightnessSaturation::HueLightnessSaturation(float h, float l, float s)
+  {}
+
+  HueSaturationValue::HueSaturationValue(RedGreenBlue const& rgb)
+  {
+    RGBtoHSV(rgb.red, rgb.green, rgb.blue, hue, saturation, value);
+  }
+
+  HueSaturationValue::HueSaturationValue(Color const& c)
+  {
+    RGBtoHSV(c.red, c.green, c.blue, hue, saturation, value);
+  }
+
+  HueLightnessSaturation::HueLightnessSaturation(float h, float l, float s)
   : hue(h)
   , lightness(l)
   , saturation(s)
-{}
-
-HueLightnessSaturation::HueLightnessSaturation(RedGreenBlue const& rgb)
-{
-  RGBtoHLS(rgb.red, rgb.green, rgb.blue, hue, lightness, saturation);
-}
-
-HueLightnessSaturation::HueLightnessSaturation(Color const& c)
-{
-  RGBtoHLS(c.red, c.green, c.blue, hue, lightness, saturation);
-}
-
-
+  {}
+
+  HueLightnessSaturation::HueLightnessSaturation(RedGreenBlue const& rgb)
+  {
+    RGBtoHLS(rgb.red, rgb.green, rgb.blue, hue, lightness, saturation);
+  }
+
+  HueLightnessSaturation::HueLightnessSaturation(Color const& c)
+  {
+    RGBtoHLS(c.red, c.green, c.blue, hue, lightness, saturation);
+  }
 }
 }

=== modified file 'NuxCore/Color.h'
--- NuxCore/Color.h	2011-05-26 21:08:18 +0000
+++ NuxCore/Color.h	2012-02-10 04:48:18 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010 Inalogic® Inc.
+ * Copyright 2010-2012 Inalogic® Inc.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License, as
@@ -81,14 +81,16 @@
   //|      blue      |      green    |     red      |     alpha     |
   //+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
-enum Model {
+  enum Model
+  {
     RGB,
     HSV,
     HLS,
     YUV
-};
+  };
 
-enum Channel {
+  enum Channel
+  {
     RED,
     GREEN,
     BLUE,
@@ -96,94 +98,121 @@
     SATURATION,
     LIGHT,
     VALUE
-};
+  };
 
-enum Format {
+  enum Format
+  {
     FLOAT,
     HEX,
     INT
-};
-
-struct RedGreenBlue;
-
-struct Color
-{
+  };
+
+  class RedGreenBlue;
+
+  class Color
+  {
+  public:
     Color();
-    explicit Color (unsigned int c);
+    explicit Color(unsigned int c);
     Color(int r, int g, int b);
     Color(float r, float g, float b, float a = 1.0f);
     Color(RedGreenBlue const& rgb, float a = 1.0f);
+    
+    //! Returns the pre-multiplied version of this color.
+    /*!
+        Returns the pre-multiplied version of this color. If this color is already pre-multiplied
+        then *this is returned.\n
+        The premultiplied color is Color(red * alpha, green * alpha, blue * alpha, alpha).
+
+        @return The pre-multiplied version of this color.
+    */
+    Color GetPremultiplied();
+
+    //! Sets a pre-multiplied color
+    /*!
+        Sets a pre-multiplied color
+
+        @param r Red value.
+        @param g Green value.
+        @param b Blue value.
+        @param a Alpha value.
+    */
+    void SetPremultiplied(float r, float g, float b, float a);
+
+    //! Returns True if this color is pre-multiplied.
+    /*!
+        Returns True if this color is pre-multiplied.
+
+        @return True is this color is pre-multiplied.
+    */
+    bool IsPremultiplied();
 
     float red;
     float green;
     float blue;
     float alpha;
-};
-
-bool operator == (Color const& lhs, Color const& rhs);
-bool operator != (Color const& lhs, Color const& rhs);
-
-Color ClampVal(Color const&);
-Color Saturate(Color const&);
-Color Complement(Color const&);
-Color Luminance(Color const&);
-Color OneMinusLuminance(Color const&);
-Color MakeOpaque(Color const&);
-
-Color operator + (Color const&, Color const&);
-Color operator + (float, Color const&);
-Color operator + (Color const&, float);
-
-Color operator - (Color const&, Color const&);
-Color operator - (float, Color const&);
-Color operator - (Color const&, float);
-
-Color operator * (float, Color const&);
-Color operator * (Color const&, float);
-
-Color RandomColor();
-unsigned int RandomColorINT();
-
-struct HueSaturationValue;
-struct HueLightnessSaturation;
-
-struct RedGreenBlue
-{
-  RedGreenBlue(float r, float g, float b);
-  RedGreenBlue(HueSaturationValue const&);
-  RedGreenBlue(HueLightnessSaturation const&);
-
-  float red;
-  float green;
-  float blue;
-};
-
-struct HueSaturationValue
-{
-  HueSaturationValue(float h, float s, float v);
-  HueSaturationValue(Color const&);
-  HueSaturationValue(RedGreenBlue const&);
-
-  float hue;
-  float saturation;
-  float value;
-};
-
-struct HueLightnessSaturation
-{
-  HueLightnessSaturation(float h, float l, float s);
-  HueLightnessSaturation(Color const&);
-  HueLightnessSaturation(RedGreenBlue const&);
-
-  float hue;
-  float lightness;
-  float saturation;
-};
-
-//  void RGBtoHSV ( float r, float g, float b, float &h, float &s, float &v );
-//  void HSVtoRGB ( float &r, float &g, float &b, float h, float s, float v );
-//  void HLStoRGB (float &r, float &g, float &b, float hue, float light, float satur);
-//  void RGBtoHLS (float rr, float gg, float bb, float &hue, float &light, float &satur);
+
+  protected:
+    bool premultiplied_; //!< True if the rgb components have been pre-multiplied with the alpha component.
+
+    friend bool operator == (Color const& lhs, Color const& rhs);
+  };
+
+  bool operator == (Color const& lhs, Color const& rhs);
+  bool operator != (Color const& lhs, Color const& rhs);
+
+  Color operator + (Color const&, Color const&);
+  Color operator + (float, Color const&);
+  Color operator + (Color const&, float);
+
+  Color operator - (Color const&, Color const&);
+  Color operator - (float, Color const&);
+  Color operator - (Color const&, float);
+
+  Color operator * (float, Color const&);
+  Color operator * (Color const&, float);
+
+  Color RandomColor();
+  unsigned int RandomColorINT();
+
+  class HueSaturationValue;
+  class HueLightnessSaturation;
+
+  class RedGreenBlue
+  {
+  public:
+    RedGreenBlue(float r, float g, float b);
+    RedGreenBlue(HueSaturationValue const&);
+    RedGreenBlue(HueLightnessSaturation const&);
+
+    float red;
+    float green;
+    float blue;
+  };
+
+  class HueSaturationValue
+  {
+  public:
+    HueSaturationValue(float h, float s, float v);
+    HueSaturationValue(Color const&);
+    HueSaturationValue(RedGreenBlue const&);
+
+    float hue;
+    float saturation;
+    float value;
+  };
+
+  class HueLightnessSaturation
+  {
+  public:
+    HueLightnessSaturation(float h, float l, float s);
+    HueLightnessSaturation(Color const&);
+    HueLightnessSaturation(RedGreenBlue const&);
+
+    float hue;
+    float lightness;
+    float saturation;
+  };
 
 }
 using color::Color;

=== modified file 'NuxCore/Colors.cpp'
--- NuxCore/Colors.cpp	2011-05-13 03:20:36 +0000
+++ NuxCore/Colors.cpp	2012-02-10 04:48:18 +0000
@@ -26,6 +26,18 @@
 {
   namespace color
   {
+    // Definition of Luma coefficients as per ITU-R Recommendation BT.601
+    // http://en.wikipedia.org/wiki/Rec._601
+    const float LumaRed   = 0.299f;
+    const float LumaGreen = 0.587f;
+    const float LumaBlue  = 0.114f;
+
+    //     // Definition of Luma coefficients as per ITU-R Recommendation BT.709
+    //     // http://en.wikipedia.org/wiki/Rec._709
+    //     float LumaRed   = 0.2126f;
+    //     float LumaGreen = 0.7152f;
+    //     float LumaBlue  = 0.0722f;
+
     const Color Transparent(0, 0, 0, 0);
 
     //Red colors

=== modified file 'NuxCore/Colors.h'
--- NuxCore/Colors.h	2011-05-13 03:20:36 +0000
+++ NuxCore/Colors.h	2012-02-10 04:48:18 +0000
@@ -28,6 +28,13 @@
 {
   namespace color
   {
+    // Definition of Luma coefficients as per ITU-R Recommendation BT.709
+    // http://en.wikipedia.org/wiki/Rec._709
+
+    extern const float LumaRed;
+    extern const float LumaGreen;
+    extern const float LumaBlue;
+
     // X11 color names from:http://en.wikipedia.org/wiki/Web_colors
     extern const Color Transparent;
 

=== modified file 'NuxImage/ImageSurface.h'
--- NuxImage/ImageSurface.h	2012-01-22 04:31:33 +0000
+++ NuxImage/ImageSurface.h	2012-02-10 04:48:18 +0000
@@ -149,7 +149,7 @@
         Sum up all the image elements and divide by the number of elements.
         @return The average color of the image.
     */
-    struct Color AverageColor();
+    Color AverageColor();
 
   private:
     void FlipDXTVertical();

=== modified file 'configure.ac'
--- configure.ac	2012-02-09 20:32:08 +0000
+++ configure.ac	2012-02-10 04:48:18 +0000
@@ -22,7 +22,7 @@
 # The number format is : year/month/day
 # e.g.: december 5th, 2011 is: 20111205
 # To make more than one API change in a day, add a number to the date. Like 20111205.xx
-m4_define([nux_abi_version], [20120209.01])
+m4_define([nux_abi_version], [20120209.02])
 
 m4_define([nux_version],
           [nux_major_version.nux_minor_version.nux_micro_version])

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2012-01-30 08:43:49 +0000
+++ tests/Makefile.am	2012-02-10 04:48:18 +0000
@@ -45,6 +45,7 @@
 gtest_nux_core_SOURCES = \
   Helpers.h \
   Helpers.cpp \
+  gtest-nuxcore-color.cpp \
   test_object.cpp \
   test_main.cpp \
   test_async_file_writer.cpp \

=== added file 'tests/gtest-nuxcore-color.cpp'
--- tests/gtest-nuxcore-color.cpp	1970-01-01 00:00:00 +0000
+++ tests/gtest-nuxcore-color.cpp	2012-02-10 04:48:18 +0000
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2012 Inalogic Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3, as
+ * published by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Jay Taoko <[e-mail]>
+ *
+ */
+
+#include <gmock/gmock.h>
+
+#include "Nux/Nux.h"
+
+using namespace testing;
+
+static const float epsilon = 0.005f;
+
+namespace {
+
+  TEST(TestColor, TestColorConstructor0)
+  {
+    nux::Color c;
+
+    EXPECT_EQ(c.red,    0.0f);
+    EXPECT_EQ(c.green,  0.0f);
+    EXPECT_EQ(c.blue,   0.0f);
+    EXPECT_EQ(c.alpha,  1.0);
+    EXPECT_EQ(c.IsPremultiplied(), false);
+  }
+
+  TEST(TestColor, TestColorConstructor1)
+  {
+    // testing float inputs
+    nux::Color c0(0.1f, 0.2f, 0.3f);
+    EXPECT_EQ(c0.red,    0.1f);
+    EXPECT_EQ(c0.green,  0.2f);
+    EXPECT_EQ(c0.blue,   0.3f);
+    EXPECT_EQ(c0.alpha,  1.0f);
+    EXPECT_EQ(c0.IsPremultiplied(), false);
+
+    // testing float inputs
+    nux::Color c1(0.1f, 0.2f, 0.3f, 0.4f);
+    EXPECT_EQ(c1.red,    0.1f);
+    EXPECT_EQ(c1.green,  0.2f);
+    EXPECT_EQ(c1.blue,   0.3f);
+    EXPECT_EQ(c1.alpha,  0.4f);
+    EXPECT_EQ(c1.IsPremultiplied(), false);
+
+    // testing double inputs
+    nux::Color c2(0.1, 0.2, 0.3, 0.4);
+    EXPECT_EQ(c2.red,    0.1f);
+    EXPECT_EQ(c2.green,  0.2f);
+    EXPECT_EQ(c2.blue,   0.3f);
+    EXPECT_EQ(c2.alpha,  0.4f);
+    EXPECT_EQ(c2.IsPremultiplied(), false);
+  }
+
+  TEST(TestColor, TestColorConstructor2)
+  {
+    nux::Color c0(255, 255, 255);
+    EXPECT_EQ(c0.red,    1.0f);
+    EXPECT_EQ(c0.green,  1.0f);
+    EXPECT_EQ(c0.blue,   1.0f);
+    EXPECT_EQ(c0.alpha,  1.0f);
+    EXPECT_EQ(c0.IsPremultiplied(), false);
+
+    nux::Color c1(10, 128, 192);
+    EXPECT_EQ(c1.red,    10/255.0f);
+    EXPECT_EQ(c1.green,  128/255.0f);
+    EXPECT_EQ(c1.blue,   192/255.0f);
+    EXPECT_EQ(c1.alpha,  1.0f);
+    EXPECT_EQ(c1.IsPremultiplied(), false);
+  }
+
+  TEST(TestColor, TestColorConstructor3)
+  {
+    nux::Color c0((255<<24)|(255<<16)|(255<<8)|255);
+    EXPECT_EQ(c0.red,    1.0f);
+    EXPECT_EQ(c0.green,  1.0f);
+    EXPECT_EQ(c0.blue,   1.0f);
+    EXPECT_EQ(c0.alpha,  1.0f);
+    EXPECT_EQ(c0.IsPremultiplied(), false);
+    
+    //             A         R         G       B
+    nux::Color c1((128<<24)|(192<<16)|(128<<8)|10);
+    EXPECT_EQ(c1.red,    192/255.0f);
+    EXPECT_EQ(c1.green,  128/255.0f);
+    EXPECT_EQ(c1.blue,   10/255.0f);
+    EXPECT_EQ(c1.alpha,  128/255.0f);
+    EXPECT_EQ(c1.IsPremultiplied(), false);
+  }
+
+
+  TEST(TestColor, TestColorPremultiplied0)
+  {
+    nux::Color c0(0.81f, 0.24f, 0.53f, 0.79f);
+    EXPECT_EQ(c0.red,    0.81f);
+    EXPECT_EQ(c0.green,  0.24f);
+    EXPECT_EQ(c0.blue,   0.53f);
+    EXPECT_EQ(c0.alpha,  0.79f);
+    EXPECT_EQ(c0.IsPremultiplied(), false);
+
+    nux::Color c1 = c0.GetPremultiplied();
+    EXPECT_EQ(c1.red,    0.81f * 0.79f);
+    EXPECT_EQ(c1.green,  0.24f * 0.79f);
+    EXPECT_EQ(c1.blue,   0.53f * 0.79f);
+    EXPECT_EQ(c1.alpha,  0.79f);
+    EXPECT_EQ(c1.IsPremultiplied(), true);
+    EXPECT_EQ(c0.IsPremultiplied(), false);
+  }
+
+  TEST(TestColor, TestColorRGBToHSV0)
+  {
+    nux::color::RedGreenBlue rgb(255/255.0f, 128/255.0f, 169/255.0f);
+    nux::color::HueSaturationValue hsv(rgb);
+
+    EXPECT_NEAR(hsv.hue,          341/360.0f, epsilon);
+    EXPECT_NEAR(hsv.saturation,   50/100.0f, epsilon);
+    EXPECT_NEAR(hsv.value,        100/100.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorHSVToRGB0)
+  {
+    nux::color::HueSaturationValue hsv(341/360.0f, 50/100.0f, 100/100.0f);
+    nux::color::RedGreenBlue rgb(hsv);
+
+    EXPECT_NEAR(rgb.red,        255/255.0f, epsilon);
+    EXPECT_NEAR(rgb.green,      128/255.0f, epsilon);
+    EXPECT_NEAR(rgb.blue,       169/255.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorRGBToHSV1)
+  {
+    nux::color::RedGreenBlue rgb(65/255.0f, 28/255.0f, 6/255.0f);
+    nux::color::HueSaturationValue hsv(rgb);
+
+    EXPECT_NEAR(hsv.hue,          22/360.0f, epsilon);
+    EXPECT_NEAR(hsv.saturation,   91/100.0f, epsilon);
+    EXPECT_NEAR(hsv.value,        25/100.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorHSVToRGB1)
+  {
+    nux::color::HueSaturationValue hsv(22/360.0f, 91/100.0f, 25/100.0f);
+    nux::color::RedGreenBlue rgb(hsv);
+
+    EXPECT_NEAR(rgb.red,        65/255.0f, epsilon);
+    EXPECT_NEAR(rgb.green,      28/255.0f, epsilon);
+    EXPECT_NEAR(rgb.blue,       6/255.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorRGBToHSV2)
+  {
+    nux::color::RedGreenBlue rgb(90/255.0f, 65/255.0f, 158/255.0f);
+    nux::color::HueSaturationValue hsv(rgb);
+
+    EXPECT_NEAR(hsv.hue,          256/360.0f, epsilon);
+    EXPECT_NEAR(hsv.saturation,   59/100.0f, epsilon);
+    EXPECT_NEAR(hsv.value,        62/100.0f, epsilon);
+  }
+
+
+  TEST(TestColor, TestColorHSVToRGB2)
+  {
+    nux::color::HueSaturationValue hsv(256/360.0f, 59/100.0f, 62/100.0f);
+    nux::color::RedGreenBlue rgb(hsv);
+
+    EXPECT_NEAR(rgb.red,        90/255.0f, epsilon);
+    EXPECT_NEAR(rgb.green,      65/255.0f, epsilon);
+    EXPECT_NEAR(rgb.blue,       158/255.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorRGBToHLS0)
+  {
+    nux::color::RedGreenBlue rgb(127/255.0f, 0/255.0f, 255/255.0f);
+    nux::color::HueLightnessSaturation hls(rgb);
+
+    EXPECT_NEAR(hls.hue,          270/360.0f, epsilon);
+    EXPECT_NEAR(hls.lightness,    50/100.0f, epsilon);
+    EXPECT_NEAR(hls.saturation,   100/100.0f,  epsilon);
+  }
+
+  TEST(TestColor, TestColorHLSToRGB0)
+  {
+    nux::color::HueLightnessSaturation hls(270/360.0f, 50/100.0f, 100/100.0f);
+    nux::color::RedGreenBlue rgb(hls);
+
+    EXPECT_NEAR(rgb.red,        127/255.0f, epsilon);
+    EXPECT_NEAR(rgb.green,      0/255.0f, epsilon);
+    EXPECT_NEAR(rgb.blue,       255/255.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorRGBToHLS1)
+  {
+    nux::color::RedGreenBlue rgb(50/255.0f, 84/255.0f, 13/255.0f);
+    nux::color::HueLightnessSaturation hls(rgb);
+
+    EXPECT_NEAR(hls.hue,          89/360.0f, epsilon);
+    EXPECT_NEAR(hls.lightness,    19/100.0f, epsilon);
+    EXPECT_NEAR(hls.saturation,   73/100.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorHLSToRGB1)
+  {
+    nux::color::HueLightnessSaturation hls(89/360.0f, 19/100.0f, 73/100.0f);
+    nux::color::RedGreenBlue rgb(hls);
+
+    EXPECT_NEAR(rgb.red,        50/255.0f, epsilon);
+    EXPECT_NEAR(rgb.green,      84/255.0f, epsilon);
+    EXPECT_NEAR(rgb.blue,       13/255.0f, epsilon);
+  }
+
+  TEST(TestColor, TestColorRGBToHLS2)
+  {
+    nux::color::RedGreenBlue rgb(201/255.0f, 200/255.0f, 239/255.0f);
+    nux::color::HueLightnessSaturation hls(rgb);
+
+    EXPECT_NEAR(hls.hue,          242/360.0f, epsilon);
+    EXPECT_NEAR(hls.lightness,    86/100.0f,  epsilon);
+    EXPECT_NEAR(hls.saturation,   55/100.0f,  epsilon);
+  }
+
+  TEST(TestColor, TestColorHLSToRGB2)
+  {
+    nux::color::HueLightnessSaturation hls(242/360.0f, 86/100.0f, 55/100.0f);
+    nux::color::RedGreenBlue rgb(hls);
+
+    EXPECT_NEAR(rgb.red,        201/255.0f, epsilon);
+    EXPECT_NEAR(rgb.green,      200/255.0f, epsilon);
+    EXPECT_NEAR(rgb.blue,       239/255.0f, epsilon);
+  }
+}
+