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

merge with dev

Browse Source
This commit is contained in:
Desmis 2019-12-01 06:53:23 +01:00
commit c0da01cf9a
116 changed files with 4040 additions and 562 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rtdata/options/options.lin
View File

@ -12,8 +12,8 @@ MultiUser=true
[File Browser] [File Browser]
# Image filename extensions to be looked for, and their corresponding search state (0/1 -> skip/include) # Image filename extensions to be looked for, and their corresponding search state (0/1 -> skip/include)
ParseExtensions=3fr;arw;arq;cr2;crf;crw;dcr;dng;fff;iiq;jpg;jpeg;kdc;mef;mos;mrw;nef;nrw;orf;pef;png;raf;raw;rw2;rwl;rwz;sr2;srf;srw;tif;tiff;x3f; ParseExtensions=3fr;arw;arq;cr2;cr3;crf;crw;dcr;dng;fff;iiq;jpg;jpeg;kdc;mef;mos;mrw;nef;nrw;orf;pef;png;raf;raw;rw2;rwl;rwz;sr2;srf;srw;tif;tiff;x3f;
ParseExtensionsEnabled=1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;0;1;1;1;1;1;1;1;1;1;1;1; ParseExtensionsEnabled=1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;0;1;1;1;1;1;1;1;1;1;1;1;
[Output] [Output]
PathTemplate=%p1/converted/%f PathTemplate=%p1/converted/%f

4
rtdata/options/options.osx
View File

@ -12,8 +12,8 @@ MultiUser=true
[File Browser] [File Browser]
# Image filename extensions to be looked for, and their corresponding search state (0/1 -> skip/include) # Image filename extensions to be looked for, and their corresponding search state (0/1 -> skip/include)
ParseExtensions=3fr;arw;arq;cr2;crf;crw;dcr;dng;fff;iiq;jpg;jpeg;kdc;mef;mos;mrw;nef;nrw;orf;pef;png;raf;raw;rw2;rwl;rwz;sr2;srf;srw;tif;tiff;x3f; ParseExtensions=3fr;arw;arq;cr2;cr3;crf;crw;dcr;dng;fff;iiq;jpg;jpeg;kdc;mef;mos;mrw;nef;nrw;orf;pef;png;raf;raw;rw2;rwl;rwz;sr2;srf;srw;tif;tiff;x3f;
ParseExtensionsEnabled=1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;0;1;1;1;1;1;1;1;1;1;1;1; ParseExtensionsEnabled=1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;0;1;1;1;1;1;1;1;1;1;1;1;
[Output] [Output]
PathTemplate=%p1/converted/%f PathTemplate=%p1/converted/%f

4
rtdata/options/options.win
View File

@ -14,8 +14,8 @@ UseSystemTheme=false
[File Browser] [File Browser]
# Image filename extensions to be looked for, and their corresponding search state (0/1 -> skip/include) # Image filename extensions to be looked for, and their corresponding search state (0/1 -> skip/include)
ParseExtensions=3fr;arw;arq;cr2;crf;crw;dcr;dng;fff;iiq;jpg;jpeg;kdc;mef;mos;mrw;nef;nrw;orf;pef;png;raf;raw;rw2;rwl;rwz;sr2;srf;srw;tif;tiff;x3f; ParseExtensions=3fr;arw;arq;cr2;cr3;crf;crw;dcr;dng;fff;iiq;jpg;jpeg;kdc;mef;mos;mrw;nef;nrw;orf;pef;png;raf;raw;rw2;rwl;rwz;sr2;srf;srw;tif;tiff;x3f;
ParseExtensionsEnabled=1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;0;1;1;1;1;1;1;1;1;1;1;1; ParseExtensionsEnabled=1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;1;0;1;1;1;1;1;1;1;1;1;1;1;
[Output] [Output]
PathTemplate=%p1/converted/%f PathTemplate=%p1/converted/%f

17
rtdata/profiles/Pixel Shift/PS ISO Low.pp3
View File

@ -1,18 +1,8 @@
[Sharpening] [Sharpening]
Enabled=true Enabled=false
Contrast=5
Method=rld
DeconvRadius=0.75
DeconvAmount=100
DeconvDamping=0
DeconvIterations=30
[SharpenMicro] [SharpenMicro]
Enabled=true Enabled=false
Contrast=15
Matrix=false
Strength=20
Uniformity=5
[RAW] [RAW]
CA=true CA=true
@ -38,3 +28,6 @@ pixelShiftBlur=true
pixelShiftSmoothFactor=0.69999999999999996 pixelShiftSmoothFactor=0.69999999999999996
pixelShiftLmmse=false pixelShiftLmmse=false
pixelShiftNonGreenCross=true pixelShiftNonGreenCross=true
[PostDemosaicSharpening]
Enabled=true

17
rtdata/profiles/Pixel Shift/PS No Motion.pp3
View File

@ -1,18 +1,8 @@
[Sharpening] [Sharpening]
Enabled=true Enabled=false
Contrast=5
Method=rld
DeconvRadius=0.75
DeconvAmount=100
DeconvDamping=0
DeconvIterations=30
[SharpenMicro] [SharpenMicro]
Enabled=true Enabled=false
Contrast=15
Matrix=false
Strength=20
Uniformity=5
[RAW] [RAW]
CA=true CA=true
@ -22,3 +12,6 @@ Method=pixelshift
PixelShiftMotion=0 PixelShiftMotion=0
PixelShiftMotionCorrection=5 PixelShiftMotionCorrection=5
PixelShiftMotionCorrectionMethod=0 PixelShiftMotionCorrectionMethod=0
[PostDemosaicSharpening]
Enabled=true

1
rtengine/CMakeLists.txt
View File

