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

Merge pull request #5885 from Beep6581/bayer_bilinear

Browse Source 
Bayer bilinear
This commit is contained in:
Ingo Weyrich 2020-08-27 15:43:30 +02:00 committed by GitHub
commit a7971abfcf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 119 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
rtdata/languages/default
View File

@ -3003,11 +3003,13 @@ TP_RAW_3PASSBEST;3-pass (Markesteijn)
TP_RAW_4PASS;3-pass+fast
TP_RAW_AHD;AHD
TP_RAW_AMAZE;AMaZE
TP_RAW_AMAZEBILINEAR;AMaZE+Bilinear
TP_RAW_AMAZEVNG4;AMaZE+VNG4
TP_RAW_BORDER;Border
TP_RAW_DCB;DCB
TP_RAW_DCBENHANCE;DCB enhancement
TP_RAW_DCBITERATIONS;Number of DCB iterations
TP_RAW_DCBBILINEAR;DCB+Bilinear
TP_RAW_DCBVNG4;DCB+VNG4
TP_RAW_DMETHOD;Method
TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing...
@ -3060,6 +3062,7 @@ TP_RAW_PIXELSHIFTSIGMA_TOOLTIP;The default radius of 1.0 usually fits well for b
TP_RAW_PIXELSHIFTSMOOTH;Smooth transitions
TP_RAW_PIXELSHIFTSMOOTH_TOOLTIP;Smooth transitions between areas with motion and areas without.\nSet to 0 to disable transition smoothing.\nSet to 1 to either get the AMaZE/LMMSE result of the selected frame (depending on whether "Use LMMSE" is selected), or the median of all four frames if "Use median" is selected.
TP_RAW_RCD;RCD
TP_RAW_RCDBILINEAR;RCD+Bilinear
TP_RAW_RCDVNG4;RCD+VNG4
TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix
TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster.\n+fast gives less artifacts in flat areas

1
rtengine/CMakeLists.txt
View File

