bitmap.h

Screen Chatting source

/*
/--------------------------------------------------------------------
|
|      $Id: bitmap.h,v 1.13 2000/03/31 12:20:05 Ulrich von Zadow Exp $
|
|      Copyright (c) 1996-1998 Ulrich von Zadow
|
\--------------------------------------------------------------------
*/

#ifndef INCL_BITMAP
#define INCL_BITMAP

#include "plobject.h"
#include "plpoint.h"
#include "debug.h"

// Define the pixel format for RGB-bitmaps. Change this if you change
// the order of the color components. At the moment, PIXEL_SIZE must
// be 4. The decoders depend on it.
#define PIXEL_SIZE  4
typedef LONG RGBAPIXEL;

#define RGBA_BLUE   0
#define RGBA_GREEN  1
#define RGBA_RED    2
#define RGBA_ALPHA  3

// Note that the preceeding #defines aren't static const ints because
// this breaks preprocessor tests in several places.

//! Device- and OS-independent bitmap class. Manipulates uncompressed
//! bitmaps of all color depths.
//!
//! This class is an abstract base class. It exists to define a
//! format-independent interface for bitmap manipulation and to
//! provide common routines. Derived classes must support at least
//! the color depths 1, 8 and 32 bpp. CBmp defines a public interface
//! for general use and a protected interface for use by derived
//! classes.
//!
//! For 32 bpp, alpha channel information is stored in one byte
//! (RGBA_ALPHA) of each 4-byte pixel. To allow for optimizations
//! when no alpha channel is present, a flag is set whenever the
//! alpha information is valid. The complete alpha channel of a
//! bitmap can be replaced by a different one by calling
//! SetAlphaChannel(). A 0 in an alpha channel entry is completely
//! transparent; a 255 is completely opaque.
class CBmp : public CPLObject
{

public:
  //! Empty constructor. Constructors in derived classes create a
  //! small empty bitmap to ensure that the object is always in a
  //! sane state.
  CBmp
    ();

  //! Empty destructor.
  virtual ~CBmp
    ();

  //! Copy constructor
  CBmp
    ( const CBmp &Orig
    );

  //! Assignment operator. Note that assignment between different derived
  //! classes is possible and results in a format conversion.
  CBmp &operator=
    ( CBmp const &Orig
    );

#ifdef _DEBUG
  virtual void AssertValid
    () const;    // Tests internal object state
#endif

  // CBmp creation

  //! Creates a new empty bitmap. Memory for the bits is allocated
  //! but not initialized. Previous contents of the bitmap object are
  //! discarded. If bAlphaChannel is true, the bitmap is assumed to
  //! contain a valid alpha channel.
  virtual void Create
    ( LONG Width,
      LONG Height,
      WORD BitsPerPixel,
      BOOL bAlphaChannel
    );

  //! Creates a copy of rSrcBmp, converting color depth if nessesary.
  //! Supports 1, 8 and 32 BPP. Alpha channel information is preserved.
  void CreateCopy
    ( const CBmp & rSrcBmp,
      int BPPWanted = 0
    );

  //! Creates a copy of rSrcBmp, converting color information to grayscale
  //! in the process. The resulting bitmap is an 8-bit bitmap.
  void CreateGrayscaleCopy
    ( CBmp & rSrcBmp
    );

  //!
  void CreateRotatedCopy
    ( CBmp & rSrcBmp,
      double angle,
      RGBAPIXEL color
    );

  //! Rotates bitmap around Point. Pos is the current upper-left corner of 
  //! the bitmap. Returns the new position of the upper-left corner.
  CPLPoint CreateRotatedCopyPoint 
    ( CBmp & rSrcBmp, 
      double angle, 
      RGBAPIXEL color, 
      CPLPoint Point, 
      CPLPoint Pos
    );

  //! Creates a bitmap containing only the alpha channel of rSrcBmp.
  void CreateFromAlphaChannel
    ( CBmp & rSrcBmp
    );

  //!
  void CreateResizedBilinear
    ( CBmp& rSrcBmp,
      int NewXSize,
      int NewYSize
    );

  //!
  void CreateResizedBox
    ( CBmp& rSrcBmp,
      int NewXSize,
      int NewYSize,
      double NewRadius
    );

  //!
  void CreateResizedGaussian
    ( CBmp& rSrcBmp,
      int NewXSize,
      int NewYSize,
      double NewRadius
    );

  //!
  void CreateResizedHamming
    ( CBmp& rSrcBmp,
      int NewXSize,
      int NewYSize,
      double NewRadius
    );

