| /*****************************************************************************/ |
| // 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 |
| |
| /*****************************************************************************/ |