RGBFloat.h

Go to the documentation of this file.

// NAP  12/13/2004  \Noel120\Include\RGBFloat.h

#ifndef __RGBFLOAT_H
#define __RGBFLOAT_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

#include <math.h>

class RGBHalf;
class ColorBuf;
class RGBByte;
//******************************************************************************
//** RGBFloat
//******************************************************************************
class RGBFloat {
public:
   float m_blue;
   float m_green;
   float m_red;

   RGBFloat( void ) { }
   RGBFloat( float red, float green, float blue ) { m_red = red; m_green = green; m_blue = blue; }
   RGBFloat( const float scalar ) { m_red = m_green = m_blue = scalar; }
   RGBFloat( COLORREF c ) { m_red=GetRValue(c); m_green=GetGValue(c); m_blue=GetBValue(c); }
   RGBFloat( const RGBFloat &other ) { *this = other; }
   RGBFloat( const RGBHalf &other );
   RGBFloat( const RGBByte &other );

#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 ); }

   RGBFloat & operator = ( float scalar) { m_red = m_green = m_blue = scalar; return *this; }
   RGBFloat & operator = ( const RGBFloat &other) { m_red = other.m_red; m_green = other.m_green; m_blue = other.m_blue; return *this; }

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

   float Red() const   { return m_red;   }
   float Green() const { return m_green; }
   float Blue() const { return m_blue;  }   
   
   void SetRed(float red)     { m_red = red;   }
   void SetGreen(float green) { m_green = green; }
   void SetBlue(float blue)   { m_blue = blue;  }   
   
   void Set( float red, float green, float blue ) { m_red = red; m_green = green; m_blue = blue; }
   void Set( float init ) { m_red = m_green = m_blue = init; }

   int operator == ( const RGBFloat &a )       const { return (m_red == a.m_red) && (m_green == a.m_green) && (m_blue == a.m_blue); }
   int operator != ( const RGBFloat &a )       const { return !(*this == a); }   

   RGBFloat operator + ( const RGBFloat &a ) const { return RGBFloat(*this) += a; }
   RGBFloat operator - ( const RGBFloat &a ) const { return RGBFloat(*this) -= a; }
   RGBFloat operator * ( const RGBFloat &a ) const { return RGBFloat(*this) *= a; }
   RGBFloat operator * ( float s )              const { return RGBFloat(*this) *= s; }
   RGBFloat operator / ( float s )              const { return RGBFloat(*this) /= s; }
   RGBFloat operator / ( const RGBFloat &a ) const { return RGBFloat(*this) /= a; }
   float operator[]( int i ) const { ASSERT(i < 3); return (&m_blue)[i]; }

   COLORREF GetCOLORREF() const { return RGB(fast_round(MAX(0.0f,MIN(255.0f, m_red))), fast_round(MAX(0.0f,MIN(255.0f, m_green))), fast_round(MAX(0.0f,MIN(255.0f, m_blue)))); }
   float GetLuminance() const { return 0.3f*m_red + 0.59f*m_green + 0.11f*m_blue; }

   friend RGBFloat operator * ( const float s, const RGBFloat &a )  { return a * s; }
   
   void Min(float min) { if (m_red<min) m_red=min; if (m_green<min) m_green=min; if (m_blue<min) m_blue=min; }
   void Max(float max) { if (m_red>max) m_red=max; if (m_green>max) m_green=max; if (m_blue>max) m_blue=max; }
   void MinMax(float min, float max) { if (m_red>max) m_red=max; else if (m_red<min) m_red=min; 
                                       if (m_green>max) m_green=max; else if (m_green<min) m_green=min;
                                       if (m_blue>max) m_blue=max; else if (m_blue<min) m_blue=min; }
   RGBFloat GammaCorrect( float power ) const
   {
      if (power == 1)
         *this;
      return RGBFloat((float)pow(m_red, 1.f/power ), (float)pow(m_green, 1.f/power ), 
       (float)pow(m_blue, 1.f/power ));
   }

