RGBHalf.h

Go to the documentation of this file.

// KB  12/2/2004  \Include\RGBHalf.h

#define __RGBHALF_H

#include "3rdparty/openexr/half.h"

#ifndef __ALLOCATE_H
#include "Allocate.h"
#endif
#ifndef __MACROS_H
#include "Macros.h"
#endif

class ColorBuf;
class RGBFloat;
class RGBAFloat;
class RGBHalf 
{
public:
   half  m_blue, m_green, m_red;
   RGBHalf() { m_red = m_green = m_blue = 0; }

//Copy Constructors
   RGBHalf( const RGBHalf &other );
   RGBHalf( const RGBFloat &colorvector );
   RGBHalf( const float &r, const float &g, const float &b );
   RGBHalf( const float &f ); //(f,f,f)

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

   RGBHalf &operator = ( const RGBHalf &other );
   
   RGBHalf & operator += ( const RGBHalf &other );
   RGBHalf & operator -= ( const RGBHalf &other );
   RGBHalf & operator *= ( const RGBHalf &other );
   RGBHalf & operator *= ( float factor );
   RGBHalf & operator /= ( float factor );
   RGBHalf operator * ( const RGBHalf &other ) const { return RGBHalf(*this) *= other; }
   RGBHalf operator * ( float s ) const { return RGBHalf(*this) *= s; }
   RGBHalf operator / ( float s ) const { return RGBHalf(*this) /= s; }

   RGBHalf operator + ( const RGBHalf &other );

   half operator [] ( int i ) const  { return (&m_red)[i]; }
   half &operator [] (int i) { return (&m_red)[i]; }

   int operator == ( const RGBHalf &other ) const;
   int operator != ( const RGBHalf &other ) const  { return !(*this == other); }   

   half Red()   const { return m_red; }
   half Green() const { return m_green; }
   half Blue()  const { return m_blue; }
   
   void Set( half value ) { m_red = m_green = m_blue = value; }
   void Set( half red, half green, half blue) { m_red = red; m_green = green; m_blue = blue; }
   void SetRed  ( half red   ) { m_red   = red;   }
   void SetGreen( half green ) { m_green = green; }
   void SetBlue ( half blue  ) { m_blue  = blue;  }
   
   void Max(float max) { //Ken, NAP: not sure if this is correct half, float etc
      SetRed(MIN(max, (float)Red()));
      SetGreen(MIN(max, (float)Green()));
      SetBlue(MIN(max, (float)Blue()));
   }
   float GetLuminance() const { return 0.3f*m_red + 0.59f*m_green + 0.11f*m_blue; }
   RGBHalf GammaCorrect( float power)
   {
      if (power == 1)
         *this;
      RGBHalf rvalue; //NAP Bitmap speed
      rvalue.Set(pow((float)m_red, 1.f/power ), pow((float)m_green, 1.f/power ), 
       pow((float)m_blue, 1.f/power ));
      return rvalue;
   }

   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 RGBHalf::RGBHalf( const RGBHalf &other )
{
   (*this) = other;
}
inline RGBHalf::RGBHalf( const float &r, const float &g, const float &b )
{
   m_red = r;
   m_green = g;
   m_blue = b;
}
inline RGBHalf::RGBHalf( const float &f )
{
   m_red = f;
   m_green = f;
   m_blue = f;
}
inline RGBHalf &RGBHalf::operator = ( const RGBHalf &other )
{
   m_red   = other.Red();
   m_green = other.Green();
   m_blue  = other.Blue();
   return *this;
}

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

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

inline RGBHalf & RGBHalf::operator *= ( const RGBHalf &other )
{
   m_red   *= other.Red();
   m_green *= other.Green();
   m_blue  *= other.Blue();
   return *this;
}

inline RGBHalf & RGBHalf::operator *= ( float factor )
{
   m_red  *= factor;
   m_green *= factor;
   m_blue  *= factor;
   return *this;
}

inline RGBHalf & RGBHalf::operator /= ( float factor )
{
   m_red   /= factor;
   m_green /= factor;
   m_blue  /= factor;
   return *this;
}

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

inline int RGBHalf::operator == ( const RGBHalf &other ) const
{
   if (m_red == other.m_red &&
    m_green == other.m_green &&
    m_blue == other.m_blue)
      return TRUE;
   return FALSE;
}

//**********************************************************
//**********************************************************
//**********************************************************
//**********************************************************
class RGBAHalf 
{
public:
   RGBHalf m_color;
   half m_alpha;
     RGBAHalf() { m_alpha = 1; }
//Copy Constructors
   RGBAHalf( const RGBAHalf &other ) { (*this) = other;}
   RGBAHalf( const RGBHalf &other ) : m_color(other) { m_alpha = 1; }
   RGBAHalf( const float &r, const float &g, const float &b, const float &a );
   RGBAHalf( const ColorBuf &colorbuf );
   RGBAHalf( const float &f ) { m_alpha = 1; m_color.m_red = m_color.m_green = m_color.m_blue = f;}

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

