source/dng_bad_pixels.h - platform/external/dng_sdk - Git at Google

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

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

	/*****************************************************************************/