   BOOL CheckOffBound( float lobound, float hibound ) { // YP : For HDR testing and debugging purpose
      if ( m_red < lobound || m_red > hibound )
         return TRUE;
      if ( m_green < lobound || m_green > hibound )
         return TRUE;
      if ( m_blue < lobound || m_blue > hibound )
         return TRUE;
      return FALSE;
   };
};

inline RGBFloat GetSpectrumColor(float x)
{
   float theta = (1.66f * (float)V_PI) * x;
   return RGBFloat((2.0f+(float)cos(theta))/3.0f, (1.0f+(float)cos(theta-(2.0f*V_PI/3.0f)))/2.0f, (2.0f+(float)cos(theta-(4.0f*V_PI/3.0f)))/3.0f);
}

//*****************************************************************************
//** RGBAFloat
//*****************************************************************************
class RGBAHalf;
class RGBAByte;
class RGBAFloat 
{
public:
   RGBFloat m_color;
   float m_alpha;

   RGBAFloat( void ) { }
   RGBAFloat( float red, float green, float blue, float alpha ) : m_color(red, green, blue) {m_alpha = alpha; }
   RGBAFloat( float scalar ) : m_color(scalar) { m_alpha = scalar; }
   RGBAFloat( COLORREF c ) : m_color(c) { m_alpha = 1.0f; }
   RGBAFloat( const RGBAFloat &other ) { *this = other; }
   RGBAFloat( const RGBAHalf &other );
   RGBAFloat( const RGBAByte &other );
   RGBAFloat( const ColorBuf &other );
   RGBAFloat( const RGBHalf &other );

#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 ); }

   RGBAFloat & operator = ( const RGBAFloat &other) { m_color = other.Color(); m_alpha = other.Alpha(); return *this; }

   RGBAFloat & operator += ( const RGBAFloat &other ) { m_color += other.Color(); m_alpha += other.m_alpha; return *this; }
   RGBAFloat & operator -= ( const RGBAFloat &other ) { m_color -= other.Color(); m_alpha -= other.m_alpha; return *this; }
   RGBAFloat & operator *= ( const RGBAFloat &other ) { m_color *= other.Color(); m_alpha *= other.m_alpha; return *this; }
   RGBAFloat & operator *= ( float scale ) { m_color *= scale; m_alpha *= scale; return *this; }
   RGBAFloat & operator /= ( const RGBAFloat &other ) { m_color /= other.Color(); m_alpha /= other.m_alpha; return *this; }
   RGBAFloat & operator /= ( float scale ) { return (*this *= (1/scale)); }

   RGBFloat Color() const { return m_color; }
   float Red() const { return m_color.Red();  }   
   float Green() const { return m_color.Green();  }   
   float Blue() const { return m_color.Blue();  }   
   float Alpha() const { return m_alpha;  }   
   void SetRed(float red) { m_color.SetRed(red); }
   void SetGreen(float green) { m_color.SetGreen(green); }
   void SetBlue(float blue) { m_color.SetBlue(blue); }
   void SetAlpha(float alpha) { m_alpha = alpha; }

   void Set( float red, float green, float blue, float alpha )  { m_color.Set(red, green, blue); m_alpha = alpha; }
   void Set( float init ) { m_color.Set(init); m_alpha = init; }
   void SetNoAlpha( const RGBFloat &color) { m_color = color; }
   
   int operator == ( const RGBAFloat &a )       const { return (m_color == a.Color()) && (m_alpha == a.Alpha()); }
   int operator != ( const RGBAFloat &a )       const { return !(*this == a); }   

   RGBAFloat operator + ( const RGBAFloat &a ) const { return RGBAFloat(*this) += a; }
   RGBAFloat operator - ( const RGBAFloat &a ) const { return RGBAFloat(*this) -= a; }
   RGBAFloat operator * ( const RGBAFloat &a ) const { return RGBAFloat(*this) *= a; }
   RGBAFloat operator * ( float s )              const { return RGBAFloat(*this) *= s; }
   RGBAFloat operator / ( float s )              const { return RGBAFloat(*this) /= s; }
   RGBAFloat operator / ( const RGBAFloat &a ) const { return RGBAFloat(*this) /= a; }
   float operator[]( int i ) const { ASSERT(i < 4); return (&m_color.m_blue)[i]; }

