ColorBuf.h

Go to the documentation of this file.

// Dan  7/22/2004  \DanLP115\Include\ColorBuf.h

#define __COLORBUF_H

#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>
#define V_PI 3.1415926535898

#define BACKGROUNDMASK        0x00FFFFFF
#define MAXCOLOR     255
#define DEPTH24      24
#define NUMMIPLEVEL  4

typedef union {
   struct {
      unsigned blue     :  4;
      unsigned green    :  4;
      unsigned red      :  4;
      unsigned unused   :  3;
      unsigned edge  :  1;
   } bits;
   SWORD color;
} Color;

class RGBAFloat;
class RGBFloat;
class ColorBuf {
public:
   union {
      struct {
#ifndef _MAC
        UBYTE             red, green, blue, alpha;
#else
        UBYTE             alpha, blue, green, red;
#endif
      } values;
      ULONG color;
   };

   void operator += ( const ColorBuf & );
   void operator -= ( const ColorBuf & );
   void operator *= ( const float );
   ColorBuf operator + ( const ColorBuf &other );
   operator COLORREF() { return RGB(values.red, values.green, values.blue); }
   ColorBuf &operator = ( const ColorBuf &other) { color = other.color; return *this; }
   
   RGBFloat GetFactoredRGBFloat() const;
   RGBFloat GetNormalizedRGBFloat() const;

   ColorBuf() { color = 0; values.alpha = MAXCOLOR; }
   ColorBuf( LONG col ) { color = col; values.alpha = MAXCOLOR; }
   ColorBuf( UBYTE pred, UBYTE pgreen, UBYTE pblue ) { values.red = pred; values.green = pgreen; values.blue = pblue; values.alpha = MAXCOLOR; }
   ColorBuf( UBYTE pred, UBYTE pgreen, UBYTE pblue, UBYTE palpha ) { values.red = pred; values.green = pgreen; values.blue = pblue; values.alpha = palpha; }
   ColorBuf( COLORREF c ) { values.red=GetRValue(c); values.green=GetGValue(c); values.blue=GetBValue(c); }
   ColorBuf( const RGBAFloat &color );
   
   UBYTE Red()   const { return values.red; }
   UBYTE Green() const { return values.green; }
   UBYTE Blue()  const { return values.blue; }
   UBYTE Alpha() const { return values.alpha; }
   ULONG Color() const { return color; }
   void Set( UBYTE pred, UBYTE pgreen, UBYTE pblue, UBYTE alpha ) { values.red = pred; values.green = pgreen; values.blue = pblue; values.alpha = alpha; }
   void SetRed( UBYTE red ) { values.red = red; }
   void SetGreen( UBYTE green ) { values.green = green; }
   void SetBlue( UBYTE blue ) { values.blue = blue; }
   void SetAlpha( UBYTE alpha ) { values.alpha = alpha; }
   void SetColor( ULONG pcolor ) { color = pcolor; values.alpha = MAXCOLOR; }
   void GammaCorrect(float power);

   inline RGBFloat Get() const;
   float GetOpacity() const;
   inline void Set( const RGBFloat & );
   void SetOpacity( const float value );
};

inline float ColorBuf::GetOpacity( void ) const
{
   return (float)values.alpha/MAXCOLOR;
}

inline void ColorBuf::SetOpacity( const float opacity )
{
   values.alpha = fast_ftol_unsigned(opacity * MAXCOLOR + .5f);
}

inline void ColorBuf::operator += ( const ColorBuf &other )
{
   int tempred, tempgreen, tempblue, tempalpha;
   if ((tempred = values.red + other.values.red) > MAXCOLOR)
      values.red = MAXCOLOR;
   else
      values.red = tempred;
   if ((tempgreen = values.green + other.values.green) > MAXCOLOR)
      values.green = MAXCOLOR;
   else
      values.green = tempgreen;
   if ((tempblue = values.blue + other.values.blue) > MAXCOLOR)
      values.blue = MAXCOLOR;
   else
      values.blue = tempblue;
   if ((tempalpha = values.alpha + other.values.alpha) > MAXCOLOR)
      values.alpha = MAXCOLOR;
   else
      values.alpha = tempalpha;
}

inline ColorBuf ColorBuf::operator + ( const ColorBuf &other )
{
   ColorBuf temp(*this);
   temp.red += other.values.red;
   temp.green += other.values.green;
   temp.blue += other.values.blue;
   temp.alpha += other.values.alpha;
   return temp;
}

inline void ColorBuf::operator -= ( const ColorBuf &other )
{
   values.red -= other.values.red;
   values.green -= other.values.green;
   values.blue -= other.values.blue;
   values.alpha -= other.values.alpha;
}

inline void ColorBuf::operator *= ( const float factor )
{
   values.red = (UBYTE)(values.red * factor + .5);
   values.green = (UBYTE)(values.green * factor + .5);
   values.blue = (UBYTE)(values.blue * factor + .5);
   values.alpha = (UBYTE)(values.alpha * factor + .5);
}

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

inline void ColorBuf::GammaCorrect(float power)
{
   if (power == 1)
      return;
   ::GammaCorrectColBuf(&values.red,   power);
   ::GammaCorrectColBuf(&values.green, power);
   ::GammaCorrectColBuf(&values.blue,  power);
}

#define MAKELUMINANCE( red, green, blue ) (0.3f*red + 0.59f*green + 0.11f*blue)

---