| /*****************************************************************************/ |
| // Copyright 2008-2009 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_gain_map.h#2 $ */ |
| /* $DateTime: 2012/07/31 22:04:34 $ */ |
| /* $Change: 840853 $ */ |
| /* $Author: tknoll $ */ |
| |
| /** \file |
| * Opcode to fix 2D uniformity defects, such as shading. |
| */ |
| |
| /*****************************************************************************/ |
| |
| #ifndef __dng_gain_map__ |
| #define __dng_gain_map__ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_memory.h" |
| #include "dng_misc_opcodes.h" |
| #include "dng_tag_types.h" |
| |
| /*****************************************************************************/ |
| |
| /// \brief Holds a discrete (i.e., sampled) 2D representation of a gain map. This is |
| /// effectively an image containing scale factors. |
| |
| class dng_gain_map |
| { |
| |
| private: |
| |
| dng_point fPoints; |
| |
| dng_point_real64 fSpacing; |
| |
| dng_point_real64 fOrigin; |
| |
| uint32 fPlanes; |
| |
| uint32 fRowStep; |
| |
| AutoPtr<dng_memory_block> fBuffer; |
| |
| public: |
| |
| /// Construct a gain map with the specified memory allocator, number of |
| /// samples (points), sample spacing, origin, and number of color planes. |
| |
| dng_gain_map (dng_memory_allocator &allocator, |
| const dng_point &points, |
| const dng_point_real64 &spacing, |
| const dng_point_real64 &origin, |
| uint32 planes); |
| |
| /// The number of samples in the horizontal and vertical directions. |
| |
| const dng_point & Points () const |
| { |
| return fPoints; |
| } |
| |
| /// The space between adjacent samples in the horizontal and vertical |
| /// directions. |
| |
| const dng_point_real64 & Spacing () const |
| { |
| return fSpacing; |
| } |
| |
| /// The 2D coordinate for the first (i.e., top-left-most) sample. |
| |
| const dng_point_real64 & Origin () const |
| { |
| return fOrigin; |
| } |
| |
| /// The number of color planes. |
| |
| uint32 Planes () const |
| { |
| return fPlanes; |
| } |
| |
| /// Getter for a gain map sample (specified by row, column, and plane). |
| |
| real32 & Entry (uint32 rowIndex, |
| uint32 colIndex, |
| uint32 plane) |
| { |
| |
| return *(fBuffer->Buffer_real32 () + |
| rowIndex * fRowStep + |
| colIndex * fPlanes + |
| plane); |
| |
| } |
| |
| /// Getter for a gain map sample (specified by row index, column index, and |
| /// plane index). |
| |
| const real32 & Entry (uint32 rowIndex, |
| uint32 colIndex, |
| uint32 plane) const |
| { |
| |
| return *(fBuffer->Buffer_real32 () + |
| rowIndex * fRowStep + |
| colIndex * fPlanes + |
| plane); |
| |
| } |
| |
| /// Compute the interpolated gain (i.e., scale factor) at the specified pixel |
| /// position and color plane, within the specified image bounds (in pixels). |
| |
| real32 Interpolate (int32 row, |
| int32 col, |
| uint32 plane, |
| const dng_rect &bounds) const; |
| |
| /// The number of bytes needed to hold the gain map data. |
| |
| uint32 PutStreamSize () const; |
| |
| /// Write the gain map to the specified stream. |
| |
| void PutStream (dng_stream &stream) const; |
| |
| /// Read a gain map from the specified stream. |
| |
| static dng_gain_map * GetStream (dng_host &host, |
| dng_stream &stream); |
| |
| private: |
| |
| // Hidden copy constructor and assignment operator. |
| |
| dng_gain_map (const dng_gain_map &map); |
| |
| dng_gain_map & operator= (const dng_gain_map &map); |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| /// \brief An opcode to fix 2D spatially-varying light falloff or color casts (i.e., |
| /// uniformity issues). This is commonly due to shading. |
| |
| class dng_opcode_GainMap: public dng_inplace_opcode |
| { |
| |
| private: |
| |
| dng_area_spec fAreaSpec; |
| |
| AutoPtr<dng_gain_map> fGainMap; |
| |
| public: |
| |
| /// Construct a GainMap opcode for the specified image area and the specified |
| /// gain map. |
| |
| dng_opcode_GainMap (const dng_area_spec &areaSpec, |
| AutoPtr<dng_gain_map> &gainMap); |
| |
| /// Construct a GainMap opcode from the specified stream. |
| |
| dng_opcode_GainMap (dng_host &host, |
| dng_stream &stream); |
| |
| /// Write the opcode to the specified stream. |
| |
| virtual void PutData (dng_stream &stream) const; |
| |
| /// The pixel data type of this opcode. |
| |
| virtual uint32 BufferPixelType (uint32 /* imagePixelType */) |
| { |
| return ttFloat; |
| } |
| |
| /// The adjusted bounds (processing area) of this opcode. It is limited to |
| /// the intersection of the specified image area and the GainMap area. |
| |
| virtual dng_rect ModifiedBounds (const dng_rect &imageBounds) |
| { |
| return fAreaSpec.Overlap (imageBounds); |
| } |
| |
| /// Apply the gain map. |
| |
| virtual void ProcessArea (dng_negative &negative, |
| uint32 threadIndex, |
| dng_pixel_buffer &buffer, |
| const dng_rect &dstArea, |
| const dng_rect &imageBounds); |
| |
| private: |
| |
| // Hidden copy constructor and assignment operator. |
| |
| dng_opcode_GainMap (const dng_opcode_GainMap &opcode); |
| |
| dng_opcode_GainMap & operator= (const dng_opcode_GainMap &opcode); |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| #endif |
| |
| /*****************************************************************************/ |