@ -63,6 +63,7 @@ set(RTENGINESOURCEFILES
ahd_demosaic_RT.cc
amaze_demosaic_RT.cc
badpixels.cc
bayer_bilinear_demosaic.cc
boxblur.cc
canon_cr3_decoder.cc
CA_correct_RT.cc

58
rtengine/bayer_bilinear_demosaic.cc Normal file
View File

@ -0,0 +1,58 @@
////////////////////////////////////////////////////////////////
//
// Bilinear bayer demosaic, optimized for speed, intended use is for flat regions of dual-demosaic
//
// copyright (c) 2020 Ingo Weyrich <heckflosse67@gmx.de>
//
//
// code dated: May 09, 2020
//
// bayer_bilinear_demosaic.cc is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////
#include "rawimagesource.h"
#include "rt_math.h"
#define BENCHMARK
#include "StopWatch.h"
using namespace rtengine;
void RawImageSource::bayer_bilinear_demosaic(const float* const * blend, const array2D<float> &rawData, array2D<float> &red, array2D<float> &green, array2D<float> &blue)
{
BENCHFUN
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (int i = 1; i < H - 1; ++i) {
float **nonGreen1 = red;
float **nonGreen2 = blue;
if (FC(i, 0) == 2 || FC(i, 1) == 2) { // blue row => swap pointers
std::swap(nonGreen1, nonGreen2);
}
#if defined(__clang__)
#pragma clang loop vectorize(assume_safety)
#elif defined(__GNUC__)
#pragma GCC ivdep
#endif
for (int j = 2 - (FC(i, 1) & 1); j < W - 2; j += 2) { // always begin with a green pixel
green[i][j] = intp(blend[i][j], green[i][j], rawData[i][j]);
nonGreen1[i][j] = intp(blend[i][j], nonGreen1[i][j], (rawData[i][j - 1] + rawData[i][j + 1]) * 0.5f);
nonGreen2[i][j] = intp(blend[i][j], nonGreen2[i][j], (rawData[i - 1][j] + rawData[i + 1][j]) * 0.5f);
green[i][j + 1] = intp(blend[i][j + 1], green[i][j + 1], ((rawData[i - 1][j + 1] + rawData[i][j]) + (rawData[i][j + 2] + rawData[i + 1][j + 1])) * 0.25f);
nonGreen1[i][j + 1] = intp(blend[i][j + 1], nonGreen1[i][j + 1], rawData[i][j + 1]);
nonGreen2[i][j + 1] = intp(blend[i][j + 1], nonGreen2[i][j + 1], ((rawData[i - 1][j] + rawData[i - 1][j + 2]) + (rawData[i + 1][j] + rawData[i + 1][j + 2])) * 0.25f);
}
}
}

72
rtengine/dual_demosaic_RT.cc
View File

@ -33,7 +33,7 @@
#include "../rtgui/options.h"
//#define BENCHMARK
#define BENCHMARK
#include "StopWatch.h"
using namespace std;
@ -48,15 +48,18 @@ void RawImageSource::dual_demosaic_RT(bool isBayer, const procparams::RAWParams
if (contrast == 0.0 && !autoContrast) {
// contrast == 0.0 means only first demosaicer will be used
if(isBayer) {
if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEVNG4) ) {
if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEVNG4)) {
amaze_demosaic_RT(0, 0, winw, winh, rawData, red, green, blue, options.chunkSizeAMAZE, options.measure);
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBVNG4) ) {
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBVNG4)) {
dcb_demosaic(raw.bayersensor.dcb_iterations, raw.bayersensor.dcb_enhance);
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDVNG4) ) {
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDVNG4)) {
rcd_demosaic(options.chunkSizeRCD, options.measure);
}
} else {
if (raw.xtranssensor.method == procparams::RAWParams::XTransSensor::getMethodString(procparams::RAWParams::XTransSensor::Method::FOUR_PASS) ) {
if (raw.xtranssensor.method == procparams::RAWParams::XTransSensor::getMethodString(procparams::RAWParams::XTransSensor::Method::FOUR_PASS)) {
xtrans_interpolate (3, true, options.chunkSizeXT, options.measure);
} else {
xtrans_interpolate (1, false, options.chunkSizeXT, options.measure);
@ -69,15 +72,19 @@ void RawImageSource::dual_demosaic_RT(bool isBayer, const procparams::RAWParams
array2D<float> L(winw, winh);
if (isBayer) {
if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEVNG4) || raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::PIXELSHIFT)) {
if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEVNG4) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::PIXELSHIFT)) {
amaze_demosaic_RT(0, 0, winw, winh, rawData, red, green, blue, options.chunkSizeAMAZE, options.measure);
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBVNG4) ) {
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBVNG4)) {
dcb_demosaic(raw.bayersensor.dcb_iterations, raw.bayersensor.dcb_enhance);
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDVNG4) ) {
} else if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDVNG4)) {
rcd_demosaic(options.chunkSizeRCD, options.measure);
}
} else {
if (raw.xtranssensor.method == procparams::RAWParams::XTransSensor::getMethodString(procparams::RAWParams::XTransSensor::Method::FOUR_PASS) ) {
if (raw.xtranssensor.method == procparams::RAWParams::XTransSensor::getMethodString(procparams::RAWParams::XTransSensor::Method::FOUR_PASS)) {
xtrans_interpolate (3, true, options.chunkSizeXT, options.measure);
} else {
xtrans_interpolate (1, false, options.chunkSizeXT, options.measure);
@ -91,17 +98,13 @@ void RawImageSource::dual_demosaic_RT(bool isBayer, const procparams::RAWParams
};
#ifdef _OPENMP
#pragma omp parallel
#pragma omp parallel for schedule(dynamic,16)
#endif
{
#ifdef _OPENMP
#pragma omp for
#endif
for(int i = 0; i < winh; ++i) {
Color::RGB2L(red[i], green[i], blue[i], L[i], xyz_rgb, winw);
}
for(int i = 0; i < winh; ++i) {
Color::RGB2L(red[i], green[i], blue[i], L[i], xyz_rgb, winw);
}
// calculate contrast based blend factors to use vng4 in regions with low contrast
// calculate contrast based blend factors to use flat demosaicer in regions with low contrast
JaggedArray<float> blend(winw, winh);
float contrastf = contrast / 100.0;
@ -109,41 +112,40 @@ void RawImageSource::dual_demosaic_RT(bool isBayer, const procparams::RAWParams
contrast = contrastf * 100.f;
array2D<float>& redTmp = L; // L is not needed anymore => reuse it
array2D<float> greenTmp(winw, winh);
array2D<float> blueTmp(winw, winh);
array2D<float> greenTmp;
array2D<float> blueTmp;
if (isBayer) {
vng4_demosaic(rawData, redTmp, greenTmp, blueTmp);
if (raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDBILINEAR) ||
raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBBILINEAR)) {
bayer_bilinear_demosaic(blend, rawData, red, green, blue);
return;
} else {
greenTmp(winw, winh);
blueTmp(winw, winh);
vng4_demosaic(rawData, redTmp, greenTmp, blueTmp);
}
} else {
greenTmp(winw, winh);
blueTmp(winw, winh);
fast_xtrans_interpolate(rawData, redTmp, greenTmp, blueTmp);
}
// the following is split into 3 loops intentionally to avoid cache conflicts on CPUs with only 4-way cache
#ifdef _OPENMP
#pragma omp parallel for
#pragma omp parallel for schedule(dynamic,16)
#endif
for(int i = 0; i < winh; ++i) {
// the following is split into 3 loops intentionally to avoid cache conflicts on CPUs with only 4-way cache
for(int j = 0; j < winw; ++j) {
red[i][j] = intp(blend[i][j], red[i][j], redTmp[i][j]);
}
}
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(int i = 0; i < winh; ++i) {
for(int j = 0; j < winw; ++j) {
green[i][j] = intp(blend[i][j], green[i][j], greenTmp[i][j]);
}
}
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(int i = 0; i < winh; ++i) {
for(int j = 0; j < winw; ++j) {
blue[i][j] = intp(blend[i][j], blue[i][j], blueTmp[i][j]);
}
}
}
}

3
rtengine/procparams.cc
View File

@ -4633,10 +4633,13 @@ const std::vector<const char*>& RAWParams::BayerSensor::getMethodStrings()
{
static const std::vector<const char*> method_strings {
"amaze",
"amazebilinear",
"amazevng4",
"rcd",
"rcdbilinear",
"rcdvng4",
"dcb",
"dcbbilinear",
"dcbvng4",
"lmmse",
"igv",

3
rtengine/procparams.h
View File

@ -1947,10 +1947,13 @@ struct RAWParams {
struct BayerSensor {
enum class Method {
AMAZE,
AMAZEBILINEAR,
AMAZEVNG4,
RCD,
RCDBILINEAR,
RCDVNG4,
DCB,
DCBBILINEAR,
DCBVNG4,
LMMSE,
IGV,

5
rtengine/rawimagesource.cc
View File

@ -1578,8 +1578,11 @@ void RawImageSource::demosaic(const RAWParams &raw, bool autoContrast, double &c
ahd_demosaic ();
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AMAZE)) {
amaze_demosaic_RT (0, 0, W, H, rawData, red, green, blue, options.chunkSizeAMAZE, options.measure);
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AMAZEVNG4)
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AMAZEBILINEAR)
|| raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AMAZEVNG4)
|| raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::DCBBILINEAR)
|| raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::DCBVNG4)
|| raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::RCDBILINEAR)
|| raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::RCDVNG4)) {
if (!autoContrast) {
double threshold = raw.bayersensor.dualDemosaicContrast;

1
rtengine/rawimagesource.h
View File

@ -300,6 +300,7 @@ protected:
void xtrans_interpolate (const int passes, const bool useCieLab, size_t chunkSize = 1, bool measure = false);
void fast_xtrans_interpolate (const array2D<float> &rawData, array2D<float> &red, array2D<float> &green, array2D<float> &blue);
void pixelshift(int winx, int winy, int winw, int winh, const procparams::RAWParams &rawParams, unsigned int frame, const std::string &make, const std::string &model, float rawWpCorrection);
void bayer_bilinear_demosaic(const float *const * blend, const array2D<float> &rawData, array2D<float> &red, array2D<float> &green, array2D<float> &blue);
void hflip (Imagefloat* im);
void vflip (Imagefloat* im);
void getRawValues(int x, int y, int rotate, int &R, int &G, int &B) override;

10
rtgui/bayerprocess.cc
View File

@ -349,7 +349,10 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
dcbOptions->set_visible(pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCB) || pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBVNG4));
lmmseOptions->set_visible(pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::LMMSE));
dualDemosaicOptions->set_visible(pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEVNG4)
|| pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEBILINEAR)
|| pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBVNG4)
|| pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCBBILINEAR)
|| pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDBILINEAR)
|| pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDVNG4));
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::PIXELSHIFT)) {
pixelShiftOptions->set_visible(pp->raw.bayersensor.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::PSMotionCorrectionMethod::CUSTOM);
@ -558,7 +561,12 @@ void BayerProcess::methodChanged ()
lmmseOptions->hide();
}
if (currentMethod == procparams::RAWParams::BayerSensor::Method::AMAZEVNG4 || currentMethod == procparams::RAWParams::BayerSensor::Method::DCBVNG4 || currentMethod == procparams::RAWParams::BayerSensor::Method::RCDVNG4) {
if (currentMethod == procparams::RAWParams::BayerSensor::Method::AMAZEVNG4 ||
currentMethod == procparams::RAWParams::BayerSensor::Method::DCBVNG4 ||
currentMethod == procparams::RAWParams::BayerSensor::Method::RCDVNG4 ||
currentMethod == procparams::RAWParams::BayerSensor::Method::AMAZEBILINEAR ||
currentMethod == procparams::RAWParams::BayerSensor::Method::DCBBILINEAR ||
currentMethod == procparams::RAWParams::BayerSensor::Method::RCDBILINEAR) {
dualDemosaicOptions->show();
} else {
dualDemosaicOptions->hide();