@ -34,6 +34,7 @@ set(RTENGINESOURCEFILES
amaze_demosaic_RT.cc amaze_demosaic_RT.cc
badpixels.cc badpixels.cc
boxblur.cc boxblur.cc
canon_cr3_decoder.cc
CA_correct_RT.cc CA_correct_RT.cc
calc_distort.cc calc_distort.cc
camconst.cc camconst.cc

6
rtengine/FTblockDN.cc
View File

@ -1599,9 +1599,9 @@ BENCHFUN
Color::Lab2RGBLimit(labdn->L[i1], labdn->a[i1], labdn->b[i1], labdn->L[i1], labdn->a[i1], labdn->b[i1], wip, 9000000.f, 1.f + qhighFactor * realred, 1.f + qhighFactor * realblue, width); Color::Lab2RGBLimit(labdn->L[i1], labdn->a[i1], labdn->b[i1], labdn->L[i1], labdn->a[i1], labdn->b[i1], wip, 9000000.f, 1.f + qhighFactor * realred, 1.f + qhighFactor * realblue, width);
for (int j = tileleft; j < tileright; ++j) { for (int j = tileleft; j < tileright; ++j) {
int j1 = j - tileleft; int j1 = j - tileleft;
float r_ = labdn->L[i1][j1]; float r_ = std::max(0.f, labdn->L[i1][j1]);
float g_ = labdn->a[i1][j1]; float g_ = std::max(0.f, labdn->a[i1][j1]);
float b_ = labdn->b[i1][j1]; float b_ = std::max(0.f, labdn->b[i1][j1]);
//inverse gamma standard (slider) //inverse gamma standard (slider)
r_ = r_ < 32768.f ? igamcurve[r_] : (Color::gammanf(r_ / 32768.f, igam) * 65535.f); r_ = r_ < 32768.f ? igamcurve[r_] : (Color::gammanf(r_ / 32768.f, igam) * 65535.f);
g_ = g_ < 32768.f ? igamcurve[g_] : (Color::gammanf(g_ / 32768.f, igam) * 65535.f); g_ = g_ < 32768.f ? igamcurve[g_] : (Color::gammanf(g_ / 32768.f, igam) * 65535.f);

193
rtengine/badpixels.cc
View File

@ -22,12 +22,39 @@
#include "pixelsmap.h" #include "pixelsmap.h"
#include "rawimage.h" #include "rawimage.h"
#include "rawimagesource.h" #include "rawimagesource.h"
//#define BENCHMARK
#include "StopWatch.h"
namespace namespace
{ {
unsigned fc(const unsigned int cfa[2][2], int r, int c) { unsigned fc(const unsigned int cfa[2][2], int r, int c) {
return cfa[r & 1][c & 1]; return cfa[r & 1][c & 1];
} }
inline void sum5x5(const array2D<float>& in, int col, float &sum) {
#ifdef __SSE2__
// sum up 5*4 = 20 values using SSE
// 10 fabs function calls and 10 float additions with SSE
const vfloat sumv = (vabsf(LVFU(in[0][col])) + vabsf(LVFU(in[1][col]))) +
(vabsf(LVFU(in[2][col])) + vabsf(LVFU(in[3][col]))) +
vabsf(LVFU(in[4][col]));
// horizontally add the values and add the result to hfnbrave
sum += vhadd(sumv);
// add remaining 5 values of last column
sum += (fabsf(in[0][col + 4]) + fabsf(in[1][col + 4])) +
(fabsf(in[2][col + 4]) + fabsf(in[3][col + 4])) +
fabsf(in[4][col + 4]);
#else
// 25 fabs function calls and 25 float additions without SSE
for (int nn = col; nn < col + 5; ++nn) {
sum += (fabsf(in[0][nn]) + fabsf(in[1][nn])) +
(fabsf(in[2][nn]) + fabsf(in[3][nn])) +
fabsf(in[4][nn]);
}
#endif
}
} }
namespace rtengine namespace rtengine
@ -445,126 +472,124 @@ int RawImageSource::interpolateBadPixelsXtrans(const PixelsMap &bitmapBads)
/* Search for hot or dead pixels in the image and update the map /* Search for hot or dead pixels in the image and update the map
* For each pixel compare its value to the average of similar color surrounding * For each pixel compare its value to the average of similar color surrounding
* (Taken from Emil Martinec idea) * (Taken from Emil Martinec idea)
* (Optimized by Ingo Weyrich 2013 and 2015) * (Optimized by Ingo Weyrich 2013, 2015, and 2019)
*/ */
int RawImageSource::findHotDeadPixels(PixelsMap &bpMap, const float thresh, const bool findHotPixels, const bool findDeadPixels) const int RawImageSource::findHotDeadPixels(PixelsMap &bpMap, const float thresh, const bool findHotPixels, const bool findDeadPixels) const
{ {
BENCHFUN
const float varthresh = (20.0 * (thresh / 100.0) + 1.0) / 24.f; const float varthresh = (20.0 * (thresh / 100.0) + 1.0) / 24.f;
// allocate temporary buffer
float* cfablur = new float[H * W];
// counter for dead or hot pixels // counter for dead or hot pixels
int counter = 0; int counter = 0;
#ifdef _OPENMP #ifdef _OPENMP
#pragma omp parallel #pragma omp parallel reduction(+:counter)
#endif #endif
{ {
array2D<float> cfablur(W, 5, ARRAY2D_CLEAR_DATA);
int firstRow = -1;
int lastRow = -1;
#ifdef _OPENMP #ifdef _OPENMP
#pragma omp for schedule(dynamic,16) nowait // note, static scheduling is important in this implementation
#pragma omp for schedule(static) nowait
#endif #endif
for (int i = 2; i < H - 2; i++) { for (int i = 2; i < H - 2; ++i) {
for (int j = 2; j < W - 2; j++) { if (firstRow == -1) {
firstRow = i;
if (firstRow > 2) {
for (int row = firstRow - 2; row < firstRow; ++row) {
const int destRow = row % 5;
for (int j = 2; j < W - 2; ++j) {
const float temp = median(rawData[row - 2][j - 2], rawData[row - 2][j], rawData[row - 2][j + 2],
rawData[row][j - 2], rawData[row][j], rawData[row][j + 2],
rawData[row + 2][j - 2], rawData[row + 2][j], rawData[row + 2][j + 2]);
cfablur[destRow][j] = rawData[row][j] - temp;
}
}
}
}
lastRow = i;
const int destRow = i % 5;
for (int j = 2; j < W - 2; ++j) {
const float temp = median(rawData[i - 2][j - 2], rawData[i - 2][j], rawData[i - 2][j + 2], const float temp = median(rawData[i - 2][j - 2], rawData[i - 2][j], rawData[i - 2][j + 2],
rawData[i][j - 2], rawData[i][j], rawData[i][j + 2], rawData[i][j - 2], rawData[i][j], rawData[i][j + 2],
rawData[i + 2][j - 2], rawData[i + 2][j], rawData[i + 2][j + 2]); rawData[i + 2][j - 2], rawData[i + 2][j], rawData[i + 2][j + 2]);
cfablur[i * W + j] = rawData[i][j] - temp; cfablur[destRow][j] = rawData[i][j] - temp;
}
} }
// process borders. Former version calculated the median using mirrored border which does not make sense because the original pixel loses weight if (i - 1 > firstRow) {
// Setting the difference between pixel and median for border pixels to zero should do the job not worse then former version const int rr = i - 2;
#ifdef _OPENMP const int rr0 = rr % 5;
#pragma omp single for (int cc = 2; cc < W - 2; ++cc) {
#endif
{
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < W; ++j) {
cfablur[i * W + j] = 0.f;
}
}
for (int i = 2; i < H - 2; ++i) {
for (int j = 0; j < 2; ++j) {
cfablur[i * W + j] = 0.f;
}
for (int j = W - 2; j < W; ++j) {
cfablur[i * W + j] = 0.f;
}
}
for (int i = H - 2; i < H; ++i) {
for (int j = 0; j < W; ++j) {
cfablur[i * W + j] = 0.f;
}
}
}
#ifdef _OPENMP
#pragma omp barrier // barrier because of nowait clause above
#pragma omp for reduction(+:counter) schedule(dynamic,16)
#endif
//cfa pixel heat/death evaluation
for (int rr = 2; rr < H - 2; ++rr) {
for (int cc = 2, rrmWpcc = rr * W + 2; cc < W - 2; ++cc, ++rrmWpcc) {
//evaluate pixel for heat/death //evaluate pixel for heat/death
float pixdev = cfablur[rrmWpcc]; float pixdev = cfablur[rr0][cc];
if (pixdev == 0.f) { if (!findDeadPixels && pixdev <= 0.f) {
continue; continue;
} }
if ((!findDeadPixels) && pixdev < 0) { if (!findHotPixels && pixdev >= 0.f) {
continue;
}
if ((!findHotPixels) && pixdev > 0) {
continue; continue;
} }
pixdev = fabsf(pixdev); pixdev = fabsf(pixdev);
float hfnbrave = -pixdev; float hfnbrave = -pixdev;
sum5x5(cfablur, cc - 2, hfnbrave);
#ifdef __SSE2__
// sum up 5*4 = 20 values using SSE
// 10 fabs function calls and 10 float additions with SSE
vfloat sum = vabsf(LVFU(cfablur[(rr - 2) * W + cc - 2])) + vabsf(LVFU(cfablur[(rr - 1) * W + cc - 2]));
sum += vabsf(LVFU(cfablur[(rr) * W + cc - 2]));
sum += vabsf(LVFU(cfablur[(rr + 1) * W + cc - 2]));
sum += vabsf(LVFU(cfablur[(rr + 2) * W + cc - 2]));
// horizontally add the values and add the result to hfnbrave
hfnbrave += vhadd(sum);
// add remaining 5 values of last column
for (int mm = rr - 2; mm <= rr + 2; ++mm) {
hfnbrave += fabsf(cfablur[mm * W + cc + 2]);
}
#else
// 25 fabs function calls and 25 float additions without SSE
for (int mm = rr - 2; mm <= rr + 2; ++mm) {
for (int nn = cc - 2; nn <= cc + 2; ++nn) {
hfnbrave += fabsf(cfablur[mm * W + nn]);
}
}
#endif
if (pixdev > varthresh * hfnbrave) { if (pixdev > varthresh * hfnbrave) {
// mark the pixel as "bad" // mark the pixel as "bad"
bpMap.set(cc, rr); bpMap.set(cc, rr);
counter++; ++counter;
} }
} //end of pixel evaluation } //end of pixel evaluation
} }
}
if (lastRow > 0 && lastRow < H - 2) {
//cfa pixel heat/death evaluation
for (int rr = lastRow - 1; rr < lastRow + 1; ++rr) {
const int i = rr + 2;
const int destRow = i % 5;
if (i >= H - 2) {
for (int j = 2; j < W - 2; j++) {
cfablur[destRow][j] = 0.f;
}
} else {
for (int j = 2; j < W - 2; ++j) {
const float temp = median(rawData[i - 2][j - 2], rawData[i - 2][j], rawData[i - 2][j + 2],
rawData[i][j - 2], rawData[i][j], rawData[i][j + 2],
rawData[i + 2][j - 2], rawData[i + 2][j], rawData[i + 2][j + 2]);
cfablur[destRow][j] = rawData[i][j] - temp;
}
}
const int rr0 = rr % 5;
for (int cc = 2; cc < W - 2; ++cc) {
//evaluate pixel for heat/death
float pixdev = cfablur[rr0][cc];
if (!findDeadPixels && pixdev <= 0.f) {
continue;
}
if (!findHotPixels && pixdev >= 0.f) {
continue;
}
pixdev = fabsf(pixdev);
float hfnbrave = -pixdev;
sum5x5(cfablur, cc - 2, hfnbrave);
if (pixdev > varthresh * hfnbrave) {
// mark the pixel as "bad"
bpMap.set(cc, rr);
++counter;
}
}//end of pixel evaluation
}
}
}//end of parallel processing }//end of parallel processing
delete [] cfablur;
return counter; return counter;
} }

1
rtengine/boxblur.cc
View File

@ -33,6 +33,7 @@ void boxblur(float** src, float** dst, int radius, int W, int H, bool multiThrea
{ {
//box blur using rowbuffers and linebuffers instead of a full size buffer //box blur using rowbuffers and linebuffers instead of a full size buffer
radius = rtengine::min(radius, W - 1, H - 1);
if (radius == 0) { if (radius == 0) {
if (src != dst) { if (src != dst) {
#ifdef _OPENMP #ifdef _OPENMP

6
rtengine/cJSON.c
View File

@ -445,9 +445,7 @@ static unsigned char* ensure(printbuffer * const p, size_t needed)
p->buffer = NULL; p->buffer = NULL;
return NULL; return NULL;
} } else {
if (newbuffer)
{
memcpy(newbuffer, p->buffer, p->offset + 1); memcpy(newbuffer, p->buffer, p->offset + 1);
} }
p->hooks.deallocate(p->buffer); p->hooks.deallocate(p->buffer);
@ -1436,7 +1434,7 @@ fail:
static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer)
{ {
unsigned char *output_pointer = NULL; unsigned char *output_pointer = NULL;
size_t length = 0; size_t length;
cJSON *current_element = item->child; cJSON *current_element = item->child;
if (output_buffer == NULL) if (output_buffer == NULL)

12
rtengine/camconst.json
View File

@ -1138,6 +1138,16 @@ Camera constants:
} }
}, },
{ // Quality C, only raw crop
"make_model": [ "Canon EOS M6 Mark II", "Canon EOS 90D" ],
"raw_crop": [ 144, 72, 6984, 4660 ]
},
{ // Quality C, only raw crop
"make_model": [ "Canon EOS R" ],
"raw_crop": [ 144, 46, 6744, 4500 ]
},
// Canon Powershot // Canon Powershot
{ // Quality C, CHDK DNGs, raw frame correction { // Quality C, CHDK DNGs, raw frame correction
"make_model": "Canon PowerShot A3100 IS", "make_model": "Canon PowerShot A3100 IS",
@ -2506,7 +2516,7 @@ Camera constants:
{ // Quality C, { // Quality C,
"make_model": "Sony ILCE-7RM4", "make_model": "Sony ILCE-7RM4",
"raw_crop": [ 0, 0, 9568, 0 ] // full raw frame 9600x6376 - 32 rightmost columns are garbage "raw_crop": [ 0, 0, -32, 0 ] // full raw frame 9600x6376 - 32 rightmost columns are garbage. Using -32 instead of 9568 to support also 16-shot pixelshift files
}, },
{ // Quality B, color matrix copied from a7rm2 { // Quality B, color matrix copied from a7rm2

3116
rtengine/canon_cr3_decoder.cc Normal file
View File

File diff suppressed because it is too large Load Diff

181
rtengine/capturesharpening.cc
View File

@ -409,92 +409,88 @@ float calcRadiusXtrans(const float * const *rawData, int W, int H, float lowerLi
#ifdef _OPENMP #ifdef _OPENMP
#pragma omp parallel for reduction(max:maxRatio) schedule(dynamic, 16) #pragma omp parallel for reduction(max:maxRatio) schedule(dynamic, 16)
#endif #endif
for (int row = starty + 3; row < H - 4; row += 3) { for (int row = starty + 2; row < H - 4; row += 3) {
for (int col = startx + 3; col < W - 4; col += 3) { for (int col = startx + 2; col < W - 4; col += 3) {
const float valtl = rawData[row][col]; const float valp1p1 = rawData[row + 1][col + 1];
const float valtr = rawData[row][col + 1]; const bool squareClipped = rtengine::max(valp1p1, rawData[row + 1][col + 2], rawData[row + 2][col + 1], rawData[row + 2][col + 2]) >= upperLimit;
const float valbl = rawData[row + 1][col]; const float greenSolitary = rawData[row][col];
const float valbr = rawData[row + 1][col + 1]; if (greenSolitary > 1.f && std::max(rawData[row - 1][col - 1], rawData[row - 1][col + 1]) < upperLimit) {
if (valtl > 1.f) { if (greenSolitary < upperLimit) {
const float maxValtltr = std::max(valtl, valtr); const float valp1m1 = rawData[row + 1][col - 1];
if (valtr > 1.f && maxValtltr > lowerLimit) { if (valp1m1 > 1.f && rtengine::max(rawData[row + 1][col - 2], valp1m1, rawData[row + 2][col - 2], rawData[row + 1][col - 1]) < upperLimit) {
const float minVal = std::min(valtl, valtr); const float maxVal = std::max(greenSolitary, valp1m1);
if (UNLIKELY(maxValtltr > maxRatio * minVal)) { if (maxVal > lowerLimit) {
bool clipped = false; const float minVal = std::min(greenSolitary, valp1m1);
if (maxValtltr == valtl) { // check for influence by clipped green in neighborhood if (UNLIKELY(maxVal > maxRatio * minVal)) {
if (rtengine::max(rawData[row - 1][col - 1], valtr, valbl, valbr) >= upperLimit) { maxRatio = maxVal / minVal;
clipped = true;
}
} else { // check for influence by clipped green in neighborhood
if (rtengine::max(rawData[row - 1][col + 2], valtl, valbl, valbr) >= upperLimit) {
clipped = true;
}
}
if (!clipped) {
maxRatio = maxValtltr / minVal;
} }
} }
} }
const float maxValtlbl = std::max(valtl, valbl); if (valp1p1 > 1.f && !squareClipped) {
if (valbl > 1.f && maxValtlbl > lowerLimit) { const float maxVal = std::max(greenSolitary, valp1p1);
const float minVal = std::min(valtl, valbl); if (maxVal > lowerLimit) {
if (UNLIKELY(maxValtlbl > maxRatio * minVal)) { const float minVal = std::min(greenSolitary, valp1p1);
bool clipped = false; if (UNLIKELY(maxVal > maxRatio * minVal)) {
if (maxValtlbl == valtl) { // check for influence by clipped green in neighborhood maxRatio = maxVal / minVal;
if (rtengine::max(rawData[row - 1][col - 1], valtr, valbl, valbr) >= upperLimit) {
clipped = true;
}
} else { // check for influence by clipped green in neighborhood
if (rtengine::max(valtl, valtr, rawData[row + 2][col - 1], valbr) >= upperLimit) {
clipped = true;
}
}
if (!clipped) {
maxRatio = maxValtlbl / minVal;
}
}
}
}
if (valbr > 1.f) {
const float maxValblbr = std::max(valbl, valbr);
if (valbl > 1.f && maxValblbr > lowerLimit) {
const float minVal = std::min(valbl, valbr);
if (UNLIKELY(maxValblbr > maxRatio * minVal)) {
bool clipped = false;
if (maxValblbr == valbr) { // check for influence by clipped green in neighborhood
if (rtengine::max(valtl, valtr, valbl, rawData[row + 2][col + 2]) >= upperLimit) {
clipped = true;
}
} else { // check for influence by clipped green in neighborhood
if (rtengine::max(valtl, valtr, rawData[row + 2][col - 1], valbr) >= upperLimit) {
clipped = true;
}
}
if (!clipped) {
maxRatio = maxValblbr / minVal;
}
}
}
const float maxValtrbr = std::max(valtr, valbr);
if (valtr > 1.f && maxValtrbr > lowerLimit) {
const float minVal = std::min(valtr, valbr);
if (UNLIKELY(maxValtrbr > maxRatio * minVal)) {
if (maxValtrbr == valbr) { // check for influence by clipped green in neighborhood
if (rtengine::max(valtl, valtr, valbl, rawData[row + 2][col + 2]) >= upperLimit) {
continue;
}
} else { // check for influence by clipped green in neighborhood
if (rtengine::max(rawData[row - 1][col + 2], valtl, valbl, valbr) >= upperLimit) {
continue;
}
}
maxRatio = maxValtrbr / minVal;
} }
} }
} }
} }
} }
return std::sqrt((1.f / (std::log(1.f / maxRatio))) / -2.f); if (!squareClipped) {
const float valp2p2 = rawData[row + 2][col + 2];
if (valp2p2 > 1.f) {
if (valp1p1 > 1.f) {
const float maxVal = std::max(valp1p1, valp2p2);
if (maxVal > lowerLimit) {
const float minVal = std::min(valp1p1, valp2p2);
if (UNLIKELY(maxVal > maxRatio * minVal)) {
maxRatio = maxVal / minVal;
}
}
}
const float greenSolitaryRight = rawData[row + 3][col + 3];
if (rtengine::max(greenSolitaryRight, rawData[row + 4][col + 2], rawData[row + 4][col + 4]) < upperLimit) {
if (greenSolitaryRight > 1.f) {
const float maxVal = std::max(greenSolitaryRight, valp2p2);
if (maxVal > lowerLimit) {
const float minVal = std::min(greenSolitaryRight, valp2p2);
if (UNLIKELY(maxVal > maxRatio * minVal)) {
maxRatio = maxVal / minVal;
}
}
}
}
}
const float valp1p2 = rawData[row + 1][col + 2];
const float valp2p1 = rawData[row + 2][col + 1];
if (valp2p1 > 1.f) {
if (valp1p2 > 1.f) {
const float maxVal = std::max(valp1p2, valp2p1);
if (maxVal > lowerLimit) {
const float minVal = std::min(valp1p2, valp2p1);
if (UNLIKELY(maxVal > maxRatio * minVal)) {
maxRatio = maxVal / minVal;
}
}
}
const float greenSolitaryLeft = rawData[row + 3][col];
if (rtengine::max(greenSolitaryLeft, rawData[row + 4][col - 1], rawData[row + 4][col + 1]) < upperLimit) {
if (greenSolitaryLeft > 1.f) {
const float maxVal = std::max(greenSolitaryLeft, valp2p1);
if (maxVal > lowerLimit) {
const float minVal = std::min(greenSolitaryLeft, valp2p1);
if (UNLIKELY(maxVal > maxRatio * minVal)) {
maxRatio = maxVal / minVal;
}
}
}
}
}
}
}
}
return std::sqrt((1.f / (std::log(1.f / maxRatio) / 2.f)) / -2.f);
} }
bool checkForStop(float** tmpIThr, float** iterCheck, int fullTileSize, int border) bool checkForStop(float** tmpIThr, float** iterCheck, int fullTileSize, int border)
@ -537,8 +533,8 @@ BENCHFUN
} }
constexpr int tileSize = 32; constexpr int tileSize = 32;
constexpr int border = 5; const int border = iterations <= 30 ? 5 : 7;
constexpr int fullTileSize = tileSize + 2 * border; const int fullTileSize = tileSize + 2 * border;
const float cornerRadius = std::min<float>(1.15f, sigma + sigmaCornerOffset); const float cornerRadius = std::min<float>(1.15f, sigma + sigmaCornerOffset);
const float cornerDistance = sqrt(rtengine::SQR(W * 0.5f) + rtengine::SQR(H * 0.5f)); const float cornerDistance = sqrt(rtengine::SQR(W * 0.5f) + rtengine::SQR(H * 0.5f));
const float distanceFactor = (cornerRadius - sigma) / cornerDistance; const float distanceFactor = (cornerRadius - sigma) / cornerDistance;
@ -573,10 +569,10 @@ BENCHFUN
} }
} }
} }
for (int k = 0, ii = endOfCol ? H - fullTileSize : i; k < fullTileSize; ++k, ++ii) { for (int k = 0, ii = endOfCol ? H - fullTileSize : i - border; k < fullTileSize; ++k, ++ii) {
for (int l = 0, jj = endOfRow ? W - fullTileSize : j; l < fullTileSize; ++l, ++jj) { for (int l = 0, jj = endOfRow ? W - fullTileSize : j - border; l < fullTileSize; ++l, ++jj) {
tmpIThr[k][l] = oldLuminance[ii - border][jj - border]; tmpIThr[k][l] = oldLuminance[ii][jj];
lumThr[k][l] = oldLuminance[ii - border][jj - border]; lumThr[k][l] = oldLuminance[ii][jj];
} }
} }
} else { } else {
@ -618,6 +614,7 @@ BENCHFUN
const float distance = sqrt(rtengine::SQR(i + tileSize / 2 - H / 2) + rtengine::SQR(j + tileSize / 2 - W / 2)); const float distance = sqrt(rtengine::SQR(i + tileSize / 2 - H / 2) + rtengine::SQR(j + tileSize / 2 - W / 2));
const float sigmaTile = static_cast<float>(sigma) + distanceFactor * distance; const float sigmaTile = static_cast<float>(sigma) + distanceFactor * distance;
if (sigmaTile >= 0.4f) { if (sigmaTile >= 0.4f) {
if (sigmaTile > 0.84) { // have to use 7x7 kernel
float lkernel7[7][7]; float lkernel7[7][7];
compute7x7kernel(static_cast<float>(sigma) + distanceFactor * distance, lkernel7); compute7x7kernel(static_cast<float>(sigma) + distanceFactor * distance, lkernel7);
for (int k = 0; k < iterations && !stopped; ++k) { for (int k = 0; k < iterations && !stopped; ++k) {
@ -628,6 +625,18 @@ BENCHFUN
stopped = checkForStop(tmpIThr, iterCheck, fullTileSize, border); stopped = checkForStop(tmpIThr, iterCheck, fullTileSize, border);
} }
} }
} else { // can use 5x5 kernel
float lkernel7[5][5];
compute5x5kernel(static_cast<float>(sigma) + distanceFactor * distance, lkernel7);
for (int k = 0; k < iterations && !stopped; ++k) {
// apply 7x7 gaussian blur and divide luminance by result of gaussian blur
gauss5x5div(tmpIThr, tmpThr, lumThr, fullTileSize, lkernel7);
gauss5x5mult(tmpThr, tmpIThr, fullTileSize, lkernel7);
if (checkIterStop) {
stopped = checkForStop(tmpIThr, iterCheck, fullTileSize, border);
}
}
}
} }
} else { } else {
for (int k = 0; k < iterations && !stopped; ++k) { for (int k = 0; k < iterations && !stopped; ++k) {
@ -642,8 +651,8 @@ BENCHFUN
} }
if (endOfRow || endOfCol) { if (endOfRow || endOfCol) {
// special handling for small tiles at end of row or column // special handling for small tiles at end of row or column
for (int k = border, ii = endOfCol ? H - fullTileSize - border : i - border; k < fullTileSize - border; ++k) { for (int k = border, ii = endOfCol ? H - fullTileSize : i - border; k < fullTileSize - border; ++k) {
for (int l = border, jj = endOfRow ? W - fullTileSize - border : j - border; l < fullTileSize - border; ++l) { for (int l = border, jj = endOfRow ? W - fullTileSize : j - border; l < fullTileSize - border; ++l) {
luminance[ii + k][jj + l] = rtengine::intp(blend[ii + k][jj + l], std::max(tmpIThr[k][l], 0.0f), luminance[ii + k][jj + l]); luminance[ii + k][jj + l] = rtengine::intp(blend[ii + k][jj + l], std::max(tmpIThr[k][l], 0.0f), luminance[ii + k][jj + l]);
} }
} }

2
rtengine/ciecam02.cc
View File

@ -404,7 +404,7 @@ void Ciecam02::calculate_abfloat ( vfloat &aa, vfloat &bb, vfloat h, vfloat e, v
#endif #endif
void Ciecam02::initcam1float (float yb, float pilotd, float f, float la, float xw, float yw, float zw, float &n, float &d, float &nbb, float &ncb, void Ciecam02::initcam1float (float yb, float pilotd, float f, float la, float xw, float yw, float zw, float &n, float &d, float &nbb, float &ncb,
float &cz, float &aw, float &wh, float &pfl, float &fl, float &c) float &cz, float &aw, float &wh, float &pfl, float &fl, float c)
{ {
n = yb / yw; n = yb / yw;

2
rtengine/ciecam02.h
View File

@ -84,7 +84,7 @@ public:
* Forward transform from XYZ to CIECAM02 JCh. * Forward transform from XYZ to CIECAM02 JCh.
*/ */
static void initcam1float (float yb, float pilotd, float f, float la, float xw, float yw, float zw, float &n, float &d, float &nbb, float &ncb, static void initcam1float (float yb, float pilotd, float f, float la, float xw, float yw, float zw, float &n, float &d, float &nbb, float &ncb,
float &cz, float &aw, float &wh, float &pfl, float &fl, float &c); float &cz, float &aw, float &wh, float &pfl, float &fl, float c);
static void initcam2float (float yb, float pilotd, float f, float la, float xw, float yw, float zw, float &n, float &d, float &nbb, float &ncb, static void initcam2float (float yb, float pilotd, float f, float la, float xw, float yw, float zw, float &n, float &d, float &nbb, float &ncb,
float &cz, float &aw, float &fl); float &cz, float &aw, float &fl);

2
rtengine/cplx_wavelet_level.h
View File

@ -272,7 +272,7 @@ template<typename T> void wavelet_level<T>::SynthesisFilterHaarVertical (const T
#pragma omp for nowait #pragma omp for nowait
#endif #endif
for(int i = 0; i < skip; i++) for(int i = 0; i < std::min(skip, height); i++)
{ {
for(int j = 0; j < width; j++) { for(int j = 0; j < width; j++) {
dst[width * i + j] = (srcLo[i * width + j] + srcHi[i * width + j]); dst[width * i + j] = (srcLo[i * width + j] + srcHi[i * width + j]);

359
rtengine/dcraw.cc
View File

@ -5595,13 +5595,26 @@ nf: order = 0x4949;
else if (!strcmp (buf,"AOC") || else if (!strcmp (buf,"AOC") ||
!strcmp (buf,"QVC")) !strcmp (buf,"QVC"))
fseek (ifp, -4, SEEK_CUR); fseek (ifp, -4, SEEK_CUR);
// ALB -- taken from LibRaw ------------------------------------------------
else if (!strncmp(buf, "CMT3", 4))
{
order = sget2((uchar *)(buf + 4));
fseek(ifp, 2L, SEEK_CUR);
}
else if (RT_canon_CR3_data.CR3_CTMDtag)
{
order = sget2((uchar *)buf);
fseek(ifp, -2L, SEEK_CUR);
}
// -------------------------------------------------------------------------
else { else {
fseek (ifp, -10, SEEK_CUR); fseek (ifp, -10, SEEK_CUR);
if (!strncmp(make,"SAMSUNG",7)) if (!strncmp(make,"SAMSUNG",7))
base = ftell(ifp); base = ftell(ifp);
} }
entries = get2(); entries = get2();
if (entries > 1000) return; if (entries > 2000) return;
morder = order; morder = order;
while (entries--) { while (entries--) {
order = morder; order = morder;
@ -5806,16 +5819,335 @@ get2_256:
parse_thumb_note (base, 136, 137); parse_thumb_note (base, 136, 137);
} }
if (tag == 0x4001 && len > 500) { if (tag == 0x4001 && len > 500) {
i = len == 582 ? 50 : len == 653 ? 68 : len == 5120 ? 142 : 126; // i = len == 582 ? 50 : len == 653 ? 68 : len == 5120 ? 142 : 126;
fseek (ifp, i, SEEK_CUR); // fseek (ifp, i, SEEK_CUR);
FORC4 cam_mul[c ^ (c >> 1)] = get2(); // FORC4 cam_mul[c ^ (c >> 1)] = get2();
for (i+=18; i <= len; i+=10) { // for (i+=18; i <= len; i+=10) {
get2(); // get2();
// FORC4 sraw_mul[c ^ (c >> 1)] = get2();
// if (sraw_mul[1] == 1170) break;
// }
// -- ALB -- adapted from LibRaw --------------------------------------
int bls = 0;
long int offsetChannelBlackLevel = 0L;
long int offsetChannelBlackLevel2 = 0L;
long int offsetWhiteLevels = 0L;
struct {
int AverageBlackLevel;
int ColorDataSubVer;
int NormalWhiteLevel;
int SpecularWhiteLevel;
} imCanon = { 0, 0, 0, 0 };
long int save1 = ftell(ifp);
switch (len)
{
case 582:
// imCanon.ColorDataVer = 1; // 20D / 350D
fseek(ifp, save1 + (0x0019 << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// fseek(ifp, save1 + (0x001e << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0041 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom1][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0046 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom2][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0023 << 1), SEEK_SET);
// Canon_WBpresets(2, 2);
// fseek(ifp, save1 + (0x004b << 1), SEEK_SET);
// Canon_WBCTpresets(1); // ABCT
offsetChannelBlackLevel = save1 + (0x00a6 << 1);
break;
case 653:
// imCanon.ColorDataVer = 2; // 1Dmk2 / 1DsMK2
// fseek(ifp, save1 + (0x0018 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
fseek(ifp, save1 + (0x0022 << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// fseek(ifp, save1 + (0x0090 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom1][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0095 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom2][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x009a << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom3][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0027 << 1), SEEK_SET);
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x00a4 << 1), SEEK_SET);
// Canon_WBCTpresets(1); // ABCT
offsetChannelBlackLevel = save1 + (0x011e << 1);
break;
case 796:
// imCanon.ColorDataVer = 3; // 1DmkIIN / 5D / 30D / 400D
// imCanon.ColorDataSubVer = get2();
fseek(ifp, save1 + (0x003f << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// fseek(ifp, save1 + (0x0044 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0049 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0071 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom1][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0076 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom2][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x007b << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom3][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0080 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Custom][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x004e << 1), SEEK_SET);
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x0085 << 1), SEEK_SET);
// Canon_WBCTpresets(0); // BCAT
offsetChannelBlackLevel = save1 + (0x00c4 << 1);
break;
// 1DmkIII / 1DSmkIII / 1DmkIV / 5DmkII
// 7D / 40D / 50D / 60D / 450D / 500D
// 550D / 1000D / 1100D
case 674:
case 692:
case 702:
case 1227:
case 1250:
case 1251:
case 1337:
case 1338:
case 1346:
// imCanon.ColorDataVer = 4;
imCanon.ColorDataSubVer = get2();
fseek(ifp, save1 + (0x003f << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// fseek(ifp, save1 + (0x0044 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0049 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] = get2();
fseek(ifp, save1 + (0x004e << 1), SEEK_SET);
FORC4 sraw_mul[c ^ (c >> 1)] = get2(); FORC4 sraw_mul[c ^ (c >> 1)] = get2();
if (sraw_mul[1] == 1170) break; // fseek(ifp, save1 + (0x0053 << 1), SEEK_SET);
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x00a8 << 1), SEEK_SET);
// Canon_WBCTpresets(0); // BCAT
if ((imCanon.ColorDataSubVer == 4) ||
(imCanon.ColorDataSubVer == 5))
{
offsetChannelBlackLevel = save1 + (0x02b4 << 1);
offsetWhiteLevels = save1 + (0x02b8 << 1);
} }
else if ((imCanon.ColorDataSubVer == 6) ||
(imCanon.ColorDataSubVer == 7))
{
offsetChannelBlackLevel = save1 + (0x02cb << 1);
offsetWhiteLevels = save1 + (0x02cf << 1);
} }
if (tag == 0x4021 && get4() && get4()) else if (imCanon.ColorDataSubVer == 9)
{
offsetChannelBlackLevel = save1 + (0x02cf << 1);
offsetWhiteLevels = save1 + (0x02d3 << 1);
}
else
offsetChannelBlackLevel = save1 + (0x00e7 << 1);
break;
case 5120: // PowerShot G10, G12, G5 X, G7 X, G9 X, EOS M3, EOS M5, EOS M6
// imCanon.ColorDataVer = 5;
imCanon.ColorDataSubVer = get2();
fseek(ifp, save1 + (0x0047 << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
if (imCanon.ColorDataSubVer == 0xfffc)
{ // -4: G7 X Mark II, G9 X Mark II, G1 X Mark III, M5, M100, M6
// fseek(ifp, save1 + (0x004f << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// fseek(ifp, 8, SEEK_CUR);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] =
// get2();
// fseek(ifp, 8, SEEK_CUR);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Other][c ^ (c >> 1)] = get2();
// fseek(ifp, 8, SEEK_CUR);
// Canon_WBpresets(8, 24);
// fseek(ifp, 168, SEEK_CUR);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_FL_WW][c ^ (c >> 1)] = get2();
// fseek(ifp, 24, SEEK_CUR);
// Canon_WBCTpresets(2); // BCADT
offsetChannelBlackLevel = save1 + (0x014d << 1);
offsetWhiteLevels = save1 + (0x0569 << 1);
}
else if (imCanon.ColorDataSubVer == 0xfffd)
{ // -3: M10/M3/G1 X/G1 X II/G10/G11/G12/G15/G16/G3 X/G5 X/G7 X/G9
// X/S100/S110/S120/S90/S95/SX1 IX/SX50 HS/SX60 HS
// fseek(ifp, save1 + (0x004c << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// get2();
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] =
// get2();
// get2();
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Other][c ^ (c >> 1)] = get2();
// get2();
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x00ba << 1), SEEK_SET);
// Canon_WBCTpresets(2); // BCADT
offsetChannelBlackLevel = save1 + (0x0108 << 1);
}
break;
case 1273:
case 1275:
// imCanon.ColorDataVer = 6; // 600D / 1200D
imCanon.ColorDataSubVer = get2();
fseek(ifp, save1 + (0x003f << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// fseek(ifp, save1 + (0x0044 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0049 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] = get2();
fseek(ifp, save1 + (0x0062 << 1), SEEK_SET);
FORC4 sraw_mul[c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0067 << 1), SEEK_SET);
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x00bc << 1), SEEK_SET);
// Canon_WBCTpresets(0); // BCAT
offsetChannelBlackLevel = save1 + (0x01df << 1);
offsetWhiteLevels = save1 + (0x01e3 << 1);
break;
// 1DX / 5DmkIII / 6D / 100D / 650D / 700D / EOS M / 7DmkII / 750D / 760D
case 1312:
case 1313:
case 1316:
case 1506:
// imCanon.ColorDataVer = 7;
imCanon.ColorDataSubVer = get2();
fseek(ifp, save1 + (0x003f << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// fseek(ifp, save1 + (0x0044 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0049 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] = get2();
fseek(ifp, save1 + (0x007b << 1), SEEK_SET);
FORC4 sraw_mul[c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0080 << 1), SEEK_SET);
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x00d5 << 1), SEEK_SET);
// Canon_WBCTpresets(0); // BCAT
if (imCanon.ColorDataSubVer == 10)
{
offsetChannelBlackLevel = save1 + (0x01f8 << 1);
offsetWhiteLevels = save1 + (0x01fc << 1);
}
else if (imCanon.ColorDataSubVer == 11)
{
offsetChannelBlackLevel = save1 + (0x02d8 << 1);
offsetWhiteLevels = save1 + (0x02dc << 1);
}
break;
// 5DS / 5DS R / 80D / 1300D / 1500D / 3000D / 5D4 / 800D / 77D / 6D II /
// 200D
case 1560:
case 1592:
case 1353:
case 1602:
// imCanon.ColorDataVer = 8;
imCanon.ColorDataSubVer = get2();
fseek(ifp, save1 + (0x003f << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// fseek(ifp, save1 + (0x0044 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0049 << 1), SEEK_SET);
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] = get2();
fseek(ifp, save1 + (0x0080 << 1), SEEK_SET);
FORC4 sraw_mul[c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0085 << 1), SEEK_SET);
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x0107 << 1), SEEK_SET);
// Canon_WBCTpresets(0); // BCAT
if (imCanon.ColorDataSubVer == 14)
{ // 1300D / 1500D / 3000D
offsetChannelBlackLevel = save1 + (0x022c << 1);
offsetWhiteLevels = save1 + (0x0230 << 1);
}
else
{
offsetChannelBlackLevel = save1 + (0x030a << 1);
offsetWhiteLevels = save1 + (0x030e << 1);
}
break;
case 1820: // M50, ColorDataSubVer 16
case 1824: // EOS R, SX740HS, ColorDataSubVer 17
case 1816: // EOS RP, SX70HS, ColorDataSubVer 18;
// EOS M6 Mark II, EOS 90D, G7XmkIII, ColorDataSubVer 19
// imCanon.ColorDataVer = 9;
imCanon.ColorDataSubVer = get2();
fseek(ifp, save1 + (0x0047 << 1), SEEK_SET);
FORC4 cam_mul[c ^ (c >> 1)] = (float)get2();
// get2();
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Auto][c ^ (c >> 1)] = get2();
// get2();
// FORC4 imgdata.color.WB_Coeffs[LIBRAW_WBI_Measured][c ^ (c >> 1)] = get2();
// fseek(ifp, save1 + (0x0088 << 1), SEEK_SET);
// Canon_WBpresets(2, 12);
// fseek(ifp, save1 + (0x010a << 1), SEEK_SET);
// Canon_WBCTpresets(0);
offsetChannelBlackLevel = save1 + (0x0318 << 1);
offsetChannelBlackLevel2 = save1 + (0x0149 << 1);
offsetWhiteLevels = save1 + (0x031c << 1);
break;
}
if (offsetChannelBlackLevel)
{
fseek(ifp, offsetChannelBlackLevel, SEEK_SET);
FORC4
bls += (cblack/*imCanon.ChannelBlackLevel*/[c ^ (c >> 1)] = get2());
imCanon.AverageBlackLevel = bls / 4;
// RT_blacklevel_from_constant = ThreeValBool::F;
}
if (offsetWhiteLevels)
{
if ((offsetWhiteLevels - offsetChannelBlackLevel) != 8L)
fseek(ifp, offsetWhiteLevels, SEEK_SET);
imCanon.NormalWhiteLevel = get2();
imCanon.SpecularWhiteLevel = get2();
// FORC4
// imgdata.color.linear_max[c] = imCanon.SpecularWhiteLevel;
maximum = imCanon.SpecularWhiteLevel;
// RT_whitelevel_from_constant = ThreeValBool::F;
}
if(!imCanon.AverageBlackLevel && offsetChannelBlackLevel2)
{
fseek(ifp, offsetChannelBlackLevel2, SEEK_SET);
FORC4
bls += (cblack/*imCanon.ChannelBlackLevel*/[c ^ (c >> 1)] = get2());
imCanon.AverageBlackLevel = bls / 4;
// RT_blacklevel_from_constant = ThreeValBool::F;
}
fseek(ifp, save1, SEEK_SET);
//---------------------------------------------------------------------
} if (tag == 0x4021 && get4() && get4())
FORC4 cam_mul[c] = 1024; FORC4 cam_mul[c] = 1024;
if (tag == 0xa021) if (tag == 0xa021)
FORC4 cam_mul[c ^ (c >> 1)] = get4(); FORC4 cam_mul[c ^ (c >> 1)] = get4();
@ -6683,7 +7015,8 @@ int CLASS parse_tiff (int base)
void CLASS apply_tiff() void CLASS apply_tiff()
{ {
int max_samp=0, ties=0, os, ns, raw=-1, thm=-1, i; int max_samp=0, ties=0, /*os, ns,*/ raw=-1, thm=-1, i;
uint64_t os, ns; // RT
struct jhead jh; struct jhead jh;
thumb_misc = 16; thumb_misc = 16;
@ -6713,6 +7046,7 @@ void CLASS apply_tiff()
} }
if ((tiff_ifd[i].comp != 6 || tiff_ifd[i].samples != 3) && if ((tiff_ifd[i].comp != 6 || tiff_ifd[i].samples != 3) &&
(tiff_ifd[i].width | tiff_ifd[i].height) < 0x10000 && (tiff_ifd[i].width | tiff_ifd[i].height) < 0x10000 &&
(unsigned)tiff_ifd[i].bps < 33 && (unsigned)tiff_ifd[i].samples < 13 && // RT
ns && ((ns > os && (ties = 1)) || ns && ((ns > os && (ties = 1)) ||
(ns == os && shot_select == ties++))) { (ns == os && shot_select == ties++))) {
raw_width = tiff_ifd[i].width; raw_width = tiff_ifd[i].width;
@ -6780,7 +7114,7 @@ void CLASS apply_tiff()
load_raw = &CLASS olympus_load_raw; load_raw = &CLASS olympus_load_raw;
// ------- RT ------- // ------- RT -------
if (!strncmp(make,"SONY",4) && if (!strncmp(make,"SONY",4) &&
!strncmp(model,"ILCE-7RM3",9) && (!strncmp(model,"ILCE-7RM3",9) || !strncmp(model,"ILCE-7RM4",9)) &&
tiff_samples == 4 && tiff_samples == 4 &&
tiff_ifd[raw].bytes == raw_width*raw_height*tiff_samples*2) { tiff_ifd[raw].bytes == raw_width*raw_height*tiff_samples*2) {
load_raw = &CLASS sony_arq_load_raw; load_raw = &CLASS sony_arq_load_raw;
@ -9313,6 +9647,11 @@ void CLASS identify()
parse_foveon(); parse_foveon();
else if (!memcmp (head,"CI",2)) else if (!memcmp (head,"CI",2))
parse_cine(); parse_cine();
//--- RT ----------------------------------------------------------------
else if (!memcmp(head + 4, "ftypcrx ", 8)) {
parse_canon_cr3();
}
//-------------------------------------------------------------------------
if (make[0] == 0) if (make[0] == 0)
for (zero_fsize=i=0; i < sizeof table / sizeof *table; i++) for (zero_fsize=i=0; i < sizeof table / sizeof *table; i++)
if (fsize == table[i].fsize) { if (fsize == table[i].fsize) {

46
rtengine/dcraw.h
View File

@ -68,6 +68,7 @@ public:
gamm[0]=0.45;gamm[1]=4.5;gamm[2]=gamm[3]=gamm[4]=gamm[5]=0; gamm[0]=0.45;gamm[1]=4.5;gamm[2]=gamm[3]=gamm[4]=gamm[5]=0;
user_mul[0]=user_mul[1]=user_mul[2]=user_mul[3]=0; user_mul[0]=user_mul[1]=user_mul[2]=user_mul[3]=0;
greybox[0]=greybox[1]=0; greybox[2]=greybox[3]= UINT_MAX; greybox[0]=greybox[1]=0; greybox[2]=greybox[3]= UINT_MAX;
RT_canon_CR3_data.CR3_CTMDtag = 0;
} }
protected: protected:
@ -164,6 +165,35 @@ protected:
PanasonicRW2Info(): bpp(0), encoding(0) {} PanasonicRW2Info(): bpp(0), encoding(0) {}
}; };
PanasonicRW2Info RT_pana_info; PanasonicRW2Info RT_pana_info;
public:
struct CanonCR3Data {
// contents of tag CMP1 for relevant track in CR3 file
struct crx_data_header_t {
int32_t version;
int32_t f_width;
int32_t f_height;
int32_t tileWidth;
int32_t tileHeight;
int32_t nBits;
int32_t nPlanes;
int32_t cfaLayout;
int32_t encType;
int32_t imageLevels;
int32_t hasTileCols;
int32_t hasTileRows;
int32_t mdatHdrSize;
// Not from header, but from datastream
uint32_t MediaSize;
INT64 MediaOffset;
uint32_t MediaType; /* 1 -> /C/RAW, 2-> JPEG */
};
static constexpr size_t CRXTRACKS_MAXCOUNT = 16;
crx_data_header_t crx_header[CRXTRACKS_MAXCOUNT];
int crx_track_selected;
short CR3_CTMDtag;
};
protected:
CanonCR3Data RT_canon_CR3_data;
float cam_mul[4], pre_mul[4], cmatrix[3][4], rgb_cam[3][4]; float cam_mul[4], pre_mul[4], cmatrix[3][4], rgb_cam[3][4];
@ -529,4 +559,20 @@ void shiftXtransMatrix( const int offsy, const int offsx) {
void nikon_14bit_load_raw(); // ported from LibRaw void nikon_14bit_load_raw(); // ported from LibRaw
//-----------------------------------------------------------------------------
// Canon CR3 support ported from LibRaw
//-----------------------------------------------------------------------------
void parse_canon_cr3();
void selectCRXTrack(short maxTrack);
int parseCR3(unsigned long long oAtomList,
unsigned long long szAtomList, short &nesting,
char *AtomNameStack, short &nTrack, short &TrackType);
int crxDecodePlane(void *p, uint32_t planeNumber);
void crxLoadDecodeLoop(void *img, int nPlanes);
void crxConvertPlaneLineDf(void *p, int imageRow);
void crxLoadFinalizeLoopE3(void *p, int planeHeight);
void crxLoadRaw();
int crxParseImageHeader(uchar *cmp1TagData, int nTrack);
//-----------------------------------------------------------------------------
}; };

14
rtengine/dcrop.cc
View File

@ -196,18 +196,8 @@ void Crop::update(int todo)
params.dirpyrDenoise.getCurves(noiseLCurve, noiseCCurve); params.dirpyrDenoise.getCurves(noiseLCurve, noiseCCurve);
int tilesize; const int tilesize = settings->leveldnti == 0 ? 1024 : 768;
int overlap; const int overlap = settings->leveldnti == 0 ? 128 : 96;
if (settings->leveldnti == 0) {
tilesize = 1024;
overlap = 128;
}
if (settings->leveldnti == 1) {
tilesize = 768;
overlap = 96;
}
int numtiles_W, numtiles_H, tilewidth, tileheight, tileWskip, tileHskip; int numtiles_W, numtiles_H, tilewidth, tileheight, tileWskip, tileHskip;

17
rtengine/dual_demosaic_RT.cc
View File

@ -66,14 +66,9 @@ void RawImageSource::dual_demosaic_RT(bool isBayer, const procparams::RAWParams
return; return;
} }
array2D<float> redTmp(winw, winh);
array2D<float> greenTmp(winw, winh);
array2D<float> blueTmp(winw, winh);
array2D<float> L(winw, winh); array2D<float> L(winw, winh);
if (isBayer) { if (isBayer) {
vng4_demosaic(rawData, redTmp, greenTmp, blueTmp);
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::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); 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::DCBVNG4) ) {
@ -87,7 +82,6 @@ void RawImageSource::dual_demosaic_RT(bool isBayer, const procparams::RAWParams
} else { } else {
xtrans_interpolate (1, false, options.chunkSizeXT, options.measure); xtrans_interpolate (1, false, options.chunkSizeXT, options.measure);
} }
fast_xtrans_interpolate(rawData, redTmp, greenTmp, blueTmp);
} }
const float xyz_rgb[3][3] = { // XYZ from RGB const float xyz_rgb[3][3] = { // XYZ from RGB
@ -114,6 +108,17 @@ void RawImageSource::dual_demosaic_RT(bool isBayer, const procparams::RAWParams
buildBlendMask(L, blend, winw, winh, contrastf, 1.f, autoContrast); buildBlendMask(L, blend, winw, winh, contrastf, 1.f, autoContrast);
contrast = contrastf * 100.f; 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);
if (isBayer) {
vng4_demosaic(rawData, redTmp, greenTmp, blueTmp);
} else {
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 // the following is split into 3 loops intentionally to avoid cache conflicts on CPUs with only 4-way cache
#ifdef _OPENMP #ifdef _OPENMP
#pragma omp parallel for #pragma omp parallel for

3
rtengine/guidedfilter.h
View File

@ -20,11 +20,12 @@
#pragma once #pragma once
#include "array2D.h" template<typename T> class array2D;
namespace rtengine namespace rtengine
{ {
void guidedFilter(const array2D<float> &guide, const array2D<float> &src, array2D<float> &dst, int r, float epsilon, bool multithread, int subsampling=0); void guidedFilter(const array2D<float> &guide, const array2D<float> &src, array2D<float> &dst, int r, float epsilon, bool multithread, int subsampling=0);
} // namespace rtengine } // namespace rtengine

8
rtengine/image8.cc
View File

@ -233,10 +233,10 @@ void Image8::getStdImage (const ColorTemp &ctemp, int tran, Imagefloat* image, P
lineB[dst_x] = CLIP(bm * btot); lineB[dst_x] = CLIP(bm * btot);
} else { } else {
// computing a special factor for this incomplete sub-region // computing a special factor for this incomplete sub-region
float area = src_sub_width * src_sub_height; float larea = src_sub_width * src_sub_height;
lineR[dst_x] = CLIP(rm2 * rtot / area); lineR[dst_x] = CLIP(rm2 * rtot / larea);
lineG[dst_x] = CLIP(gm2 * gtot / area); lineG[dst_x] = CLIP(gm2 * gtot / larea);
lineB[dst_x] = CLIP(bm2 * btot / area); lineB[dst_x] = CLIP(bm2 * btot / larea);
} }
} }
} }

83
rtengine/improccoordinator.cc
View File

@ -231,9 +231,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
MyMutex::MyLock processingLock(mProcessing); MyMutex::MyLock processingLock(mProcessing);
constexpr int numofphases = 14;
int readyphase = 0;
bool highDetailNeeded = options.prevdemo == PD_Sidecar ? true : (todo & M_HIGHQUAL); bool highDetailNeeded = options.prevdemo == PD_Sidecar ? true : (todo & M_HIGHQUAL);
// Check if any detail crops need high detail. If not, take a fast path short cut // Check if any detail crops need high detail. If not, take a fast path short cut
@ -274,8 +271,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
//rp.deadPixelFilter = rp.hotPixelFilter = false; //rp.deadPixelFilter = rp.hotPixelFilter = false;
} }
progress("Applying white balance, color correction & sRGB conversion...", 100 * readyphase / numofphases);
if (frameCountListener) { if (frameCountListener) {
frameCountListener->FrameCountChanged(imgsrc->getFrameCount(), params->raw.bayersensor.imageNum); frameCountListener->FrameCountChanged(imgsrc->getFrameCount(), params->raw.bayersensor.imageNum);
} }
@ -539,8 +534,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
ipf.firstAnalysis(orig_prev, *params, vhist16); ipf.firstAnalysis(orig_prev, *params, vhist16);
} }
readyphase++;
if ((todo & M_HDR) && (params->fattal.enabled || params->dehaze.enabled)) { if ((todo & M_HDR) && (params->fattal.enabled || params->dehaze.enabled)) {
if (fattal_11_dcrop_cache) { if (fattal_11_dcrop_cache) {
delete fattal_11_dcrop_cache; delete fattal_11_dcrop_cache;
@ -557,7 +550,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
oprevi = orig_prev; oprevi = orig_prev;
progress("Rotate / Distortion...", 100 * readyphase / numofphases);
// Remove transformation if unneeded // Remove transformation if unneeded
bool needstransform = ipf.needsTransform(); bool needstransform = ipf.needsTransform();
@ -583,11 +575,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
ipf.lab2rgb(labcbdl, *oprevi, params->icm.workingProfile); ipf.lab2rgb(labcbdl, *oprevi, params->icm.workingProfile);
} }
readyphase++;
progress("Preparing shadow/highlight map...", 100 * readyphase / numofphases);
readyphase++;
if (todo & M_AUTOEXP) { if (todo & M_AUTOEXP) {
if (params->toneCurve.autoexp) { if (params->toneCurve.autoexp) {
LUTu aehist; LUTu aehist;
@ -624,8 +611,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
} }
} }
progress("Exposure curve & CIELAB conversion...", 100 * readyphase / numofphases);
if (todo & (M_AUTOEXP | M_RGBCURVE)) { if (todo & (M_AUTOEXP | M_RGBCURVE)) {
if (params->icm.workingTRC == "Custom") { //exec TRC IN free if (params->icm.workingTRC == "Custom") { //exec TRC IN free
if (oprevi == orig_prev) { if (oprevi == orig_prev) {
@ -777,8 +762,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
params->crop.mapToResized(pW, pH, scale, x1, x2, y1, y2); params->crop.mapToResized(pW, pH, scale, x1, x2, y1, y2);
} }
readyphase++;
if (todo & (M_LUMACURVE | M_CROP)) { if (todo & (M_LUMACURVE | M_CROP)) {
LUTu lhist16(32768); LUTu lhist16(32768);
lhist16.clear(); lhist16.clear();
@ -821,8 +804,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
if (todo & (M_LUMINANCE + M_COLOR)) { if (todo & (M_LUMINANCE + M_COLOR)) {
nprevl->CopyFrom(oprevl); nprevl->CopyFrom(oprevl);
progress("Applying Color Boost...", 100 * readyphase / numofphases);
histCCurve.clear(); histCCurve.clear();
histLCurve.clear(); histLCurve.clear();
ipf.chromiLuminanceCurve(nullptr, pW, nprevl, nprevl, chroma_acurve, chroma_bcurve, satcurve, lhskcurve, clcurve, lumacurve, utili, autili, butili, ccutili, cclutili, clcutili, histCCurve, histLCurve); ipf.chromiLuminanceCurve(nullptr, pW, nprevl, nprevl, chroma_acurve, chroma_bcurve, satcurve, lhskcurve, clcurve, lumacurve, utili, autili, butili, ccutili, cclutili, clcutili, histCCurve, histLCurve);
@ -833,68 +814,20 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
ipf.EPDToneMap(nprevl, 0, scale); ipf.EPDToneMap(nprevl, 0, scale);
} }
// for all treatments Defringe, Sharpening, Contrast detail , Microcontrast they are activated if "CIECAM" function are disabled
readyphase++;
/* Issue 2785, disabled some 1:1 tools
if (scale==1) {
if((params->colorappearance.enabled && !settings->autocielab) || (!params->colorappearance.enabled)){
progress ("Denoising luminance impulse...",100*readyphase/numofphases);
ipf.impulsedenoise (nprevl);
readyphase++;
}
if((params->colorappearance.enabled && !settings->autocielab) || (!params->colorappearance.enabled)){
progress ("Defringing...",100*readyphase/numofphases);
ipf.defringe (nprevl);
readyphase++;
}
if (params->sharpenEdge.enabled) {
progress ("Edge sharpening...",100*readyphase/numofphases);
ipf.MLsharpen (nprevl);
readyphase++;
}
if (params->sharpenMicro.enabled) {
if(( params->colorappearance.enabled && !settings->autocielab) || (!params->colorappearance.enabled)){
progress ("Microcontrast...",100*readyphase/numofphases);
ipf.MLmicrocontrast (nprevl);
readyphase++;
}
}
if(((params->colorappearance.enabled && !settings->autocielab) || (!params->colorappearance.enabled)) && params->sharpening.enabled) {
progress ("Sharpening...",100*readyphase/numofphases);
float **buffer = new float*[pH];
for (int i=0; i<pH; i++)
buffer[i] = new float[pW];
ipf.sharpening (nprevl, (float**)buffer);
for (int i=0; i<pH; i++)
delete [] buffer[i];
delete [] buffer;
readyphase++;
}
}
*/
if (params->dirpyrequalizer.cbdlMethod == "aft") { if (params->dirpyrequalizer.cbdlMethod == "aft") {
if (((params->colorappearance.enabled && !settings->autocielab) || (!params->colorappearance.enabled))) { if (((params->colorappearance.enabled && !settings->autocielab) || (!params->colorappearance.enabled))) {
progress("Pyramid wavelet...", 100 * readyphase / numofphases);
ipf.dirpyrequalizer(nprevl, scale); ipf.dirpyrequalizer(nprevl, scale);
//ipf.Lanczoslab (ip_wavelet(LabImage * lab, LabImage * dst, const procparams::EqualizerParams & eqparams), nprevl, 1.f/scale);
readyphase++;
} }
} }
wavcontlutili = false; wavcontlutili = false;
//CurveFactory::curveWavContL ( wavcontlutili,params->wavelet.lcurve, wavclCurve, LUTu & histogramwavcl, LUTu & outBeforeWavCLurveHistogram,int skip);
CurveFactory::curveWavContL(wavcontlutili, params->wavelet.wavclCurve, wavclCurve, scale == 1 ? 1 : 16); CurveFactory::curveWavContL(wavcontlutili, params->wavelet.wavclCurve, wavclCurve, scale == 1 ? 1 : 16);
if ((params->wavelet.enabled)) { if ((params->wavelet.enabled)) {
WaveletParams WaveParams = params->wavelet; WaveletParams WaveParams = params->wavelet;
WaveParams.getCurves(wavCLVCurve, waOpacityCurveRG, waOpacityCurveBY, waOpacityCurveW, waOpacityCurveWL); WaveParams.getCurves(wavCLVCurve, waOpacityCurveRG, waOpacityCurveBY, waOpacityCurveW, waOpacityCurveWL);
int kall = 0; int kall = 0;
progress("Wavelet...", 100 * readyphase / numofphases);
LabImage *unshar = nullptr; LabImage *unshar = nullptr;
Glib::ustring provis; Glib::ustring provis;
LabImage *provradius = nullptr; LabImage *provradius = nullptr;
@ -1190,8 +1123,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
if (params->colorappearance.autoybscen && acListener && params->colorappearance.enabled) { if (params->colorappearance.autoybscen && acListener && params->colorappearance.enabled) {
acListener->ybCamChanged((int) yb); //real value Yb scene acListener->ybCamChanged((int) yb); //real value Yb scene
} }
readyphase++;
} else { } else {
// CIECAM is disabled, we free up its image buffer to save some space // CIECAM is disabled, we free up its image buffer to save some space
if (ncie) { if (ncie) {
@ -1226,8 +1157,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
} }
if (panningRelatedChange || (todo & M_MONITOR)) { if (panningRelatedChange || (todo & M_MONITOR)) {
progress("Conversion to RGB...", 100 * readyphase / numofphases);
if ((todo != CROP && todo != MINUPDATE) || (todo & M_MONITOR)) { if ((todo != CROP && todo != MINUPDATE) || (todo & M_MONITOR)) {
MyMutex::MyLock prevImgLock(previmg->getMutex()); MyMutex::MyLock prevImgLock(previmg->getMutex());
@ -1239,7 +1168,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
delete workimg; delete workimg;
workimg = ipf.lab2rgb(nprevl, 0, 0, pW, pH, params->icm); workimg = ipf.lab2rgb(nprevl, 0, 0, pW, pH, params->icm);
} catch (char * str) { } catch (char * str) {
progress("Error converting file...", 0);
return; return;
} }
} }
@ -1258,8 +1186,6 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
imageListener->imageReady(params->crop); imageListener->imageReady(params->crop);
} }
readyphase++;
if (hListener) { if (hListener) {
updateLRGBHistograms(); updateLRGBHistograms();
hListener->histogramChanged(histRed, histGreen, histBlue, histLuma, histToneCurve, histLCurve, histCCurve, /*histCLurve, histLLCurve,*/ histLCAM, histCCAM, histRedRaw, histGreenRaw, histBlueRaw, histChroma, histLRETI); hListener->histogramChanged(histRed, histGreen, histBlue, histLuma, histToneCurve, histLCurve, histCCurve, /*histCLurve, histLLCurve,*/ histLCAM, histCCAM, histRedRaw, histGreenRaw, histBlueRaw, histChroma, histLRETI);
@ -1423,15 +1349,6 @@ void ImProcCoordinator::updateLRGBHistograms()
} }
void ImProcCoordinator::progress(Glib::ustring str, int pr)
{
/* if (plistener) {
plistener->setProgressStr (str);
plistener->setProgress ((double)pr / 100.0);
}*/
}
bool ImProcCoordinator::getAutoWB(double& temp, double& green, double equal, double tempBias) bool ImProcCoordinator::getAutoWB(double& temp, double& green, double equal, double tempBias)
{ {

1
rtengine/improccoordinator.h
View File

@ -186,7 +186,6 @@ protected:
MyMutex minit; // to gain mutually exclusive access to ... to what exactly? MyMutex minit; // to gain mutually exclusive access to ... to what exactly?
void progress (Glib::ustring str, int pr);
void reallocAll (); void reallocAll ();
void updateLRGBHistograms (); void updateLRGBHistograms ();
void setScale (int prevscale); void setScale (int prevscale);

64
rtengine/improcfun.cc
View File

@ -869,7 +869,9 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
mean = (sum / ((height) * width)) / 327.68f; //for Yb for all image...if one day "pipette" we can adapt Yb for each zone mean = (sum / ((height) * width)) / 327.68f; //for Yb for all image...if one day "pipette" we can adapt Yb for each zone
} }
} }
#ifdef _OPENMP
static_cast<void>(numThreads); // to silence cppcheck warning
#endif
//evaluate lightness, contrast //evaluate lightness, contrast
} }
@ -1469,8 +1471,8 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
if (ciedata) { //only with improccoordinator if (ciedata) { //only with improccoordinator
// Data for J Q M s and C histograms // Data for J Q M s and C histograms
int posl, posc; int posl, posc;
float brli = 327.f; float brli;
float chsacol = 327.f; float chsacol;
float libr; float libr;
float colch; float colch;
@ -2049,17 +2051,25 @@ filmlike_clip (float *r, float *g, float *b)
} }
} }
void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, LUTf & hltonecurve, LUTf & shtonecurve, LUTf & tonecurve, void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, const LUTf& hltonecurve, const LUTf& shtonecurve, const LUTf& tonecurve,
int sat, LUTf & rCurve, LUTf & gCurve, LUTf & bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, bool opautili, LUTf & clToningcurve, LUTf & cl2Toningcurve, int sat, const LUTf& rCurve, const LUTf& gCurve, const LUTf& bCurve, float satLimit, float satLimitOpacity,
const ToneCurve & customToneCurve1, const ToneCurve & customToneCurve2, const ToneCurve & customToneCurvebw1, const ToneCurve & customToneCurvebw2, double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, DCPProfile *dcpProf, const DCPProfileApplyState &asIn, LUTu &histToneCurve, size_t chunkSize, bool measure) const ColorGradientCurve& ctColorCurve, const OpacityCurve& ctOpacityCurve, bool opautili, const LUTf& clToningcurve, const LUTf& cl2Toningcurve,
const ToneCurve& customToneCurve1, const ToneCurve& customToneCurve2, const ToneCurve& customToneCurvebw1, const ToneCurve& customToneCurvebw2,
double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, DCPProfile *dcpProf, const DCPProfileApplyState& asIn,
LUTu& histToneCurve, size_t chunkSize, bool measure)
{ {
rgbProc (working, lab, pipetteBuffer, hltonecurve, shtonecurve, tonecurve, sat, rCurve, gCurve, bCurve, satLimit, satLimitOpacity, ctColorCurve, ctOpacityCurve, opautili, clToningcurve, cl2Toningcurve, customToneCurve1, customToneCurve2, customToneCurvebw1, customToneCurvebw2, rrm, ggm, bbm, autor, autog, autob, params->toneCurve.expcomp, params->toneCurve.hlcompr, params->toneCurve.hlcomprthresh, dcpProf, asIn, histToneCurve, chunkSize, measure); rgbProc(working, lab, pipetteBuffer, hltonecurve, shtonecurve, tonecurve, sat, rCurve, gCurve, bCurve, satLimit, satLimitOpacity, ctColorCurve, ctOpacityCurve, opautili,
clToningcurve, cl2Toningcurve, customToneCurve1, customToneCurve2, customToneCurvebw1, customToneCurvebw2, rrm, ggm, bbm, autor, autog, autob,
params->toneCurve.expcomp, params->toneCurve.hlcompr, params->toneCurve.hlcomprthresh, dcpProf, asIn, histToneCurve, chunkSize, measure);
} }
// Process RGB image and convert to LAB space // Process RGB image and convert to LAB space
void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, LUTf & hltonecurve, LUTf & shtonecurve, LUTf & tonecurve, void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, const LUTf& hltonecurve, const LUTf& shtonecurve, const LUTf& tonecurve,
int sat, LUTf & rCurve, LUTf & gCurve, LUTf & bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, bool opautili, LUTf & clToningcurve, LUTf & cl2Toningcurve, int sat, const LUTf& rCurve, const LUTf& gCurve, const LUTf& bCurve, float satLimit, float satLimitOpacity,
const ToneCurve & customToneCurve1, const ToneCurve & customToneCurve2, const ToneCurve & customToneCurvebw1, const ToneCurve & customToneCurvebw2, double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, double expcomp, int hlcompr, int hlcomprthresh, DCPProfile *dcpProf, const DCPProfileApplyState &asIn, LUTu &histToneCurve, size_t chunkSize, bool measure) const ColorGradientCurve& ctColorCurve, const OpacityCurve& ctOpacityCurve, bool opautili, const LUTf& clToningcurve, const LUTf& cl2Toningcurve,
const ToneCurve& customToneCurve1, const ToneCurve& customToneCurve2, const ToneCurve& customToneCurvebw1, const ToneCurve& customToneCurvebw2,
double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, double expcomp, int hlcompr, int hlcomprthresh,
DCPProfile *dcpProf, const DCPProfileApplyState& asIn, LUTu& histToneCurve, size_t chunkSize, bool measure)
{ {
std::unique_ptr<StopWatch> stop; std::unique_ptr<StopWatch> stop;
@ -3759,10 +3769,9 @@ void ImProcFunctions::toningsmh(float r, float g, float b, float &ro, float &go,
float rlo; //0.4 0.5 float rlo; //0.4 0.5
float rlm; //1.1 float rlm; //1.1
float rlh; //1.1 float rlh; //1.1
float rlob; //for BW old mode
if (mode == 0) { //colour if (mode == 0) { //colour
rlo = rlob = strProtect; //0.5 ==> 0.75 rlo = strProtect; //0.5 ==> 0.75
rlh = 2.2f * strProtect; rlh = 2.2f * strProtect;
rlm = 1.5f * strProtect; rlm = 1.5f * strProtect;
constexpr float v0 = 0.15f; constexpr float v0 = 0.15f;
@ -3779,7 +3788,6 @@ void ImProcFunctions::toningsmh(float r, float g, float b, float &ro, float &go,
} }
} else { //bw coefficient to preserve same results as before for satlimtopacity = 0.5 (default) } else { //bw coefficient to preserve same results as before for satlimtopacity = 0.5 (default)
rlo = strProtect * 0.8f; //0.4 rlo = strProtect * 0.8f; //0.4
rlob = strProtect; //0.5
rlm = strProtect * 2.2f; //1.1 rlm = strProtect * 2.2f; //1.1
rlh = strProtect * 2.4f; //1.2 rlh = strProtect * 2.4f; //1.2
if (v > 0.15f) { if (v > 0.15f) {
@ -4081,7 +4089,7 @@ void ImProcFunctions::toning2col (float r, float g, float b, float &ro, float &g
* @param iplow iphigh [0..1] luminance * @param iplow iphigh [0..1] luminance
* @param wp wip 3x3 matrix and inverse conversion rgb XYZ * @param wp wip 3x3 matrix and inverse conversion rgb XYZ
**/ **/
void ImProcFunctions::labtoning (float r, float g, float b, float &ro, float &go, float &bo, int algm, int metchrom, int twoc, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, LUTf & clToningcurve, LUTf & cl2Toningcurve, float iplow, float iphigh, double wp[3][3], double wip[3][3] ) void ImProcFunctions::labtoning (float r, float g, float b, float &ro, float &go, float &bo, int algm, int metchrom, int twoc, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, const LUTf & clToningcurve, const LUTf & cl2Toningcurve, float iplow, float iphigh, double wp[3][3], double wip[3][3] )
{ {
ro = CLIP(r); ro = CLIP(r);
go = CLIP(g); go = CLIP(g);
@ -4140,7 +4148,7 @@ void ImProcFunctions::labtoning (float r, float g, float b, float &ro, float &go
} }
void ImProcFunctions::luminanceCurve (LabImage* lold, LabImage* lnew, LUTf & curve) void ImProcFunctions::luminanceCurve (LabImage* lold, LabImage* lnew, const LUTf& curve)
{ {
int W = lold->W; int W = lold->W;
@ -4160,7 +4168,7 @@ void ImProcFunctions::luminanceCurve (LabImage* lold, LabImage* lnew, LUTf & cur
void ImProcFunctions::chromiLuminanceCurve (PipetteBuffer *pipetteBuffer, int pW, LabImage* lold, LabImage* lnew, LUTf & acurve, LUTf & bcurve, LUTf & satcurve, LUTf & lhskcurve, LUTf & clcurve, LUTf & curve, bool utili, bool autili, bool butili, bool ccutili, bool cclutili, bool clcutili, LUTu &histCCurve, LUTu &histLCurve) void ImProcFunctions::chromiLuminanceCurve (PipetteBuffer *pipetteBuffer, int pW, LabImage* lold, LabImage* lnew, const LUTf& acurve, const LUTf& bcurve, const LUTf& satcurve, const LUTf& lhskcurve, const LUTf& clcurve, LUTf & curve, bool utili, bool autili, bool butili, bool ccutili, bool cclutili, bool clcutili, LUTu &histCCurve, LUTu &histLCurve)
{ {
int W = lold->W; int W = lold->W;
@ -5354,7 +5362,7 @@ void ImProcFunctions::getAutoExp (const LUTu &histogram, int histcompr, double
int imax = 65536 >> histcompr; int imax = 65536 >> histcompr;
int overex = 0; int overex = 0;
float sum = 0.f, hisum = 0.f, losum = 0.f; float sum = 0.f, hisum = 0.f, losum = 0.f;
float ave = 0.f, hidev = 0.f, lodev = 0.f; float ave = 0.f;
//find average luminance //find average luminance
histogram.getSumAndAverage (sum, ave); histogram.getSumAndAverage (sum, ave);
@ -5382,36 +5390,32 @@ void ImProcFunctions::getAutoExp (const LUTu &histogram, int histcompr, double
float octile[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}, ospread = 0.f; float octile[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}, ospread = 0.f;
count = 0; count = 0;
int i = 0; int j = 0;
for (; i < min ((int)ave, imax); i++) { for (; j < min ((int)ave, imax); ++j) {
if (count < 8) { if (count < 8) {
octile[count] += histogram[i]; octile[count] += histogram[j];
if (octile[count] > sum / 8.f || (count == 7 && octile[count] > sum / 16.f)) { if (octile[count] > sum / 8.f || (count == 7 && octile[count] > sum / 16.f)) {
octile[count] = xlog (1. + (float)i) / log (2.f); octile[count] = xlog (1. + j) / log (2.f);
count++;// = min(count+1,7); count++;// = min(count+1,7);
} }
} }
//lodev += SQR(ave-i)*histogram[i]; losum += histogram[j];
lodev += (xlog (ave + 1.f) - xlog ((float)i + 1.)) * histogram[i];
losum += histogram[i];
} }
for (; i < imax; i++) { for (; j < imax; ++j) {
if (count < 8) { if (count < 8) {
octile[count] += histogram[i]; octile[count] += histogram[j];
if (octile[count] > sum / 8.f || (count == 7 && octile[count] > sum / 16.f)) { if (octile[count] > sum / 8.f || (count == 7 && octile[count] > sum / 16.f)) {
octile[count] = xlog (1. + (float)i) / log (2.f); octile[count] = xlog (1. + j) / log (2.f);
count++;// = min(count+1,7); count++;// = min(count+1,7);
} }
} }
//hidev += SQR(i-ave)*histogram[i]; hisum += histogram[j];
hidev += (xlog ((float)i + 1.) - xlog (ave + 1.f)) * histogram[i];
hisum += histogram[i];
} }

26
rtengine/improcfun.h
View File

@ -23,7 +23,6 @@
#include "coord2d.h" #include "coord2d.h"
#include "gamutwarning.h" #include "gamutwarning.h"
#include "pipettebuffer.h" #include "pipettebuffer.h"
#include "shmap.h"
template<typename T> template<typename T>
class LUT; class LUT;
@ -125,14 +124,19 @@ public:
void firstAnalysis(const Imagefloat* const working, const procparams::ProcParams &params, LUTu & vhist16); void firstAnalysis(const Imagefloat* const working, const procparams::ProcParams &params, LUTu & vhist16);
void updateColorProfiles(const Glib::ustring& monitorProfile, RenderingIntent monitorIntent, bool softProof, bool gamutCheck); void updateColorProfiles(const Glib::ustring& monitorProfile, RenderingIntent monitorIntent, bool softProof, bool gamutCheck);
void rgbProc(Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, LUTf & hltonecurve, LUTf & shtonecurve, LUTf & tonecurve, void rgbProc(Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, const LUTf& hltonecurve, const LUTf& shtonecurve, const LUTf& tonecurve,
int sat, LUTf & rCurve, LUTf & gCurve, LUTf & bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, bool opautili, LUTf & clcurve, LUTf & cl2curve, const ToneCurve & customToneCurve1, const ToneCurve & customToneCurve2, int sat, const LUTf& rCurve, const LUTf& gCurve, const LUTf& bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve& ctColorCurve,
const ToneCurve & customToneCurvebw1, const ToneCurve & customToneCurvebw2, double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, DCPProfile *dcpProf, const DCPProfileApplyState &asIn, LUTu &histToneCurve, size_t chunkSize = 1, bool measure = false); const OpacityCurve& ctOpacityCurve, bool opautili, const LUTf& clcurve, const LUTf& cl2curve, const ToneCurve& customToneCurve1,
void rgbProc(Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, LUTf & hltonecurve, LUTf & shtonecurve, LUTf & tonecurve, const ToneCurve& customToneCurve2, const ToneCurve& customToneCurvebw1, const ToneCurve& customToneCurvebw2,
int sat, LUTf & rCurve, LUTf & gCurve, LUTf & bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, bool opautili, LUTf & clcurve, LUTf & cl2curve, const ToneCurve & customToneCurve1, const ToneCurve & customToneCurve2, double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, DCPProfile *dcpProf,
const ToneCurve & customToneCurvebw1, const ToneCurve & customToneCurvebw2, double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, const DCPProfileApplyState& asIn, LUTu& histToneCurve, size_t chunkSize = 1, bool measure = false);
double expcomp, int hlcompr, int hlcomprthresh, DCPProfile *dcpProf, const DCPProfileApplyState &asIn, LUTu &histToneCurve, size_t chunkSize = 1, bool measure = false); void rgbProc(Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, const LUTf& hltonecurve, const LUTf& shtonecurve, const LUTf& tonecurve,
void labtoning(float r, float g, float b, float &ro, float &go, float &bo, int algm, int metchrom, int twoc, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, LUTf & clToningcurve, LUTf & cl2Toningcurve, float iplow, float iphigh, double wp[3][3], double wip[3][3]); int sat, const LUTf& rCurve, const LUTf& gCurve, const LUTf& bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve& ctColorCurve,
const OpacityCurve& ctOpacityCurve, bool opautili, const LUTf& clcurve, const LUTf& cl2curve, const ToneCurve& customToneCurve1,
const ToneCurve& customToneCurve2, const ToneCurve& customToneCurvebw1, const ToneCurve& customToneCurvebw2,
double &rrm, double &ggm, double &bbm, float &autor, float &autog, float &autob, double expcomp, int hlcompr,
int hlcomprthresh, DCPProfile *dcpProf, const DCPProfileApplyState& asIn, LUTu& histToneCurve, size_t chunkSize = 1, bool measure = false);
void labtoning(float r, float g, float b, float &ro, float &go, float &bo, int algm, int metchrom, int twoc, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, const LUTf & clToningcurve, const LUTf & cl2Toningcurve, float iplow, float iphigh, double wp[3][3], double wip[3][3]);
void toning2col(float r, float g, float b, float &ro, float &go, float &bo, float iplow, float iphigh, float rl, float gl, float bl, float rh, float gh, float bh, float SatLow, float SatHigh, float balanS, float balanH, float reducac, int mode, int preser, float strProtect); void toning2col(float r, float g, float b, float &ro, float &go, float &bo, float iplow, float iphigh, float rl, float gl, float bl, float rh, float gh, float bh, float SatLow, float SatHigh, float balanS, float balanH, float reducac, int mode, int preser, float strProtect);
void toningsmh(float r, float g, float b, float &ro, float &go, float &bo, float RedLow, float GreenLow, float BlueLow, float RedMed, float GreenMed, float BlueMed, float RedHigh, float GreenHigh, float BlueHigh, float reducac, int mode, float strProtect); void toningsmh(float r, float g, float b, float &ro, float &go, float &bo, float RedLow, float GreenLow, float BlueLow, float RedMed, float GreenMed, float BlueMed, float RedHigh, float GreenHigh, float BlueHigh, float reducac, int mode, float strProtect);
void toningsmh2(float r, float g, float b, float &ro, float &go, float &bo, float low[3], float satLow, float med[3], float satMed, float high[3], float satHigh, float reducac, int mode, int preser); void toningsmh2(float r, float g, float b, float &ro, float &go, float &bo, float low[3], float satLow, float med[3], float satMed, float high[3], float satHigh, float reducac, int mode, int preser);
@ -142,12 +146,12 @@ public:
void retreavergb(float &r, float &g, float &b); void retreavergb(float &r, float &g, float &b);
void moyeqt(Imagefloat* working, float &moyS, float &eqty); void moyeqt(Imagefloat* working, float &moyS, float &eqty);
void luminanceCurve(LabImage* lold, LabImage* lnew, LUTf &curve); void luminanceCurve(LabImage* lold, LabImage* lnew, const LUTf &curve);
void ciecam_02float(CieImage* ncie, float adap, int pW, int pwb, LabImage* lab, const procparams::ProcParams* params, void ciecam_02float(CieImage* ncie, float adap, int pW, int pwb, LabImage* lab, const procparams::ProcParams* params,
const ColorAppearance & customColCurve1, const ColorAppearance & customColCurve, const ColorAppearance & customColCurve3, const ColorAppearance & customColCurve1, const ColorAppearance & customColCurve, const ColorAppearance & customColCurve3,
LUTu &histLCAM, LUTu &histCCAM, LUTf & CAMBrightCurveJ, LUTf & CAMBrightCurveQ, float &mean, int Iterates, int scale, bool execsharp, float &d, float &dj, float &yb, int rtt, LUTu &histLCAM, LUTu &histCCAM, LUTf & CAMBrightCurveJ, LUTf & CAMBrightCurveQ, float &mean, int Iterates, int scale, bool execsharp, float &d, float &dj, float &yb, int rtt,
bool showSharpMask = false); bool showSharpMask = false);
void chromiLuminanceCurve(PipetteBuffer *pipetteBuffer, int pW, LabImage* lold, LabImage* lnew, LUTf &acurve, LUTf &bcurve, LUTf & satcurve, LUTf & satclcurve, LUTf &clcurve, LUTf &curve, bool utili, bool autili, bool butili, bool ccutili, bool cclutili, bool clcutili, LUTu &histCCurve, LUTu &histLurve); void chromiLuminanceCurve(PipetteBuffer *pipetteBuffer, int pW, LabImage* lold, LabImage* lnew, const LUTf& acurve, const LUTf& bcurve, const LUTf& satcurve, const LUTf& satclcurve, const LUTf& clcurve, LUTf &curve, bool utili, bool autili, bool butili, bool ccutili, bool cclutili, bool clcutili, LUTu &histCCurve, LUTu &histLurve);
void vibrance(LabImage* lab); //Jacques' vibrance void vibrance(LabImage* lab); //Jacques' vibrance
// void colorCurve (LabImage* lold, LabImage* lnew); // void colorCurve (LabImage* lold, LabImage* lnew);
void sharpening(LabImage* lab, const procparams::SharpeningParams &sharpenParam, bool showMask = false); void sharpening(LabImage* lab, const procparams::SharpeningParams &sharpenParam, bool showMask = false);

1
rtengine/iplabregions.cc
View File

@ -18,6 +18,7 @@
* along with RawTherapee. If not, see <https://www.gnu.org/licenses/>. * along with RawTherapee. If not, see <https://www.gnu.org/licenses/>.
*/ */
#include "array2D.h"
#include "color.h" #include "color.h"
#include "curves.h" #include "curves.h"
#include "guidedfilter.h" #include "guidedfilter.h"

1
rtengine/ipretinex.cc
View File

@ -51,6 +51,7 @@
#include "procparams.h" #include "procparams.h"
#include "rawimagesource.h" #include "rawimagesource.h"
#include "rtengine.h" #include "rtengine.h"
#include "shmap.h"
#include "StopWatch.h" #include "StopWatch.h"
namespace namespace

1
rtengine/ipshadowshighlights.cc
View File

@ -20,6 +20,7 @@
#include "improcfun.h" #include "improcfun.h"
#include "array2D.h"
#include "color.h" #include "color.h"
#include "curves.h" #include "curves.h"
#include "gauss.h" #include "gauss.h"

2
rtengine/iptransform.cc
View File

@ -220,7 +220,7 @@ bool ImProcFunctions::transCoord (int W, int H, const std::vector<Coord2D> &src,
blue.push_back (Coord2D (src[i].x, src[i].y)); blue.push_back (Coord2D (src[i].x, src[i].y));
} }
return clipped; return false;
} }
double oW = W, oH = H; double oW = W, oH = H;

2
rtengine/ipwavelet.cc
View File

@ -1205,7 +1205,7 @@ void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int kall, const
b = 327.68f * Chprov * sincosv.x; //aply Munsell b = 327.68f * Chprov * sincosv.x; //aply Munsell
} else {//general case } else {//general case
L = labco->L[i1][j1]; L = labco->L[i1][j1];
const float Lin = labco->L[i1][j1]; const float Lin = std::max(0.f, L);
if (wavclCurve && cp.finena) { if (wavclCurve && cp.finena) {
labco->L[i1][j1] = (0.5f * Lin + 1.5f * wavclCurve[Lin]) / 2.f; //apply contrast curve labco->L[i1][j1] = (0.5f * Lin + 1.5f * wavclCurve[Lin]) / 2.f; //apply contrast curve

1
rtengine/lcp.cc
View File

@ -27,7 +27,6 @@
#ifdef WIN32 #ifdef WIN32
#include <shlobj.h> #include <shlobj.h>
#include <windows.h>
#endif #endif
#include "lcp.h" #include "lcp.h"

2
rtengine/mytime.h
View File

@ -19,7 +19,7 @@
#pragma once #pragma once
#ifdef WIN32 #ifdef WIN32
#include <windows.h> #include <profileapi.h>
#elif defined __APPLE__ #elif defined __APPLE__
#include <sys/time.h> #include <sys/time.h>
#else #else

2
rtengine/panasonic_decoders.cc
View File

@ -64,7 +64,7 @@ class pana_cs6_page_decoder
unsigned char current, *buffer; unsigned char current, *buffer;
public: public:
pana_cs6_page_decoder(unsigned char *_buffer, unsigned int bsize) pana_cs6_page_decoder(unsigned char *_buffer, unsigned int bsize)
: lastoffset(0), maxoffset(bsize), current(0), buffer(_buffer) : pixelbuffer{}, lastoffset(0), maxoffset(bsize), current(0), buffer(_buffer)
{ {
} }
void read_page(); // will throw IO error if not enough space in buffer void read_page(); // will throw IO error if not enough space in buffer

4
rtengine/pdaflinesfilter.cc
View File

@ -206,7 +206,7 @@ std::unique_ptr<RawImageSource::CFALineDenoiseRowBlender> PDAFLinesFilter::lineD
} }
int PDAFLinesFilter::markLine(array2D<float> &rawData, PixelsMap &bpMap, int y) int PDAFLinesFilter::markLine(const array2D<float> &rawData, PixelsMap &bpMap, int y)
{ {
rowmap_.clear(); rowmap_.clear();
rowmap_.resize((W_+1)/2, false); rowmap_.resize((W_+1)/2, false);
@ -258,7 +258,7 @@ int PDAFLinesFilter::markLine(array2D<float> &rawData, PixelsMap &bpMap, int y)
} }
int PDAFLinesFilter::mark(array2D<float> &rawData, PixelsMap &bpMap) int PDAFLinesFilter::mark(const array2D<float> &rawData, PixelsMap &bpMap)
{ {
if (pattern_.empty()) { if (pattern_.empty()) {

4
rtengine/pdaflinesfilter.h
View File

@ -36,12 +36,12 @@ public:
explicit PDAFLinesFilter(RawImage *ri); explicit PDAFLinesFilter(RawImage *ri);
~PDAFLinesFilter(); ~PDAFLinesFilter();
int mark(array2D<float> &rawData, PixelsMap &bpMap); int mark(const array2D<float> &rawData, PixelsMap &bpMap);
RawImageSource::GreenEqulibrateThreshold &greenEqThreshold(); RawImageSource::GreenEqulibrateThreshold &greenEqThreshold();
std::unique_ptr<RawImageSource::CFALineDenoiseRowBlender> lineDenoiseRowBlender(); std::unique_ptr<RawImageSource::CFALineDenoiseRowBlender> lineDenoiseRowBlender();
private: private:
int markLine(array2D<float> &rawData, PixelsMap &bpMap, int y); int markLine(const array2D<float>& rawData, PixelsMap &bpMap, int y);
RawImage *ri_; RawImage *ri_;
int W_; int W_;

1
rtengine/pipettebuffer.h
View File

@ -18,7 +18,6 @@
*/ */
#pragma once #pragma once
#include "array2D.h"
#include "iimage.h" #include "iimage.h"
class EditDataProvider; class EditDataProvider;

8
rtengine/pixelshift.cc
View File

@ -339,6 +339,8 @@ BENCHFUN
lmmse_interpolate_omp(winw, winh, *(rawDataFrames[0]), red, green, blue, bayerParams.lmmse_iterations); lmmse_interpolate_omp(winw, winh, *(rawDataFrames[0]), red, green, blue, bayerParams.lmmse_iterations);
} else if (bayerParams.pixelShiftDemosaicMethod == bayerParams.getPSDemosaicMethodString(procparams::RAWParams::BayerSensor::PSDemosaicMethod::AMAZEVNG4)) { } else if (bayerParams.pixelShiftDemosaicMethod == bayerParams.getPSDemosaicMethodString(procparams::RAWParams::BayerSensor::PSDemosaicMethod::AMAZEVNG4)) {
dual_demosaic_RT (true, rawParamsIn, winw, winh, *(rawDataFrames[0]), red, green, blue, bayerParams.dualDemosaicContrast, true); dual_demosaic_RT (true, rawParamsIn, winw, winh, *(rawDataFrames[0]), red, green, blue, bayerParams.dualDemosaicContrast, true);
} else if (bayerParams.pixelShiftDemosaicMethod == bayerParams.getPSDemosaicMethodString(procparams::RAWParams::BayerSensor::PSDemosaicMethod::RCDVNG4)) {
dual_demosaic_RT (true, rawParamsIn, winw, winh, *(rawDataFrames[0]), red, green, blue, bayerParams.dualDemosaicContrast, true);
} else { } else {
amaze_demosaic_RT(winx, winy, winw, winh, *(rawDataFrames[0]), red, green, blue, options.chunkSizeAMAZE, options.measure); amaze_demosaic_RT(winx, winy, winw, winh, *(rawDataFrames[0]), red, green, blue, options.chunkSizeAMAZE, options.measure);
} }
@ -351,6 +353,8 @@ BENCHFUN
lmmse_interpolate_omp(winw, winh, *(rawDataFrames[i + 1]), redTmp[i], greenTmp[i], blueTmp[i], bayerParams.lmmse_iterations); lmmse_interpolate_omp(winw, winh, *(rawDataFrames[i + 1]), redTmp[i], greenTmp[i], blueTmp[i], bayerParams.lmmse_iterations);
} else if (bayerParams.pixelShiftDemosaicMethod == bayerParams.getPSDemosaicMethodString(procparams::RAWParams::BayerSensor::PSDemosaicMethod::AMAZEVNG4)) { } else if (bayerParams.pixelShiftDemosaicMethod == bayerParams.getPSDemosaicMethodString(procparams::RAWParams::BayerSensor::PSDemosaicMethod::AMAZEVNG4)) {
dual_demosaic_RT (true, rawParamsIn, winw, winh, *(rawDataFrames[i + 1]), redTmp[i], greenTmp[i], blueTmp[i], bayerParams.dualDemosaicContrast, true); dual_demosaic_RT (true, rawParamsIn, winw, winh, *(rawDataFrames[i + 1]), redTmp[i], greenTmp[i], blueTmp[i], bayerParams.dualDemosaicContrast, true);
} else if (bayerParams.pixelShiftDemosaicMethod == bayerParams.getPSDemosaicMethodString(procparams::RAWParams::BayerSensor::PSDemosaicMethod::RCDVNG4)) {
dual_demosaic_RT (true, rawParamsIn, winw, winh, *(rawDataFrames[i + 1]), redTmp[i], greenTmp[i], blueTmp[i], bayerParams.dualDemosaicContrast, true);
} else { } else {
amaze_demosaic_RT(winx, winy, winw, winh, *(rawDataFrames[i + 1]), redTmp[i], greenTmp[i], blueTmp[i], options.chunkSizeAMAZE, options.measure); amaze_demosaic_RT(winx, winy, winw, winh, *(rawDataFrames[i + 1]), redTmp[i], greenTmp[i], blueTmp[i], options.chunkSizeAMAZE, options.measure);
} }
@ -380,6 +384,10 @@ BENCHFUN
procparams::RAWParams rawParamsTmp = rawParamsIn; procparams::RAWParams rawParamsTmp = rawParamsIn;
rawParamsTmp.bayersensor.method = procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEVNG4); rawParamsTmp.bayersensor.method = procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::AMAZEVNG4);
dual_demosaic_RT (true, rawParamsTmp, winw, winh, rawData, red, green, blue, bayerParams.dualDemosaicContrast, true); dual_demosaic_RT (true, rawParamsTmp, winw, winh, rawData, red, green, blue, bayerParams.dualDemosaicContrast, true);
} else if (bayerParams.pixelShiftDemosaicMethod == bayerParams.getPSDemosaicMethodString(procparams::RAWParams::BayerSensor::PSDemosaicMethod::RCDVNG4)) {
procparams::RAWParams rawParamsTmp = rawParamsIn;
rawParamsTmp.bayersensor.method = procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::RCDVNG4);
dual_demosaic_RT (true, rawParamsTmp, winw, winh, rawData, red, green, blue, bayerParams.dualDemosaicContrast, true);
} else { } else {
amaze_demosaic_RT(winx, winy, winw, winh, rawData, red, green, blue, options.chunkSizeAMAZE, options.measure); amaze_demosaic_RT(winx, winy, winw, winh, rawData, red, green, blue, options.chunkSizeAMAZE, options.measure);
} }

1
rtengine/procparams.cc
View File

@ -2692,6 +2692,7 @@ const std::vector<const char*>& RAWParams::BayerSensor::getPSDemosaicMethodStrin
static const std::vector<const char*> method_strings { static const std::vector<const char*> method_strings {
"amaze", "amaze",
"amazevng4", "amazevng4",
"rcdvng4",
"lmmse" "lmmse"
}; };
return method_strings; return method_strings;

1
rtengine/procparams.h
View File

@ -1398,6 +1398,7 @@ struct RAWParams {
enum class PSDemosaicMethod { enum class PSDemosaicMethod {
AMAZE, AMAZE,
AMAZEVNG4, AMAZEVNG4,
RCDVNG4,
LMMSE LMMSE
}; };

10
rtengine/rtlensfun.cc
View File

@ -500,6 +500,7 @@ std::unique_ptr<LFModifier> LFDatabase::getModifier(const LFCamera &camera, cons
return ret; return ret;
} }
std::set<std::string> LFDatabase::notFound;
std::unique_ptr<LFModifier> LFDatabase::findModifier(const procparams::LensProfParams &lensProf, const FramesMetaData *idata, int width, int height, const procparams::CoarseTransformParams &coarse, int rawRotationDeg) std::unique_ptr<LFModifier> LFDatabase::findModifier(const procparams::LensProfParams &lensProf, const FramesMetaData *idata, int width, int height, const procparams::CoarseTransformParams &coarse, int rawRotationDeg)
{ {
@ -521,6 +522,11 @@ std::unique_ptr<LFModifier> LFDatabase::findModifier(const procparams::LensProfP
return nullptr; return nullptr;
} }
const std::string key = (make + model + lens).collate_key();
if (notFound.find(key) != notFound.end()) {
// This combination was not found => do not search again
return nullptr;
}
const LFDatabase *db = getInstance(); const LFDatabase *db = getInstance();
LFCamera c = db->findCamera(make, model); LFCamera c = db->findCamera(make, model);
LFLens l = db->findLens(lensProf.lfAutoMatch() ? c : LFCamera(), lens); LFLens l = db->findLens(lensProf.lfAutoMatch() ? c : LFCamera(), lens);
@ -549,6 +555,10 @@ std::unique_ptr<LFModifier> LFDatabase::findModifier(const procparams::LensProfP
<< (ret ? ret->getDisplayString() : "NONE") << std::endl; << (ret ? ret->getDisplayString() : "NONE") << std::endl;
} }
if (!ret) {
notFound.emplace(key);
}
return ret; return ret;
} }

2
rtengine/rtlensfun.h
View File

@ -21,6 +21,7 @@
#pragma once #pragma once
#include <memory> #include <memory>
#include <set>
#include <vector> #include <vector>
#include <glibmm/ustring.h> #include <glibmm/ustring.h>
@ -135,6 +136,7 @@ private:
mutable MyMutex lfDBMutex; mutable MyMutex lfDBMutex;
static LFDatabase instance_; static LFDatabase instance_;
lfDatabase *data_; lfDatabase *data_;
static std::set<std::string> notFound;
}; };
} // namespace rtengine } // namespace rtengine

2
rtengine/shmap.cc
View File

@ -351,7 +351,7 @@ void SHMap::forceStat (float max_, float min_, float avg_)
avg = avg_; avg = avg_;
} }
void SHMap::dirpyr_shmap(float ** data_fine, float ** data_coarse, int width, int height, LUTf & rangefn, int level, int scale) void SHMap::dirpyr_shmap(float ** data_fine, float ** data_coarse, int width, int height, const LUTf& rangefn, int level, int scale)
{ {
//scale is spacing of directional averaging weights //scale is spacing of directional averaging weights

2
rtengine/shmap.h
View File

@ -50,7 +50,7 @@ private:
void fillLuminance( Imagefloat * img, float **luminance, double lumi[3] ); void fillLuminance( Imagefloat * img, float **luminance, double lumi[3] );
void fillLuminanceL( float ** L, float **luminance ); void fillLuminanceL( float ** L, float **luminance );
void dirpyr_shmap(float ** data_fine, float ** data_coarse, int width, int height, LUTf & rangefn, int level, int scale); void dirpyr_shmap(float ** data_fine, float ** data_coarse, int width, int height, const LUTf& rangefn, int level, int scale);
}; };

