RGBByte.h

Go to the documentation of this file.

// NAP  12/20/2004  \Noel120\Include\RGBByte.h

#define __RGBBYTE_H

#ifndef __ALLOCATE_H
#include "Allocate.h"
#endif
#ifndef __FASTFTOL_H
#include "FastFTOL.h"
#endif
#ifndef __VECTOR_H
#include "Vector.h"
#endif
#ifndef __DATATYPE_H
#include "DataType.h"
#endif
#ifndef __OS9ROS_H
#include "Macros.h"
#endif

class RGBAFloat;
class RGBFloat;

#define MAXCOLOR 255
#define FLOATTOBYTE(flt) MAX(0,MIN(MAXCOLOR, fast_ftol_unsigned((flt) * MAXCOLOR + .5f)))

//******************************************************************************
//** RGBByte
//******************************************************************************
class RGBByte {
public:
#ifdef _MAC
   UBYTE m_red, m_green, m_blue;
#else
   UBYTE m_blue, m_green, m_red;
#endif
   RGBByte() { m_red = m_green = m_blue = 0;  }
   RGBByte( UBYTE pred, UBYTE pgreen, UBYTE pblue ) { m_red = pred; m_green = pgreen; m_blue = pblue; }
   RGBByte( COLORREF c ) { m_red=GetRValue(c); m_green=GetGValue(c); m_blue=GetBValue(c); }
   RGBByte( const RGBFloat &color );

#if _MEMDEBUG
   void             *operator new( size_t size, char *file, const int line ) { return ALLOCBITMAP( size, file, line ); }
#else
   void             *operator new( size_t size ) { return AllocBitmap( size ); }
#endif   
   void              operator delete( void *ptr ) { FreeBitmap( ptr ); }

   RGBByte &operator += ( const RGBByte & );
   RGBByte &operator -= ( const RGBByte & );
   RGBByte &operator *= ( const float );
   RGBByte operator + ( const RGBByte &other );
   operator COLORREF() { return RGB(m_red, m_green, m_blue); }
   RGBByte &operator = ( const RGBByte &other) { m_red=other.m_red;m_green=other.m_green;m_blue=other.m_blue; return *this; }
   RGBByte &operator /= ( float scale )  { return (*this *= (1/scale)); }
   
   RGBFloat GetFactoredRGBFloat() const;
   RGBFloat GetNormalizedRGBFloat() const;

   UBYTE Red()   const { return m_red; }
   UBYTE Green() const { return m_green; }
   UBYTE Blue()  const { return m_blue; }

   void Set( UBYTE pred, UBYTE pgreen, UBYTE pblue ) { m_red = pred; m_green = pgreen; m_blue = pblue; }
   void Set( UBYTE value) { m_red = m_green = m_blue = value; }
   void SetRed( UBYTE red ) { m_red = red; }
   void SetGreen( UBYTE green ) { m_green = green; }
   void SetBlue( UBYTE blue ) { m_blue = blue; }
   RGBByte GammaCorrect(float power);
 
   RGBFloat Get() const;
   void Set( const RGBFloat & );
   
   float GetLuminance() { return 0.3f*m_red + 0.59f*m_green + 0.11f*m_blue; }   

   BOOL CheckOffBound( float lobound, float hibound ) { return FALSE; }; // YP : For HDR testing and debugging purpose
};

inline RGBByte &RGBByte::operator += ( const RGBByte &other )
{
   int tempred, tempgreen, tempblue;
   if ((tempred = m_red + other.m_red) > MAXCOLOR)
      m_red = MAXCOLOR;
   else
      m_red = tempred;
   if ((tempgreen = m_green + other.m_green) > MAXCOLOR)
      m_green = MAXCOLOR;
   else
      m_green = tempgreen;
   if ((tempblue = m_blue + other.m_blue) > MAXCOLOR)
      m_blue = MAXCOLOR;
   else
      m_blue = tempblue;
   return *this;
}

inline RGBByte RGBByte::operator + ( const RGBByte &other )
{
   m_red   += other.m_red;
   m_green += other.m_green;
   m_blue  += other.m_blue;
   return *this;
}

inline RGBByte &RGBByte::operator -= ( const RGBByte &other )
{
   m_red   -= other.m_red;
   m_green -= other.m_green;
   m_blue  -= other.m_blue;
   return *this;
}

inline RGBByte &RGBByte::operator *= ( const float factor )
{
   m_red   = (UBYTE)(m_red   * factor + .5);
   m_green = (UBYTE)(m_green * factor + .5);
   m_blue  = (UBYTE)(m_blue  * factor + .5);
   return *this;
}

inline void GammaCorrect( UBYTE *color, float power)
{
   if (power == 1)
      return;
   *color = fast_round(MIN(255.0f, MAXCOLOR * (float)pow((float)*color/MAXCOLOR, 1.f/power )));
}

