From 156f3009d5b92b410267cc6ae674eeeab4b7c1e4 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 10 Jun 2019 22:15:16 +0200 Subject: [PATCH] badpixels code: further cleanups --- rtengine/badpixels.cc | 88 +++++++++++++++++++-------------------- rtengine/pixelsmap.h | 2 +- rtengine/rawimagesource.h | 2 +- 3 files changed, 46 insertions(+), 46 deletions(-) diff --git a/rtengine/badpixels.cc b/rtengine/badpixels.cc index 8d02be4a7..895294cae 100644 --- a/rtengine/badpixels.cc +++ b/rtengine/badpixels.cc @@ -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 &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) */ diff --git a/rtengine/pixelsmap.h b/rtengine/pixelsmap.h index 63dce4233..9089ac91c 100644 --- a/rtengine/pixelsmap.h +++ b/rtengine/pixelsmap.h @@ -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: diff --git a/rtengine/rawimagesource.h b/rtengine/rawimagesource.h index 95dba61f4..4c7b0ba21 100644 --- a/rtengine/rawimagesource.h +++ b/rtengine/rawimagesource.h @@ -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); }