GiRasterImage.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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) {}

  virtual void setSourceFileName(const OdString&) {}

  virtual void setTransparencyMode(TransparencyMode) {}
};

typedef OdSmartPtr<OdGiRasterImageParam> OdGiRasterImageParamPtr;
 
#include "TD_PackPop.h"
 
#endif //#ifndef _OD_ODGIRASTERIMAGE_H_