You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
314 lines
8.4 KiB
314 lines
8.4 KiB
/*****************************************************************************/
|
|
// 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
|
|
|
|
/*****************************************************************************/
|