Home Page Toolkit Overview Using GML   User Input Services     Finger Tracker     Calibrator     Frame Grabber     Service protocol Obtaining GML   Installing GML   Licence Developer Documentation   Tcl/Tk API     The GML Canvas     Image processing   Tcl Scripts Library     List of Classes     List of Files   C/C++ API     List of Classes     List of Files

gml_HLSColor.h // gml_HLSColor.h -- // // Defines the gml_TColor_HLS class template // // Copyright (c) 2004 CLIPS-IMAG // // See the file "gml_LicenseTerms.txt" for information on usage and redistribution // of this file, and for a DISCLAIMER OF ALL WARRANTIES. // // Created on January 9, 2004 (JL). #ifndef __GML_HLSCOLOR__ #define __GML_HLSCOLOR__ #include <float.h> #include <assert.h> #include "gml/base/gml_Types.h" #include "gml/base/gml_Attributes.h" #include "gml/math/gml_Math.h" #include "gml/math/gml_Tables.h" /// /// gml_TColor_HLS_FFF -- /// A union type used to represent HLS-encoded color pixels. /// HLS is Metrick's Hue, Lightness, Saturation colorspace. /// /// Some of this code is adapted from section 15.3.5 of "Computer Graphics: /// Principles and Practice", by J.D. Foley and A. van Dam. /// class gml_TColor_HLS_FFF { public: /// /// Constructor -- /// Convert a 24-bit RGB triplet into HLS and fill in the object. /// gml_TColor_HLS_FFF (UInt8 const r, UInt8 const g, UInt8 const b) { Float32 fr = Float32 (r) * 0.00392156862745F; // that's 1/255 Float32 fg = Float32 (g) * 0.00392156862745F; Float32 fb = Float32 (b) * 0.00392156862745F; Float32 min = Min (fr, fg, fb); Float32 max = Max (fr, fg, fb); Float32 delta = max - min; Float32 sum = max + min; Float32 h, l, s; l = 0.5F * sum; if(delta < FLT_EPSILON) { // achromatic case s = 0.0F; h = 0.0F; } else { s = (l <= 0.5F) ? Divide (delta, sum) : Divide (delta, 2.0F - sum); if (fr == max) h = Divide (fg - fb, delta); else if (fg == max) h = 2.0F + Divide (fb - fr, delta); else /*fb == max*/ h = 4.0F + Divide (fr - fg, delta); } H = fmodf (0.166666666667 * h + 1.0F, 1.0F); L = l; S = s; assert (H >= 0.0F && H <= 1.0F); assert (L >= 0.0F && L <= 1.0F); assert (S >= 0.0F && S <= 1.0F); } /// /// Constructor -- /// Fill the structure from data in memory /// gml_TColor_HLS_FFF (const void *const ptr) { *this = *((gml_TColor_HLS_FFF *) ptr); } /// /// Constructor -- /// Leave the structure `as is'. /// I.e. probably zero. /// gml_TColor_HLS_FFF () {} /// /// Print -- /// Dump a representation of the pixel to stdout: channels in hex and /// in degrees, percent, percent format. /// @warning no newline appended ! /// void Print () { printf ("%f %f %f (%3d %3d%% %3d%%)", H, L, S, (int) LRound (fmod (360.0 * H + 360.0, 360.0)), (int) LRound (100 * L), (int) LRound (100 * S) ); } /// /// Store -- /// Place the structure's data in memory /// void Store (void *const ptr) { *((gml_TColor_HLS_FFF *) ptr) = *this; } /// /// Convert -- /// Convert the HLS data in this object to a 24 bit RGB triplet. /// void Convert (UInt8 &r, UInt8 &g, UInt8 &b) { Float32 fr, fg, fb; Float32 m2 = (L <= 0.5F) ? (L + L * S) : (L + S - L * S); Float32 m1 = 2.0F * L - m2; if (S == 0.0F) { fr = fg = fb = L; } else { fr = Value (m1, m2, H + 0.333333333333F); fg = Value (m1, m2, H); fb = Value (m1, m2, H - 0.333333333333F); } assert (fr <= 1.0F + FLT_EPSILON && fr >= 0.0F - FLT_EPSILON); assert (fg <= 1.0F + FLT_EPSILON && fg >= 0.0F - FLT_EPSILON); assert (fb <= 1.0F + FLT_EPSILON && fb >= 0.0F - FLT_EPSILON); r = (UInt8) LRound (fr * 255.0F); g = (UInt8) LRound (fg * 255.0F); b = (UInt8) LRound (fb * 255.0F); } /// /// Distance -- /// Compute the 16-bit distance to another HLS pixel. /// The euclidian distance in the hue, saturation disc is used. /// UInt16 Distance (const gml_TColor_HLS_FFF other) { const Float32 pi = 3.14159265358979323846F; Float32 x0, x1, y0, y1, res; x0 = S * Cos (2.0F * pi * H); y0 = S * Sin (2.0F * pi * H); x1 = other.S * Cos (2.0F * pi * other.H); y1 = other.S * Sin (2.0F * pi * other.H); res = Min (1.0F, Norm (x0, y0, x1, y1)); assert (res >= 0.0F && res <= 1.0F); return (UInt16) LFloor (res * 65535.0F); } struct { ///< structure for transparent channel access #if BYTE_ORDER == BIG_ENDIAN Float32 H; ///< hue channel Float32 L; ///< saturation channel Float32 S; ///< value channel #else Float32 S; ///< value channel Float32 L; ///< saturation channel Float32 H; ///< hue channel #endif } GML_PACKED; private: /// Helper for Convert() inline static Float32 Value (Float32 n1, Float32 n2, Float32 hue) { hue = fmodf (hue + 1.0F, 1.0F); if (hue < 0.166666666667F) { return n1 + (n2 - n1) * hue * 6.0F; } else if (hue < 0.5F) { return n2; } else if (hue < 0.666666666667F) { return n1 + (n2 - n1) * (0.666666666667F - hue) * 6.0F; } else { return n1; } } }; /// /// gml_TColor_HLS -- /// A union type used to represent HLS-encoded color pixels. /// HLS is Metrick's Hue, Lightness, Saturation colorspace. /// The type (and bitwidth) used for each channel is the template parameter. /// template <typename Channel> class gml_TColor_HLS { public: /// /// Constructor -- /// Convert a 24-bit RGB triplet into HLS and fill in the object. /// gml_TColor_HLS (UInt8 const r, UInt8 const g, UInt8 const b) { UInt8 max, min; // max and min RGB values SInt32 h; max = Max (r, g, b); min = Min (r, g, b); #ifndef __GML_AVOID_EUCLIDIAN_DIVISION L = ((max + min) * sChannelMax + 255) / (2 * 255); #else L = (((max + min) * sChannelMax) * 257ULL + (1<<16)) >> 17; #endif // achromatic case if (max == min) { S = H = 0; return; } // chromatic case SInt32 dr, dg, db; // intermediate values: % of spread from max UInt32 dif = max-min; UInt32 sum = Select (UInt32(L), UInt32(sChannelMax / 2), UInt32(max+min), UInt32(2*255 - (max+min))); #ifndef __GML_AVOID_EUCLIDIAN_DIVISION S = ((dif * sChannelMax) + (sum / 2)) / sum; dr = (((max - r) * (sChannelMax / 6)) + (dif / 2)) / dif; dg = (((max - g) * (sChannelMax / 6)) + (dif / 2)) / dif; db = (((max - b) * (sChannelMax / 6)) + (dif / 2)) / dif; #else UInt64 rdif_mnt; // mantissa of dif's reciprocate UInt64 rsum_mnt; // mantissa of sum's reciprocate rdif_mnt = ReciprocalMantissa_15_10bit (dif); rsum_mnt = ReciprocalMantissa_15_10bit (sum); S = (((dif * sChannelMax) + (sum / 2)) * rsum_mnt + (1<<14)) >> 15; dr = ((((max - r) * (sChannelMax / 6)) + (dif / 2)) * rdif_mnt + (1<<14)) >> 15; dg = ((((max - g) * (sChannelMax / 6)) + (dif / 2)) * rdif_mnt + (1<<14)) >> 15; db = ((((max - b) * (sChannelMax / 6)) + (dif / 2)) * rdif_mnt + (1<<14)) >> 15; #endif if (r == max) h = db - dg; else if (g == max) h = (sChannelMax / 3) + dr - db; else /* b == max */ h = ((2 * sChannelMax) / 3) + dg - dr; if (h < 0) H = h + sChannelMax; else if ((UInt32) h > sChannelMax) H = h - sChannelMax; else H = h; } /// /// Constructor -- /// Fill the structure from data in memory /// gml_TColor_HLS (const void *const ptr) { *this = *((gml_TColor_HLS < Channel > *)ptr); } /// /// Constructor -- /// Leave the structure `as is'. I.e. probably zero. /// gml_TColor_HLS () { } /// /// Print -- /// Dump a representation of the pixel to stdout: channels in hex and /// in degrees, percent, percent format. /// @warning no newline appended ! /// void Print () { printf ("% 8X % 8X % 8X (%3d %3d%% %3d%%)", H, L, S, (UInt32) round (fmod (360.0 * H / sChannelMax + 360.0, 360.0)), 100 * L / sChannelMax, 100 * S / sChannelMax); } /// /// Store -- /// Place the structure's data in memory /// void Store (void *const ptr) { *((gml_TColor_HLS<Channel> *) ptr) = *this; } /// /// Convert -- /// Convert the HLS data in this object to a 24 bit RGB triplet. /// void Convert (UInt8 &r, UInt8 &g, UInt8 &b) { SInt32 R, G, B; // RGB component values SInt32 m1, m2; // magic numbers (really!) if (S == 0) { /* achromatic case */ R = G = B = (L * 255) >> (sChannelBits-1); } else { /* chromatic case */ // set up magic numbers if (L <= (sChannelMax / 2)) m2 = (L * (sChannelMax + S) + (sChannelMax / 2)) >> (sChannelBits-1); else m2 = L + S - (((L * S) + (sChannelMax / 2)) >> (sChannelBits-1)); m1 = 2 * L - m2; // get RGB, change units from sChannelMax to 255 R = (HueToRGB (m1, m2, H + (sChannelMax / 3)) * 255 + (sChannelMax / 2)) >> (sChannelBits-1); G = (HueToRGB (m1, m2, H ) * 255 + (sChannelMax / 2)) >> (sChannelBits-1); B = (HueToRGB (m1, m2, H - (sChannelMax / 3)) * 255 + (sChannelMax / 2)) >> (sChannelBits-1); } assert (R >=0 && R <= 255); assert (G >=0 && G <= 255); assert (B >=0 && B <= 255); r = R; g = G; b = B; } /// /// Distance -- /// Compute the 16-bit distance to another HLS pixel. /// The euclidian distance in the hue, saturation disc is used. /// UInt16 Distance (const gml_TColor_HLS<Channel> other) { gml_TColor_HLS_FFF pix0, pix1; pix0.H = Divide (H, sChannelMax); pix0.L = Divide (L, sChannelMax); pix0.S = Divide (S, sChannelMax); pix1.H = Divide (other.H, other.sChannelMax); pix1.L = Divide (other.L, other.sChannelMax); pix1.S = Divide (other.S, other.sChannelMax); return pix0.Distance (pix1); } static UInt8 const sChannelBits = 8 * sizeof (Channel); ///< bits per channel static UInt64 const sChannelMax = (1 << (sChannelBits-1)); ///< max channel value // static UInt64 const sChannelMax = (1 << sChannelBits) - 1; ///< max channel value struct { ///< structure for transparent channel access #if BYTE_ORDER == BIG_ENDIAN Channel H; ///< hue channel Channel L; ///< saturation channel Channel S; ///< value channel #else Channel S; ///< value channel Channel L; ///< saturation channel Channel H; ///< hue channel #endif } GML_PACKED; private: inline static SInt32 HueToRGB (SInt32 n1, SInt32 n2, SInt32 hue) { // range check: note values passed add/subtract thirds of range if (hue < 0) hue += sChannelMax; if (hue > SInt32(sChannelMax)) hue -= sChannelMax; // return r,g, or b value from this tridrant if (hue < SInt32(sChannelMax / 6)) return (n1 + (((n2 - n1) * hue + (sChannelMax / 12)) / (sChannelMax / 6))); if (hue < SInt32(sChannelMax / 2)) return (n2); if (hue < SInt32((sChannelMax * 2) / 3)) return (n1 + (((n2 - n1) * (((sChannelMax * 2) / 3) - hue) + (sChannelMax / 12)) / (sChannelMax / 6))); else return (n1); } }; // // gml_TColor_HLS_888, gml_TColor_HLS_SSS, gml_TColor_HLS_LLL -- // typedef gml_TColor_HLS <UInt8>gml_TColor_HLS_888; typedef gml_TColor_HLS <UInt16>gml_TColor_HLS_SSS; typedef gml_TColor_HLS <UInt32>gml_TColor_HLS_LLL; #endif /* __GML_HLSCOLOR__ */ Generated on Tue Jun 12 14:03:27 2007 for gml by Doxygen 1.5.2.

Contact: julien (dot) letessier (at) gmail (dot) com. Copyright (c) 2000-2007 CLIPS-IMAG Laboratory, Grenoble, France. All rights reserved. W3CXHTML 1.0 W3CCSS 2.0