23
rtengine/simpleprocess.cc
View File

@ -810,17 +810,7 @@ private:
void stage_denoise() void stage_denoise()
{ {
procparams::ProcParams& params = job->pparams; const procparams::ProcParams& params = job->pparams;
//ImProcFunctions ipf (&params, true);
ImProcFunctions &ipf = * (ipf_p.get());
// perform luma/chroma denoise
// CieImage *cieView;
// NoisCurve noiseLCurve;
// bool lldenoiseutili=false;
// Imagefloat *calclum ;
// params.dirpyrDenoise.getCurves(noiseLCurve, lldenoiseutili);
// if (params.dirpyrDenoise.enabled && lldenoiseutili) {
DirPyrDenoiseParams denoiseParams = params.dirpyrDenoise; // make a copy because we cheat here DirPyrDenoiseParams denoiseParams = params.dirpyrDenoise; // make a copy because we cheat here
@ -853,9 +843,7 @@ private:
} }
if (denoiseParams.enabled) { if (denoiseParams.enabled) {
// CurveFactory::denoiseLL(lldenoiseutili, denoiseParams.lcurve, Noisecurve,1); ImProcFunctions &ipf = * (ipf_p.get());
//denoiseParams.getCurves(noiseLCurve);
// ipf.RGB_denoise(baseImg, baseImg, calclum, imgsrc->isRAW(), denoiseParams, params.defringe, imgsrc->getDirPyrDenoiseExpComp(), noiseLCurve, lldenoiseutili);
float nresi, highresi; float nresi, highresi;
int kall = 2; int kall = 2;
ipf.RGB_denoise(kall, baseImg, baseImg, calclum, ch_M, max_r, max_b, imgsrc->isRAW(), denoiseParams, imgsrc->getDirPyrDenoiseExpComp(), noiseLCurve, noiseCCurve, nresi, highresi); ipf.RGB_denoise(kall, baseImg, baseImg, calclum, ch_M, max_r, max_b, imgsrc->isRAW(), denoiseParams, imgsrc->getDirPyrDenoiseExpComp(), noiseLCurve, noiseCCurve, nresi, highresi);
@ -877,7 +865,7 @@ private:
void stage_transform() void stage_transform()
{ {
procparams::ProcParams& params = job->pparams; const procparams::ProcParams& params = job->pparams;
//ImProcFunctions ipf (&params, true); //ImProcFunctions ipf (&params, true);
ImProcFunctions &ipf = * (ipf_p.get()); ImProcFunctions &ipf = * (ipf_p.get());
@ -1095,13 +1083,10 @@ private:
ipf.vibrance(labView); ipf.vibrance(labView);
ipf.labColorCorrectionRegions(labView); ipf.labColorCorrectionRegions(labView);
if ((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) {
ipf.impulsedenoise(labView);
}
// for all treatments Defringe, Sharpening, Contrast detail ,Microcontrast they are activated if "CIECAM" function are disabled // for all treatments Defringe, Sharpening, Contrast detail ,Microcontrast they are activated if "CIECAM" function are disabled
if ((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) { if ((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) {
ipf.impulsedenoise (labView);
ipf.defringe(labView); ipf.defringe(labView);
} }

4
rtgui/adjuster.cc
View File

@ -246,7 +246,7 @@ void Adjuster::autoToggled ()
} }
if (adjusterListener != nullptr && !blocked) { if (adjusterListener != nullptr && !blocked) {
adjusterListener->adjusterAutoToggled(this, automatic->get_active()); adjusterListener->adjusterAutoToggled(this);
} }
} }
@ -493,7 +493,7 @@ bool Adjuster::notifyListenerAutoToggled ()
{ {
if (adjusterListener != nullptr && !blocked) { if (adjusterListener != nullptr && !blocked) {
adjusterListener->adjusterAutoToggled(this, automatic->get_active()); adjusterListener->adjusterAutoToggled(this);
} }
return false; return false;

2
rtgui/adjuster.h
View File

@ -28,7 +28,7 @@ class AdjusterListener
public: public:
virtual ~AdjusterListener() = default; virtual ~AdjusterListener() = default;
virtual void adjusterChanged (Adjuster* a, double newval) = 0; virtual void adjusterChanged (Adjuster* a, double newval) = 0;
virtual void adjusterAutoToggled (Adjuster* a, bool newval) {} virtual void adjusterAutoToggled (Adjuster* a) {}
}; };
typedef double(*double2double_fun)(double val); typedef double(*double2double_fun)(double val);

7
rtgui/batchqueue.cc
View File

@ -147,7 +147,7 @@ int BatchQueue::getThumbnailHeight ()
return std::max(std::min(options.thumbSizeQueue, 200), 10); return std::max(std::min(options.thumbSizeQueue, 200), 10);
} }
void BatchQueue::rightClicked (ThumbBrowserEntryBase* entry) void BatchQueue::rightClicked ()
{ {
pmenu.popup (3, this->eventTime); pmenu.popup (3, this->eventTime);
} }
@ -344,9 +344,8 @@ bool BatchQueue::loadBatchQueue ()
auto job = rtengine::ProcessingJob::create (source, thumb->getType () == FT_Raw, pparams, fast); auto job = rtengine::ProcessingJob::create (source, thumb->getType () == FT_Raw, pparams, fast);
auto prevh = getMaxThumbnailHeight (); const auto prevh = getMaxThumbnailHeight ();
auto prevw = prevh; const auto prevw = thumb->getThumbnailWidth(prevh, &pparams);
thumb->getThumbnailSize (prevw, prevh, &pparams);
auto entry = new BatchQueueEntry (job, pparams, source, prevw, prevh, thumb, options.overwriteOutputFile); auto entry = new BatchQueueEntry (job, pparams, source, prevw, prevh, thumb, options.overwriteOutputFile);
thumb->decreaseRef (); // Removing the refCount acquired by cacheMgr->getEntry thumb->decreaseRef (); // Removing the refCount acquired by cacheMgr->getEntry

2
rtgui/batchqueue.h
View File

@ -74,7 +74,7 @@ public:
void error(const Glib::ustring& descr) override; void error(const Glib::ustring& descr) override;
rtengine::ProcessingJob* imageReady(rtengine::IImagefloat* img) override; rtengine::ProcessingJob* imageReady(rtengine::IImagefloat* img) override;
void rightClicked (ThumbBrowserEntryBase* entry) override; void rightClicked () override;
void doubleClicked (ThumbBrowserEntryBase* entry) override; void doubleClicked (ThumbBrowserEntryBase* entry) override;
bool keyPressed (GdkEventKey* event) override; bool keyPressed (GdkEventKey* event) override;
void buttonPressed (LWButton* button, int actionCode, void* actionData) override; void buttonPressed (LWButton* button, int actionCode, void* actionData) override;

1
rtgui/batchqueuepanel.cc
View File

@ -18,7 +18,6 @@
*/ */
#include "batchqueuepanel.h" #include "batchqueuepanel.h"
#include "options.h" #include "options.h"
#include "preferences.h"
#include "multilangmgr.h" #include "multilangmgr.h"
#include "rtwindow.h" #include "rtwindow.h"
#include "soundman.h" #include "soundman.h"

2
rtgui/bayerprocess.cc
View File

@ -672,7 +672,7 @@ void BayerProcess::checkBoxToggled (CheckBox* c, CheckValue newval)
} }
} }
void BayerProcess::adjusterAutoToggled(Adjuster* a, bool newval) void BayerProcess::adjusterAutoToggled(Adjuster* a)
{ {
if (multiImage) { if (multiImage) {
if (dualDemosaicContrast->getAutoInconsistent()) { if (dualDemosaicContrast->getAutoInconsistent()) {

2
rtgui/bayerprocess.h
View File

@ -88,7 +88,7 @@ public:
void methodChanged(); void methodChanged();
void imageNumberChanged(); void imageNumberChanged();
void adjusterChanged(Adjuster* a, double newval) override; void adjusterChanged(Adjuster* a, double newval) override;
void adjusterAutoToggled (Adjuster* a, bool newval) override; void adjusterAutoToggled (Adjuster* a) override;
void checkBoxToggled(CheckBox* c, CheckValue newval) override; void checkBoxToggled(CheckBox* c, CheckValue newval) override;
void pixelShiftMotionMethodChanged(); void pixelShiftMotionMethodChanged();
void pixelShiftDemosaicMethodChanged(); void pixelShiftDemosaicMethodChanged();

2
rtgui/cachemanager.cc
View File

@ -25,7 +25,7 @@
#include <glib/gstdio.h> #include <glib/gstdio.h>
#ifdef WIN32 #ifdef WIN32
#include <windows.h> #include <fileapi.h>
#endif #endif
#include "cachemanager.h" #include "cachemanager.h"

2
rtgui/colorappearance.cc
View File

@ -1565,7 +1565,7 @@ void ColorAppearance::adjusterChanged(Adjuster* a, double newval)
} }
} }
void ColorAppearance::adjusterAutoToggled(Adjuster* a, bool newval) void ColorAppearance::adjusterAutoToggled(Adjuster* a)
{ {
if (multiImage) { if (multiImage) {
if (degree->getAutoInconsistent()) { if (degree->getAutoInconsistent()) {

2
rtgui/colorappearance.h
View File

@ -47,7 +47,7 @@ public:
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override; void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override;
void setBatchMode (bool batchMode) override; void setBatchMode (bool batchMode) override;
void adjusterChanged (Adjuster* a, double newval) override; void adjusterChanged (Adjuster* a, double newval) override;
void adjusterAutoToggled (Adjuster* a, bool newval) override; void adjusterAutoToggled (Adjuster* a) override;
// void adjusterAdapToggled (Adjuster* a, bool newval); // void adjusterAdapToggled (Adjuster* a, bool newval);
void enabledChanged () override; void enabledChanged () override;
void surroundChanged (); void surroundChanged ();

1
rtgui/crophandler.h
View File

@ -24,7 +24,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "editbuffer.h"
#include "lockablecolorpicker.h" #include "lockablecolorpicker.h"
#include "threadutils.h" #include "threadutils.h"

3
rtgui/cropwindow.cc
View File

@ -33,6 +33,7 @@
#include "editcallbacks.h" #include "editcallbacks.h"
#include "editbuffer.h" #include "editbuffer.h"
#include "editwidgets.h" #include "editwidgets.h"
#include "pointermotionlistener.h"
#include "rtsurface.h" #include "rtsurface.h"
#include "../rtengine/dcrop.h" #include "../rtengine/dcrop.h"
@ -259,7 +260,7 @@ void CropWindow::getCropAnchorPosition (int& x, int& y)
cropHandler.getAnchorPosition(x, y); cropHandler.getAnchorPosition(x, y);
} }
void CropWindow::setCropAnchorPosition (int& x, int& y) void CropWindow::setCropAnchorPosition (int x, int y)
{ {
cropHandler.setAnchorPosition(x, y); cropHandler.setAnchorPosition(x, y);
} }

4
rtgui/cropwindow.h
View File

@ -30,7 +30,6 @@
#include "editenums.h" #include "editenums.h"
#include "lwbutton.h" #include "lwbutton.h"
#include "lwbuttonset.h" #include "lwbuttonset.h"
#include "pointermotionlistener.h"
#include "../rtengine/noncopyable.h" #include "../rtengine/noncopyable.h"
@ -42,6 +41,7 @@ struct Coord;
} }
class CropWindow; class CropWindow;
class PointerMotionListener;
class CropWindowListener class CropWindowListener
{ {
@ -224,7 +224,7 @@ public:
void centerCrop (bool update = true); void centerCrop (bool update = true);
void getCropSize (int& w, int& h); void getCropSize (int& w, int& h);
void getCropAnchorPosition (int& w, int& h); void getCropAnchorPosition (int& w, int& h);
void setCropAnchorPosition (int& w, int& h); void setCropAnchorPosition (int w, int h);
// listeners // listeners
void setCropGUIListener (CropGUIListener* cgl); void setCropGUIListener (CropGUIListener* cgl);

1
rtgui/curveeditorgroup.h
View File

@ -23,7 +23,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "adjuster.h"
#include "guiutils.h" #include "guiutils.h"
#include "mycurve.h" #include "mycurve.h"
#include "shcselector.h" #include "shcselector.h"

2
rtgui/diagonalcurveeditorsubgroup.h
View File

@ -21,7 +21,7 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "curveeditorgroup.h" #include "curveeditorgroup.h"
#include "adjuster.h"
#include "../rtengine/noncopyable.h" #include "../rtengine/noncopyable.h"
class DiagonalCurveEditor; class DiagonalCurveEditor;

4
rtgui/dirbrowser.h
View File

@ -23,10 +23,6 @@
#include "guiutils.h" #include "guiutils.h"
#ifdef WIN32
#include "windows.h"
#endif
class DirBrowser : public Gtk::VBox class DirBrowser : public Gtk::VBox
{ {
public: public:

7
rtgui/editorpanel.cc
View File

@ -28,9 +28,12 @@
#include "soundman.h" #include "soundman.h"
#include "rtimage.h" #include "rtimage.h"
#include "rtwindow.h" #include "rtwindow.h"
#include "filepanel.h"
#include "guiutils.h" #include "guiutils.h"
#include "popupbutton.h" #include "popupbutton.h"
#include "options.h" #include "options.h"
#include "navigator.h"
#include "previewwindow.h"
#include "progressconnector.h" #include "progressconnector.h"
#include "procparamchangers.h" #include "procparamchangers.h"
#include "placesbrowser.h" #include "placesbrowser.h"
@ -38,6 +41,10 @@
#include "thumbnail.h" #include "thumbnail.h"
#include "toolpanelcoord.h" #include "toolpanelcoord.h"
#ifdef WIN32
#include "windows.h"
#endif
using namespace rtengine::procparams; using namespace rtengine::procparams;
namespace namespace

3
rtgui/editorpanel.h
View File

@ -21,11 +21,9 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "filepanel.h"
#include "histogrampanel.h" #include "histogrampanel.h"
#include "history.h" #include "history.h"
#include "imageareapanel.h" #include "imageareapanel.h"
#include "navigator.h"
#include "profilepanel.h" #include "profilepanel.h"
#include "progressconnector.h" #include "progressconnector.h"
#include "saveasdlg.h" #include "saveasdlg.h"
@ -38,6 +36,7 @@ class BatchQueueEntry;
class EditorPanel; class EditorPanel;
class FilePanel; class FilePanel;
class MyProgressBar; class MyProgressBar;
class Navigator;
class Thumbnail; class Thumbnail;
class ToolPanelCoordinator; class ToolPanelCoordinator;

6
rtgui/editwidgets.h
View File

@ -20,9 +20,9 @@
#ifdef GUIVERSION #ifdef GUIVERSION
#include <cairomm/cairomm.h>
#include <glibmm/ustring.h> #include <glibmm/ustring.h>
#include "editbuffer.h"
#include "editcoordsys.h" #include "editcoordsys.h"
#include "../rtengine/coord.h" #include "../rtengine/coord.h"
@ -285,7 +285,7 @@ public:
rtengine::Coord end; rtengine::Coord end;
Line (); Line ();
Line (rtengine::Coord& begin, rtengine::Coord& end); Line (const rtengine::Coord& begin, const rtengine::Coord& end);
Line (int beginX, int beginY, int endX, int endY); Line (int beginX, int beginY, int endX, int endY);
void drawOuterGeometry (Cairo::RefPtr<Cairo::Context> &cr, ObjectMOBuffer *objectBuffer, EditCoordSystem &coordSystem) override; void drawOuterGeometry (Cairo::RefPtr<Cairo::Context> &cr, ObjectMOBuffer *objectBuffer, EditCoordSystem &coordSystem) override;
@ -532,7 +532,7 @@ inline Circle::Circle (int centerX, int centerY, int radius, bool filled,
radiusInImageSpace) { radiusInImageSpace) {
} }
inline Line::Line (rtengine::Coord& begin, rtengine::Coord& end) : inline Line::Line (const rtengine::Coord& begin, const rtengine::Coord& end) :
begin (begin), end (end) { begin (begin), end (end) {
} }

3
rtgui/editwindow.cc
View File

@ -16,13 +16,14 @@
*/ */
#include "editwindow.h" #include "editwindow.h"
#include "editorpanel.h"
#include "filepanel.h"
#include "../rtengine/procparams.h" #include "../rtengine/procparams.h"
#include "options.h" #include "options.h"
#include "preferences.h" #include "preferences.h"
#include "cursormanager.h" #include "cursormanager.h"
#include "rtwindow.h" #include "rtwindow.h"
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "rtimage.h"
#include "threadutils.h" #include "threadutils.h"
extern Glib::ustring argv0; extern Glib::ustring argv0;

5
rtgui/editwindow.h
View File

@ -20,10 +20,11 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "editorpanel.h"
#include "filepanel.h"
#include "rtimage.h" #include "rtimage.h"
class EditorPanel;
class RTWindow;
class EditWindow : class EditWindow :
public Gtk::Window public Gtk::Window
{ {

1
rtgui/exportpanel.h
View File

@ -21,7 +21,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "adjuster.h"
#include "guiutils.h" #include "guiutils.h"
class ExportPanelListener class ExportPanelListener

11
rtgui/extprog.cc
View File

@ -22,8 +22,8 @@
#include <iostream> #include <iostream>
#ifdef WIN32 #ifdef WIN32
#include <windows.h>
#include <shlobj.h> #include <shlobj.h>
#include <shellapi.h>
#endif #endif
#include <gtkmm.h> #include <gtkmm.h>
@ -157,7 +157,6 @@ bool ExtProgStore::searchProgram (const Glib::ustring& name,
break; break;
} }
} }
filePath.clear(); filePath.clear();
} }
} else { } else {
@ -178,9 +177,7 @@ bool ExtProgStore::searchProgram (const Glib::ustring& name,
break; break;
} }
} }
filePath.clear(); filePath.clear();
} while (false); } while (false);
} }
@ -264,7 +261,7 @@ bool ExtProgStore::openInGimp (const Glib::ustring& fileName)
#endif #endif
#ifdef WIN32 #ifdef WIN32
if ((uintptr_t)success > 32) { if (reinterpret_cast<uintptr_t>(success) > 32) {
return true; return true;
} }
#else #else
@ -279,9 +276,9 @@ bool ExtProgStore::openInGimp (const Glib::ustring& fileName)
for (auto ver = 12; ver >= 0; --ver) { for (auto ver = 12; ver >= 0; --ver) {
executable = Glib::build_filename (options.gimpDir, "bin", Glib::ustring::compose (Glib::ustring("gimp-2.%1.exe"), ver)); executable = Glib::build_filename (options.gimpDir, "bin", Glib::ustring::compose (Glib::ustring("gimp-2.%1.exe"), ver));
auto success = ShellExecute( NULL, "open", executable.c_str(), fileName.c_str(), NULL, SW_SHOWNORMAL ); auto lsuccess = ShellExecute( NULL, "open", executable.c_str(), fileName.c_str(), NULL, SW_SHOWNORMAL );
if ((uintptr_t)success > 32) { if (reinterpret_cast<uintptr_t>(lsuccess) > 32) {
return true; return true;
} }
} }