   friend RGBAFloat operator * ( const float s, const RGBAFloat &a )  { return a * s; }

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

//*****************************************************************************
//** YAFloat
//*****************************************************************************
class YAHalf;
class YAByte;
class YAFloat 
{
public:
   float m_luminance;
   float m_alpha;

   YAFloat( void ) { }
   YAFloat( float luminance ) : m_luminance(luminance), m_alpha(1.0f) {};
   YAFloat( float luminance, float alpha ) : m_luminance(luminance), m_alpha(alpha) {};
   YAFloat( const YAFloat &other ) { *this = other; }
   YAFloat( const YAHalf &other );
   YAFloat( const YAByte &other );

   // Compute the CIE Rec.709 luminance
   YAFloat( const RGBAFloat &other ) { m_luminance = other.Red() * 0.2125f + other.Green() * 0.7154f + other.Blue() * 0.0721f; m_alpha = other.Alpha(); };
   YAFloat( const RGBAHalf &other );
   YAFloat( const RGBAByte &other );
   YAFloat( const ColorBuf &other );
   YAFloat( const RGBHalf &other );
   YAFloat( const RGBByte &other );

#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 ); }

   YAFloat & operator = ( const YAFloat &other) { m_luminance = other.m_luminance; m_alpha = other.m_alpha; return *this; }

   YAFloat & operator += ( const YAFloat &other ) { m_luminance += other.m_luminance; m_alpha += other.m_alpha; return *this; }
   YAFloat & operator -= ( const YAFloat &other ) { m_luminance -= other.m_luminance; m_alpha -= other.m_alpha; return *this; }
   YAFloat & operator *= ( const YAFloat &other ) { m_luminance *= other.m_luminance; m_alpha *= other.m_alpha; return *this; }
   YAFloat & operator *= ( float scale ) { m_luminance *= scale; m_alpha *= scale; return *this; }
   YAFloat & operator /= ( const YAFloat &other ) { m_luminance /= other.m_luminance; m_alpha /= other.m_alpha; return *this; }
   YAFloat & operator /= ( float scale ) { return (*this *= (1/scale)); }

   float Luminance() const { return m_luminance; }
   float Alpha() const { return m_alpha;  }   
   void SetLuminance(float luminance) { m_luminance = luminance; }
   void SetAlpha(float alpha) { m_alpha = alpha; }

   void Set( float luminance, float alpha )  { m_luminance = luminance; m_alpha = alpha; }
   void Set( float luminance ) { m_luminance = luminance; m_alpha = 1.0f; }
   // Compute the CIE Rec.709 luminance
   void Set( float red, float green, float blue, float alpha=1.0f ) { m_luminance = red * 0.2125f + green * 0.7154f + blue * 0.0721f; m_alpha = alpha; };
   void SetNoAlpha( const float luminance) { m_luminance = luminance; }
   
   int operator == ( const YAFloat &a )       const { return (m_luminance == a.m_luminance) && (m_alpha == a.m_alpha); }
   int operator != ( const YAFloat &a )       const { return !(*this == a); }   

   YAFloat operator + ( const YAFloat &a ) const { return YAFloat(*this) += a; }
   YAFloat operator - ( const YAFloat &a ) const { return YAFloat(*this) -= a; }
   YAFloat operator * ( const YAFloat &a ) const { return YAFloat(*this) *= a; }
   YAFloat operator * ( float s )              const { return YAFloat(*this) *= s; }
   YAFloat operator / ( float s )              const { return YAFloat(*this) /= s; }
   YAFloat operator / ( const YAFloat &a ) const { return YAFloat(*this) /= a; }
   float operator[]( int i ) const { ASSERT(i < 2); return (&m_luminance)[i]; }

   friend YAFloat operator * ( const float s, const YAFloat &a )  { return a * s; }

   BOOL CheckOffBound( float lobound, float hibound ) { // YP : For HDR testing and debugging purpose
      if ( m_luminance < lobound || m_luminance > hibound )
         return TRUE;
      return FALSE;
   };
};
#endif

---