| /*****************************************************************************/ |
| // Copyright 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_bad_pixels.h#3 $ */ |
| /* $DateTime: 2012/07/11 10:36:56 $ */ |
| /* $Change: 838485 $ */ |
| /* $Author: tknoll $ */ |
| |
| /** \file |
| * Opcodes to fix defective pixels, including individual pixels and regions (such as |
| * defective rows and columns). |
| */ |
| |
| /*****************************************************************************/ |
| |
| #ifndef __dng_bad_pixels__ |
| #define __dng_bad_pixels__ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_memory.h" |
| #include "dng_opcodes.h" |
| |
| #include <vector> |
| |
| /*****************************************************************************/ |
| |
| /// \brief An opcode to fix individual bad pixels that are marked with a constant |
| /// value (e.g., 0) in a Bayer image. |
| |
| class dng_opcode_FixBadPixelsConstant: public dng_filter_opcode |
| { |
| |
| private: |
| |
| uint32 fConstant; |
| |
| uint32 fBayerPhase; |
| |
| public: |
| |
| /// Construct an opcode to fix an individual bad pixels that are marked with |
| /// a constant value in a Bayer image. |
| /// \param constant The constant value that indicates a bad pixel. |
| /// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3). |
| |
| dng_opcode_FixBadPixelsConstant (uint32 constant, |
| uint32 bayerPhase); |
| |
| dng_opcode_FixBadPixelsConstant (dng_stream &stream); |
| |
| virtual void PutData (dng_stream &stream) const; |
| |
| virtual dng_point SrcRepeat (); |
| |
| virtual dng_rect SrcArea (const dng_rect &dstArea, |
| const dng_rect &imageBounds); |
| |
| virtual void Prepare (dng_negative &negative, |
| uint32 threadCount, |
| const dng_point &tileSize, |
| const dng_rect &imageBounds, |
| uint32 imagePlanes, |
| uint32 bufferPixelType, |
| dng_memory_allocator &allocator); |
| |
| virtual void ProcessArea (dng_negative &negative, |
| uint32 threadIndex, |
| dng_pixel_buffer &srcBuffer, |
| dng_pixel_buffer &dstBuffer, |
| const dng_rect &dstArea, |
| const dng_rect &imageBounds); |
| |
| protected: |
| |
| #if defined(__clang__) && defined(__has_attribute) |
| #if __has_attribute(no_sanitize) |
| __attribute__((no_sanitize("unsigned-integer-overflow"))) |
| #endif |
| #endif |
| bool IsGreen (int32 row, int32 col) const |
| { |
| return (((uint32) row + (uint32) col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0; |
| } |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| /// \brief A list of bad pixels and rectangles (usually single rows or columns). |
| |
| class dng_bad_pixel_list |
| { |
| |
| public: |
| |
| enum |
| { |
| kNoIndex = 0xFFFFFFFF |
| }; |
| |
| private: |
| |
| // List of bad single pixels. |
| |
| dng_std_vector<dng_point> fBadPoints; |
| |
| // List of bad rectangles (usually single rows or columns). |
| |
| dng_std_vector<dng_rect> fBadRects; |
| |
| public: |
| |
| /// Create an empty bad pixel list. |
| |
| dng_bad_pixel_list (); |
| |
| /// Returns the number of bad single pixels. |
| |
| uint32 PointCount () const |
| { |
| return (uint32) fBadPoints.size (); |
| } |
| |
| /// Retrieves the bad single pixel coordinate via the specified list index. |
| /// |
| /// \param index The list index from which to retrieve the bad single pixel |
| /// coordinate. |
| |
| const dng_point & Point (uint32 index) const |
| { |
| return fBadPoints [index]; |
| } |
| |
| /// Returns the number of bad rectangles. |
| |
| uint32 RectCount () const |
| { |
| return (uint32) fBadRects.size (); |
| } |
| |
| /// Retrieves the bad rectangle via the specified list index. |
| /// |
| /// \param index The list index from which to retrieve the bad rectangle |
| /// coordinates. |
| |
| const dng_rect & Rect (uint32 index) const |
| { |
| return fBadRects [index]; |
| } |
| |
| /// Returns true iff there are zero bad single pixels and zero bad |
| /// rectangles. |
| |
| bool IsEmpty () const |
| { |
| return PointCount () == 0 && |
| RectCount () == 0; |
| } |
| |
| /// Returns true iff there is at least one bad single pixel or at least one |
| /// bad rectangle. |
| |
| bool NotEmpty () const |
| { |
| return !IsEmpty (); |
| } |
| |
| /// Add the specified coordinate to the list of bad single pixels. |
| /// |
| /// \param pt The bad single pixel to add. |
| |
| void AddPoint (const dng_point &pt); |
| |
| /// Add the specified rectangle to the list of bad rectangles. |
| /// |
| /// \param pt The bad rectangle to add. |
| |
| void AddRect (const dng_rect &r); |
| |
| /// Sort the bad single pixels and bad rectangles by coordinates (top to |
| /// bottom, then left to right). |
| |
| void Sort (); |
| |
| /// Returns true iff the specified bad single pixel is isolated, i.e., there |
| /// is no other bad single pixel or bad rectangle that lies within radius |
| /// pixels of this bad single pixel. |
| /// |
| /// \param index The index of the bad single pixel to test. |
| /// \param radius The pixel radius to test for isolation. |
| |
| bool IsPointIsolated (uint32 index, |
| uint32 radius) const; |
| |
| /// Returns true iff the specified bad rectangle is isolated, i.e., there |
| /// is no other bad single pixel or bad rectangle that lies within radius |
| /// pixels of this bad rectangle. |
| /// |
| /// \param index The index of the bad rectangle to test. |
| /// \param radius The pixel radius to test for isolation. |
| |
| bool IsRectIsolated (uint32 index, |
| uint32 radius) const; |
| |
| /// Returns true iff the specified point is valid, i.e., lies within the |
| /// specified image bounds, is different from all other bad single pixels, |
| /// and is not contained in any bad rectangle. The second and third |
| /// conditions are only checked if provided with a starting search index. |
| /// |
| /// \param pt The point to test for validity. |
| /// \param imageBounds The pt must lie within imageBounds to be valid. |
| /// \index The search index to use (or kNoIndex, to avoid a search) for |
| /// checking for validity. |
| |
| bool IsPointValid (const dng_point &pt, |
| const dng_rect &imageBounds, |
| uint32 index = kNoIndex) const; |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| /// \brief An opcode to fix lists of bad pixels (indicated by position) in a Bayer |
| /// image. |
| |
| class dng_opcode_FixBadPixelsList: public dng_filter_opcode |
| { |
| |
| protected: |
| |
| enum |
| { |
| kBadPointPadding = 2, |
| kBadRectPadding = 4 |
| }; |
| |
| private: |
| |
| AutoPtr<dng_bad_pixel_list> fList; |
| |
| uint32 fBayerPhase; |
| |
| public: |
| |
| /// Construct an opcode to fix lists of bad pixels (indicated by position) in |
| /// a Bayer image. |
| /// \param list The list of bad pixels to fix. |
| /// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3). |
| |
| dng_opcode_FixBadPixelsList (AutoPtr<dng_bad_pixel_list> &list, |
| uint32 bayerPhase); |
| |
| dng_opcode_FixBadPixelsList (dng_stream &stream); |
| |
| virtual void PutData (dng_stream &stream) const; |
| |
| virtual dng_point SrcRepeat (); |
| |
| virtual dng_rect SrcArea (const dng_rect &dstArea, |
| const dng_rect &imageBounds); |
| |
| virtual void Prepare (dng_negative &negative, |
| uint32 threadCount, |
| const dng_point &tileSize, |
| const dng_rect &imageBounds, |
| uint32 imagePlanes, |
| uint32 bufferPixelType, |
| dng_memory_allocator &allocator); |
| |
| virtual void ProcessArea (dng_negative &negative, |
| uint32 threadIndex, |
| dng_pixel_buffer &srcBuffer, |
| dng_pixel_buffer &dstBuffer, |
| const dng_rect &dstArea, |
| const dng_rect &imageBounds); |
| |
| protected: |
| |
| bool IsGreen (int32 row, int32 col) const |
| { |
| return ((row + col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0; |
| } |
| |
| virtual void FixIsolatedPixel (dng_pixel_buffer &buffer, |
| dng_point &badPoint); |
| |
| virtual void FixClusteredPixel (dng_pixel_buffer &buffer, |
| uint32 pointIndex, |
| const dng_rect &imageBounds); |
| |
| virtual void FixSingleColumn (dng_pixel_buffer &buffer, |
| const dng_rect &badRect); |
| |
| virtual void FixSingleRow (dng_pixel_buffer &buffer, |
| const dng_rect &badRect); |
| |
| virtual void FixClusteredRect (dng_pixel_buffer &buffer, |
| const dng_rect &badRect, |
| const dng_rect &imageBounds); |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| #endif |
| |
| /*****************************************************************************/ |