33
rtgui/filebrowser.cc
View File

@ -90,41 +90,36 @@ ThumbBrowserEntryBase* selectOriginalEntry (ThumbBrowserEntryBase* original, Thu
void findOriginalEntries (const std::vector<ThumbBrowserEntryBase*>& entries) void findOriginalEntries (const std::vector<ThumbBrowserEntryBase*>& entries)
{ {
typedef std::vector<ThumbBrowserEntryBase*> EntryVector;
typedef EntryVector::const_iterator EntryIterator;
typedef std::map<Glib::ustring, EntryVector> BasenameMap;
typedef BasenameMap::const_iterator BasenameIterator;
// Sort all entries into buckets by basename without extension // Sort all entries into buckets by basename without extension
BasenameMap byBasename; std::map<Glib::ustring, std::vector<ThumbBrowserEntryBase*>> byBasename;
for (EntryIterator entry = entries.begin (); entry != entries.end (); ++entry) { for (const auto entry : entries) {
const Glib::ustring basename = Glib::path_get_basename ((*entry)->filename.lowercase()); const auto basename = Glib::path_get_basename(entry->filename.lowercase());
const Glib::ustring::size_type pos = basename.find_last_of ('.'); const auto pos = basename.find_last_of('.');
if (pos >= basename.length() - 1) { if (pos >= basename.length() - 1) {
(*entry)->setOriginal (nullptr); entry->setOriginal(nullptr);
continue; continue;
} }
const Glib::ustring withoutExtension = basename.substr (0, pos); const auto withoutExtension = basename.substr(0, pos);
byBasename[withoutExtension].push_back (*entry); byBasename[withoutExtension].push_back(entry);
} }
// Find the original image for each bucket // Find the original image for each bucket
for (BasenameIterator bucket = byBasename.begin (); bucket != byBasename.end (); ++bucket) { for (const auto& bucket : byBasename) {
const EntryVector& entries = bucket->second; const auto& lentries = bucket.second;
ThumbBrowserEntryBase* original = nullptr; ThumbBrowserEntryBase* original = nullptr;
// Select the most likely original in a first pass... // Select the most likely original in a first pass...
for (EntryIterator entry = entries.begin (); entry != entries.end (); ++entry) { for (const auto entry : lentries) {
original = selectOriginalEntry (original, *entry); original = selectOriginalEntry(original, entry);
} }
// ...and link all other images to it in a second pass. // ...and link all other images to it in a second pass.
for (EntryIterator entry = entries.begin (); entry != entries.end (); ++entry) { for (const auto entry : lentries) {
(*entry)->setOriginal (*entry != original ? original : nullptr); entry->setOriginal(entry != original ? original : nullptr);
} }
} }
} }
@ -487,7 +482,7 @@ FileBrowser::~FileBrowser ()
delete[] amiExtProg; delete[] amiExtProg;
} }
void FileBrowser::rightClicked (ThumbBrowserEntryBase* entry) void FileBrowser::rightClicked ()
{ {
{ {

3
rtgui/filebrowser.h
View File

@ -23,7 +23,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "browserfilter.h" #include "browserfilter.h"
#include "exiffiltersettings.h"
#include "exportpanel.h" #include "exportpanel.h"
#include "extprog.h" #include "extprog.h"
#include "filebrowserentry.h" #include "filebrowserentry.h"
@ -174,7 +173,7 @@ public:
void buttonPressed (LWButton* button, int actionCode, void* actionData) override; void buttonPressed (LWButton* button, int actionCode, void* actionData) override;
void redrawNeeded (LWButton* button) override; void redrawNeeded (LWButton* button) override;
bool checkFilter (ThumbBrowserEntryBase* entry) const override; bool checkFilter (ThumbBrowserEntryBase* entry) const override;
void rightClicked (ThumbBrowserEntryBase* entry) override; void rightClicked () override;
void doubleClicked (ThumbBrowserEntryBase* entry) override; void doubleClicked (ThumbBrowserEntryBase* entry) override;
bool keyPressed (GdkEventKey* event) override; bool keyPressed (GdkEventKey* event) override;

2
rtgui/filebrowserentry.cc
View File

@ -118,7 +118,7 @@ void FileBrowserEntry::calcThumbnailSize ()
{ {
if (thumbnail) { if (thumbnail) {
thumbnail->getThumbnailSize (prew, preh); prew = thumbnail->getThumbnailWidth(preh);
} }
} }

1
rtgui/filebrowserentry.h
View File

@ -23,7 +23,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "crophandler.h"
#include "editenums.h" #include "editenums.h"
#include "filethumbnailbuttonset.h" #include "filethumbnailbuttonset.h"
#include "imageareatoollistener.h" #include "imageareatoollistener.h"

7
rtgui/filecatalog.cc
View File

@ -32,6 +32,7 @@
#include "rtimage.h" #include "rtimage.h"
#include "cachemanager.h" #include "cachemanager.h"
#include "multilangmgr.h" #include "multilangmgr.h"
#include "coarsepanel.h"
#include "filepanel.h" #include "filepanel.h"
#include "renamedlg.h" #include "renamedlg.h"
#include "thumbimageupdater.h" #include "thumbimageupdater.h"
@ -40,6 +41,7 @@
#include "placesbrowser.h" #include "placesbrowser.h"
#include "pathutils.h" #include "pathutils.h"
#include "thumbnail.h" #include "thumbnail.h"
#include "toolbar.h"
using namespace std; using namespace std;
@ -1222,9 +1224,8 @@ void FileCatalog::developRequested(const std::vector<FileBrowserEntry*>& tbe, bo
rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params, fastmode && options.fastexport_use_fast_pipeline); rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params, fastmode && options.fastexport_use_fast_pipeline);
int pw; const int ph = BatchQueue::calcMaxThumbnailHeight();
int ph = BatchQueue::calcMaxThumbnailHeight(); const int pw = th->getThumbnailWidth(ph);
th->getThumbnailSize (pw, ph);
// processThumbImage is the processing intensive part, but adding to queue must be ordered // processThumbImage is the processing intensive part, but adding to queue must be ordered
//#pragma omp ordered //#pragma omp ordered

6
rtgui/filecatalog.h
View File

@ -22,21 +22,21 @@
#include <giomm.h> #include <giomm.h>
#include "coarsepanel.h"
#include "exiffiltersettings.h" #include "exiffiltersettings.h"
#include "exportpanel.h" #include "exportpanel.h"
#include "filebrowser.h" #include "filebrowser.h"
#include "fileselectionchangelistener.h" #include "fileselectionchangelistener.h"
#include "fileselectionlistener.h" #include "fileselectionlistener.h"
#include "filterpanel.h" #include "filterpanel.h"
#include "multilangmgr.h"
#include "previewloader.h" #include "previewloader.h"
#include "threadutils.h" #include "threadutils.h"
#include "toolbar.h"
#include "../rtengine/noncopyable.h" #include "../rtengine/noncopyable.h"
class FilePanel; class FilePanel;
class CoarsePanel;
class ToolBar;
/* /*
* Class: * Class:
* - handling the list of file (add/remove them) * - handling the list of file (add/remove them)

5
rtgui/filepanel.cc
View File

@ -18,6 +18,7 @@
*/ */
#include "filepanel.h" #include "filepanel.h"
#include "dirbrowser.h"
#include "batchtoolpanelcoord.h" #include "batchtoolpanelcoord.h"
#include "editorpanel.h" #include "editorpanel.h"
#include "rtwindow.h" #include "rtwindow.h"
@ -25,6 +26,10 @@
#include "placesbrowser.h" #include "placesbrowser.h"
#include "thumbnail.h" #include "thumbnail.h"
#ifdef WIN32
#include "windows.h"
#endif
FilePanel::FilePanel () : parent(nullptr), error(0) FilePanel::FilePanel () : parent(nullptr), error(0)
{ {

2
rtgui/filepanel.h
View File

@ -20,7 +20,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "dirbrowser.h"
#include "exportpanel.h" #include "exportpanel.h"
#include "filecatalog.h" #include "filecatalog.h"
#include "fileselectionlistener.h" #include "fileselectionlistener.h"
@ -35,6 +34,7 @@
class BatchToolPanelCoordinator; class BatchToolPanelCoordinator;
class RTWindow; class RTWindow;
class DirBrowser;
class FilePanel final : class FilePanel final :
public Gtk::HPaned, public Gtk::HPaned,

2
rtgui/flatfield.cc
View File

@ -252,7 +252,7 @@ void FlatField::adjusterChanged(Adjuster* a, double newval)
} }
} }
void FlatField::adjusterAutoToggled (Adjuster* a, bool newval) void FlatField::adjusterAutoToggled (Adjuster* a)
{ {
if (multiImage) { if (multiImage) {
if (flatFieldClipControl->getAutoInconsistent()) { if (flatFieldClipControl->getAutoInconsistent()) {

2
rtgui/flatfield.h
View File

@ -79,7 +79,7 @@ public:
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override; void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override;
void adjusterChanged (Adjuster* a, double newval) override; void adjusterChanged (Adjuster* a, double newval) override;
void adjusterAutoToggled (Adjuster* a, bool newval) override; void adjusterAutoToggled (Adjuster* a) override;
void flatFieldFileChanged (); void flatFieldFileChanged ();
void flatFieldFile_Reset (); void flatFieldFile_Reset ();
void flatFieldAutoSelectChanged (); void flatFieldAutoSelectChanged ();

7
rtgui/guiutils.cc
View File

@ -946,22 +946,21 @@ bool MyScrolledWindow::on_scroll_event (GdkEventScroll* event)
const double lowerBound = adjust->get_lower(); const double lowerBound = adjust->get_lower();
double value = adjust->get_value(); double value = adjust->get_value();
double step = adjust->get_step_increment(); double step = adjust->get_step_increment();
double value2 = 0.;
if (event->direction == GDK_SCROLL_DOWN) { if (event->direction == GDK_SCROLL_DOWN) {
value2 = rtengine::min<double>(value + step, upperBound); const double value2 = rtengine::min<double>(value + step, upperBound);
if (value2 != value) { if (value2 != value) {
scroll->set_value(value2); scroll->set_value(value2);
} }
} else if (event->direction == GDK_SCROLL_UP) { } else if (event->direction == GDK_SCROLL_UP) {
value2 = rtengine::max<double>(value - step, lowerBound); const double value2 = rtengine::max<double>(value - step, lowerBound);
if (value2 != value) { if (value2 != value) {
scroll->set_value(value2); scroll->set_value(value2);
} }
} else if (event->direction == GDK_SCROLL_SMOOTH) { } else if (event->direction == GDK_SCROLL_SMOOTH) {
value2 = rtengine::LIM<double>(value + event->delta_y * step, lowerBound, upperBound); const double value2 = rtengine::LIM<double>(value + event->delta_y * step, lowerBound, upperBound);
if (value2 != value) { if (value2 != value) {
scroll->set_value(value2); scroll->set_value(value2);

4
rtgui/histogrampanel.cc
View File

@ -983,7 +983,7 @@ void HistogramArea::on_realize ()
} }
void HistogramArea::drawCurve(Cairo::RefPtr<Cairo::Context> &cr, void HistogramArea::drawCurve(Cairo::RefPtr<Cairo::Context> &cr,
LUTu & data, double scale, int hsize, int vsize) const LUTu & data, double scale, int hsize, int vsize)
{ {
double s = RTScalable::getScale(); double s = RTScalable::getScale();
@ -1013,7 +1013,7 @@ void HistogramArea::drawCurve(Cairo::RefPtr<Cairo::Context> &cr,
} }
void HistogramArea::drawMarks(Cairo::RefPtr<Cairo::Context> &cr, void HistogramArea::drawMarks(Cairo::RefPtr<Cairo::Context> &cr,
LUTu & data, double scale, int hsize, int & ui, int & oi) const LUTu & data, double scale, int hsize, int & ui, int & oi)
{ {
int s = 8 * RTScalable::getScale(); int s = 8 * RTScalable::getScale();

4
rtgui/histogrampanel.h
View File

@ -165,8 +165,8 @@ public:
type_signal_factor_changed signal_factor_changed(); type_signal_factor_changed signal_factor_changed();
private: private:
void drawCurve(Cairo::RefPtr<Cairo::Context> &cr, LUTu & data, double scale, int hsize, int vsize); void drawCurve(Cairo::RefPtr<Cairo::Context> &cr, const LUTu & data, double scale, int hsize, int vsize);
void drawMarks(Cairo::RefPtr<Cairo::Context> &cr, LUTu & data, double scale, int hsize, int & ui, int & oi); void drawMarks(Cairo::RefPtr<Cairo::Context> &cr, const LUTu & data, double scale, int hsize, int & ui, int & oi);
Gtk::SizeRequestMode get_request_mode_vfunc () const override; Gtk::SizeRequestMode get_request_mode_vfunc () const override;
void get_preferred_height_vfunc (int& minimum_height, int& natural_height) const override; void get_preferred_height_vfunc (int& minimum_height, int& natural_height) const override;
void get_preferred_width_vfunc (int &minimum_width, int &natural_width) const override; void get_preferred_width_vfunc (int &minimum_width, int &natural_width) const override;

2
rtgui/hsvequalizer.h
View File

@ -20,7 +20,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "adjuster.h"
#include "colorprovider.h" #include "colorprovider.h"
#include "curvelistener.h" #include "curvelistener.h"
#include "guiutils.h" #include "guiutils.h"
@ -58,6 +57,5 @@ public:
void autoOpenCurve () override; void autoOpenCurve () override;
void colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller* caller) override; void colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller* caller) override;
//void adjusterChanged (Adjuster* a, double newval);
void enabledChanged() override; void enabledChanged() override;
}; };

8
rtgui/lockablecolorpicker.cc
View File

@ -240,7 +240,7 @@ void LockableColorPicker::updateBackBuffer ()
} }
void LockableColorPicker::draw (Cairo::RefPtr<Cairo::Context> &cr) void LockableColorPicker::draw (const Cairo::RefPtr<Cairo::Context> &cr)
{ {
if (validity == Validity::OUTSIDE) { if (validity == Validity::OUTSIDE) {
return; return;
@ -284,12 +284,12 @@ void LockableColorPicker::setRGB (const float R, const float G, const float B, c
} }
} }
void LockableColorPicker::getImagePosition (rtengine::Coord &imgPos) void LockableColorPicker::getImagePosition (rtengine::Coord &imgPos) const
{ {
imgPos = position; imgPos = position;
} }
void LockableColorPicker::getScreenPosition (rtengine::Coord &screenPos) void LockableColorPicker::getScreenPosition (rtengine::Coord &screenPos) const
{ {
if (cropWindow) { if (cropWindow) {
cropWindow->imageCoordToScreen(position.x, position.y, screenPos.x, screenPos.y); cropWindow->imageCoordToScreen(position.x, position.y, screenPos.x, screenPos.y);
@ -328,7 +328,7 @@ void LockableColorPicker::setSize (Size newSize)
} }
} }
LockableColorPicker::Size LockableColorPicker::getSize () LockableColorPicker::Size LockableColorPicker::getSize () const
{ {
return size; return size;
} }

8
rtgui/lockablecolorpicker.h
View File

@ -74,14 +74,14 @@ public:
LockableColorPicker (CropWindow* cropWindow, Glib::ustring *oProfile, Glib::ustring *wProfile); LockableColorPicker (CropWindow* cropWindow, Glib::ustring *oProfile, Glib::ustring *wProfile);
void draw (Cairo::RefPtr<Cairo::Context> &cr); void draw (const Cairo::RefPtr<Cairo::Context> &cr);
// Used to update the RGB color, the HSV values will be updated accordingly // Used to update the RGB color, the HSV values will be updated accordingly
void setPosition (const rtengine::Coord &newPos); void setPosition (const rtengine::Coord &newPos);
void setRGB (const float R, const float G, const float B, const float previewR, const float previewG, const float previewB); void setRGB (const float R, const float G, const float B, const float previewR, const float previewG, const float previewB);
void getImagePosition (rtengine::Coord &imgPos); void getImagePosition (rtengine::Coord &imgPos) const;
void getScreenPosition (rtengine::Coord &screenPos); void getScreenPosition (rtengine::Coord &screenPos) const;
Size getSize (); Size getSize () const;
bool isOver (int x, int y); bool isOver (int x, int y);
void setValidity (Validity isValid); void setValidity (Validity isValid);
void setSize (Size newSize); void setSize (Size newSize);

2
rtgui/lwbutton.cc
View File

@ -153,7 +153,7 @@ bool LWButton::releaseNotify (int x, int y)
{ {
bool in = inside (x, y); bool in = inside (x, y);
State nstate = state; State nstate;
bool action = false; bool action = false;
if (in && (state == Pressed_In || state == Pressed_Out)) { if (in && (state == Pressed_In || state == Pressed_Out)) {

1
rtgui/main.cc
View File

@ -53,6 +53,7 @@
#else #else
#include <glibmm/thread.h> #include <glibmm/thread.h>
#include "conio.h" #include "conio.h"
#include "windows.h"
#endif #endif
// Set this to 1 to make RT work when started with Eclipse and arguments, at least on Windows platform // Set this to 1 to make RT work when started with Eclipse and arguments, at least on Windows platform

3
rtgui/mydiagonalcurve.cc
View File

@ -592,7 +592,6 @@ bool MyDiagonalCurve::handleEvents (GdkEvent* event)
curve.x.insert (itx, 0); curve.x.insert (itx, 0);
curve.y.insert (ity, 0); curve.y.insert (ity, 0);
num++;
// the graph is refreshed only if a new point is created // the graph is refreshed only if a new point is created
curve.x.at(closest_point) = clampedX; curve.x.at(closest_point) = clampedX;
@ -1504,7 +1503,7 @@ void MyDiagonalCurve::setActiveParam (int ac)
queue_draw (); queue_draw ();
} }
void MyDiagonalCurve::updateBackgroundHistogram (LUTu & hist) void MyDiagonalCurve::updateBackgroundHistogram (const LUTu & hist)
{ {
if (hist) { if (hist) {
//memcpy (bghist, hist, 256*sizeof(unsigned int)); //memcpy (bghist, hist, 256*sizeof(unsigned int));

2
rtgui/mydiagonalcurve.h
View File

@ -85,7 +85,7 @@ public:
bool handleEvents (GdkEvent* event) override; bool handleEvents (GdkEvent* event) override;
void setActiveParam (int ac); void setActiveParam (int ac);
void reset (const std::vector<double> &resetCurve, double identityValue = 0.5) override; void reset (const std::vector<double> &resetCurve, double identityValue = 0.5) override;
void updateBackgroundHistogram (LUTu & hist); void updateBackgroundHistogram (const LUTu & hist);
void pipetteMouseOver (CurveEditor *ce, EditDataProvider *provider, int modifierKey) override; void pipetteMouseOver (CurveEditor *ce, EditDataProvider *provider, int modifierKey) override;
bool pipetteButton1Pressed(EditDataProvider *provider, int modifierKey) override; bool pipetteButton1Pressed(EditDataProvider *provider, int modifierKey) override;

1
rtgui/myflatcurve.cc
View File

@ -653,7 +653,6 @@ bool MyFlatCurve::handleEvents (GdkEvent* event)
curve.y.insert (ity, 0); curve.y.insert (ity, 0);
curve.leftTangent.insert (itlt, 0); curve.leftTangent.insert (itlt, 0);
curve.rightTangent.insert (itrt, 0); curve.rightTangent.insert (itrt, 0);
num++;
if (mod_type & GDK_CONTROL_MASK) { if (mod_type & GDK_CONTROL_MASK) {
clampedY = point.getVal01(clampedX); clampedY = point.getVal01(clampedX);

1
rtgui/navigator.cc
View File

@ -18,6 +18,7 @@
*/ */
#include <iomanip> #include <iomanip>
#include "navigator.h" #include "navigator.h"
#include "previewwindow.h"
#include "toolpanel.h" #include "toolpanel.h"
#include "../rtengine/color.h" #include "../rtengine/color.h"
#include "../rtengine/rt_math.h" #include "../rtengine/rt_math.h"

3
rtgui/navigator.h
View File

@ -22,7 +22,8 @@
#include "options.h" #include "options.h"
#include "pointermotionlistener.h" #include "pointermotionlistener.h"
#include "previewwindow.h"
class PreviewWindow;
class Navigator : class Navigator :
public Gtk::Frame, public Gtk::Frame,

18
rtgui/partialpastedlg.cc
View File

@ -136,6 +136,8 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren
raw_ca_avoid_colourshift = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_AVOIDCOLORSHIFT"))); raw_ca_avoid_colourshift = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_AVOIDCOLORSHIFT")));
//--- //---
filmNegative = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_FILMNEGATIVE")) ); filmNegative = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_FILMNEGATIVE")) );
//---
captureSharpening = Gtk::manage (new Gtk::CheckButton (M("TP_PDSHARPENING_LABEL")) );
Gtk::VBox* vboxes[8]; Gtk::VBox* vboxes[8];
Gtk::HSeparator* hseps[8]; Gtk::HSeparator* hseps[8];
@ -253,6 +255,7 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren
vboxes[7]->pack_start (*raw_ca_avoid_colourshift, Gtk::PACK_SHRINK, 2); vboxes[7]->pack_start (*raw_ca_avoid_colourshift, Gtk::PACK_SHRINK, 2);
vboxes[7]->pack_start (*Gtk::manage (new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 0); vboxes[7]->pack_start (*Gtk::manage (new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 0);
vboxes[7]->pack_start (*filmNegative, Gtk::PACK_SHRINK, 2); vboxes[7]->pack_start (*filmNegative, Gtk::PACK_SHRINK, 2);
vboxes[7]->pack_start (*captureSharpening, Gtk::PACK_SHRINK, 2);
Gtk::VBox* vbCol1 = Gtk::manage (new Gtk::VBox ()); Gtk::VBox* vbCol1 = Gtk::manage (new Gtk::VBox ());
Gtk::VBox* vbCol2 = Gtk::manage (new Gtk::VBox ()); Gtk::VBox* vbCol2 = Gtk::manage (new Gtk::VBox ());
@ -402,6 +405,8 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren
raw_ca_avoid_colourshiftconn = raw_ca_avoid_colourshift->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_ca_avoid_colourshiftconn = raw_ca_avoid_colourshift->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true));
//--- //---
filmNegativeConn = filmNegative->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); filmNegativeConn = filmNegative->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true));
//---
captureSharpeningConn = captureSharpening->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true));
add_button (M("GENERAL_OK"), Gtk::RESPONSE_OK); add_button (M("GENERAL_OK"), Gtk::RESPONSE_OK);
add_button (M("GENERAL_CANCEL"), Gtk::RESPONSE_CANCEL); add_button (M("GENERAL_CANCEL"), Gtk::RESPONSE_CANCEL);
@ -474,6 +479,7 @@ void PartialPasteDlg::rawToggled ()
ConnectionBlocker raw_caredblueBlocker(raw_caredblueConn); ConnectionBlocker raw_caredblueBlocker(raw_caredblueConn);
ConnectionBlocker raw_ca_avoid_colourshiftBlocker(raw_ca_avoid_colourshiftconn); ConnectionBlocker raw_ca_avoid_colourshiftBlocker(raw_ca_avoid_colourshiftconn);
ConnectionBlocker filmNegativeBlocker(filmNegativeConn); ConnectionBlocker filmNegativeBlocker(filmNegativeConn);
ConnectionBlocker captureSharpeningBlocker(captureSharpeningConn);
raw->set_inconsistent (false); raw->set_inconsistent (false);
@ -503,6 +509,7 @@ void PartialPasteDlg::rawToggled ()
raw_caredblue->set_active (raw->get_active ()); raw_caredblue->set_active (raw->get_active ());
raw_ca_avoid_colourshift->set_active (raw->get_active ()); raw_ca_avoid_colourshift->set_active (raw->get_active ());
filmNegative->set_active (raw->get_active()); filmNegative->set_active (raw->get_active());
captureSharpening->set_active (raw->get_active());
} }
void PartialPasteDlg::basicToggled () void PartialPasteDlg::basicToggled ()
@ -981,6 +988,17 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
filterPE.filmNegative.blueRatio = falsePE.filmNegative.blueRatio; filterPE.filmNegative.blueRatio = falsePE.filmNegative.blueRatio;
} }
if (!captureSharpening->get_active ()) {
filterPE.pdsharpening.enabled = falsePE.pdsharpening.enabled;
filterPE.pdsharpening.contrast = falsePE.pdsharpening.contrast;
filterPE.pdsharpening.autoContrast = falsePE.pdsharpening.autoContrast;
filterPE.pdsharpening.autoRadius = falsePE.pdsharpening.autoRadius;
filterPE.pdsharpening.deconvradius = falsePE.pdsharpening.deconvradius;
filterPE.pdsharpening.deconvradiusOffset = falsePE.pdsharpening.deconvradiusOffset;
filterPE.pdsharpening.deconviter = falsePE.pdsharpening.deconviter;
filterPE.pdsharpening.deconvitercheck = falsePE.pdsharpening.deconvitercheck;
}
if (dstPE) { if (dstPE) {
*dstPE = filterPE; *dstPE = filterPE;
} }

