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_LRGColor.h // gml_LRGColor.h -- // // Defines the gml_TColor_LRG 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 March 14, 2003 (JL). // Updated to GML on January 12, 2004 (JL). #ifndef __GML_LRGCOLOR__ #define __GML_LRGCOLOR__ #include <assert.h> #include <stdio.h> #include <float.h> #include "gml/base/gml_Types.h" #include "gml/base/gml_BytePack.h" #include "gml/base/gml_Attributes.h" #include "gml/math/gml_Tables.h" #include "gml/math/gml_Math.h" /// /// gml_TColor_LRG -- /// A union type used to represent LRG-color pixels. /// LRG stands for Luminance, Normalized Red, Normalized Green colorspace. /// /// The channels' storage type is specified as template parameter <Channel>. /// The second template parameter <KSize> specifies an integer type large /// enough to hold all computations. /// /// @bug /// The following should be true, but for now we assume that: /// <pre>sChannelMax == 1 << sChannelBits</pre> in Convert(). /// This of course leads to some rounding errors, max 4/255. /// /// Note that the full range of data that a channel can represent isn't used: /// for instance L values range from 0 to <tt>2 ** (sChannelBits() - 1)</tt>. /// This is done to accelerate some computation, e.g. replacing divisions by /// sChannelMax() by bit-shifting operations. /// /// @note /// Depending on the machine, this code is 10 to 20 times faster than /// OpenCV's version, which uses euclidian divisions extensively. We use a /// small (3k) lookup table and lots of bit-shifting. /// template <typename Channel, typename KSize> class gml_TColor_LRG { public: /// /// Constructor -- /// Convert a 24-bit RGB triplet into LRG and fill in the object. /// gml_TColor_LRG (const UInt8 r, const UInt8 g, const UInt8 b) { #ifndef __GML_AVOID_EUCLIDIAN_DIVISION UInt32 const sum = (UInt32) r + g + b; UInt32 const denom = Max (1UL, (UInt32) r + g + b); L = (sChannelMax() * sum + 765/2) / 765; R = (sChannelMax() * r + denom/2) / denom; G = (sChannelMax() * g + denom/2) / denom; #else UInt32 const sum = (UInt32) r + g + b; // avoid doing a division by 3*255 by noting that 3*255 ~= 2^24 / 21931 ~= 2^17 / 171 // the (1<<23) allows for rounding division (rather than flooring divison) L = ShiftRight (KSize(21931) * sChannelMax() * sum + (1<<23), 24); // avoid divisions by <sum> by using a tabulated reciprocal UInt32 const mantissa = ReciprocalMantissa_15_10bit (sum); KSize const tR = ShiftRight (sChannelMax() * r * mantissa + (1<<14), 15); KSize const tG = ShiftRight (sChannelMax() * g * mantissa + (1<<14), 15); R = Min (sChannelMax(), tR); G = Min (sChannelMax(), tG); // assert (R+G < sChannelMax()); // this should pass, but fails miserably #endif /* __GML_AVOID_EUCLIDIAN_DIVISION */ } /// /// Constructor -- /// Fill the structure from data in memory. /// gml_TColor_LRG (const void * const ptr) { *this = *((gml_TColor_LRG<Channel,KSize>*)ptr); } /// /// Constructor -- /// Leave structure `as is'. /// gml_TColor_LRG () {} /// /// Print -- /// Dump a representation of the pixel to stdout: channels in hex and /// in 8-bit per channel hex format. /// @warning no newline appended ! /// void Print () { printf ("% 8X % 8X % 8X (%02X %02X %02X)", L, R, G, L >> (sChannelBits() - 8), R >> (sChannelBits() - 8), G >> (sChannelBits() - 8) ); } /// /// Store -- /// Place the structure's data in memory /// void Store (void * const ptr) { *((gml_TColor_LRG<Channel,KSize>*)ptr) = *this; } /// /// Convert -- /// Convert the LRG data in this object to a 24 bit RGB triplet. /// void Convert (UInt8 &r, UInt8 &g, UInt8 &b) { /// @todo replace the ?: selector with Select() #ifndef __GML_AVOID_EUCLIDIAN_DIVISION KSize const denom = sChannelMax() * sChannelMax(); Channel const B = ((KSize) R+G >= sChannelMax()) ? 0 : (sChannelMax() - (R+G)); UInt32 const tr = (KSize(765) * L * R + denom/2) / denom; UInt32 const tg = (KSize(765) * L * G + denom/2) / denom; UInt32 const tb = (KSize(765) * L * B + denom/2) / denom; r = Min (tr, 255UL); g = Min (tg, 255UL); b = Min (tb, 255UL); #else KSize const delta = (1 << (2*sChannelBits()-9)); // for rounding division Channel const B = ((KSize) R+G >= sChannelMax()) ? 0 : (sChannelMax() - (R+G)); UInt32 const tr = (KSize(3) * L * R + delta) >> (2*sChannelBits()-8); UInt32 const tg = (KSize(3) * L * G + delta) >> (2*sChannelBits()-8); UInt32 const tb = (KSize(3) * L * B + delta) >> (2*sChannelBits()-8); r = Min (tr, 255UL); g = Min (tg, 255UL); b = Min (tb, 255UL); #endif } /// /// Distance -- /// Compute the 16-bit distance to another LRG pixel. /// Depending on __GML_LRG_USE_EUCLIDIAN_DISTANCE, /// the euclidian distance in the (Cr,Cg) plane is used, or /// the city block distance. /// UInt16 Distance (const gml_TColor_LRG<Channel,KSize> other) { return Min (65535UL, #ifdef __GML_LRGCOLOR_USE_EUCLIDIAN_DISTANCE 64UL * Norm ( ShiftRight (R, sChannelBits() - 12), ShiftRight (G, sChannelBits() - 12), ShiftRight (other.R, sChannelBits() - 12), ShiftRight (other.G, sChannelBits() - 12) ) #else (UInt32) ShiftLeft ( KSize (Abs (KSize (other.R) - KSize (R)) + Abs (KSize (other.G) - KSize (G))), 18 - sChannelBits() ) #endif ); } inline static UInt8 sChannelBits() { return 8 * sizeof (Channel); } ///< bits per channel inline static KSize sChannelMax() { return (1ULL << sChannelBits()) - 1; } ///< max channel value struct { ///< structure for transparent channel access #if BYTE_ORDER == BIG_ENDIAN Channel L; ///< luminance channel Channel R; ///< red chrominance channel Channel G; ///< green chrominance channel #else Channel G; ///< green chrominance channel Channel R; ///< red chrominance channel Channel L; ///< luminance channel #endif } GML_PACKED; }; // // gml_TColor_LRG_888, gml_TColor_LRG_SSS, gml_TColor_LRG_LLL -- // 24-bit, 48-bit, and 96-bit structures for LRG-color pixels. // typedef gml_TColor_LRG<UInt8, SInt32> gml_TColor_LRG_888; typedef gml_TColor_LRG<UInt16, SInt64> gml_TColor_LRG_SSS; typedef gml_TColor_LRG<UInt32, SInt64> gml_TColor_LRG_LLL; /// /// gml_TColor_LRG_FFF -- /// Floating-point variant of gml_TColor_LRG. /// class gml_TColor_LRG_FFF : public gml_TColor_LRG<Float32, Float32> { public: /// /// Constructor -- /// Convert a 24-bit RGB triplet into LRG and fill in the object. /// gml_TColor_LRG_FFF (const UInt8 r, const UInt8 g, const UInt8 b) { Float32 const sum = (Float32) r + g + b; L = Divide (sum, 765.0F); R = Divide (r, sum + FLT_EPSILON); G = Divide (g, sum + FLT_EPSILON); assert (0.0F <= L && L <= 1.0F); assert (0.0F <= R && R <= 1.0F); assert (0.0F <= G && G <= 1.0F); } /// /// Constructor -- /// Fill the structure from data in memory. /// gml_TColor_LRG_FFF (const void * const ptr) { *this = *((gml_TColor_LRG_FFF*)ptr); assert (0.0F <= L && L <= 1.0F); assert (0.0F <= R && R <= 1.0F); assert (0.0F <= G && G <= 1.0F); } /// /// Print -- /// Dump a representation of the pixel to stdout: channels in hex and /// in 8-bit per channel hex format. /// @warning no newline appended ! /// void Print () { printf ("%f %f %f (%02X %02X %02X)", L, R, G, (unsigned int) LFloor (255.0F * L), (unsigned int) LFloor (255.0F * R), (unsigned int) LFloor (255.0F * G) ); } /// /// Convert -- /// Convert the LRG data in this object to a 24 bit RGB triplet. /// void Convert (UInt8 &r, UInt8 &g, UInt8 &b) { r = LRound (765.0F * L * R); g = LRound (765.0F * L * G); b = LRound (765.0F * L * (1.0F - R - G)); } /// /// Distance -- /// Compute the 16-bit distance to another LRG pixel. /// Depending on __GML_LRG_USE_EUCLIDIAN_DISTANCE, /// the euclidian distance in the (Cr,Cg) plane is used, or /// the city block distance. /// UInt16 Distance (const gml_TColor_LRG_FFF other) { return Min (65535UL, #ifdef __GML_LRGCOLOR_USE_EUCLIDIAN_DISTANCE LFloor (64.0F * 255.0F * Norm (R, G, other.R, other.G)) #else LFloor (1024.0F * 255.0F * (Abs (other.R - R) + Abs (other.G - G))) #endif ); } static Float32 sChannelMax() { return 1.0F; }; ///< max channel value }; #endif /* __GML_LRGCOLOR__ */ 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