  //!
  void CreateCropped
    ( CBmp& rSrcBmp,
      int XMin,
      int XMax,
      int YMin,
      int YMax
    );

  // CBmp manipulation

  //! Sets quality of conversion to 8 bpp. Valid parameters are
  //! defined in Dither8bit.h. (Floyd-Steinberg dithering still seems
  //! to have problems in this release.)
  void SetQuantizationMode
    ( int DitherType,
      int DitherPaletteType
    );

  //! Fills the color table with a grayscale palette. This function
  //! is only useable for bitmaps containing a color table. Index 0
  //! contains black (0) and the last index contains white (255). The
  //! alpha channel is set to opaque (255) for every palette entry.
  void SetGrayPalette
    ();

  //! Sets the color table to pPal. The contents or pPal are copied.
  void SetPalette
    ( RGBAPIXEL * pPal
    );

  //! Sets one entry in the color table. The function may only be
  //! called if there is a color table stored with the bitmap. The
  //! color table entry is set to the red, green, blue, and alpha
  //! values specified.
  void SetPaletteEntry
    ( BYTE Entry,
      BYTE r,
      BYTE g,
      BYTE b,
      BYTE a
    );

  //! Replaces the alpha channel of the bitmap with a new one. This
  //! only works for bitmaps with 32 bpp. pAlphaBmp must point to an
  //! 8 bpp bitmap with the same dimensions as the object. The alpha
  //! channel information is physically copied into the bitmap.
  void SetAlphaChannel
    ( CBmp * pAlphaBmp
    );

  //!
  void ResizeBilinear
    ( int NewXSize,
      int NewYSize
    );

  //!
  void ResizeBox
    ( int NewXSize,
      int NewYSize,
      double NewRadius
    );

  //!
  void ResizeGaussian
    ( int NewXSize,
      int NewYSize,
      double NewRadius
    );

  //!
  void ResizeHamming
    ( int NewXSize,
      int NewYSize,
      double NewRadius
    );

  //!
  void Crop
    ( int XMin,
      int XMax,
      int YMin,
      int YMax
    );

  //!
  void MakeGrayscale
    ();

  //!
  void Rotate
    ( double angle,
      RGBAPIXEL color
    );

  //!
  void Invert
    ();

  //! Slow but simple function to set a single pixel
  void SetPixel
    ( int x,
      int y,
      RGBAPIXEL pixel
    );

  //! Slow but simple function to get a single pixel
  RGBAPIXEL GetPixel
    ( int x,
      int y
    );

  //! Find the nearest color to cr in the palette used by this bitmap
  //! The function returns the palette index of the color if the
  //! bitmap has a palette. For true-color bitmaps, it returns
  //! the color itself.
  int FindNearestColor
    ( RGBAPIXEL cr
    );

  // CBmp information.

  //!
  int GetWidth
    () const;

  //!
  int GetHeight
    () const;

  //!
  virtual long GetMemUsed
    () = 0;

  //!
  int GetNumColors
    ();

  //!
  int GetBitsPerPixel
    () const;

  //!
  BOOL HasAlpha
    () const;

  //!
  void SetHasAlpha
    (BOOL b
    );

  //! Returns number of bytes used per line.
  virtual long GetBytesPerLine
    () = 0;

  // CBmp direct manipulation

  //! Returns the address of the color table of the bitmap or NULL if
  //! no color table exists. The color table is stored as an array of
  //! consecutive RGBAPIXELs.
  RGBAPIXEL * GetPalette
    () const;

  //! Returns pointer to an array containing the starting addresses of
  //! the bitmap lines. This array should be used whenever the bitmap
  //! bits need to be manipulated directly.
  BYTE ** GetLineArray
    () const;

protected:

  //! Create a new bitmap with uninitialized bits. (Assume no memory
  //! is allocated yet.)
  virtual void internalCreate
    ( LONG Width,
      LONG Height,
      WORD BitsPerPixel,
      BOOL bAlphaChannel
    ) = 0;

  //! Delete memory allocated by member variables.
  virtual void freeMembers
    () = 0;

  //! Initialize internal table of line addresses.
  virtual void initLineArray
    () = 0;

  //! Can be called from internalCreate() to initialize object state.
  void initLocals
    ( LONG Width,
      LONG Height,
      WORD BitsPerPixel,
      BOOL bAlphaChannel
    );

  void create32BPPCopy
    ( const CBmp & rSrcBmp
    );

  void create8BPPCopy
    ( const CBmp & rSrcBmp
    );

  void create1BPPCopy
    ( const CBmp & rSrcBmp
    );

  // Member variables