2
rtgui/partialpastedlg.h
View File

@ -141,6 +141,7 @@ public:
Gtk::CheckButton* ff_ClipControl; Gtk::CheckButton* ff_ClipControl;
Gtk::CheckButton* filmNegative; Gtk::CheckButton* filmNegative;
Gtk::CheckButton* captureSharpening;
sigc::connection everythingConn, basicConn, detailConn, colorConn, lensConn, compositionConn, metaConn, rawConn, advancedConn; sigc::connection everythingConn, basicConn, detailConn, colorConn, lensConn, compositionConn, metaConn, rawConn, advancedConn;
@ -153,6 +154,7 @@ public:
sigc::connection df_fileConn, df_AutoSelectConn, ff_fileConn, ff_AutoSelectConn, ff_BlurRadiusConn, ff_BlurTypeConn, ff_ClipControlConn; sigc::connection df_fileConn, df_AutoSelectConn, ff_fileConn, ff_AutoSelectConn, ff_BlurRadiusConn, ff_BlurTypeConn, ff_ClipControlConn;
sigc::connection raw_caredblueConn, raw_ca_autocorrectConn, raw_ca_avoid_colourshiftconn, raw_hotpix_filtConn, raw_deadpix_filtConn, raw_pdaf_lines_filterConn, raw_linenoiseConn, raw_greenthreshConn, raw_ccStepsConn, raw_methodConn, raw_borderConn, raw_imagenumConn, raw_dcb_iterationsConn, raw_lmmse_iterationsConn, raw_pixelshiftConn, raw_dcb_enhanceConn, raw_exposConn, raw_blackConn; sigc::connection raw_caredblueConn, raw_ca_autocorrectConn, raw_ca_avoid_colourshiftconn, raw_hotpix_filtConn, raw_deadpix_filtConn, raw_pdaf_lines_filterConn, raw_linenoiseConn, raw_greenthreshConn, raw_ccStepsConn, raw_methodConn, raw_borderConn, raw_imagenumConn, raw_dcb_iterationsConn, raw_lmmse_iterationsConn, raw_pixelshiftConn, raw_dcb_enhanceConn, raw_exposConn, raw_blackConn;
sigc::connection filmNegativeConn; sigc::connection filmNegativeConn;
sigc::connection captureSharpeningConn;
public: public:
PartialPasteDlg (const Glib::ustring &title, Gtk::Window* parent); PartialPasteDlg (const Glib::ustring &title, Gtk::Window* parent);

