liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

badpixels code: further cleanups

Browse Source
This commit is contained in:
heckflosse
2019-06-10 22:15:16 +02:00
parent fe16bf7917
commit 156f3009d5
3 changed files with 46 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
rtengine/badpixels.cc
View File

@@ -26,7 +26,7 @@ namespace rtengine
{
/* interpolateBadPixelsBayer: correct raw pixels looking at the bitmap
* takes into consideration if there are multiple bad pixels in the neighbourhood
* takes into consideration if there are multiple bad pixels in the neighborhood
*/
int RawImageSource::interpolateBadPixelsBayer(const PixelsMap &bitmapBads, array2D<float> &rawData)
{
@@ -37,8 +37,8 @@ int RawImageSource::interpolateBadPixelsBayer(const PixelsMap &bitmapBads, array
#pragma omp parallel for reduction(+:counter) schedule(dynamic,16)
#endif
for(int row = 2; row < H - 2; ++row) {
for(int col = 2; col < W - 2; ++col) {
for (int row = 2; row < H - 2; ++row) {
for (int col = 2; col < W - 2; ++col) {
const int sk = bitmapBads.skipIfZero(col, row); //optimization for a stripe all zero
if (sk) {
@@ -54,8 +54,8 @@ int RawImageSource::interpolateBadPixelsBayer(const PixelsMap &bitmapBads, array
// diagonal interpolation
if (FC(row, col) == 1) {
// green channel. We can use closer pixels than for red or blue channel. Distance to centre pixel is sqrt(2) => weighting is 0.70710678
// For green channel following pixels will be used for interpolation. Pixel to be interpolated is in centre.
// green channel. We can use closer pixels than for red or blue channel. Distance to center pixel is sqrt(2) => weighting is 0.70710678
// For green channel following pixels will be used for interpolation. Pixel to be interpolated is in center.
// 1 means that pixel is used in this step, if itself and his counterpart are not marked bad
// 0 0 0 0 0
// 0 1 0 1 0
@@ -72,8 +72,8 @@ int RawImageSource::interpolateBadPixelsBayer(const PixelsMap &bitmapBads, array
norm += dirwt;
}
} else {
// red and blue channel. Distance to centre pixel is sqrt(8) => weighting is 0.35355339
// For red and blue channel following pixels will be used for interpolation. Pixel to be interpolated is in centre.
// red and blue channel. Distance to center pixel is sqrt(8) => weighting is 0.35355339
// For red and blue channel following pixels will be used for interpolation. Pixel to be interpolated is in center.
// 1 means that pixel is used in this step, if itself and his counterpart are not marked bad
// 1 0 0 0 1
// 0 0 0 0 0
@@ -91,8 +91,8 @@ int RawImageSource::interpolateBadPixelsBayer(const PixelsMap &bitmapBads, array
}
}
// channel independent. Distance to centre pixel is 2 => weighting is 0.5
// Additionally for all channel following pixels will be used for interpolation. Pixel to be interpolated is in centre.
// channel independent. Distance to center pixel is 2 => weighting is 0.5
// Additionally for all channel following pixels will be used for interpolation. Pixel to be interpolated is in center.
// 1 means that pixel is used in this step, if itself and his counterpart are not marked bad
// 0 0 1 0 0
// 0 0 0 0 0
@@ -143,10 +143,10 @@ int RawImageSource::interpolateBadPixelsBayer(const PixelsMap &bitmapBads, array
return counter; // Number of interpolated pixels.
}
/* interpolateBadPixelsNColours: correct raw pixels looking at the bitmap
* takes into consideration if there are multiple bad pixels in the neighbourhood
/* interpolateBadPixelsNcolors: correct raw pixels looking at the bitmap
* takes into consideration if there are multiple bad pixels in the neighborhood
*/
int RawImageSource::interpolateBadPixelsNColours(const PixelsMap &bitmapBads, const int colours)
int RawImageSource::interpolateBadPixelsNColours(const PixelsMap &bitmapBads, const int colors)
{
constexpr float eps = 1.f;
int counter = 0;
@@ -168,8 +168,8 @@ int RawImageSource::interpolateBadPixelsNColours(const PixelsMap &bitmapBads, co
continue;
}
float wtdsum[colours] = {};
float norm[colours] = {};
float wtdsum[colors] = {};
float norm[colors] = {};
// diagonal interpolation
for (int dx = -1; dx <= 1; dx += 2) {
@@ -177,40 +177,40 @@ int RawImageSource::interpolateBadPixelsNColours(const PixelsMap &bitmapBads, co
continue;
}
for (int c = 0; c < colours; ++c) {
const float dirwt = 0.70710678f / (fabsf(rawData[row - 1][(col + dx) * colours + c] - rawData[row + 1][(col - dx) * colours + c]) + eps);
wtdsum[c] += dirwt * (rawData[row - 1][(col + dx) * colours + c] + rawData[row + 1][(col - dx) * colours + c]);
for (int c = 0; c < colors; ++c) {
const float dirwt = 0.70710678f / (fabsf(rawData[row - 1][(col + dx) * colors + c] - rawData[row + 1][(col - dx) * colors + c]) + eps);
wtdsum[c] += dirwt * (rawData[row - 1][(col + dx) * colors + c] + rawData[row + 1][(col - dx) * colors + c]);
norm[c] += dirwt;
}
}
// horizontal interpolation
if (!(bitmapBads.get(col - 1, row) || bitmapBads.get(col + 1, row))) {
for (int c = 0; c < colours; ++c) {
const float dirwt = 1.f / (fabsf(rawData[row][(col - 1) * colours + c] - rawData[row][(col + 1) * colours + c]) + eps);
wtdsum[c] += dirwt * (rawData[row][(col - 1) * colours + c] + rawData[row][(col + 1) * colours + c]);
for (int c = 0; c < colors; ++c) {
const float dirwt = 1.f / (fabsf(rawData[row][(col - 1) * colors + c] - rawData[row][(col + 1) * colors + c]) + eps);
wtdsum[c] += dirwt * (rawData[row][(col - 1) * colors + c] + rawData[row][(col + 1) * colors + c]);
norm[c] += dirwt;
}
}
// vertical interpolation
if (!(bitmapBads.get(col, row - 1) || bitmapBads.get(col, row + 1))) {
for (int c = 0; c < colours; ++c) {
const float dirwt = 1.f / (fabsf(rawData[row - 1][col * colours + c] - rawData[row + 1][col * colours + c]) + eps);
wtdsum[c] += dirwt * (rawData[row - 1][col * colours + c] + rawData[row + 1][col * colours + c]);
for (int c = 0; c < colors; ++c) {
const float dirwt = 1.f / (fabsf(rawData[row - 1][col * colors + c] - rawData[row + 1][col * colors + c]) + eps);
wtdsum[c] += dirwt * (rawData[row - 1][col * colors + c] + rawData[row + 1][col * colors + c]);
norm[c] += dirwt;
}
}
if (LIKELY(norm[0] > 0.f)) { // This means, we found at least one pair of valid pixels in the steps above, likelihood of this case is about 99.999%
for (int c = 0; c < colours; ++c) {
rawData[row][col * colours + c] = wtdsum[c] / (2.f * norm[c]); //gradient weighted average, Factor of 2.f is an optimization to avoid multiplications in former steps
for (int c = 0; c < colors; ++c) {
rawData[row][col * colors + c] = wtdsum[c] / (2.f * norm[c]); //gradient weighted average, Factor of 2.f is an optimization to avoid multiplications in former steps
}
counter++;
} else { //backup plan -- simple average. Same method for all channels. We could improve this, but it's really unlikely that this case happens
int tot = 0;
float sum[colours] = {};
float sum[colors] = {};
for (int dy = -2; dy <= 2; dy += 2) {
for (int dx = -2; dx <= 2; dx += 2) {
@@ -218,8 +218,8 @@ int RawImageSource::interpolateBadPixelsNColours(const PixelsMap &bitmapBads, co
continue;
}
for (int c = 0; c < colours; ++c) {
sum[c] += rawData[row + dy][(col + dx) * colours + c];
for (int c = 0; c < colors; ++c) {
sum[c] += rawData[row + dy][(col + dx) * colors + c];
}
tot++;
@@ -227,8 +227,8 @@ int RawImageSource::interpolateBadPixelsNColours(const PixelsMap &bitmapBads, co
}
if (tot > 0) {
for (int c = 0; c < colours; ++c) {
rawData[row][col * colours + c] = sum[c] / tot;
for (int c = 0; c < colors; ++c) {
rawData[row][col * colors + c] = sum[c] / tot;
}
counter ++;
@@ -241,7 +241,7 @@ int RawImageSource::interpolateBadPixelsNColours(const PixelsMap &bitmapBads, co
}
/* interpolateBadPixelsXtrans: correct raw pixels looking at the bitmap
* takes into consideration if there are multiple bad pixels in the neighbourhood
* takes into consideration if there are multiple bad pixels in the neighborhood
*/
int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
{
@@ -266,15 +266,15 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
}
float wtdsum = 0.f, norm = 0.f;
unsigned int pixelColor = ri->XTRANSFC(row, col);
const unsigned int pixelColor = ri->XTRANSFC(row, col);
if (pixelColor == 1) {
// green channel. A green pixel can either be a solitary green pixel or a member of a 2x2 square of green pixels
if (ri->XTRANSFC(row, col - 1) == ri->XTRANSFC(row, col + 1)) {
// If left and right neighbour have same colour, then this is a solitary green pixel
// For these the following pixels will be used for interpolation. Pixel to be interpolated is in centre and marked with a P.
// If left and right neighbor have same color, then this is a solitary green pixel
// For these the following pixels will be used for interpolation. Pixel to be interpolated is in center and marked with a P.
// Pairs of pixels used in this step are numbered. A pair will be used if none of the pixels of the pair is marked bad
// 0 means, the pixel has a different colour and will not be used
// 0 means, the pixel has a different color and will not be used
// 0 1 0 2 0
// 3 5 0 6 4
// 0 0 P 0 0
@@ -313,7 +313,7 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
// this is a member of a 2x2 square of green pixels
// For these the following pixels will be used for interpolation. Pixel to be interpolated is at position P in the example.
// Pairs of pixels used in this step are numbered. A pair will be used if none of the pixels of the pair is marked bad
// 0 means, the pixel has a different colour and will not be used
// 0 means, the pixel has a different color and will not be used
// 1 0 0 3
// 0 P 2 0
// 0 2 1 0
@@ -352,9 +352,9 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
}
} else {
// red and blue channel.
// Each red or blue pixel has exactly one neighbour of same colour in distance 2 and four neighbours of same colour which can be reached by a move of a knight in chess.
// Each red or blue pixel has exactly one neighbor of same color in distance 2 and four neighbors of same color which can be reached by a move of a knight in chess.
// For the distance 2 pixel (marked with an X) we generate a virtual counterpart (marked with a V)
// For red and blue channel following pixels will be used for interpolation. Pixel to be interpolated is in centre and marked with a P.
// For red and blue channel following pixels will be used for interpolation. Pixel to be interpolated is in center and marked with a P.
// Pairs of pixels used in this step are numbered except for distance 2 pixels which are marked X and V. A pair will be used if none of the pixels of the pair is marked bad
// 0 1 0 0 0 0 0 X 0 0 remaining cases are symmetric
// 0 0 0 0 2 1 0 0 0 2
@@ -362,9 +362,9 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
// 0 0 0 0 1 0 0 0 0 0
// 0 2 0 0 0 0 2 V 1 0
// Find two knight moves landing on a pixel of same colour as the pixel to be interpolated.
// Find two knight moves landing on a pixel of same color as the pixel to be interpolated.
// If we look at first and last row of 5x5 square, we will find exactly two knight pixels.
// Additionally we know that the column of this pixel has 1 or -1 horizontal distance to the centre pixel
// Additionally we know that the column of this pixel has 1 or -1 horizontal distance to the center pixel
// When we find a knight pixel, we get its counterpart, which has distance (+-3,+-3), where the signs of distance depend on the corner of the found knight pixel.
// These pixels are marked 1 or 2 in above examples. Distance to P is sqrt(5) => weighting is 0.44721359f
// The following loop simply scans the four possible places. To keep things simple, it does not stop after finding two knight pixels, because it will not find more than two
@@ -380,12 +380,12 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
}
}
// now scan for the pixel of same colour in distance 2 in each direction (marked with an X in above examples).
// now scan for the pixel of same color in distance 2 in each direction (marked with an X in above examples).
bool distance2PixelFound = false;
int dx, dy;
// check horizontal
for (dx = -2, dy = 0; dx <= 2 && !distance2PixelFound; dx += 4) {
for (dx = -2, dy = 0; dx <= 2; dx += 4) {
if (ri->XTRANSFC(row, col + dx) == pixelColor) {
distance2PixelFound = true;
break;
@@ -394,7 +394,7 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
if (!distance2PixelFound) {
// no distance 2 pixel on horizontal, check vertical
for (dx = 0, dy = -2; dy <= 2 && !distance2PixelFound; dy += 4) {
for (dx = 0, dy = -2; dy <= 2; dy += 4) {
if (ri->XTRANSFC(row + dy, col) == pixelColor) {
distance2PixelFound = true;
break;
@@ -428,7 +428,7 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
}
/* Search for hot or dead pixels in the image and update the map
* For each pixel compare its value to the average of similar colour surrounding
* For each pixel compare its value to the average of similar color surrounding
* (Taken from Emil Martinec idea)
* (Optimized by Ingo Weyrich 2013 and 2015)
*/

2
rtengine/pixelsmap.h
View File

@@ -39,7 +39,7 @@ class PixelsMap :
int w; // line width in base_t units
int h; // height
typedef unsigned long base_t;
static const size_t base_t_size = sizeof(base_t);
static constexpr size_t base_t_size = sizeof(base_t);
base_t *pm;
public:

2
rtengine/rawimagesource.h
View File

@@ -102,7 +102,7 @@ protected:
void transformRect (const PreviewProps &pp, int tran, int &sx1, int &sy1, int &width, int &height, int &fw);
void transformPosition (int x, int y, int tran, int& tx, int& ty);
unsigned FC(int row, int col)
unsigned FC(int row, int col) const
{
return ri->FC(row, col);
}