inline RGBByte RGBByte::GammaCorrect(float power)
{
   if (power == 1)
      return *this;
   return RGBByte(
    fast_round(MIN(255.0f, MAXCOLOR * (float)pow((float)m_red/MAXCOLOR, 1.f/power ))),
    fast_round(MIN(255.0f, MAXCOLOR * (float)pow((float)m_green/MAXCOLOR, 1.f/power ))),
    fast_round(MIN(255.0f, MAXCOLOR * (float)pow((float)m_blue/MAXCOLOR, 1.f/power ))));
}

//******************************************************************************
//** RGBAByte
//******************************************************************************
class RGBAByte {
public:
   RGBByte m_color;
   UBYTE m_alpha;

   RGBAByte() { m_color.Set(0); m_alpha = MAXCOLOR; }
   RGBAByte( UBYTE pred, UBYTE pgreen, UBYTE pblue ) { m_color.Set(pred, pgreen, pblue); m_alpha = MAXCOLOR; }
   RGBAByte( UBYTE pred, UBYTE pgreen, UBYTE pblue, UBYTE palpha ) { m_color.Set(pred, pgreen, pblue); m_alpha = palpha; }
   RGBAByte( COLORREF c ) : m_color(c) { m_alpha = MAXCOLOR; }
   RGBAByte( const RGBAFloat &color );

#if _MEMDEBUG
   void             *operator new( size_t size, char *file, const int line ) { return ALLOCBITMAP( size, file, line ); }
#else
   void             *operator new( size_t size ) { return AllocBitmap( size ); }
#endif   
   void              operator delete( void *ptr ) { FreeBitmap( ptr ); }

   RGBAByte &operator += ( const RGBAByte & );
   RGBAByte &operator -= ( const RGBAByte & );
   RGBAByte &operator *= ( const float );
   RGBAByte operator + ( const RGBAByte &other );
   operator COLORREF() { return (COLORREF)m_color; }
   RGBAByte &operator = ( const RGBAByte &other) { m_color = other.m_color; m_alpha = other.m_alpha; return *this; }
   RGBAByte &operator /= ( float scale )              { return (*this *= (1/scale)); }
   
   RGBFloat GetFactoredRGBFloat() const;
   RGBFloat GetNormalizedRGBFloat() const;
   RGBAFloat GetFactoredRGBAFloat() const;
   RGBAFloat GetNormalizedRGBAFloat() const;
   
   UBYTE Red()   const { return m_color.m_red; }
   UBYTE Green() const { return m_color.m_green; }
   UBYTE Blue()  const { return m_color.m_blue; }
   UBYTE Alpha() const { return m_alpha; }
   void Set( UBYTE pred, UBYTE pgreen, UBYTE pblue, UBYTE alpha ) { m_color.Set(pred, pgreen, pblue); m_alpha = alpha; }
   void SetRed( UBYTE red ) { m_color.SetRed(red); }
   void SetGreen( UBYTE green ) { m_color.SetGreen(green); }
   void SetBlue( UBYTE blue ) { m_color.SetBlue(blue); }
   void SetAlpha( UBYTE alpha ) { m_alpha = alpha; }
   RGBAByte GammaCorrect(float power) { 
      RGBAByte value; 
      value.m_color = m_color.GammaCorrect(power);
      value.m_alpha = m_alpha;
      return value;
   }

   inline RGBFloat GetRGBFloat() const;
   inline RGBAFloat GetRGBAFloat() const;
   float GetOpacity() const;
   inline void Set( const RGBFloat & );
   inline void Set( const RGBAFloat & );
   void SetOpacity( const float value );
   
   float GetLuminance() { return m_color.GetLuminance(); }

   BOOL CheckOffBound( float lobound, float hibound ) { return FALSE; }; // YP : For HDR testing and debugging purpose
};

inline float RGBAByte::GetOpacity( void ) const
{
   return (float)m_alpha/MAXCOLOR;
}

inline void RGBAByte::SetOpacity( const float opacity )
{
   m_alpha = FLOATTOBYTE(opacity);
}

inline RGBAByte &RGBAByte::operator += ( const RGBAByte &other )
{
   m_color.operator+=(other.m_color);

   int tempalpha;
   if ((tempalpha = m_alpha + other.m_alpha) > MAXCOLOR)
      m_alpha = MAXCOLOR;
   else
      m_alpha = tempalpha;
   return *this;
}

inline RGBAByte RGBAByte::operator + ( const RGBAByte &other )
{
   m_color += other.m_color;
   m_alpha += other.m_alpha;
   return RGBAByte(*this);
}

inline RGBAByte &RGBAByte::operator -= ( const RGBAByte &other )
{
   m_color -= other.m_color;
   m_alpha -= other.m_alpha;
   return *this;
}