2
rtgui/pdsharpening.cc
View File

@ -270,7 +270,7 @@ void PdSharpening::autoRadiusChanged(double autoRadius)
); );
} }
void PdSharpening::adjusterAutoToggled(Adjuster* a, bool newval) void PdSharpening::adjusterAutoToggled(Adjuster* a)
{ {
if (multiImage) { if (multiImage) {
if (a->getAutoInconsistent()) { if (a->getAutoInconsistent()) {

2
rtgui/pdsharpening.h
View File

@ -59,7 +59,7 @@ public:
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override; void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override;
void setBatchMode (bool batchMode) override; void setBatchMode (bool batchMode) override;
void adjusterAutoToggled (Adjuster* a, bool newval) override; void adjusterAutoToggled (Adjuster* a) override;
void adjusterChanged (Adjuster* a, double newval) override; void adjusterChanged (Adjuster* a, double newval) override;
void enabledChanged () override; void enabledChanged () override;

2
rtgui/placesbrowser.h
View File

@ -22,8 +22,6 @@
#include <giomm.h> #include <giomm.h>
#include "multilangmgr.h"
class PlacesBrowser : class PlacesBrowser :
public Gtk::VBox public Gtk::VBox
{ {

2
rtgui/preferences.cc
View File

@ -128,7 +128,7 @@ Preferences::~Preferences ()
get_size (options.preferencesWidth, options.preferencesHeight); get_size (options.preferencesWidth, options.preferencesHeight);
} }
int Preferences::getThemeRowNumber (Glib::ustring& longThemeFName) int Preferences::getThemeRowNumber (const Glib::ustring& longThemeFName)
{ {
if (regex->match (longThemeFName + ".css", matchInfo)) { if (regex->match (longThemeFName + ".css", matchInfo)) {

3
rtgui/preferences.h
View File

@ -22,7 +22,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "adjuster.h"
#include "dynamicprofilepanel.h" #include "dynamicprofilepanel.h"
#include "options.h" #include "options.h"
#include "../rtengine/profilestore.h" #include "../rtengine/profilestore.h"
@ -249,7 +248,7 @@ class Preferences :
void switchFontTo (const Glib::ustring &newFontFamily, const int newFontSize); void switchFontTo (const Glib::ustring &newFontFamily, const int newFontSize);
bool splashClosed (GdkEventAny* event); bool splashClosed (GdkEventAny* event);
int getThemeRowNumber (Glib::ustring& longThemeFName); int getThemeRowNumber (const Glib::ustring& longThemeFName);
void appendBehavList (Gtk::TreeModel::iterator& parent, Glib::ustring label, int id, bool set); void appendBehavList (Gtk::TreeModel::iterator& parent, Glib::ustring label, int id, bool set);

2
rtgui/previewmodepanel.h
View File

@ -19,8 +19,6 @@
#include <gtkmm.h> #include <gtkmm.h>
#include "adjuster.h"
class ImageArea; class ImageArea;
class PreviewModePanel : class PreviewModePanel :

2
rtgui/previewwindow.cc
View File

@ -230,7 +230,7 @@ bool PreviewWindow::on_motion_notify_event (GdkEventMotion* event)
if (x>imgX || y>imgY || w < imgW || h < imgH) { if (x>imgX || y>imgY || w < imgW || h < imgH) {
bool inside = event->x > x - 6 && event->x < x + w - 1 + 6 && event->y > y - 6 && event->y < y + h - 1 + 6; bool inside = event->x > x - 6 && event->x < x + w - 1 + 6 && event->y > y - 6 && event->y < y + h - 1 + 6;
CursorShape newType = cursor_type; CursorShape newType;
if (isMoving) { if (isMoving) {
mainCropWin->remoteMove ((event->x - press_x) / zoom, (event->y - press_y) / zoom); mainCropWin->remoteMove ((event->x - press_x) / zoom, (event->y - press_y) / zoom);

Some files were not shown because too many files have changed in this diff Show More