1/*****************************************************************************/
2// Copyright 2008 Adobe Systems Incorporated
3// All Rights Reserved.
4//
5// NOTICE:  Adobe permits you to use, modify, and distribute this file in
6// accordance with the terms of the Adobe license agreement accompanying it.
7/*****************************************************************************/
8
9/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_bad_pixels.h#3 $ */
10/* $DateTime: 2012/07/11 10:36:56 $ */
11/* $Change: 838485 $ */
12/* $Author: tknoll $ */
13
14/** \file
15 * Opcodes to fix defective pixels, including individual pixels and regions (such as
16 * defective rows and columns).
17 */
18
19/*****************************************************************************/
20
21#ifndef __dng_bad_pixels__
22#define __dng_bad_pixels__
23
24/*****************************************************************************/
25
26#include "dng_memory.h"
27#include "dng_opcodes.h"
28
29#include <vector>
30
31/*****************************************************************************/
32
33/// \brief An opcode to fix individual bad pixels that are marked with a constant
34/// value (e.g., 0) in a Bayer image.
35
36class dng_opcode_FixBadPixelsConstant: public dng_filter_opcode
37	{
38
39	private:
40
41		uint32 fConstant;
42
43		uint32 fBayerPhase;
44
45	public:
46
47		/// Construct an opcode to fix an individual bad pixels that are marked with
48		/// a constant value in a Bayer image.
49		/// \param constant The constant value that indicates a bad pixel.
50		/// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3).
51
52		dng_opcode_FixBadPixelsConstant (uint32 constant,
53										 uint32 bayerPhase);
54
55		dng_opcode_FixBadPixelsConstant (dng_stream &stream);
56
57		virtual void PutData (dng_stream &stream) const;
58
59		virtual dng_point SrcRepeat ();
60
61		virtual dng_rect SrcArea (const dng_rect &dstArea,
62								  const dng_rect &imageBounds);
63
64		virtual void Prepare (dng_negative &negative,
65							  uint32 threadCount,
66							  const dng_point &tileSize,
67							  const dng_rect &imageBounds,
68							  uint32 imagePlanes,
69							  uint32 bufferPixelType,
70							  dng_memory_allocator &allocator);
71
72		virtual void ProcessArea (dng_negative &negative,
73								  uint32 threadIndex,
74								  dng_pixel_buffer &srcBuffer,
75								  dng_pixel_buffer &dstBuffer,
76								  const dng_rect &dstArea,
77								  const dng_rect &imageBounds);
78
79	protected:
80
81#if defined(__clang__) && defined(__has_attribute)
82#if __has_attribute(no_sanitize)
83__attribute__((no_sanitize("unsigned-integer-overflow")))
84#endif
85#endif
86		bool IsGreen (int32 row, int32 col) const
87			{
88			return (((uint32) row + (uint32) col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0;
89			}
90
91	};
92
93/*****************************************************************************/
94
95/// \brief A list of bad pixels and rectangles (usually single rows or columns).
96
97class dng_bad_pixel_list
98	{
99
100	public:
101
102		enum
103			{
104			kNoIndex = 0xFFFFFFFF
105			};
106
107	private:
108
109		// List of bad single pixels.
110
111		dng_std_vector<dng_point> fBadPoints;
112
113		// List of bad rectangles (usually single rows or columns).
114
115		dng_std_vector<dng_rect> fBadRects;
116
117	public:
118
119		/// Create an empty bad pixel list.
120
121		dng_bad_pixel_list ();
122
123		/// Returns the number of bad single pixels.
124
125		uint32 PointCount () const
126			{
127			return (uint32) fBadPoints.size ();
128			}
129
130		/// Retrieves the bad single pixel coordinate via the specified list index.
131		///
132		/// \param index The list index from which to retrieve the bad single pixel
133		/// coordinate.
134
135		const dng_point & Point (uint32 index) const
136			{
137			return fBadPoints [index];
138			}
139
140		/// Returns the number of bad rectangles.
141
142		uint32 RectCount () const
143			{
144			return (uint32) fBadRects.size ();
145			}
146
147		/// Retrieves the bad rectangle via the specified list index.
148		///
149		/// \param index The list index from which to retrieve the bad rectangle
150		/// coordinates.
151
152		const dng_rect & Rect (uint32 index) const
153			{
154			return fBadRects [index];
155			}
156
157		/// Returns true iff there are zero bad single pixels and zero bad
158		/// rectangles.
159
160		bool IsEmpty () const
161			{
162			return PointCount () == 0 &&
163				   RectCount  () == 0;
164			}
165
166		/// Returns true iff there is at least one bad single pixel or at least one
167		/// bad rectangle.
168
169		bool NotEmpty () const
170			{
171			return !IsEmpty ();
172			}
173
174		/// Add the specified coordinate to the list of bad single pixels.
175		///
176		/// \param pt The bad single pixel to add.
177
178		void AddPoint (const dng_point &pt);
179
180		/// Add the specified rectangle to the list of bad rectangles.
181		///
182		/// \param pt The bad rectangle to add.
183
184		void AddRect (const dng_rect &r);
185
186		/// Sort the bad single pixels and bad rectangles by coordinates (top to
187		/// bottom, then left to right).
188
189		void Sort ();
190
191		/// Returns true iff the specified bad single pixel is isolated, i.e., there
192		/// is no other bad single pixel or bad rectangle that lies within radius
193		/// pixels of this bad single pixel.
194		///
195		/// \param index The index of the bad single pixel to test.
196		/// \param radius The pixel radius to test for isolation.
197
198		bool IsPointIsolated (uint32 index,
199							  uint32 radius) const;
200
201		/// Returns true iff the specified bad rectangle is isolated, i.e., there
202		/// is no other bad single pixel or bad rectangle that lies within radius
203		/// pixels of this bad rectangle.
204		///
205		/// \param index The index of the bad rectangle to test.
206		/// \param radius The pixel radius to test for isolation.
207
208		bool IsRectIsolated (uint32 index,
209							 uint32 radius) const;
210
211		/// Returns true iff the specified point is valid, i.e., lies within the
212		/// specified image bounds, is different from all other bad single pixels,
213		/// and is not contained in any bad rectangle. The second and third
214		/// conditions are only checked if provided with a starting search index.
215		///
216		/// \param pt The point to test for validity.
217		/// \param imageBounds The pt must lie within imageBounds to be valid.
218		/// \index The search index to use (or kNoIndex, to avoid a search) for
219		/// checking for validity.
220
221		bool IsPointValid (const dng_point &pt,
222						   const dng_rect &imageBounds,
223						   uint32 index = kNoIndex) const;
224
225	};
226
227/*****************************************************************************/
228
229/// \brief An opcode to fix lists of bad pixels (indicated by position) in a Bayer
230/// image.
231
232class dng_opcode_FixBadPixelsList: public dng_filter_opcode
233	{
234
235	protected:
236
237		enum
238			{
239			kBadPointPadding = 2,
240			kBadRectPadding  = 4
241			};
242
243	private:
244
245		AutoPtr<dng_bad_pixel_list> fList;
246
247		uint32 fBayerPhase;
248
249	public:
250
251		/// Construct an opcode to fix lists of bad pixels (indicated by position) in
252		/// a Bayer image.
253		/// \param list The list of bad pixels to fix.
254		/// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3).
255
256		dng_opcode_FixBadPixelsList (AutoPtr<dng_bad_pixel_list> &list,
257									 uint32 bayerPhase);
258
259		dng_opcode_FixBadPixelsList (dng_stream &stream);
260
261		virtual void PutData (dng_stream &stream) const;
262
263		virtual dng_point SrcRepeat ();
264
265		virtual dng_rect SrcArea (const dng_rect &dstArea,
266								  const dng_rect &imageBounds);
267
268		virtual void Prepare (dng_negative &negative,
269							  uint32 threadCount,
270							  const dng_point &tileSize,
271							  const dng_rect &imageBounds,
272							  uint32 imagePlanes,
273							  uint32 bufferPixelType,
274							  dng_memory_allocator &allocator);
275
276		virtual void ProcessArea (dng_negative &negative,
277								  uint32 threadIndex,
278								  dng_pixel_buffer &srcBuffer,
279								  dng_pixel_buffer &dstBuffer,
280								  const dng_rect &dstArea,
281								  const dng_rect &imageBounds);
282
283	protected:
284
285		bool IsGreen (int32 row, int32 col) const
286			{
287			return ((row + col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0;
288			}
289
290		virtual void FixIsolatedPixel (dng_pixel_buffer &buffer,
291									   dng_point &badPoint);
292
293		virtual void FixClusteredPixel (dng_pixel_buffer &buffer,
294								        uint32 pointIndex,
295										const dng_rect &imageBounds);
296
297		virtual void FixSingleColumn (dng_pixel_buffer &buffer,
298									  const dng_rect &badRect);
299
300		virtual void FixSingleRow (dng_pixel_buffer &buffer,
301								   const dng_rect &badRect);
302
303		virtual void FixClusteredRect (dng_pixel_buffer &buffer,
304									   const dng_rect &badRect,
305									   const dng_rect &imageBounds);
306
307	};
308
309/*****************************************************************************/
310
311#endif
312
313/*****************************************************************************/
314