inline RGBAByte &RGBAByte::operator *= ( const float factor )
{
   m_color*=factor;
   m_alpha = (UBYTE)(m_alpha * factor + .5);
   return *this;
}

//******************************************************************************
//** YAByte
//******************************************************************************
class YAFloat;
class YAByte {
public:
   UBYTE m_luminance;
   UBYTE m_alpha;

   YAByte() { m_luminance = 0; m_alpha = MAXCOLOR; }
   YAByte( const UBYTE luminance ) { m_luminance = luminance; m_alpha = MAXCOLOR; };
   YAByte( const UBYTE luminance, const UBYTE alpha ) { m_luminance = luminance; m_alpha = alpha; };
   YAByte( const float luminance ) { m_luminance = (UBYTE) (luminance*255.0f); m_alpha = MAXCOLOR; };
   YAByte( const float luminance, const float alpha ) { m_luminance = (UBYTE) (luminance*255.0f); m_alpha = (UBYTE) (alpha*255.0f); };
   // compute CIE Rec.709 luminance
   YAByte( UBYTE pred, UBYTE pgreen, UBYTE pblue ) { m_luminance = (UINT) (pred * 0.2125f + pgreen * 0.7154f + pblue * 0.0721f); m_alpha = MAXCOLOR; }
   YAByte( UBYTE pred, UBYTE pgreen, UBYTE pblue, UBYTE palpha ) { m_luminance = (UINT) (pred * 0.2125f + pgreen * 0.7154f + pblue * 0.0721f); m_alpha = palpha; }

#if _MEMDEBUG
   void             *operator new( size_t size, char *file, const int line ) { return ALLOCBITMAP( size, file, line ); }
#else
   void             *operator new( size_t size ) { return AllocBitmap( size ); }
#endif   
   void              operator delete( void *ptr ) { FreeBitmap( ptr ); }

   YAByte &operator += ( const YAByte & );
   YAByte &operator -= ( const YAByte & );
   YAByte &operator *= ( const float );
   YAByte operator + ( const YAByte &other );
   operator UBYTE() { return m_luminance; }
   YAByte &operator = ( const YAByte &other) { m_luminance = other.m_luminance; m_alpha = other.m_alpha; return *this; }
   YAByte &operator /= ( float scale ) { return (*this *= (1/scale)); }
   
   float GetFactoredFloat() const { return m_luminance; };
   float GetNormalizedFloat() const { return (float) m_luminance/MAXCOLOR; };
   YAFloat GetFactoredRGBAFloat() const;
   YAFloat GetNormalizedRGBAFloat() const;
   
   UBYTE Luminance()   const { return m_luminance; }
   UBYTE Alpha() const { return m_alpha; }
   void Set( UBYTE luminance, UBYTE alpha ) { m_luminance = luminance; m_alpha = alpha; }
   void SetLuminance( UBYTE luminance ) { m_luminance = luminance; }
   void SetLuminance( float luminance ) { m_luminance = (UBYTE) (luminance*MAXCOLOR); }
   void SetAlpha( UBYTE alpha ) { m_alpha = alpha; }
   YAByte GammaCorrect(float power) { 
      if (power == 1)
         return *this;
      YAByte value; 
      value.m_luminance = fast_round(MIN(255.0f, MAXCOLOR * (float)pow((float)m_luminance/MAXCOLOR, 1.f/power )));
      value.m_alpha = m_alpha;
      return value;
   }

   float GetFloat() const { return (float) m_luminance/MAXCOLOR; };
   YAFloat GetYAFloat() const;
   float GetOpacity() const { return (float) m_alpha/MAXCOLOR; };
   void SetOpacity( const float value ) { m_alpha = FLOATTOBYTE(value); };
   float GetLuminance() { return (float) m_luminance / MAXCOLOR; }

   BOOL CheckOffBound( float lobound, float hibound ) { return FALSE; }; // YP : For HDR testing and debugging purpose
};

inline YAByte &YAByte::operator += ( const YAByte &other )
{
   int temp;
   if ((temp = m_luminance + other.m_luminance) > MAXCOLOR)
      m_luminance = MAXCOLOR;
   else
      m_luminance = temp;
   if ((temp = m_alpha + other.m_alpha) > MAXCOLOR)
      m_alpha = MAXCOLOR;
   else
      m_alpha = temp;
   return *this;
}

inline YAByte YAByte::operator + ( const YAByte &other )
{
   m_luminance += other.m_luminance;
   m_alpha += other.m_alpha;
   return YAByte(*this);
}

inline YAByte &YAByte::operator -= ( const YAByte &other )
{
   m_luminance -= other.m_luminance;
   m_alpha -= other.m_alpha;
   return *this;
}

inline YAByte &YAByte::operator *= ( const float factor )
{
   m_luminance = (UBYTE)(m_luminance * factor + .5);
   m_alpha = (UBYTE)(m_alpha * factor + .5);
   return *this;
}

---