  int m_Width;
  int m_Height;
  WORD m_bpp;

  RGBAPIXEL * m_pClrTab;      // Pointer to the color table.
  BYTE      * m_pBits;        // Pointer to the bits.
  BOOL        m_bAlphaChannel;
  BYTE     ** m_pLineArray;   // Table of the starting addresses of
                              // the lines.
  int m_DitherType;
  int m_DitherPaletteType;

private:
};

inline CBmp::CBmp
    ( const CBmp &Orig
    )
{
  CreateCopy(Orig);
}


inline CBmp & CBmp::operator=
    ( CBmp const &Orig
    )
{
  if (this != &Orig)
    CreateCopy(Orig);
  return *this;
}

inline void CBmp::SetPaletteEntry
    ( BYTE Entry,
      BYTE r,
      BYTE g,
      BYTE b,
      BYTE a
    )
{
  BYTE * pEntry = (BYTE *)(m_pClrTab+Entry);

  pEntry[RGBA_RED] = r;
  pEntry[RGBA_GREEN] = g;
  pEntry[RGBA_BLUE] = b;
  pEntry[RGBA_ALPHA] = a;
}


// CBmp information

inline int CBmp::GetWidth
    () const
{
  PLASSERT_VALID (this);

  return m_Width;

}


inline int CBmp::GetHeight
    () const
{
  PLASSERT_VALID (this);

  return m_Height;
}


inline int CBmp::GetNumColors
    ()
{
  PLASSERT_VALID (this);

  if (m_bpp == 32)
    return 1 << 24;
   else
    return 1 << m_bpp;
}


inline int CBmp::GetBitsPerPixel
    () const
{
  PLASSERT_VALID (this);

  return m_bpp;
}


inline BOOL CBmp::HasAlpha
    () const
{
  PLASSERT_VALID (this);

  return m_bAlphaChannel;
}


inline void CBmp::SetHasAlpha
    (BOOL b
	)
{
  PLASSERT_VALID (this);
  m_bAlphaChannel = b;
}

// CBmp direct manipulation


inline BYTE ** CBmp::GetLineArray
    () const
{
  return m_pLineArray;
}


inline RGBAPIXEL * CBmp::GetPalette
    () const
    // Returns adress of the color table of the bitmap or NULL if no
    // color table exists.
{
  PLASSERT_VALID (this);

  return m_pClrTab;
}

// Global function

inline void SetRGBAPixel
    ( RGBAPIXEL * pPixel,
      BYTE r,
      BYTE g,
      BYTE b,
      BYTE a
    )
{
  ((BYTE *)pPixel)[RGBA_RED  ] = r;
  ((BYTE *)pPixel)[RGBA_GREEN] = g;
  ((BYTE *)pPixel)[RGBA_BLUE ] = b;
  ((BYTE *)pPixel)[RGBA_ALPHA] = a;
}

#ifndef _WINDOWS	// bdelmee; added for *nix
inline BYTE GetRValue(RGBAPIXEL rgba) { return ((BYTE *) &rgba)[RGBA_RED  ]; }
inline BYTE GetGValue(RGBAPIXEL rgba) { return ((BYTE *) &rgba)[RGBA_GREEN]; }
inline BYTE GetBValue(RGBAPIXEL rgba) { return ((BYTE *) &rgba)[RGBA_BLUE ]; }
inline BYTE GetAValue(RGBAPIXEL rgba) { return ((BYTE *) &rgba)[RGBA_ALPHA]; }
#endif

#endif
/*
/--------------------------------------------------------------------
|
|      $Log: bitmap.h,v $
|      Revision 1.13  2000/03/31 12:20:05  Ulrich von Zadow
|      Video invert filter (beta)
|
|      Revision 1.12  2000/03/31 11:53:30  Ulrich von Zadow
|      Added quantization support.
|
|      Revision 1.11  2000/01/16 20:43:12  anonymous
|      Removed MFC dependencies
|
|      Revision 1.10  1999/12/10 01:27:26  Ulrich von Zadow
|      Added assignment operator and copy constructor to
|      bitmap classes.
|
|      Revision 1.9  1999/12/09 16:35:22  Ulrich von Zadow
|      no message
|
|      Revision 1.8  1999/12/08 15:39:45  Ulrich von Zadow
|      Unix compatibility changes
|
|      Revision 1.7  1999/12/02 17:07:34  Ulrich von Zadow
|      Changes by bdelmee.
|
|      Revision 1.6  1999/10/22 21:25:51  Ulrich von Zadow
|      Removed buggy octree quantization
|
|
\--------------------------------------------------------------------
*/