You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
434 lines
10 KiB
434 lines
10 KiB
/*****************************************************************************/
|
|
// Copyright 2006-2008 Adobe Systems Incorporated
|
|
// All Rights Reserved.
|
|
//
|
|
// NOTICE: Adobe permits you to use, modify, and distribute this file in
|
|
// accordance with the terms of the Adobe license agreement accompanying it.
|
|
/*****************************************************************************/
|
|
|
|
/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_image.h#1 $ */
|
|
/* $DateTime: 2012/05/30 13:28:51 $ */
|
|
/* $Change: 832332 $ */
|
|
/* $Author: tknoll $ */
|
|
|
|
/** \file
|
|
* Support for working with image data in DNG SDK.
|
|
*/
|
|
|
|
/*****************************************************************************/
|
|
|
|
#ifndef __dng_image__
|
|
#define __dng_image__
|
|
|
|
/*****************************************************************************/
|
|
|
|
#include "dng_assertions.h"
|
|
#include "dng_classes.h"
|
|
#include "dng_pixel_buffer.h"
|
|
#include "dng_point.h"
|
|
#include "dng_rect.h"
|
|
#include "dng_tag_types.h"
|
|
#include "dng_types.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Class to get resource acquisition is instantiation behavior for tile
|
|
/// buffers. Can be dirty or constant tile access.
|
|
|
|
class dng_tile_buffer: public dng_pixel_buffer
|
|
{
|
|
|
|
protected:
|
|
|
|
const dng_image &fImage;
|
|
|
|
void *fRefData;
|
|
|
|
protected:
|
|
|
|
/// Obtain a tile from an image.
|
|
/// \param image Image tile will come from.
|
|
/// \param tile Rectangle denoting extent of tile.
|
|
/// \param dirty Flag indicating whether this is read-only or read-write acesss.
|
|
|
|
dng_tile_buffer (const dng_image &image,
|
|
const dng_rect &tile,
|
|
bool dirty);
|
|
|
|
virtual ~dng_tile_buffer ();
|
|
|
|
public:
|
|
|
|
void SetRefData (void *refData)
|
|
{
|
|
fRefData = refData;
|
|
}
|
|
|
|
void * GetRefData () const
|
|
{
|
|
return fRefData;
|
|
}
|
|
|
|
private:
|
|
|
|
// Hidden copy constructor and assignment operator.
|
|
|
|
dng_tile_buffer (const dng_tile_buffer &buffer);
|
|
|
|
dng_tile_buffer & operator= (const dng_tile_buffer &buffer);
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Class to get resource acquisition is instantiation behavior for
|
|
/// constant (read-only) tile buffers.
|
|
|
|
class dng_const_tile_buffer: public dng_tile_buffer
|
|
{
|
|
|
|
public:
|
|
|
|
/// Obtain a read-only tile from an image.
|
|
/// \param image Image tile will come from.
|
|
/// \param tile Rectangle denoting extent of tile.
|
|
|
|
dng_const_tile_buffer (const dng_image &image,
|
|
const dng_rect &tile);
|
|
|
|
virtual ~dng_const_tile_buffer ();
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Class to get resource acquisition is instantiation behavior for
|
|
/// dirty (writable) tile buffers.
|
|
|
|
class dng_dirty_tile_buffer: public dng_tile_buffer
|
|
{
|
|
|
|
public:
|
|
|
|
/// Obtain a writable tile from an image.
|
|
/// \param image Image tile will come from.
|
|
/// \param tile Rectangle denoting extent of tile.
|
|
|
|
dng_dirty_tile_buffer (dng_image &image,
|
|
const dng_rect &tile);
|
|
|
|
virtual ~dng_dirty_tile_buffer ();
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Base class for holding image data in DNG SDK. See dng_simple_image
|
|
/// for derived class most often used in DNG SDK.
|
|
|
|
class dng_image
|
|
{
|
|
|
|
friend class dng_tile_buffer;
|
|
|
|
protected:
|
|
|
|
// Bounds for this image.
|
|
|
|
dng_rect fBounds;
|
|
|
|
// Number of image planes.
|
|
|
|
uint32 fPlanes;
|
|
|
|
// Basic pixel type (TIFF tag type code).
|
|
|
|
uint32 fPixelType;
|
|
|
|
public:
|
|
|
|
/// How to handle requests to get image areas outside the image bounds.
|
|
|
|
enum edge_option
|
|
{
|
|
|
|
/// Leave edge pixels unchanged.
|
|
|
|
edge_none,
|
|
|
|
/// Pad with zeros.
|
|
|
|
edge_zero,
|
|
|
|
/// Repeat edge pixels.
|
|
|
|
edge_repeat,
|
|
|
|
/// Repeat edge pixels, except for last plane which is zero padded.
|
|
|
|
edge_repeat_zero_last
|
|
|
|
};
|
|
|
|
protected:
|
|
|
|
dng_image (const dng_rect &bounds,
|
|
uint32 planes,
|
|
uint32 pixelType);
|
|
|
|
public:
|
|
|
|
virtual ~dng_image ();
|
|
|
|
virtual dng_image * Clone () const;
|
|
|
|
/// Getter method for bounds of an image.
|
|
|
|
const dng_rect & Bounds () const
|
|
{
|
|
return fBounds;
|
|
}
|
|
|
|
/// Getter method for size of an image.
|
|
|
|
dng_point Size () const
|
|
{
|
|
return Bounds ().Size ();
|
|
}
|
|
|
|
/// Getter method for width of an image.
|
|
|
|
uint32 Width () const
|
|
{
|
|
return Bounds ().W ();
|
|
}
|
|
|
|
/// Getter method for height of an image.
|
|
|
|
uint32 Height () const
|
|
{
|
|
return Bounds ().H ();
|
|
}
|
|
|
|
/// Getter method for number of planes in an image.
|
|
|
|
uint32 Planes () const
|
|
{
|
|
return fPlanes;
|
|
}
|
|
|
|
/// Getter for pixel type.
|
|
/// \retval See dng_tagtypes.h . Valid values are ttByte, ttShort, ttSShort,
|
|
/// ttLong, ttFloat .
|
|
|
|
uint32 PixelType () const
|
|
{
|
|
return fPixelType;
|
|
}
|
|
|
|
/// Setter for pixel type.
|
|
/// \param pixelType The new pixel type .
|
|
|
|
virtual void SetPixelType (uint32 pixelType);
|
|
|
|
/// Getter for pixel size.
|
|
/// \retval Size, in bytes, of pixel type for this image .
|
|
|
|
uint32 PixelSize () const;
|
|
|
|
/// Getter for pixel range.
|
|
/// For unsigned types, range is 0 to return value.
|
|
/// For signed types, range is return value - 0x8000U.
|
|
/// For ttFloat type, pixel range is 0.0 to 1.0 and this routine returns 1.
|
|
|
|
uint32 PixelRange () const;
|
|
|
|
/// Getter for best "tile stride" for accessing image.
|
|
|
|
virtual dng_rect RepeatingTile () const;
|
|
|
|
/// Get a pixel buffer of data on image with proper edge padding.
|
|
/// \param buffer Receives resulting pixel buffer.
|
|
/// \param edgeOption edge_option describing how to pad edges.
|
|
/// \param repeatV Amount of repeated padding needed in vertical for
|
|
/// edge_repeat and edge_repeat_zero_last edgeOption cases.
|
|
/// \param repeatH Amount of repeated padding needed in horizontal for
|
|
/// edge_repeat and edge_repeat_zero_last edgeOption cases.
|
|
|
|
void Get (dng_pixel_buffer &buffer,
|
|
edge_option edgeOption = edge_none,
|
|
uint32 repeatV = 1,
|
|
uint32 repeatH = 1) const;
|
|
|
|
/// Put a pixel buffer into image.
|
|
/// \param buffer Pixel buffer to copy from.
|
|
|
|
void Put (const dng_pixel_buffer &buffer);
|
|
|
|
/// Shrink bounds of image to given rectangle.
|
|
/// \param r Rectangle to crop to.
|
|
|
|
virtual void Trim (const dng_rect &r);
|
|
|
|
/// Rotate image to reflect given orientation change.
|
|
/// \param orientation Directive to rotate image in a certain way.
|
|
|
|
virtual void Rotate (const dng_orientation &orientation);
|
|
|
|
/// Copy image data from an area of one image to same area of another.
|
|
/// \param src Image to copy from.
|
|
/// \param area Rectangle of images to copy.
|
|
/// \param srcPlane Plane to start copying in src.
|
|
/// \param dstPlane Plane to start copying in this.
|
|
/// \param planes Number of planes to copy.
|
|
|
|
void CopyArea (const dng_image &src,
|
|
const dng_rect &area,
|
|
uint32 srcPlane,
|
|
uint32 dstPlane,
|
|
uint32 planes);
|
|
|
|
/// Copy image data from an area of one image to same area of another.
|
|
/// \param src Image to copy from.
|
|
/// \param area Rectangle of images to copy.
|
|
/// \param plane Plane to start copying in src and this.
|
|
/// \param planes Number of planes to copy.
|
|
|
|
void CopyArea (const dng_image &src,
|
|
const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes)
|
|
{
|
|
|
|
CopyArea (src, area, plane, plane, planes);
|
|
|
|
}
|
|
|
|
/// Return true if the contents of an area of the image are the same as those of another.
|
|
/// \param rhs Image to compare against.
|
|
/// \param area Rectangle of image to test.
|
|
/// \param plane Plane to start comparing.
|
|
/// \param planes Number of planes to compare.
|
|
|
|
bool EqualArea (const dng_image &rhs,
|
|
const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes) const;
|
|
|
|
// Routines to set the entire image to a constant value.
|
|
|
|
void SetConstant_uint8 (uint8 value,
|
|
const dng_rect &area)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttByte, "Mismatched pixel type");
|
|
|
|
SetConstant ((uint32) value, area);
|
|
|
|
}
|
|
|
|
void SetConstant_uint8 (uint8 value)
|
|
{
|
|
SetConstant (value, Bounds ());
|
|
}
|
|
|
|
void SetConstant_uint16 (uint16 value,
|
|
const dng_rect &area)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttShort, "Mismatched pixel type");
|
|
|
|
SetConstant ((uint32) value, area);
|
|
|
|
}
|
|
|
|
void SetConstant_uint16 (uint16 value)
|
|
{
|
|
SetConstant_uint16 (value, Bounds ());
|
|
}
|
|
|
|
void SetConstant_int16 (int16 value,
|
|
const dng_rect &area)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttSShort, "Mismatched pixel type");
|
|
|
|
SetConstant ((uint32) (uint16) value, area);
|
|
|
|
}
|
|
|
|
void SetConstant_int16 (int16 value)
|
|
{
|
|
SetConstant_int16 (value, Bounds ());
|
|
}
|
|
|
|
void SetConstant_uint32 (uint32 value,
|
|
const dng_rect &area)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttLong, "Mismatched pixel type");
|
|
|
|
SetConstant (value, area);
|
|
|
|
}
|
|
|
|
void SetConstant_uint32 (uint32 value)
|
|
{
|
|
SetConstant_uint32 (value, Bounds ());
|
|
}
|
|
|
|
void SetConstant_real32 (real32 value,
|
|
const dng_rect &area)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttFloat, "Mismatched pixel type");
|
|
|
|
union
|
|
{
|
|
uint32 i;
|
|
real32 f;
|
|
} x;
|
|
|
|
x.f = value;
|
|
|
|
SetConstant (x.i, area);
|
|
|
|
}
|
|
|
|
void SetConstant_real32 (real32 value)
|
|
{
|
|
SetConstant_real32 (value, Bounds ());
|
|
}
|
|
|
|
virtual void GetRepeat (dng_pixel_buffer &buffer,
|
|
const dng_rect &srcArea,
|
|
const dng_rect &dstArea) const;
|
|
|
|
protected:
|
|
|
|
virtual void AcquireTileBuffer (dng_tile_buffer &buffer,
|
|
const dng_rect &area,
|
|
bool dirty) const;
|
|
|
|
virtual void ReleaseTileBuffer (dng_tile_buffer &buffer) const;
|
|
|
|
virtual void DoGet (dng_pixel_buffer &buffer) const;
|
|
|
|
virtual void DoPut (const dng_pixel_buffer &buffer);
|
|
|
|
void GetEdge (dng_pixel_buffer &buffer,
|
|
edge_option edgeOption,
|
|
const dng_rect &srcArea,
|
|
const dng_rect &dstArea) const;
|
|
|
|
virtual void SetConstant (uint32 value,
|
|
const dng_rect &area);
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************/
|