GiRasterImage.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _OD_ODGIRASTERIMAGE_H_
#define _OD_ODGIRASTERIMAGE_H_
 
#include "RxObject.h"
 
#include "TD_PackPush.h"
 
class FIRSTDLL_EXPORT OdGiRasterImage : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGiRasterImage);
 
  enum Units
  {
    kNone = 0,
    kMillimeter,
    kCentimeter,
    kMeter,
    kKilometer,
    kInch,
    kFoot,
    kYard,
    kMile,
    kMicroinches,
    kMils,
    kAngstroms,
    kNanometers,
    kMicrons,
    kDecimeters,
    kDekameters,
    kHectometers,
    kGigameters,
    kAstronomical,
    kLightYears,
    kParsecs     
  };
 
  enum ImageSource
  {
    kUndefinedSource = -1, // Flag not set (unknown source).
    kFromDwg         = 0,  // Raster image loaded from raster image definition.
    kFromOleObject   = 1,  // Raster image generated from OLE data source.
    kFromRender      = 2,  // Raster image generated from rendering.
 
    kFromUnderlay    = 10, // Raster image is part of underlay.
    kFromImageBGRA32 = 11, // Raster image wraps OdGiImageBGRA32 image.
 
    // Aliases
    kFromPdfUnderlay = kFromOleObject, // Raster image generated from PdfUnderlay.
    kFromFile        = kFromDwg        // Raster image generated from disk file.
  };
 
  enum TransparencyMode
  {
    kTransparencyDef  = -1, // Default for native raster image (alpha 0 is transparent, 1-255 is opaque).
    kTransparencyOff  = 0,  // Alpha ignored for 32bpp formats.
    kTransparency1Bit = 1,  // Alpha 0-254 is transparent, 255 is opaque.
    kTransparency8Bit = 2   // Complete alpha level support for 32bpp formats.
  };
 
  typedef struct tagPixelFormatInfo
  {
    OdUInt8 redOffset;
    OdUInt8 numRedBits;
    OdUInt8 greenOffset;
    OdUInt8 numGreenBits;
    OdUInt8 blueOffset;
    OdUInt8 numBlueBits;
    OdUInt8 alphaOffset;
    OdUInt8 numAlphaBits;
    OdUInt8 bitsPerPixel;
 
    bool operator ==(const struct tagPixelFormatInfo& other) const
    {
      return (redOffset == other.redOffset) && (greenOffset == other.greenOffset) &&
        (blueOffset == other.blueOffset) && (alphaOffset == other.alphaOffset) && (bitsPerPixel == other.bitsPerPixel) &&
        (numRedBits == other.numRedBits) && (numGreenBits == other.numGreenBits) && (numBlueBits == other.numBlueBits) &&
        (numAlphaBits == other.numAlphaBits);
    }
 
    tagPixelFormatInfo()
      : redOffset(0)
      , numRedBits(0)
      , greenOffset(0)
      , numGreenBits(0)
      , blueOffset(0)
      , numBlueBits(0)
      , alphaOffset(0)
      , numAlphaBits(0)
      , bitsPerPixel(0)
    {}
 
    bool isRGB() const
    {
      return bitsPerPixel == 24 && 
        redOffset == 0 && greenOffset == 8 && blueOffset == 16 && numRedBits == 8 && numGreenBits == 8 && numBlueBits == 8;
    }
 
    void setRGB()
    {
      bitsPerPixel = 24;
      redOffset    = 0;
      greenOffset  = 8;
      blueOffset   = 16;
      numRedBits   = 8;
      numGreenBits = 8;
      numBlueBits  = 8;
    }
 
    bool isBGR() const
    {
      return bitsPerPixel == 24 && 
        redOffset == 16 && greenOffset == 8 && blueOffset == 0 && numRedBits == 8 && numGreenBits == 8 && numBlueBits == 8;
    }
 
    void setBGR()
    {
      bitsPerPixel = 24;
      redOffset    = 16;
      greenOffset  = 8;
      blueOffset   = 0;
      numRedBits   = 8;
      numGreenBits = 8;
      numBlueBits  = 8;
    }
 
    bool is16bitBGR() const
    {
      return bitsPerPixel == 16 && 
        redOffset == 10 && greenOffset == 5 && blueOffset == 0 && numRedBits == 5 && numGreenBits == 5 && numBlueBits == 5;
    }
 
    void set16bitBGR()
    {
      bitsPerPixel = 16;
      redOffset    = 10;
      greenOffset  = 5;
      blueOffset   = 0;
      numRedBits   = 5;
      numGreenBits = 5;
      numBlueBits  = 5;
    }
 
    bool isRGBA() const
    {
      return bitsPerPixel == 32 && alphaOffset == 24 && numAlphaBits == 8 &&
        redOffset == 0 && greenOffset == 8 && blueOffset == 16 && numRedBits == 8 && numGreenBits == 8 && numBlueBits == 8;
    }
 
    void setRGBA()
    {
      bitsPerPixel = 32;
      alphaOffset  = 24;
      numAlphaBits = 8;
      redOffset    = 0;
      greenOffset  = 8;
      blueOffset   = 16;
      numRedBits   = 8;
      numGreenBits = 8;
      numBlueBits  = 8;
    }
 
    bool isBGRA() const
    {
      return bitsPerPixel == 32 && alphaOffset == 24 && numAlphaBits == 8 &&
        redOffset == 16 && greenOffset == 8 && blueOffset == 0 && numRedBits == 8 && numGreenBits == 8 && numBlueBits == 8;
    }
 
    void setBGRA()
    {
      bitsPerPixel = 32;
      alphaOffset  = 24;
      numAlphaBits = 8;
      redOffset    = 16;
      greenOffset  = 8;
      blueOffset   = 0;
      numRedBits   = 8;
      numGreenBits = 8;
      numBlueBits  = 8;
    }
  } PixelFormatInfo;
 
  virtual OdUInt32 pixelWidth() const = 0;
 
  virtual OdUInt32 pixelHeight() const = 0;
 
   virtual Units defaultResolution(double& xPelsPerUnit, double& yPelsPerUnit) const;
 
  virtual OdUInt32 colorDepth() const = 0;
 
  virtual OdUInt32 numColors() const = 0;
 
  virtual int transparentColor() const;
 
  virtual ODCOLORREF color(OdUInt32 colorIndex) const = 0;
 
  virtual OdUInt32 paletteDataSize() const = 0;
 
  virtual void paletteData(OdUInt8* bytes) const = 0;
 
  virtual OdUInt32 scanLineSize() const;
 
  virtual const OdUInt8* scanLines() const = 0;
  
  virtual void scanLines(OdUInt8* scnLines, OdUInt32 firstScanline, OdUInt32 numLines = 1) const = 0;
 
  virtual PixelFormatInfo pixelFormat() const = 0;
 
  virtual OdUInt32 scanLinesAlignment() const = 0;
 
  virtual ImageSource imageSource() const;
 
  virtual const OdString &sourceFileName() const;
 
  virtual TransparencyMode transparencyMode() const;
 
  OdSmartPtr<OdGiRasterImage> changeImageSource(ImageSource source, const OdChar *pFileName = NULL);
 
  OdSmartPtr<OdGiRasterImage> changeSourceFileName(const OdString &fileName);
 
  OdSmartPtr<OdGiRasterImage> changeTransparencyMode(TransparencyMode mode);
 
  static OdUInt32 calcBMPScanLineSize(OdUInt32 pixelWidth, int colorDepth);
 
  static OdUInt32 calcColorMask(OdUInt8 numColorBits, OdUInt8 colorOffset = 0);
 
  OdSmartPtr<OdGiRasterImage> convert(bool convertPaletteToRGB,
    double brightness = 50.0, double contrast = 50.0, double fade = 0.0, ODCOLORREF backgroundColor = 0,
    bool flipX = false, bool flipY = false, bool rotate90 = false,
    const OdGiRasterImage* pDestDesc = 0,
    bool transparency = false) const;
 
  virtual OdSmartPtr<OdGiRasterImage> crop(OdUInt32 x, OdUInt32 y, OdUInt32 width, OdUInt32 height) const;
 
  virtual void *imp() const;
};
 
typedef OdSmartPtr<OdGiRasterImage> OdGiRasterImagePtr;
 
class FIRSTDLL_EXPORT OdGiRasterImageParam : public OdGiRasterImage
{
public:
  ODRX_DECLARE_MEMBERS(OdGiRasterImageParam);
 
  enum ParamType
  {
    kImageSource      = (1 << 0),
    kTransparencyMode = (1 << 1),
    kSourceFileName   = (1 << 2)
  };
 
  virtual OdUInt32 supportedParams() const = 0;
 
  virtual void setImageSource(ImageSource source) { }
 
  virtual void setSourceFileName(const OdString &fileName) { }
 
  virtual void setTransparencyMode(TransparencyMode mode) { }
};
 
typedef OdSmartPtr<OdGiRasterImageParam> OdGiRasterImageParamPtr;
 
#include "TD_PackPop.h"
 
#endif //#ifndef _OD_ODGIRASTERIMAGE_H_