GiRasterImage.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 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:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdGiRasterImage);
  //DOM-IGNORE-END
 
  enum Units
  {
    kNone = 0,
    kMillimeter,
    kCentimeter,
    kMeter,
    kKilometer,
    kInch,
    kFoot,
    kYard,
    kMile,
    kMicroinches,
    kMils,
    kAngstroms,
    kNanometers,
    kMicrons,
    kDecimeters,
    kDekameters,
    kHectometers,
    kGigameters,
    kAstronomical,
    kLightYears,
    kParsecs
  };
 
  static double millimetersInUnit(Units units)
  {
    switch (units)
    {
    case kNone:
      throw OdError(eInvalidInput);
    case kMillimeter:
      return 1.0;
    case kCentimeter:
      return 10.0;
    case kMeter:
      return 1000.0;
    case kKilometer:
      return 1000000.0;
    case kInch:
      return 25.4;
    case kFoot:
      return 25.4 * 12.0;
    case kYard:
      return 25.4 * 12.0 * 3.;
    case kMile:
      return 25.4 * 12.0 * 3. * 1760.;
    case kMicroinches:
      return 25.4 * 0.000001;
    case kMils:
      return 25.4 * 0.001;
    case kAngstroms:
      return 1000.0 * 1.e-10;
    case kNanometers:
      return 0.000001;
    case kMicrons:
      return 0.001;
    case kDecimeters:
      return 100.0;
    case kDekameters:
      return 10000.0;
    case kHectometers:
      return 100000.0;
    case kGigameters:
      return 1000. * 1.e9;
    case kAstronomical:
      return 1000. * 149597870700.;   // Approx. the length of the semi-major axis of the Earth's elliptical orbit around the Sun
    case kLightYears:
      return 1000. * 9460730472580800.;
    case kParsecs:
      return 1000. * 30856775814671900.;
    }
    ODA_ASSERT_ONCE(!"Unknown unit");
    return 1.0;
  }
 
  enum ImageSource
  {
    kUndefinedSource = -1,
    kFromDwg         = 0,
    kFromOleObject   = 1,
    kFromRender      = 2,
 
    kFromUnderlay    = 10,
    kFromImageBGRA32 = 11,
 
    // Aliases
    kFromPdfUnderlay = kFromOleObject,
    kFromFile        = kFromDwg
  };
 
  enum TransparencyMode
  {
    kTransparencyDef  = -1,
    kTransparencyOff  = 0,
    kTransparency1Bit = 1,
    kTransparency8Bit = 2
  };
 
  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; // Represents data for pixel formatting.
 
  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:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdGiRasterImageParam);
  //DOM-IGNORE-END
 
  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_