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