///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, 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-2016 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_ODEXGIRASTERIMAGE_H_
|
#define _OD_ODEXGIRASTERIMAGE_H_
|
|
#include "TD_PackPush.h"
|
|
#include "OdBinaryData.h"
|
#include "Gi/GiRasterImage.h"
|
#include "FlatMemStream.h"
|
#include "OdPlatform.h"
|
#include "RxRasterServices.h"
|
#include "StaticRxObject.h"
|
|
class OdExGiRasterImage;
|
/** \details
|
This template class is a specialization of the OdSmartPtr class for OdExGiRasterImage object pointers.
|
*/
|
typedef OdSmartPtr<OdExGiRasterImage> OdExGiRasterImagePtr;
|
/** \details
|
This class represents a raster image within the Teigha vectorization framework.
|
<group ExServices_Classes>
|
Library: Source code provided.
|
*/
|
class OdExGiRasterImage : public OdGiRasterImageParam
|
{
|
public:
|
OdRxObjectPtr clone() const
|
{
|
OdSmartPtr<OdExGiRasterImage> pRes = OdRxObjectImpl<OdExGiRasterImage>::createObject();
|
pRes->m_bits = m_bits;
|
pRes->m_palette = m_palette;
|
pRes->m_header = m_header;
|
pRes->m_imageSource = m_imageSource;
|
pRes->m_transparencyMode = m_transparencyMode;
|
return (OdRxObject*)pRes;
|
}
|
|
struct Header
|
{
|
Header(OdUInt32 width, OdUInt32 height, OdUInt16 bitPerPixel)
|
: m_width(width), m_height(height)
|
, m_bitPerPixel(bitPerPixel)
|
, m_xPelsPerUnit(0.0)
|
, m_yPelsPerUnit(0.0)
|
, m_resUnits(OdGiRasterImage::kNone)
|
{}
|
Header()
|
: m_width(0), m_height(0)
|
, m_bitPerPixel(0)
|
, m_xPelsPerUnit(0.0)
|
, m_yPelsPerUnit(0.0)
|
, m_resUnits(OdGiRasterImage::kNone)
|
{}
|
|
OdUInt32 m_width;
|
OdUInt32 m_height;
|
OdUInt16 m_bitPerPixel;
|
double m_xPelsPerUnit,
|
m_yPelsPerUnit;
|
OdGiRasterImage::Units
|
m_resUnits;
|
};
|
|
class Palette
|
{
|
OdBinaryData m_colorsData;
|
public:
|
const OdUInt8* getData() const { return m_colorsData.getPtr(); }
|
OdBinaryData& data() { return m_colorsData; }
|
const OdBinaryData& getBinData() const { return m_colorsData; }
|
OdUInt32 numColors() const { return m_colorsData.size() / 4; }
|
void setNumColors(OdUInt32 nColors) { m_colorsData.resize(nColors * 4); }
|
void setColorAt(OdUInt32 nIndex, OdUInt8 blue, OdUInt8 green, OdUInt8 red, OdUInt8 alpha = 0)
|
{
|
ODA_ASSERT(nIndex < m_colorsData.size());
|
nIndex *= 4;
|
m_colorsData[nIndex] = blue;
|
m_colorsData[nIndex + 1] = green;
|
m_colorsData[nIndex + 2] = red;
|
m_colorsData[nIndex + 3] = alpha;
|
}
|
|
void colorAt(OdUInt32 nIndex, OdUInt8& blue, OdUInt8& green, OdUInt8& red, OdUInt8* pAlpha = 0) const
|
{
|
ODA_ASSERT(nIndex < m_colorsData.size());
|
nIndex *= 4;
|
blue = m_colorsData[nIndex];
|
green = m_colorsData[nIndex + 1];
|
red = m_colorsData[nIndex + 2];
|
if(pAlpha)
|
{
|
*pAlpha = m_colorsData[nIndex + 3];
|
}
|
}
|
};
|
|
private:
|
Header m_header;
|
OdBinaryData m_bits;
|
Palette m_palette;
|
ImageSource m_imageSource;
|
TransparencyMode m_transparencyMode;
|
public:
|
/** \param bitsPerPixel [in] Color depth.
|
\param xPixels [in] X pixels.
|
\param yPixels [in] Y pixels.
|
*/
|
OdExGiRasterImage(OdUInt32 xPixels, OdUInt32 yPixels, OdUInt8 bitsPerPixel);
|
OdExGiRasterImage();
|
|
/** \details
|
Returns the size in bytes of the pixel data for a specified (or this) RasterImage object.
|
\param bitsPerPixel [in] Color depth.
|
\param xPixels [in] X pixels.
|
\param yPixels [in] Y pixels.
|
*/
|
static OdUInt32 bitDataSize(OdUInt32 xPixels, OdUInt32 yPixels, OdUInt16 bitsPerPixel)
|
{
|
return ((xPixels * bitsPerPixel +31) & ~31) /8 * yPixels;
|
}
|
|
OdUInt32 bitDataSize()
|
{
|
return OdExGiRasterImage::bitDataSize(m_header.m_width, m_header.m_height,
|
m_header.m_bitPerPixel);
|
}
|
|
/** \details
|
Returns a reference to the binary data for this RasterImage object.
|
*/
|
OdBinaryData& bits() { return m_bits; }
|
/** \details
|
Returns a the binary data for this RasterImage object.
|
*/
|
const OdBinaryData& getBits() const { return m_bits; }
|
|
/** \details
|
Returns an array of scan lines for this RasterImage object.
|
\param numBytes [out] Receives the number of bytes in the array.
|
*/
|
const OdUInt8* getScanLines(OdUInt32& numBytes) const
|
{
|
numBytes = m_bits.size();
|
return m_bits.asArrayPtr();
|
}
|
|
/** \details
|
Sets the binary data for this RasterImage object.
|
\param data [in] Binary data.
|
\param numBytes [in] Number of bytes in the array.
|
*/
|
void setBits(const OdBinaryData& data)
|
{
|
ODA_ASSERT(data.size() <= bitDataSize());
|
m_bits = data;
|
}
|
|
void setBits(const OdUInt8* data, OdUInt32 numBytes)
|
{
|
ODA_ASSERT(numBytes <= bitDataSize());
|
m_bits.resize(numBytes);
|
::memcpy(m_bits.asArrayPtr(), data, numBytes);
|
}
|
|
/** \details
|
Sets the metrics of this ReasterImage object.
|
|
\param bitsPerPixel [in] Color depth.
|
\param xPixels [in] X pixels.
|
\param yPixels [in] Y pixels.
|
*/
|
void setMetrics(OdUInt32 xPixels, OdUInt32 yPixels, OdUInt16 bitsPerPixel)
|
{
|
m_header.m_width = xPixels;
|
m_header.m_height = yPixels;
|
m_header.m_bitPerPixel = bitsPerPixel;
|
m_transparencyMode = (bitsPerPixel < 32) ? kTransparencyDef : kTransparency8Bit;
|
}
|
|
/** \details
|
Sets the default image resolution in pixels per unit of this RasterImage object.
|
|
\param xPelsPerUnit [in] Pixels per unit value (x direction).
|
\param yPelsPerUnit [in] Pixels per unit value (y direction).
|
\param units [in] Units.
|
*/
|
void setDefaultResolution(OdGiRasterImage::Units units, double xPelsPerUnit, double yPelsPerUnit)
|
{
|
m_header.m_resUnits = units;
|
m_header.m_xPelsPerUnit = xPelsPerUnit;
|
m_header.m_yPelsPerUnit = yPelsPerUnit;
|
}
|
|
/** \details
|
Sets the number of colors in the palette of this RasterImage object.
|
\param numColors [in] Number of colors.
|
*/
|
void setPalNumColors(OdUInt32 numColors)
|
{
|
m_palette.setNumColors(numColors);
|
}
|
|
/** \details
|
Returns the number of colors in the palette of this RasterImage object.
|
*/
|
OdUInt32 getPalNumColors() const
|
{
|
return m_palette.numColors();
|
}
|
|
/** \details
|
Returns the palette of this RasterImage object.
|
*/
|
const Palette& getPalette() const
|
{
|
return m_palette;
|
}
|
|
/** \details
|
Returns the size in bytes of the palette of this RasterImage object.
|
*/
|
OdUInt32 paletteDataSize() const
|
{
|
return m_palette.getBinData().size();
|
}
|
|
/** \details
|
Returns the palette data of this RasterImage object.
|
\param bytes [in] Receives the data.
|
*/
|
void paletteData(OdUInt8* bytes) const
|
{
|
const OdBinaryData& palData = m_palette.getBinData();
|
memcpy(bytes, palData.asArrayPtr(), palData.size());
|
}
|
|
/** \details
|
Returns the palette of this RasterImage object.
|
\param bytes [in] Receives the data.
|
*/
|
Palette& palette()
|
{
|
return m_palette;
|
}
|
/** \details
|
Sets the specified color in the palette of this RasterImage object.
|
|
\param paletteIndex [in] Color number.
|
\param blue [in] Blue component.
|
\param green [in] Green component.
|
\param red [in] Red component.
|
\param alpha [in] Alpha component.
|
*/
|
void setPalColorAt(OdUInt32 paletteIndex, OdUInt8 blue, OdUInt8 green, OdUInt8 red, OdUInt8 alpha = 0)
|
{
|
m_palette.setColorAt(paletteIndex, blue, green, red, alpha);
|
}
|
|
/** \details
|
Returns the specified color in the palette of this RasterImage object.
|
|
\param paletteIndex [in] Color number.
|
\param blue [out] Receives the Blue component.
|
\param green [out] Receives the Green component.
|
\param red [out] Receives the Red component.
|
\param pAlpha [out] Pointer to the object to receive the alpha component..
|
*/
|
void getPalColorAt(OdUInt32 paletteIndex, OdUInt8& blue, OdUInt8& green, OdUInt8& red, OdUInt8* pAlpha = 0) const
|
{
|
m_palette.colorAt(paletteIndex, blue, green, red, pAlpha);
|
}
|
|
// Gets the color(RGB) in specified point of raster image
|
|
/** \details
|
Returns the specified color at the specified pixel of this RasterImage object.
|
|
\param x [in] X-coordinate.
|
\param y [in] Y-Coordinate
|
\param blue [out] Receives the Blue component.
|
\param green [out] Receives the Green component.
|
\param red [out] Receives the Red component.
|
*/
|
void getColorAt(OdUInt32 x, OdUInt32 y, OdUInt8& blue, OdUInt8& green, OdUInt8& red) const;
|
|
// virtual overrides
|
|
void copyFrom(const OdRxObject* pOtherObj);
|
OdUInt32 pixelWidth() const;
|
OdUInt32 pixelHeight() const;
|
OdUInt32 colorDepth() const;
|
OdGiRasterImage::Units defaultResolution(double& xPelsPerUnit, double& yPelsPerUnit) const;
|
|
/** Returns bitmap info header
|
*/
|
// void getBitmapInfoHeader(BITMAPINFOHEADER& bmih) const;
|
|
|
OdUInt32 numColors() const;
|
|
virtual ODCOLORREF color(OdUInt32 colorIndex) const;
|
|
void scanLines(OdUInt8* scnLines, OdUInt32 firstScanline, OdUInt32 numLines = 1) const;
|
|
/** \details
|
Returns pointer to image's pixels in bmp format.
|
Note that it is optional to have implementation of this function
|
(to prevent dummy copying of pixels data). You can return NULL in your
|
implementation if it is inconvenient in some case - any functionality
|
uses this interface must take it into account.
|
*/
|
|
virtual const OdUInt8* scanLines() const;
|
|
virtual PixelFormatInfo pixelFormat() const;
|
|
virtual OdUInt32 scanLinesAlignment() const;
|
|
virtual OdUInt32 supportedParams() const;
|
virtual ImageSource imageSource() const;
|
virtual void setImageSource(ImageSource source);
|
virtual TransparencyMode transparencyMode() const;
|
virtual void setTransparencyMode(TransparencyMode mode);
|
};
|
|
/** \details
|
This class implements platform-dependent loading and saving
|
of Raster Image files for Teigha.
|
|
<group ExServices_Classes>
|
Library: Source code provided.
|
*/
|
class ExRasterModule : public OdRxRasterServices
|
{
|
public:
|
/** \details
|
Loads the specified Raster Image file.
|
\param filename [in] Filename of the Raster Image file to be read.
|
\param pStreamBuf [in] Pointer to the StreamBuf object from which the data are to be read.
|
\param pFlagsChain [in] Optional zero-terminated loading flag pairs array.
|
|
\remarks
|
The returned pointer is expected to be passed to OdGiViewportGeometry::rasterImageDc().
|
*/
|
OdGiRasterImagePtr loadRasterImage(const OdString &filename, const OdUInt32 *pFlagsChain = NULL);
|
OdGiRasterImagePtr loadRasterImage(OdStreamBuf *pStreamBuf, const OdUInt32 *pFlagsChain = NULL);
|
|
/** \details
|
Saves specified Raster Image to the specified file.
|
\param rasterImage [in] Raster image to be saved.
|
\param filename [in] Filename of the Raster Image file to be written.
|
\param type [in] Image format type to be written.
|
\param pFlagsChain [in] Optional zero-terminated saving flag pairs array.
|
*/
|
bool saveRasterImage(const OdGiRasterImage* rasterImage, const OdString& filename,
|
const OdUInt32 *pFlagsChain = NULL);
|
bool saveRasterImage(const OdGiRasterImage* rasterImage, const OdString& filename,
|
OdUInt32 type, const OdUInt32 *pFlagsChain = NULL);
|
|
/** \details
|
Try to convert raster image (RGB) to JPEG or other type.
|
\param pRaster [in] Raster image to be converted.
|
\param type [in] Image format type to be converted.
|
\param pStreamBuf [in] Pointer to the StreamBuf object to which the data are to be stored.
|
\param pFlagsChain [in] Optional zero-terminated saving flag pairs array.
|
*/
|
bool convertRasterImage(const OdGiRasterImage* pRaster, OdUInt32 type,
|
OdStreamBuf* pStreamBuf, const OdUInt32 *pFlagsChain = NULL);
|
|
/** \details
|
Try to convert raster image to other type.
|
\param pSrcStream [in] Pointer to the StreamBuf object from which the data are to be converted.
|
\param pDstStream [in] Pointer to the StreamBuf object to which the data are to be converted.
|
\param type [in] Image format type to be converted.
|
\param pFlagsChainSrc [in] Optional zero-terminated loading flag pairs array.
|
\param pFlagsChainDst [in] Optional zero-terminated saving flag pairs array.
|
*/
|
bool convertRasterImage(OdStreamBuf* pSrcStream, OdStreamBuf* pDstStream, OdUInt32 type,
|
const OdUInt32 *pFlagsChainSrc = NULL, const OdUInt32 *pFlagsChainDst = NULL);
|
|
/** \details
|
Returns array of supported image format types.
|
*/
|
OdUInt32Array getRasterImageTypes() const;
|
|
/** \details
|
Get file extension and filter name by type.
|
\param type [in] Image format type to be formatted.
|
\param psFilterName [out] Output filter name (can be Null).
|
*/
|
OdString mapTypeToExtension(OdUInt32 type, OdString* psFilterName) const;
|
|
/** \details
|
Get image format type by file extension.
|
\param extension [in] File extension.
|
*/
|
OdUInt32 mapExtensionToType(const OdString& extension) const;
|
|
/** \details
|
Try to detect image format type from input stream.
|
\param filename [in] Filename of the Raster Image file to be checked.
|
\param pStreamBuf [in] Pointer to the StreamBuf object from which the data are to be checked.
|
*/
|
OdUInt32 getImageFormat(const OdString &filename) const;
|
OdUInt32 getImageFormat(OdStreamBuf* pStreamBuf) const;
|
|
/** \details
|
Initialize module.
|
*/
|
void initApp();
|
/** \details
|
Uninitialize module.
|
*/
|
void uninitApp();
|
};
|
|
#include "TD_PackPop.h"
|
|
#endif //#ifndef _OD_ODEXGIRASTERIMAGE_H_
|