   RGBAHalf &operator = ( const RGBAHalf &other );
   inline RGBAHalf &operator = ( const RGBAFloat &other );
   
   RGBAHalf & operator += ( const RGBAHalf &other );
   RGBAHalf & operator -= ( const RGBAHalf &other );
   RGBAHalf & operator *= ( float factor);
   RGBAHalf & operator /= ( float factor);
   RGBAHalf operator * ( float s ) const { return RGBAHalf(*this) *= s; }
   RGBAHalf operator / ( float s ) const { return RGBAHalf(*this) /= s; }

   RGBAHalf operator + ( const RGBAHalf &other );
   RGBAHalf operator - ( const RGBAHalf &other );

   int operator == ( const RGBAHalf &other ) const;
   int operator != ( const RGBAHalf &other ) const  { return !(*this == other); }   

   half operator [] ( int i ) const  { return ((half *) &m_color)[i]; }
   half &operator [] (int i) { return ((half *) &m_color)[i]; }

   RGBHalf Color() const { return m_color; }

   half Red()   const { return m_color.Red(); }
   half Green() const { return m_color.Green(); }
   half Blue()  const { return m_color.Blue(); }
   half Alpha() const { return m_alpha; }

   void SetRed(half red) { m_color.SetRed(red);} 
   void SetGreen(half green) { m_color.SetGreen(green);} 
   void SetBlue(half blue) { m_color.SetBlue(blue);} 

   void SetColor ( RGBHalf &color ) { m_color = color;   }
   void SetAlpha ( half alpha ) { m_alpha = alpha;   }

   void Set( half red, half green, half blue, half alpha) { m_color.Set(red, green, blue); m_alpha = alpha; }
   
   void Max(float max) { 
      m_color.Max(max);
      SetAlpha(MIN(max, (float)Alpha()));
   }

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

inline RGBAHalf::RGBAHalf( const float &r, const float &g, const float &b, const float &a )
{
   m_color.SetRed( r );
   m_color.SetGreen( g );
   m_color.SetBlue( b );
   m_alpha = a;
}

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

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

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

inline RGBAHalf & RGBAHalf::operator *= ( float factor )
{
   m_color *= factor;
   m_alpha *= factor;
   return *this;
}

inline RGBAHalf & RGBAHalf::operator /= ( float factor )
{
   m_color /= factor;
   m_alpha /= factor;
   return *this;
}

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

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

inline int RGBAHalf::operator == ( const RGBAHalf &other ) const
{
   if (m_color == other.Color() && m_alpha == other.Alpha())
      return TRUE;
   return FALSE;
}

//**********************************************************
//**********************************************************
//**********************************************************
//**********************************************************
class YAFloat;
class YAByte;
class YAHalf 
{
public:
   half m_luminance;
   half m_alpha;
   YAHalf() { m_alpha = 1; }
//Copy Constructors
   YAHalf( const YAHalf &other ) { (*this) = other;}
   YAHalf( const half other ) : m_luminance(other) { m_alpha = 1; }
   YAHalf( const YAFloat &other );
   YAHalf( const YAByte &other );
   YAHalf( const float &l, const float &a );
   YAHalf( const float f ) { m_alpha = 1; m_luminance = f;}

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

   YAHalf & operator = ( const YAHalf &other );
   YAHalf & operator = ( const YAFloat &other );
   YAHalf & operator = ( const YAByte &other );
   YAHalf & operator = ( const RGBFloat &other );
   YAHalf & operator = ( const RGBAFloat &other );
   YAHalf & operator = ( const ColorBuf &colorbuf );
   
   YAHalf & operator += ( const YAHalf &other );
   YAHalf & operator -= ( const YAHalf &other );
   YAHalf & operator *= ( float factor);
   YAHalf & operator /= ( float factor);

   YAHalf operator + ( const YAHalf &other );

   int operator == ( const YAHalf &other ) const;
   int operator != ( const YAHalf &other ) const  { return !(*this == other); }   

   half operator [] ( int i ) const  { return ((half *) &m_luminance)[i]; }
   half &operator [] ( int i ) { return ((half *) &m_luminance)[i]; }

   half Luminance() const { return m_luminance; }
   half Alpha() const { return m_alpha; }

   void SetLuminance ( half luminance ) { m_luminance = luminance;   }
   void SetAlpha ( half alpha ) { m_alpha = alpha;   }

   void Set( half luminance, half alpha) { m_luminance = luminance; m_alpha = alpha; }

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

inline YAHalf::YAHalf( const float &l, const float &a )
{
   m_luminance = l;
   m_alpha = a;
}

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

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

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

inline YAHalf & YAHalf::operator *= ( float factor )
{
   m_luminance *= factor;
   m_alpha *= factor;
   return *this;
}

inline YAHalf & YAHalf::operator /= ( float factor )
{
   m_luminance /= factor;
   m_alpha /= factor;
   return *this;
}

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

inline int YAHalf::operator == ( const YAHalf &other ) const
{
   if (m_luminance == other.m_luminance && m_alpha == other.m_alpha)
      return TRUE;
   return FALSE;
}

---