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

Merge pull request #4192 from Beep6581/procparams-cleanup

Browse Source 
Procparams cleanup
This commit is contained in:
Beep6581 2017-12-05 23:16:00 +01:00 committed by GitHub
commit a5571a4379
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 4464 additions and 8552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rtengine/amaze_demosaic_RT.cc
View File

@ -45,7 +45,7 @@ SSEFUNCTION void RawImageSource::amaze_demosaic_RT(int winx, int winy, int winw,
volatile double progress = 0.0;
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::amaze]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AMAZE)));
plistener->setProgress (0.0);
}

20
rtengine/demosaic_algos.cc
View File

@ -65,7 +65,7 @@ extern const Settings* settings;
void RawImageSource::eahd_demosaic ()
{
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::eahd]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::EAHD)));
plistener->setProgress (0.0);
}
@ -494,7 +494,7 @@ void RawImageSource::hphd_green (float** hpmap)
void RawImageSource::hphd_demosaic ()
{
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::hphd]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::HPHD)));
plistener->setProgress (0.0);
}
@ -595,7 +595,7 @@ void RawImageSource::vng4_demosaic ()
const bool plistenerActive = plistener;
if (plistenerActive) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::vng4]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::VNG4)));
plistener->setProgress (progress);
}
@ -893,7 +893,7 @@ void RawImageSource::ppg_demosaic()
if (plistener) {
// looks like ppg isn't supported anymore
//plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::ppg]));
//plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::ppg)));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), "xxx"));
plistener->setProgress (0.0);
}
@ -1201,7 +1201,7 @@ void RawImageSource::jdl_interpolate_omp() // from "Lassus"
if (plistener) {
// this function seems to be unused
//plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::jdl]));
//plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::jdl)));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), "xxx"));
plistener->setProgress (0.0);
}
@ -1397,7 +1397,7 @@ SSEFUNCTION void RawImageSource::lmmse_interpolate_omp(int winw, int winh, array
}
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::lmmse]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::LMMSE)));
plistener->setProgress (0.0);
}
@ -1975,7 +1975,7 @@ SSEFUNCTION void RawImageSource::igv_interpolate(int winw, int winh)
border_interpolate2(winw, winh, 7);
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::igv]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::IGV)));
plistener->setProgress (0.0);
}
@ -2365,7 +2365,7 @@ void RawImageSource::igv_interpolate(int winw, int winh)
border_interpolate2(winw, winh, 7);
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::igv]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::IGV)));
plistener->setProgress (0.0);
}
@ -2640,7 +2640,7 @@ void RawImageSource::ahd_demosaic()
const float d65_white[3] = { 0.950456, 1, 1.088754 };
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::ahd]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AHD)));
plistener->setProgress (0.0);
}
@ -3703,7 +3703,7 @@ BENCHFUN
double currentProgress = 0.0;
if(plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::dcb]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::DCB)));
plistener->setProgress (currentProgress);
}

2
rtengine/fast_demo.cc
View File

@ -62,7 +62,7 @@ SSEFUNCTION void RawImageSource::fast_demosaic()
//int winw=W, winh=H;
if (plistener) {
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::fast]));
plistener->setProgressStr (Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::FAST)));
plistener->setProgress (progress);
}

8
rtengine/improccoordinator.cc
View File

@ -171,14 +171,14 @@ void ImProcCoordinator::updatePreviewImage (int todo, Crop* cropCall)
if ( !highDetailNeeded ) {
// if below 100% magnification, take a fast path
if (rp.bayersensor.method != RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::none] && rp.bayersensor.method != RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::mono]) {
rp.bayersensor.method = RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::fast];
if (rp.bayersensor.method != RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::NONE) && rp.bayersensor.method != RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::NONE)) {
rp.bayersensor.method = RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::FAST);
}
//bayerrp.all_enhance = false;
if (rp.xtranssensor.method != RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::none] && rp.xtranssensor.method != RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::mono]) {
rp.xtranssensor.method = RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::fast];
if (rp.xtranssensor.method != RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::NONE) && rp.xtranssensor.method != RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::NONE)) {
rp.xtranssensor.method = RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::FAST);
}
rp.bayersensor.ccSteps = 0;

152
rtengine/improcfun.cc
View File

@ -438,11 +438,11 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
}
// extracting datas from 'params' to avoid cache flush (to be confirmed)
ColorAppearanceParams::eTCModeId curveMode = params->colorappearance.curveMode;
ColorAppearanceParams::eTCModeId curveMode2 = params->colorappearance.curveMode2;
ColorAppearanceParams::TcMode curveMode = params->colorappearance.curveMode;
ColorAppearanceParams::TcMode curveMode2 = params->colorappearance.curveMode2;
bool hasColCurve1 = bool (customColCurve1);
bool hasColCurve2 = bool (customColCurve2);
ColorAppearanceParams::eCTCModeId curveMode3 = params->colorappearance.curveMode3;
ColorAppearanceParams::CtcMode curveMode3 = params->colorappearance.curveMode3;
bool hasColCurve3 = bool (customColCurve3);
@ -801,7 +801,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
}
if (hasColCurve1) {//curve 1 with Lightness and Brightness
if (curveMode == ColorAppearanceParams::TC_MODE_LIGHT) {
if (curveMode == ColorAppearanceParams::TcMode::LIGHT) {
/* float Jj=(float) Jpro*327.68;
float Jold=Jj;
const Lightcurve& userColCurve = static_cast<const Lightcurve&>(customColCurve1);
@ -839,7 +839,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
}
t1L = true;
} else if (curveMode == ColorAppearanceParams::TC_MODE_BRIGHT) {
} else if (curveMode == ColorAppearanceParams::TcMode::BRIGHT) {
//attention! Brightness curves are open - unlike Lightness or Lab or RGB==> rendering and algoritms will be different
float coef = ((aw + 4.f) * (4.f / c)) / 100.f;
float Qanc = Qpro;
@ -887,7 +887,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
}
if (hasColCurve2) {//curve 2 with Lightness and Brightness
if (curveMode2 == ColorAppearanceParams::TC_MODE_LIGHT) {
if (curveMode2 == ColorAppearanceParams::TcMode::LIGHT) {
float Jj = (float) Jpro * 327.68;
float Jold = Jj;
/*
@ -930,7 +930,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
Jpro = 1.;
}
} else if (curveMode2 == ColorAppearanceParams::TC_MODE_BRIGHT) { //
} else if (curveMode2 == ColorAppearanceParams::TcMode::BRIGHT) { //
float Qanc = Qpro;
float coef = ((aw + 4.f) * (4.f / c)) / 100.f;
float Qq = (float) Qpro * 327.68f * (1.f / coef);
@ -988,7 +988,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
}
if (hasColCurve3) {//curve 3 with chroma saturation colorfullness
if (curveMode3 == ColorAppearanceParams::TC_MODE_CHROMA) {
if (curveMode3 == ColorAppearanceParams::CtcMode::CHROMA) {
double parsat = 0.8; //0.68;
double coef = 327.68 / parsat;
float Cc = (float) Cpro * coef;
@ -1012,7 +1012,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
}
// Cpro=Cc/coef;
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_SATUR) { //
} else if (curveMode3 == ColorAppearanceParams::CtcMode::SATUR) { //
double parsat = 0.8; //0.6
double coef = 327.68 / parsat;
float Ss = (float) spro * coef;
@ -1032,7 +1032,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
Cpro = (spro * spro * Qpro) / (10000.0);
c1s = 1;
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_COLORF) { //
} else if (curveMode3 == ColorAppearanceParams::CtcMode::COLORF) { //
double parsat = 0.8; //0.68;
double coef = 327.68 / parsat;
float Mm = (float) Mpro * coef;
@ -1117,21 +1117,21 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
int libr = 0;
int colch = 0;
if (curveMode == ColorAppearanceParams::TC_MODE_BRIGHT) {
if (curveMode == ColorAppearanceParams::TcMode::BRIGHT) {
brli = 70.0;
libr = 1;
} else if (curveMode == ColorAppearanceParams::TC_MODE_LIGHT) {
} else if (curveMode == ColorAppearanceParams::TcMode::LIGHT) {
brli = 327.;
libr = 0;
}
if (curveMode3 == ColorAppearanceParams::TC_MODE_CHROMA) {
if (curveMode3 == ColorAppearanceParams::CtcMode::CHROMA) {
chsacol = 400.;//327.;
colch = 0;
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_SATUR) {
} else if (curveMode3 == ColorAppearanceParams::CtcMode::SATUR) {
chsacol = 450.0;
colch = 1;
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_COLORF) {
} else if (curveMode3 == ColorAppearanceParams::CtcMode::COLORF) {
chsacol = 400.;//327.0;
colch = 2;
}
@ -1302,9 +1302,9 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
// if (params->dirpyrequalizer.algo=="FI") choice=0;
// else if(params->dirpyrequalizer.algo=="LA") choice=1;
if (rtt == 1) {
float b_l = static_cast<float> (params->dirpyrequalizer.hueskin.value[0]) / 100.0f;
float t_l = static_cast<float> (params->dirpyrequalizer.hueskin.value[1]) / 100.0f;
float t_r = static_cast<float> (params->dirpyrequalizer.hueskin.value[3]) / 100.0f;
float b_l = static_cast<float> (params->dirpyrequalizer.hueskin.getBottomLeft()) / 100.0f;
float t_l = static_cast<float> (params->dirpyrequalizer.hueskin.getTopLeft()) / 100.0f;
float t_r = static_cast<float> (params->dirpyrequalizer.hueskin.getTopRight()) / 100.0f;
dirpyr_equalizercam (ncie, ncie->sh_p, ncie->sh_p, ncie->W, ncie->H, ncie->h_p, ncie->C_p, params->dirpyrequalizer.mult, params->dirpyrequalizer.threshold, params->dirpyrequalizer.skinprotect, true, b_l, t_l, t_r, scale); //contrast by detail adapted to CIECAM
}
}
@ -1378,21 +1378,21 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int pW, int pwb, L
int libr = 0;
int colch = 0;
if (curveMode == ColorAppearanceParams::TC_MODE_BRIGHT) {
if (curveMode == ColorAppearanceParams::TcMode::BRIGHT) {
brli = 70.0;
libr = 1;
} else if (curveMode == ColorAppearanceParams::TC_MODE_LIGHT) {
} else if (curveMode == ColorAppearanceParams::TcMode::LIGHT) {
brli = 327.;
libr = 0;
}
if (curveMode3 == ColorAppearanceParams::TC_MODE_CHROMA) {
if (curveMode3 == ColorAppearanceParams::CtcMode::CHROMA) {
chsacol = 400.;//327.;
colch = 0;
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_SATUR) {
} else if (curveMode3 == ColorAppearanceParams::CtcMode::SATUR) {
chsacol = 450.0;
colch = 1;
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_COLORF) {
} else if (curveMode3 == ColorAppearanceParams::CtcMode::COLORF) {
chsacol = 400.;//327.0;
colch = 2;
}
@ -1752,14 +1752,14 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
const float rstprotection = 100. - params->colorappearance.rstprotection;
// extracting datas from 'params' to avoid cache flush (to be confirmed)
const ColorAppearanceParams::eTCModeId curveMode = params->colorappearance.curveMode;
const ColorAppearanceParams::TcMode curveMode = params->colorappearance.curveMode;
const bool hasColCurve1 = bool (customColCurve1);
const bool t1L = hasColCurve1 && curveMode == ColorAppearanceParams::TC_MODE_LIGHT;
const bool t1L = hasColCurve1 && curveMode == ColorAppearanceParams::TcMode::LIGHT;
const ColorAppearanceParams::eTCModeId curveMode2 = params->colorappearance.curveMode2;
const ColorAppearanceParams::TcMode curveMode2 = params->colorappearance.curveMode2;
const bool hasColCurve2 = bool (customColCurve2);
const ColorAppearanceParams::eCTCModeId curveMode3 = params->colorappearance.curveMode3;
const ColorAppearanceParams::CtcMode curveMode3 = params->colorappearance.curveMode3;
const bool hasColCurve3 = bool (customColCurve3);
bool needJ = (alg == 0 || alg == 1 || alg == 3);
@ -2212,7 +2212,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
}
if (hasColCurve1) {//curve 1 with Lightness and Brightness
if (curveMode == ColorAppearanceParams::TC_MODE_LIGHT) {
if (curveMode == ColorAppearanceParams::TcMode::LIGHT) {
float Jj = (float) Jpro * 327.68f;
float Jold = Jj;
float Jold100 = (float) Jpro;
@ -2241,7 +2241,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
if (Jpro < 1.f) {
Jpro = 1.f;
}
} else if (curveMode == ColorAppearanceParams::TC_MODE_BRIGHT) {
} else if (curveMode == ColorAppearanceParams::TcMode::BRIGHT) {
//attention! Brightness curves are open - unlike Lightness or Lab or RGB==> rendering and algoritms will be different
float coef = ((aw + 4.f) * (4.f / c)) / 100.f;
float Qanc = Qpro;
@ -2285,7 +2285,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
}
if (hasColCurve2) {//curve 2 with Lightness and Brightness
if (curveMode2 == ColorAppearanceParams::TC_MODE_LIGHT) {
if (curveMode2 == ColorAppearanceParams::TcMode::LIGHT) {
float Jj = (float) Jpro * 327.68f;
float Jold = Jj;
float Jold100 = (float) Jpro;
@ -2323,7 +2323,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
Jpro = 1.f;
}
} else if (curveMode2 == ColorAppearanceParams::TC_MODE_BRIGHT) { //
} else if (curveMode2 == ColorAppearanceParams::TcMode::BRIGHT) { //
float Qanc = Qpro;
float coef = ((aw + 4.f) * (4.f / c)) / 100.f;
@ -2380,7 +2380,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
}
if (hasColCurve3) {//curve 3 with chroma saturation colorfullness
if (curveMode3 == ColorAppearanceParams::TC_MODE_CHROMA) {
if (curveMode3 == ColorAppearanceParams::CtcMode::CHROMA) {
float parsat = 0.8f; //0.68;
float coef = 327.68f / parsat;
float Cc = (float) Cpro * coef;
@ -2403,7 +2403,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
Cpro = 50.f;
}
*/
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_SATUR) { //
} else if (curveMode3 == ColorAppearanceParams::CtcMode::SATUR) { //
float parsat = 0.8f; //0.6
float coef = 327.68f / parsat;
float Ss = (float) spro * coef;
@ -2420,7 +2420,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
Color::skinredfloat (Jpro, hpro, Ss, Sold, dred, protect_red, sk, rstprotection, ko, spro);
Qpro = ( 4.0f / c ) * sqrtf ( Jpro / 100.0f ) * ( aw + 4.0f ) ;
Cpro = (spro * spro * Qpro) / (10000.0f);
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_COLORF) { //
} else if (curveMode3 == ColorAppearanceParams::CtcMode::COLORF) { //
float parsat = 0.8f; //0.68;
float coef = 327.68f / parsat;
float Mm = (float) Mpro * coef;
@ -2490,10 +2490,10 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
float colch;
//update histogram
if (curveMode == ColorAppearanceParams::TC_MODE_BRIGHT) {
if (curveMode == ColorAppearanceParams::TcMode::BRIGHT) {
brli = 70.0f;
libr = Q; //40.0 to 100.0 approximative factor for Q - 327 for J
} else { /*if(curveMode == ColorAppearanceParams::TC_MODE_LIGHT)*/
} else { /*if(curveMode == ColorAppearanceParams::TCMode::LIGHT)*/
brli = 327.f;
libr = J; //327 for J
}
@ -2501,13 +2501,13 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
posl = (int) (libr * brli);
hist16JCAM[posl]++;
if (curveMode3 == ColorAppearanceParams::TC_MODE_CHROMA) {
if (curveMode3 == ColorAppearanceParams::CtcMode::CHROMA) {
chsacol = 400.f;//327
colch = C; //450.0 approximative factor for s 320 for M
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_SATUR) {
} else if (curveMode3 == ColorAppearanceParams::CtcMode::SATUR) {
chsacol = 450.0f;
colch = s;
} else { /*if(curveMode3 == ColorAppearanceParams::TC_MODE_COLORF)*/
} else { /*if(curveMode3 == ColorAppearanceParams::CTCMode::COLORF)*/
chsacol = 400.0f;//327
colch = M;
}
@ -2743,9 +2743,9 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
// else if(params->dirpyrequalizer.algo=="LA") choice=1;
if (rtt == 1) {
float b_l = static_cast<float> (params->dirpyrequalizer.hueskin.value[0]) / 100.0f;
float t_l = static_cast<float> (params->dirpyrequalizer.hueskin.value[1]) / 100.0f;
float t_r = static_cast<float> (params->dirpyrequalizer.hueskin.value[3]) / 100.0f;
float b_l = static_cast<float> (params->dirpyrequalizer.hueskin.getBottomLeft()) / 100.0f;
float t_l = static_cast<float> (params->dirpyrequalizer.hueskin.getTopLeft()) / 100.0f;
float t_r = static_cast<float> (params->dirpyrequalizer.hueskin.getTopRight()) / 100.0f;
lab->deleteLab();
dirpyr_equalizercam (ncie, ncie->sh_p, ncie->sh_p, ncie->W, ncie->H, ncie->h_p, ncie->C_p, params->dirpyrequalizer.mult, params->dirpyrequalizer.threshold, params->dirpyrequalizer.skinprotect, true, b_l, t_l, t_r, scale); //contrast by detail adapted to CIECAM
lab->reallocLab();
@ -2837,10 +2837,10 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
float libr;
float colch;
if (curveMode == ColorAppearanceParams::TC_MODE_BRIGHT) {
if (curveMode == ColorAppearanceParams::TcMode::BRIGHT) {
brli = 70.0f;
libr = ncie->Q_p[i][j]; //40.0 to 100.0 approximative factor for Q - 327 for J
} else { /*if(curveMode == ColorAppearanceParams::TC_MODE_LIGHT)*/
} else { /*if(curveMode == ColorAppearanceParams::TCMode::LIGHT)*/
brli = 327.f;
libr = ncie->J_p[i][j]; //327 for J
}
@ -2848,13 +2848,13 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int pW, int pw
posl = (int) (libr * brli);
hist16JCAM[posl]++;
if (curveMode3 == ColorAppearanceParams::TC_MODE_CHROMA) {
if (curveMode3 == ColorAppearanceParams::CtcMode::CHROMA) {
chsacol = 400.f;//327.f;
colch = ncie_C_p;
} else if (curveMode3 == ColorAppearanceParams::TC_MODE_SATUR) {
} else if (curveMode3 == ColorAppearanceParams::CtcMode::SATUR) {
chsacol = 450.0f;
colch = 100.f * sqrtf (ncie_C_p / ncie->Q_p[i][j]);
} else { /*if(curveMode3 == ColorAppearanceParams::TC_MODE_COLORF)*/
} else { /*if(curveMode3 == ColorAppearanceParams::CTCMode::COLORF)*/
chsacol = 400.f;//327.0f;
colch = ncie->M_p[i][j];
}
@ -3250,25 +3250,25 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
const float hlrange = 65536.0 - shoulder;
const bool isProPhoto = (params->icm.working == "ProPhoto");
// extracting datas from 'params' to avoid cache flush (to be confirmed)
ToneCurveParams::eTCModeId curveMode = params->toneCurve.curveMode;
ToneCurveParams::eTCModeId curveMode2 = params->toneCurve.curveMode2;
ToneCurveParams::TcMode curveMode = params->toneCurve.curveMode;
ToneCurveParams::TcMode curveMode2 = params->toneCurve.curveMode2;
bool highlight = params->toneCurve.hrenabled;//Get the value if "highlight reconstruction" is activated
bool hasToneCurve1 = bool (customToneCurve1);
bool hasToneCurve2 = bool (customToneCurve2);
BlackWhiteParams::eTCModeId beforeCurveMode = params->blackwhite.beforeCurveMode;
BlackWhiteParams::eTCModeId afterCurveMode = params->blackwhite.afterCurveMode;
BlackWhiteParams::TcMode beforeCurveMode = params->blackwhite.beforeCurveMode;
BlackWhiteParams::TcMode afterCurveMode = params->blackwhite.afterCurveMode;
bool hasToneCurvebw1 = bool (customToneCurvebw1);
bool hasToneCurvebw2 = bool (customToneCurvebw2);
PerceptualToneCurveState ptc1ApplyState, ptc2ApplyState;
if (hasToneCurve1 && curveMode == ToneCurveParams::TC_MODE_PERCEPTUAL) {
if (hasToneCurve1 && curveMode == ToneCurveParams::TcMode::PERCEPTUAL) {
const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve1);
userToneCurve.initApplyState (ptc1ApplyState, params->icm.working);
}
if (hasToneCurve2 && curveMode2 == ToneCurveParams::TC_MODE_PERCEPTUAL) {
if (hasToneCurve2 && curveMode2 == ToneCurveParams::TcMode::PERCEPTUAL) {
const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve2);
userToneCurve.initApplyState (ptc2ApplyState, params->icm.working);
}
@ -3317,8 +3317,8 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
float RedHigh = (100.f + float (params->colorToning.redhigh)) / 100.f; //printf("RedH=%f\n",RedHigh);
float GreenHigh = (100.f + float (params->colorToning.greenhigh)) / 100.f;
float BlueHigh = (100.f + float (params->colorToning.bluehigh)) / 100.f;
float SatLow = float (params->colorToning.shadowsColSat.value[0]) / 100.f;
float SatHigh = float (params->colorToning.hlColSat.value[0]) / 100.f;
float SatLow = float (params->colorToning.shadowsColSat.getBottom()) / 100.f;
float SatHigh = float (params->colorToning.hlColSat.getBottom()) / 100.f;
float Balan = float (params->colorToning.balance);
@ -3621,21 +3621,21 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
}
if (hasToneCurve1) {
if (curveMode == ToneCurveParams::TC_MODE_STD) { // Standard
if (curveMode == ToneCurveParams::TcMode::STD) { // Standard
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const StandardToneCurve& userToneCurve = static_cast<const StandardToneCurve&> (customToneCurve1);
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode == ToneCurveParams::TC_MODE_FILMLIKE) { // Adobe like
} else if (curveMode == ToneCurveParams::TcMode::FILMLIKE) { // Adobe like
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const AdobeToneCurve& userToneCurve = static_cast<const AdobeToneCurve&> (customToneCurve1);
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode == ToneCurveParams::TC_MODE_SATANDVALBLENDING) { // apply the curve on the saturation and value channels
} else if (curveMode == ToneCurveParams::TcMode::SATANDVALBLENDING) { // apply the curve on the saturation and value channels
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const SatAndValueBlendingToneCurve& userToneCurve = static_cast<const SatAndValueBlendingToneCurve&> (customToneCurve1);
@ -3645,7 +3645,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode == ToneCurveParams::TC_MODE_WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
} else if (curveMode == ToneCurveParams::TcMode::WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
const WeightedStdToneCurve& userToneCurve = static_cast<const WeightedStdToneCurve&> (customToneCurve1);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
@ -3656,7 +3656,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode == ToneCurveParams::TC_MODE_LUMINANCE) { // apply the curve to the luminance channel
} else if (curveMode == ToneCurveParams::TcMode::LUMINANCE) { // apply the curve to the luminance channel
const LuminanceToneCurve& userToneCurve = static_cast<const LuminanceToneCurve&> (customToneCurve1);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
@ -3667,7 +3667,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode == ToneCurveParams::TC_MODE_PERCEPTUAL) { // apply curve while keeping color appearance constant
} else if (curveMode == ToneCurveParams::TcMode::PERCEPTUAL) { // apply curve while keeping color appearance constant
const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve1);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
@ -3692,28 +3692,28 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
}
if (hasToneCurve2) {
if (curveMode2 == ToneCurveParams::TC_MODE_STD) { // Standard
if (curveMode2 == ToneCurveParams::TcMode::STD) { // Standard
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const StandardToneCurve& userToneCurve = static_cast<const StandardToneCurve&> (customToneCurve2);
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode2 == ToneCurveParams::TC_MODE_FILMLIKE) { // Adobe like
} else if (curveMode2 == ToneCurveParams::TcMode::FILMLIKE) { // Adobe like
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const AdobeToneCurve& userToneCurve = static_cast<const AdobeToneCurve&> (customToneCurve2);
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode2 == ToneCurveParams::TC_MODE_SATANDVALBLENDING) { // apply the curve on the saturation and value channels
} else if (curveMode2 == ToneCurveParams::TcMode::SATANDVALBLENDING) { // apply the curve on the saturation and value channels
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const SatAndValueBlendingToneCurve& userToneCurve = static_cast<const SatAndValueBlendingToneCurve&> (customToneCurve2);
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode2 == ToneCurveParams::TC_MODE_WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
} else if (curveMode2 == ToneCurveParams::TcMode::WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
const WeightedStdToneCurve& userToneCurve = static_cast<const WeightedStdToneCurve&> (customToneCurve2);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
@ -3721,7 +3721,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode2 == ToneCurveParams::TC_MODE_LUMINANCE) { // apply the curve to the luminance channel
} else if (curveMode2 == ToneCurveParams::TcMode::LUMINANCE) { // apply the curve to the luminance channel
const LuminanceToneCurve& userToneCurve = static_cast<const LuminanceToneCurve&> (customToneCurve2);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
@ -3729,7 +3729,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
userToneCurve.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (curveMode2 == ToneCurveParams::TC_MODE_PERCEPTUAL) { // apply curve while keeping color appearance constant
} else if (curveMode2 == ToneCurveParams::TcMode::PERCEPTUAL) { // apply curve while keeping color appearance constant
const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve2);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
@ -4192,21 +4192,21 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
//black and white
if (blackwhite) {
if (hasToneCurvebw1) {
if (beforeCurveMode == BlackWhiteParams::TC_MODE_STD_BW) { // Standard
if (beforeCurveMode == BlackWhiteParams::TcMode::STD_BW) { // Standard
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const StandardToneCurve& userToneCurvebw = static_cast<const StandardToneCurve&> (customToneCurvebw1);
userToneCurvebw.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (beforeCurveMode == BlackWhiteParams::TC_MODE_FILMLIKE_BW) { // Adobe like
} else if (beforeCurveMode == BlackWhiteParams::TcMode::FILMLIKE_BW) { // Adobe like
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const AdobeToneCurve& userToneCurvebw = static_cast<const AdobeToneCurve&> (customToneCurvebw1);
userToneCurvebw.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (beforeCurveMode == BlackWhiteParams::TC_MODE_SATANDVALBLENDING_BW) { // apply the curve on the saturation and value channels
} else if (beforeCurveMode == BlackWhiteParams::TcMode::SATANDVALBLENDING_BW) { // apply the curve on the saturation and value channels
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const SatAndValueBlendingToneCurve& userToneCurvebw = static_cast<const SatAndValueBlendingToneCurve&> (customToneCurvebw1);
@ -4216,7 +4216,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
userToneCurvebw.Apply (rtemp[ti * TS + tj], gtemp[ti * TS + tj], btemp[ti * TS + tj]);
}
}
} else if (beforeCurveMode == BlackWhiteParams::TC_MODE_WEIGHTEDSTD_BW) { // apply the curve to the rgb channels, weighted
} else if (beforeCurveMode == BlackWhiteParams::TcMode::WEIGHTEDSTD_BW) { // apply the curve to the rgb channels, weighted
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
const WeightedStdToneCurve& userToneCurvebw = static_cast<const WeightedStdToneCurve&> (customToneCurvebw1);
@ -4652,7 +4652,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
if (hasToneCurvebw2) {
if (afterCurveMode == BlackWhiteParams::TC_MODE_STD_BW) { // Standard
if (afterCurveMode == BlackWhiteParams::TcMode::STD_BW) { // Standard
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 5)
#endif
@ -4663,7 +4663,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
userToneCurve.Apply (tmpImage->r (i, j), tmpImage->g (i, j), tmpImage->b (i, j));
}
}
} else if (afterCurveMode == BlackWhiteParams::TC_MODE_WEIGHTEDSTD_BW) { // apply the curve to the rgb channels, weighted
} else if (afterCurveMode == BlackWhiteParams::TcMode::WEIGHTEDSTD_BW) { // apply the curve to the rgb channels, weighted
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic, 5)
#endif
@ -6488,9 +6488,9 @@ void ImProcFunctions::badpixlab (LabImage* lab, double rad, int thr, int mode, f
void ImProcFunctions::dirpyrequalizer (LabImage* lab, int scale)
{
if (params->dirpyrequalizer.enabled && lab->W >= 8 && lab->H >= 8) {
float b_l = static_cast<float> (params->dirpyrequalizer.hueskin.value[0]) / 100.0f;
float t_l = static_cast<float> (params->dirpyrequalizer.hueskin.value[1]) / 100.0f;
float t_r = static_cast<float> (params->dirpyrequalizer.hueskin.value[3]) / 100.0f;
float b_l = static_cast<float> (params->dirpyrequalizer.hueskin.getBottomLeft()) / 100.0f;
float t_l = static_cast<float> (params->dirpyrequalizer.hueskin.getTopLeft()) / 100.0f;
float t_r = static_cast<float> (params->dirpyrequalizer.hueskin.getTopRight()) / 100.0f;
// if (params->dirpyrequalizer.algo=="FI") choice=0;
// else if(params->dirpyrequalizer.algo=="LA") choice=1;
float artifact = (float) settings->artifact_cbdl;

4
rtengine/ipvibrance.cc
View File

@ -126,7 +126,7 @@ void ImProcFunctions::vibrance (LabImage* lab)
const float chromaPastel = float (params->vibrance.pastels) / 100.0f;
const float chromaSatur = float (params->vibrance.saturated) / 100.0f;
const float p00 = 0.07f;
const float limitpastelsatur = (static_cast<float> (params->vibrance.psthreshold.value[ThresholdSelector::TS_TOPLEFT]) / 100.0f) * (1.0f - p00) + p00;
const float limitpastelsatur = (static_cast<float>(params->vibrance.psthreshold.getTopLeft()) / 100.0f) * (1.0f - p00) + p00;
const float maxdp = (limitpastelsatur - p00) / 4.0f;
const float maxds = (1.0 - limitpastelsatur) / 4.0f;
const float p0 = p00 + maxdp;
@ -135,7 +135,7 @@ void ImProcFunctions::vibrance (LabImage* lab)
const float s0 = limitpastelsatur + maxds;
const float s1 = limitpastelsatur + 2.0f * maxds;
const float s2 = limitpastelsatur + 3.0f * maxds;
const float transitionweighting = static_cast<float> (params->vibrance.psthreshold.value[ThresholdSelector::TS_BOTTOMLEFT]) / 100.0f;
const float transitionweighting = static_cast<float>(params->vibrance.psthreshold.getBottomLeft()) / 100.0f;
float chromamean = 0.0f;
if (chromaPastel != chromaSatur) {

72
rtengine/ipwavelet.cc
View File

@ -432,56 +432,56 @@ SSEFUNCTION void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int
cp.thH = float(waparams.thrH);
cp.sky = waparams.sky;
//skin
cp.b_l = static_cast<float>(params->wavelet.hueskin.value[0]) / 100.0f;
cp.t_l = static_cast<float>(params->wavelet.hueskin.value[1]) / 100.0f;
cp.b_r = static_cast<float>(params->wavelet.hueskin.value[2]) / 100.0f;
cp.t_r = static_cast<float>(params->wavelet.hueskin.value[3]) / 100.0f;
cp.b_l = static_cast<float>(params->wavelet.hueskin.getBottomLeft()) / 100.0f;
cp.t_l = static_cast<float>(params->wavelet.hueskin.getTopLeft()) / 100.0f;
cp.b_r = static_cast<float>(params->wavelet.hueskin.getBottomRight()) / 100.0f;
cp.t_r = static_cast<float>(params->wavelet.hueskin.getTopRight()) / 100.0f;
cp.b_ly = static_cast<float>(params->wavelet.hueskin2.value[0]) / 100.0f;
cp.t_ly = static_cast<float>(params->wavelet.hueskin2.value[1]) / 100.0f;
cp.b_ry = static_cast<float>(params->wavelet.hueskin2.value[2]) / 100.0f;
cp.t_ry = static_cast<float>(params->wavelet.hueskin2.value[3]) / 100.0f;
cp.b_ly = static_cast<float>(params->wavelet.hueskin2.getBottomLeft()) / 100.0f;
cp.t_ly = static_cast<float>(params->wavelet.hueskin2.getTopLeft()) / 100.0f;
cp.b_ry = static_cast<float>(params->wavelet.hueskin2.getBottomRight()) / 100.0f;
cp.t_ry = static_cast<float>(params->wavelet.hueskin2.getTopRight()) / 100.0f;
cp.numlevH = params->wavelet.threshold;
//shadows
cp.b_lsl = static_cast<float>(params->wavelet.bllev.value[0]);
cp.t_lsl = static_cast<float>(params->wavelet.bllev.value[1]);
cp.b_rsl = static_cast<float>(params->wavelet.bllev.value[2]);
cp.t_rsl = static_cast<float>(params->wavelet.bllev.value[3]);
cp.b_lsl = static_cast<float>(params->wavelet.bllev.getBottomLeft());
cp.t_lsl = static_cast<float>(params->wavelet.bllev.getTopLeft());
cp.b_rsl = static_cast<float>(params->wavelet.bllev.getBottomRight());
cp.t_rsl = static_cast<float>(params->wavelet.bllev.getTopRight());
cp.numlevS = params->wavelet.threshold2;
int maxlevS = 9 - cp.numlevH;
cp.numlevS = MIN(cp.numlevS, maxlevS);
//printf("levHigh=%d levShad=%d\n",cp.numlevH,cp.numlevS);
//highlight
cp.b_lhl = static_cast<float>(params->wavelet.hllev.value[0]);
cp.t_lhl = static_cast<float>(params->wavelet.hllev.value[1]);
cp.b_rhl = static_cast<float>(params->wavelet.hllev.value[2]);
cp.t_rhl = static_cast<float>(params->wavelet.hllev.value[3]);
cp.b_lhl = static_cast<float>(params->wavelet.hllev.getBottomLeft());
cp.t_lhl = static_cast<float>(params->wavelet.hllev.getTopLeft());
cp.b_rhl = static_cast<float>(params->wavelet.hllev.getBottomRight());
cp.t_rhl = static_cast<float>(params->wavelet.hllev.getTopRight());
//printf("BL=%f TL=%f BR=%f TR=%f\n",cp.b_lhl,cp.t_lhl,cp.b_rhl,cp.t_rhl);
//pastel
cp.b_lpast = static_cast<float>(params->wavelet.pastlev.value[0]);
cp.t_lpast = static_cast<float>(params->wavelet.pastlev.value[1]);
cp.b_rpast = static_cast<float>(params->wavelet.pastlev.value[2]);
cp.t_rpast = static_cast<float>(params->wavelet.pastlev.value[3]);
cp.b_lpast = static_cast<float>(params->wavelet.pastlev.getBottomLeft());
cp.t_lpast = static_cast<float>(params->wavelet.pastlev.getTopLeft());
cp.b_rpast = static_cast<float>(params->wavelet.pastlev.getBottomRight());
cp.t_rpast = static_cast<float>(params->wavelet.pastlev.getTopRight());
//saturated
cp.b_lsat = static_cast<float>(params->wavelet.satlev.value[0]);
cp.t_lsat = static_cast<float>(params->wavelet.satlev.value[1]);
cp.b_rsat = static_cast<float>(params->wavelet.satlev.value[2]);
cp.t_rsat = static_cast<float>(params->wavelet.satlev.value[3]);
cp.b_lsat = static_cast<float>(params->wavelet.satlev.getBottomLeft());
cp.t_lsat = static_cast<float>(params->wavelet.satlev.getTopLeft());
cp.b_rsat = static_cast<float>(params->wavelet.satlev.getBottomRight());
cp.t_rsat = static_cast<float>(params->wavelet.satlev.getTopRight());
//edge local contrast
cp.edg_low = static_cast<float>(params->wavelet.edgcont.value[0]);
cp.edg_mean = static_cast<float>(params->wavelet.edgcont.value[1]);
cp.edg_max = static_cast<float>(params->wavelet.edgcont.value[2]);
cp.edg_sd = static_cast<float>(params->wavelet.edgcont.value[3]);
cp.edg_low = static_cast<float>(params->wavelet.edgcont.getBottomLeft());
cp.edg_mean = static_cast<float>(params->wavelet.edgcont.getTopLeft());
cp.edg_max = static_cast<float>(params->wavelet.edgcont.getBottomRight());
cp.edg_sd = static_cast<float>(params->wavelet.edgcont.getTopRight());
//level noise
cp.lev0s = static_cast<float>(params->wavelet.level0noise.value[0]);
cp.lev0n = static_cast<float>(params->wavelet.level0noise.value[1]);
cp.lev1s = static_cast<float>(params->wavelet.level1noise.value[0]);
cp.lev1n = static_cast<float>(params->wavelet.level1noise.value[1]);
cp.lev2s = static_cast<float>(params->wavelet.level2noise.value[0]);
cp.lev2n = static_cast<float>(params->wavelet.level2noise.value[1]);
cp.lev3s = static_cast<float>(params->wavelet.level3noise.value[0]);
cp.lev3n = static_cast<float>(params->wavelet.level3noise.value[1]);
cp.lev0s = static_cast<float>(params->wavelet.level0noise.getBottom());
cp.lev0n = static_cast<float>(params->wavelet.level0noise.getTop());
cp.lev1s = static_cast<float>(params->wavelet.level1noise.getBottom());
cp.lev1n = static_cast<float>(params->wavelet.level1noise.getTop());
cp.lev2s = static_cast<float>(params->wavelet.level2noise.getBottom());
cp.lev2n = static_cast<float>(params->wavelet.level2noise.getTop());
cp.lev3s = static_cast<float>(params->wavelet.level3noise.getBottom());
cp.lev3n = static_cast<float>(params->wavelet.level3noise.getTop());
cp.detectedge = params->wavelet.medianlev;
//printf("low=%f mean=%f sd=%f max=%f\n",cp.edg_low,cp.edg_mean,cp.edg_sd,cp.edg_max);

6
rtengine/pixelshift.cc
View File

@ -311,11 +311,11 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA
bayerParams.pixelShiftAutomatic = true;
if(bayerParams.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::Automatic) {
if(bayerParams.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::PSMotionCorrectionMethod::AUTO) {
bool pixelShiftEqualBright = bayerParams.pixelShiftEqualBright;
bayerParams.setPixelShiftDefaults();
bayerParams.pixelShiftEqualBright = pixelShiftEqualBright;
} else if(bayerParams.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::Off) {
} else if(bayerParams.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::PSMotionCorrectionMethod::OFF) {
bayerParams.pixelShiftAutomatic = false;
bayerParams.pixelShiftShowMotion = false;
}
@ -506,7 +506,7 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA
static const float ePerIsoK70 = 0.5f;
if(plistener) {
plistener->setProgressStr(Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::pixelshift]));
plistener->setProgressStr(Glib::ustring::compose(M("TP_RAW_DMETHOD_PROGRESSBAR"), RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::PIXELSHIFT)));
plistener->setProgress(0.0);
}

4
rtengine/previewimage.cc
View File

@ -108,10 +108,10 @@ PreviewImage::PreviewImage (const Glib::ustring &fname, const Glib::ustring &ext
rawImage.getFullSize (fw, fh, TR_NONE);
PreviewProps pp (0, 0, fw, fh, 1);
params.icm.input = Glib::ustring("(embedded)");
params.raw.bayersensor.method = RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::fast];
params.raw.bayersensor.method = RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::FAST);
params.raw.deadPixelFilter = false;
params.raw.ca_autocorrect = false;
params.raw.xtranssensor.method = RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::fast];
params.raw.xtranssensor.method = RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::FAST);
rawImage.preprocess(params.raw, params.lensProf, params.coarse);
rawImage.demosaic(params.raw);
Imagefloat image(fw, fh);

10948
rtengine/procparams.cc
View File

File diff suppressed because it is too large Load Diff

1133
rtengine/procparams.h
View File

File diff suppressed because it is too large Load Diff

50
rtengine/rawimagesource.cc
View File

@ -650,8 +650,8 @@ void RawImageSource::getImage (const ColorTemp &ctemp, int tran, Imagefloat* ima
const float new_pre_mul[4] = { ri->get_pre_mul(0) / rm, ri->get_pre_mul(1) / gm, ri->get_pre_mul(2) / bm, ri->get_pre_mul(3) / gm };
float new_scale_mul[4];
bool isMono = (ri->getSensorType() == ST_FUJI_XTRANS && raw.xtranssensor.method == RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::mono])
|| (ri->getSensorType() == ST_BAYER && raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::mono]);
bool isMono = (ri->getSensorType() == ST_FUJI_XTRANS && raw.xtranssensor.method == RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::MONO))
|| (ri->getSensorType() == ST_BAYER && raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::MONO));
float gain = calculate_scale_mul(new_scale_mul, new_pre_mul, c_white, cblacksom, isMono, ri->get_colors());
rm = new_scale_mul[0] / scale_mul[0] * gain;
gm = new_scale_mul[1] / scale_mul[1] * gain;
@ -1921,7 +1921,7 @@ void RawImageSource::preprocess (const RAWParams &raw, const LensProfParams &le
}
// check if it is an olympus E camera or green equilibration is enabled. If yes, compute G channel pre-compensation factors
if ( ri->getSensorType() == ST_BAYER && (raw.bayersensor.greenthresh || (((idata->getMake().size() >= 7 && idata->getMake().substr(0, 7) == "OLYMPUS" && idata->getModel()[0] == 'E') || (idata->getMake().size() >= 9 && idata->getMake().substr(0, 9) == "Panasonic")) && raw.bayersensor.method != RAWParams::BayerSensor::methodstring[ RAWParams::BayerSensor::vng4])) ) {
if ( ri->getSensorType() == ST_BAYER && (raw.bayersensor.greenthresh || (((idata->getMake().size() >= 7 && idata->getMake().substr(0, 7) == "OLYMPUS" && idata->getModel()[0] == 'E') || (idata->getMake().size() >= 9 && idata->getMake().substr(0, 9) == "Panasonic")) && raw.bayersensor.method != RAWParams::BayerSensor::getMethodString( RAWParams::BayerSensor::Method::VNG4))) ) {
// global correction
if(numFrames == 4) {
for(int i = 0; i < 4; ++i) {
@ -2027,27 +2027,27 @@ void RawImageSource::demosaic(const RAWParams &raw)
t1.set();
if (ri->getSensorType() == ST_BAYER) {
if ( raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::hphd] ) {
if ( raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::HPHD) ) {
hphd_demosaic ();
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::vng4] ) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::VNG4) ) {
vng4_demosaic ();
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::ahd] ) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AHD) ) {
ahd_demosaic ();
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::amaze] ) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::AMAZE) ) {
amaze_demosaic_RT (0, 0, W, H, rawData, red, green, blue);
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::pixelshift] ) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::PIXELSHIFT) ) {
pixelshift(0, 0, W, H, raw.bayersensor, currFrame, ri->get_model(), raw.expos);
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::dcb] ) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::DCB) ) {
dcb_demosaic(raw.bayersensor.dcb_iterations, raw.bayersensor.dcb_enhance);
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::eahd]) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::EAHD)) {
eahd_demosaic ();
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::igv]) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::IGV)) {
igv_interpolate(W, H);
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::lmmse]) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::LMMSE)) {
lmmse_interpolate_omp(W, H, rawData, red, green, blue, raw.bayersensor.lmmse_iterations);
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::fast] ) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::FAST) ) {
fast_demosaic();
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::mono] ) {
} else if (raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::MONO) ) {
nodemosaic(true);
} else {
nodemosaic(false);
@ -2056,13 +2056,13 @@ void RawImageSource::demosaic(const RAWParams &raw)
//if (raw.all_enhance) refinement_lassus();
} else if (ri->getSensorType() == ST_FUJI_XTRANS) {
if (raw.xtranssensor.method == RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::fast] ) {
if (raw.xtranssensor.method == RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::FAST) ) {
fast_xtrans_interpolate();
} else if (raw.xtranssensor.method == RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::onePass]) {
} else if (raw.xtranssensor.method == RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::ONE_PASS)) {
xtrans_interpolate(1, false);
} else if (raw.xtranssensor.method == RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::threePass] ) {
} else if (raw.xtranssensor.method == RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::THREE_PASS) ) {
xtrans_interpolate(3, true);
} else if(raw.xtranssensor.method == RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::mono] ) {
} else if(raw.xtranssensor.method == RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::MONO) ) {
nodemosaic(true);
} else {
nodemosaic(false);
@ -2803,14 +2803,14 @@ void RawImageSource::processFlatField(const RAWParams &raw, RawImage *riFlatFile
BS += BS & 1;
//function call to cfabloxblur
if (raw.ff_BlurType == RAWParams::ff_BlurTypestring[RAWParams::v_ff]) {
if (raw.ff_BlurType == RAWParams::getFlatFieldBlurTypeString(RAWParams::FlatFieldBlurType::V)) {
cfaboxblur(riFlatFile, cfablur, 2 * BS, 0);
} else if (raw.ff_BlurType == RAWParams::ff_BlurTypestring[RAWParams::h_ff]) {
} else if (raw.ff_BlurType == RAWParams::getFlatFieldBlurTypeString(RAWParams::FlatFieldBlurType::H)) {
cfaboxblur(riFlatFile, cfablur, 0, 2 * BS);
} else if (raw.ff_BlurType == RAWParams::ff_BlurTypestring[RAWParams::vh_ff]) {
} else if (raw.ff_BlurType == RAWParams::getFlatFieldBlurTypeString(RAWParams::FlatFieldBlurType::VH)) {
//slightly more complicated blur if trying to correct both vertical and horizontal anomalies
cfaboxblur(riFlatFile, cfablur, BS, BS); //first do area blur to correct vignette
} else { //(raw.ff_BlurType == RAWParams::ff_BlurTypestring[RAWParams::area_ff])
} else { //(raw.ff_BlurType == RAWParams::getFlatFieldBlurTypeString(RAWParams::area_ff))
cfaboxblur(riFlatFile, cfablur, BS, BS);
}
@ -3008,7 +3008,7 @@ void RawImageSource::processFlatField(const RAWParams &raw, RawImage *riFlatFile
}
}
if (raw.ff_BlurType == RAWParams::ff_BlurTypestring[RAWParams::vh_ff]) {
if (raw.ff_BlurType == RAWParams::getFlatFieldBlurTypeString(RAWParams::FlatFieldBlurType::VH)) {
float *cfablur1 = (float (*)) malloc (H * W * sizeof * cfablur1);
float *cfablur2 = (float (*)) malloc (H * W * sizeof * cfablur2);
//slightly more complicated blur if trying to correct both vertical and horizontal anomalies
@ -3429,7 +3429,7 @@ void RawImageSource::scaleColors(int winx, int winy, int winw, int winh, const R
black_lev[2] = raw.bayersensor.black2; //B
black_lev[3] = raw.bayersensor.black3; //G2
isMono = RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::mono] == raw.bayersensor.method;
isMono = RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::MONO) == raw.bayersensor.method;
} else if (getSensorType() == ST_FUJI_XTRANS) {
black_lev[0] = raw.xtranssensor.blackred; //R
@ -3437,7 +3437,7 @@ void RawImageSource::scaleColors(int winx, int winy, int winw, int winh, const R
black_lev[2] = raw.xtranssensor.blackblue; //B
black_lev[3] = raw.xtranssensor.blackgreen; //G2 (set, only used with a Bayer filter)
isMono = RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::mono] == raw.xtranssensor.method;
isMono = RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::MONO) == raw.xtranssensor.method;
}
for(int i = 0; i < 4 ; i++) {

12
rtengine/simpleprocess.cc
View File

@ -1475,16 +1475,12 @@ private:
params.defringe.radius);
adjust_radius (defaultparams.sh.radius, scale_factor, params.sh.radius);
if (params.raw.xtranssensor.method ==
procparams::RAWParams::XTransSensor::methodstring[
procparams::RAWParams::XTransSensor::threePass]) {
params.raw.xtranssensor.method =
procparams::RAWParams::XTransSensor::methodstring[
procparams::RAWParams::XTransSensor::onePass];
if (params.raw.xtranssensor.method == procparams::RAWParams::XTransSensor::getMethodString(procparams::RAWParams::XTransSensor::Method::THREE_PASS)) {
params.raw.xtranssensor.method = procparams::RAWParams::XTransSensor::getMethodString(procparams::RAWParams::XTransSensor::Method::ONE_PASS);
}
if (params.raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::pixelshift]) {
params.raw.bayersensor.method = procparams::RAWParams::BayerSensor::methodstring[params.raw.bayersensor.pixelShiftLmmse ? procparams::RAWParams::BayerSensor::lmmse : procparams::RAWParams::BayerSensor::amaze];
if (params.raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::PIXELSHIFT)) {
params.raw.bayersensor.method = procparams::RAWParams::BayerSensor::getMethodString(params.raw.bayersensor.pixelShiftLmmse ? procparams::RAWParams::BayerSensor::Method::LMMSE : procparams::RAWParams::BayerSensor::Method::AMAZE);
}
}

2
rtengine/utils.h
View File

@ -38,7 +38,7 @@ void hflip(unsigned char* img, int w, int h);
void vflip(unsigned char* img, int w, int h);
template<typename ENUM>
typename std::underlying_type<ENUM>::type toUnderlying(ENUM value)
constexpr typename std::underlying_type<ENUM>::type toUnderlying(ENUM value)
{
return static_cast<typename std::underlying_type<ENUM>::type>(value);
}

59
rtgui/bayerprocess.cc
View File

@ -29,8 +29,8 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
hb1->pack_start (*Gtk::manage (new Gtk::Label ( M("TP_RAW_DMETHOD") + ": ")), Gtk::PACK_SHRINK, 4);
method = Gtk::manage (new MyComboBoxText ());
for( size_t i = 0; i < procparams::RAWParams::BayerSensor::numMethods; i++) {
method->append(M("TP_RAW_" + Glib::ustring(procparams::RAWParams::BayerSensor::methodstring[i]).uppercase()));
for(const auto method_string : procparams::RAWParams::BayerSensor::getMethodStrings()) {
method->append(M("TP_RAW_" + Glib::ustring(method_string).uppercase()));
}
method->set_active(0);
@ -112,7 +112,7 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
pixelShiftMotionMethod->append(M("TP_RAW_PIXELSHIFTMM_OFF"));
pixelShiftMotionMethod->append(M("TP_RAW_PIXELSHIFTMM_AUTO"));
pixelShiftMotionMethod->append(M("TP_RAW_PIXELSHIFTMM_CUSTOM"));
pixelShiftMotionMethod->set_active(RAWParams::BayerSensor::ePSMotionCorrectionMethod::Automatic);
pixelShiftMotionMethod->set_active(toUnderlying(RAWParams::BayerSensor::PSMotionCorrectionMethod::AUTO));
pixelShiftMotionMethod->show();
hb3->pack_start(*pixelShiftMotionMethod);
pixelShiftFrame->pack_start(*hb3);
@ -347,11 +347,11 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
pixelShiftMotionCorrection->block (true);
#endif
method->set_active(procparams::RAWParams::BayerSensor::numMethods);
method->set_active(std::numeric_limits<int>::max());
imageNumber->set_active(pp->raw.bayersensor.imageNum);
for( size_t i = 0; i < procparams::RAWParams::BayerSensor::numMethods; i++) {
if( pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[i]) {
for (size_t i = 0; i < procparams::RAWParams::BayerSensor::getMethodStrings().size(); ++i) {
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodStrings()[i]) {
method->set_active(i);
oldMethod = i;
break;
@ -452,7 +452,7 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
#endif
if(!pedited->raw.bayersensor.method) {
method->set_active(procparams::RAWParams::BayerSensor::numMethods); // No name
method->set_active(std::numeric_limits<int>::max()); // No name
}
if(!pedited->raw.bayersensor.imageNum) {
imageNumber->set_active_text(M("GENERAL_UNCHANGED"));
@ -468,21 +468,21 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
}
if (!batchMode) {
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::dcb] ||
method->get_active_row_number() == procparams::RAWParams::BayerSensor::numMethods) {
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::DCB) ||
method->get_active_row_number() == std::numeric_limits<int>::max()) {
dcbOptions->show();
} else {
dcbOptions->hide();
}
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::lmmse] ||
method->get_active_row_number() == procparams::RAWParams::BayerSensor::numMethods) {
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::LMMSE) ||
method->get_active_row_number() == std::numeric_limits<int>::max()) {
lmmseOptions->show();
} else {
lmmseOptions->hide();
}
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::pixelshift] ||
method->get_active_row_number() == procparams::RAWParams::BayerSensor::numMethods) {
if(pp->raw.bayersensor.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::Custom) {
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::PIXELSHIFT) ||
method->get_active_row_number() == std::numeric_limits<int>::max()) {
if(pp->raw.bayersensor.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::PSMotionCorrectionMethod::CUSTOM) {
pixelShiftOptions->show();
} else {
pixelShiftOptions->hide();
@ -493,9 +493,9 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
}
// Flase color suppression is applied to all demozaicing method, so don't hide anything
/*if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::eahd] ||
pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::hphd] ||
pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::vng4])
/*if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::EAHD) ||
pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::HPHD) ||
pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::getMethodString(procparams::RAWParams::BayerSensor::Method::VNG4))
ccSteps->show();
else
ccSteps->hide();*/
@ -520,7 +520,7 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
pp->raw.bayersensor.dcb_enhance = dcbEnhance->getLastActive ();
//pp->raw.bayersensor.all_enhance = allEnhance->getLastActive ();
pp->raw.bayersensor.lmmse_iterations = lmmseIterations->getIntValue();
pp->raw.bayersensor.pixelShiftMotionCorrectionMethod = (RAWParams::BayerSensor::ePSMotionCorrectionMethod)pixelShiftMotionMethod->get_active_row_number();
pp->raw.bayersensor.pixelShiftMotionCorrectionMethod = (RAWParams::BayerSensor::PSMotionCorrectionMethod)pixelShiftMotionMethod->get_active_row_number();
pp->raw.bayersensor.pixelShiftEperIso = pixelShiftEperIso->getValue();
pp->raw.bayersensor.pixelShiftSigma = pixelShiftSigma->getValue();
pp->raw.bayersensor.pixelShiftShowMotion = pixelShiftShowMotion->getLastActive ();
@ -554,8 +554,8 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
#endif
int currentRow = method->get_active_row_number();
if( currentRow >= 0 && currentRow < procparams::RAWParams::BayerSensor::numMethods) {
pp->raw.bayersensor.method = procparams::RAWParams::BayerSensor::methodstring[currentRow];
if( currentRow >= 0 && currentRow < std::numeric_limits<int>::max()) {
pp->raw.bayersensor.method = procparams::RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method(currentRow));
}
currentRow = imageNumber->get_active_row_number();
@ -566,7 +566,7 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
if (pedited) {
pedited->raw.bayersensor.ccSteps = ccSteps->getEditedState ();
pedited->raw.bayersensor.method = method->get_active_row_number() != procparams::RAWParams::BayerSensor::numMethods;
pedited->raw.bayersensor.method = method->get_active_row_number() != std::numeric_limits<int>::max();
pedited->raw.bayersensor.imageNum = imageNumber->get_active_text() != M("GENERAL_UNCHANGED");
pedited->raw.bayersensor.dcbIterations = dcbIterations->getEditedState ();
pedited->raw.bayersensor.dcbEnhance = !dcbEnhance->get_inconsistent();
@ -610,7 +610,7 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
void BayerProcess::setBatchMode(bool batchMode)
{
method->append (M("GENERAL_UNCHANGED"));
method->set_active(procparams::RAWParams::BayerSensor::numMethods); // No name
method->set_active(std::numeric_limits<int>::max()); // No name
#ifdef PIXELSHIFTDEV
pixelShiftMotionCorrection->append (M("GENERAL_UNCHANGED"));
pixelShiftMotionCorrection->set_active_text (M("GENERAL_UNCHANGED"));
@ -750,22 +750,23 @@ void BayerProcess::psMotionCorrectionChanged ()
void BayerProcess::methodChanged ()
{
int curSelection = method->get_active_row_number();
const int curSelection = method->get_active_row_number();
const RAWParams::BayerSensor::Method method = RAWParams::BayerSensor::Method(curSelection);
if (!batchMode) {
if ( curSelection == procparams::RAWParams::BayerSensor::dcb) {
if (method == procparams::RAWParams::BayerSensor::Method::DCB) {
dcbOptions->show();
} else {
dcbOptions->hide();
}
if ( curSelection == procparams::RAWParams::BayerSensor::lmmse) {
if (method == procparams::RAWParams::BayerSensor::Method::LMMSE) {
lmmseOptions->show();
} else {
lmmseOptions->hide();
}
if ( curSelection == procparams::RAWParams::BayerSensor::pixelshift) {
if (method == procparams::RAWParams::BayerSensor::Method::PIXELSHIFT) {
if(pixelShiftMotionMethod->get_active_row_number() == 2) {
pixelShiftOptions->show();
} else {
@ -780,10 +781,10 @@ void BayerProcess::methodChanged ()
Glib::ustring methodName = "";
bool ppreq = false;
if( curSelection >= 0 && curSelection < procparams::RAWParams::BayerSensor::numMethods) {
methodName = procparams::RAWParams::BayerSensor::methodstring[curSelection];
if (curSelection >= 0 && curSelection < std::numeric_limits<int>::max()) {
methodName = procparams::RAWParams::BayerSensor::getMethodString(method);
if (curSelection == procparams::RAWParams::BayerSensor::mono || oldMethod == procparams::RAWParams::BayerSensor::mono) {
if (method == procparams::RAWParams::BayerSensor::Method::MONO || RAWParams::BayerSensor::Method(oldMethod) == procparams::RAWParams::BayerSensor::Method::MONO) {
ppreq = true;
}
}

14
rtgui/blackwhite.cc
View File

@ -500,7 +500,7 @@ void BlackWhite::read (const ProcParams* pp, const ParamsEdited* pedited)
mixerPurple->setValue (pp->blackwhite.mixerPurple);
luminanceCurve->setCurve (pp->blackwhite.luminanceCurve);
beforeCurve->setCurve (pp->blackwhite.beforeCurve);
beforeCurveMode->set_active(pp->blackwhite.beforeCurveMode);
beforeCurveMode->set_active(toUnderlying(pp->blackwhite.beforeCurveMode));
afterCurve->setCurve (pp->blackwhite.afterCurve);
// afterCurveMode->set_active(pp->blackwhite.afterCurveMode);
@ -583,18 +583,18 @@ void BlackWhite::write (ProcParams* pp, ParamsEdited* pedited)
int tcMode = beforeCurveMode->get_active_row_number();
if (tcMode == 0) {
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TC_MODE_STD_BW;
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::STD_BW;
} else if (tcMode == 1) {
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TC_MODE_WEIGHTEDSTD_BW;
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::WEIGHTEDSTD_BW;
} else if (tcMode == 2) {
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TC_MODE_FILMLIKE_BW;
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::FILMLIKE_BW;
} else if (tcMode == 3) {
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TC_MODE_SATANDVALBLENDING_BW;
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::SATANDVALBLENDING_BW;
}
// tcMode = afterCurveMode->get_active_row_number();
// if (tcMode == 0) pp->blackwhite.afterCurveMode = BlackWhiteParams::TC_MODE_STD_BW;
// else if (tcMode == 1) pp->blackwhite.afterCurveMode = BlackWhiteParams::TC_MODE_WEIGHTEDSTD;
// if (tcMode == 0) pp->blackwhite.afterCurveMode = BlackWhiteParams::TCMode::STD_BW;
// else if (tcMode == 1) pp->blackwhite.afterCurveMode = BlackWhiteParams::TCMode::WEIGHTEDSTD;
if (pedited) {
pedited->blackwhite.enabled = !get_inconsistent();

20
rtgui/colorappearance.cc
View File

@ -799,9 +799,9 @@ void ColorAppearance::read (const ProcParams* pp, const ParamsEdited* pedited)
shape->setCurve (pp->colorappearance.curve);
shape2->setCurve (pp->colorappearance.curve2);
shape3->setCurve (pp->colorappearance.curve3);
toneCurveMode->set_active (pp->colorappearance.curveMode);
toneCurveMode2->set_active (pp->colorappearance.curveMode2);
toneCurveMode3->set_active (pp->colorappearance.curveMode3);
toneCurveMode->set_active (toUnderlying(pp->colorappearance.curveMode));
toneCurveMode2->set_active (toUnderlying(pp->colorappearance.curveMode2));
toneCurveMode3->set_active (toUnderlying(pp->colorappearance.curveMode3));
curveMode3Changed(); // This will set the correct sensitive state of depending Adjusters
if (pedited) {
@ -1044,27 +1044,27 @@ void ColorAppearance::write (ProcParams* pp, ParamsEdited* pedited)
int tcMode = toneCurveMode->get_active_row_number();
if (tcMode == 0) {
pp->colorappearance.curveMode = ColorAppearanceParams::TC_MODE_LIGHT;
pp->colorappearance.curveMode = ColorAppearanceParams::TcMode::LIGHT;
} else if (tcMode == 1) {
pp->colorappearance.curveMode = ColorAppearanceParams::TC_MODE_BRIGHT;
pp->colorappearance.curveMode = ColorAppearanceParams::TcMode::BRIGHT;
}
tcMode = toneCurveMode2->get_active_row_number();
if (tcMode == 0) {
pp->colorappearance.curveMode2 = ColorAppearanceParams::TC_MODE_LIGHT;
pp->colorappearance.curveMode2 = ColorAppearanceParams::TcMode::LIGHT;
} else if (tcMode == 1) {
pp->colorappearance.curveMode2 = ColorAppearanceParams::TC_MODE_BRIGHT;
pp->colorappearance.curveMode2 = ColorAppearanceParams::TcMode::BRIGHT;
}
int tcMode3 = toneCurveMode3->get_active_row_number();
if (tcMode3 == 0) {
pp->colorappearance.curveMode3 = ColorAppearanceParams::TC_MODE_CHROMA;
pp->colorappearance.curveMode3 = ColorAppearanceParams::CtcMode::CHROMA;
} else if (tcMode3 == 1) {
pp->colorappearance.curveMode3 = ColorAppearanceParams::TC_MODE_SATUR;
pp->colorappearance.curveMode3 = ColorAppearanceParams::CtcMode::SATUR;
} else if (tcMode3 == 2) {
pp->colorappearance.curveMode3 = ColorAppearanceParams::TC_MODE_COLORF;
pp->colorappearance.curveMode3 = ColorAppearanceParams::CtcMode::COLORF;
}
if (pedited) {

15
rtgui/colortoning.cc
View File

@ -54,14 +54,14 @@ ColorToning::ColorToning () : FoldableToolPanel(this, "colortoning", M("TP_COLOR
colorShape->setLeftBarBgGradient(milestones);
const ColorToningParams default_params;
// luminance gradient
milestones.clear();
milestones.push_back( GradientMilestone(0., 0., 0., 0.) );
milestones.push_back( GradientMilestone(1., 1., 1., 1.) );
colorShape->setBottomBarBgGradient(milestones);
std::vector<double> defaultCurve;
rtengine::ColorToningParams::getDefaultColorCurve(defaultCurve);
colorShape->setResetCurve(FCT_MinMaxCPoints, defaultCurve);
colorShape->setResetCurve(FCT_MinMaxCPoints, default_params.colorCurve);
// This will add the reset button at the end of the curveType buttons
colorCurveEditorG->curveListComplete();
@ -88,10 +88,9 @@ ColorToning::ColorToning () : FoldableToolPanel(this, "colortoning", M("TP_COLOR
opacityCurveEditorG = new CurveEditorGroup (options.lastColorToningCurvesDir, M("TP_COLORTONING_OPACITY"));
opacityCurveEditorG->setCurveListener (this);
rtengine::ColorToningParams::getDefaultOpacityCurve(defaultCurve);
opacityShape = static_cast<FlatCurveEditor*>(opacityCurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
opacityShape->setIdentityValue(0.);
opacityShape->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);
opacityShape->setResetCurve(FlatCurveType(default_params.opacityCurve.at(0)), default_params.opacityCurve);
opacityShape->setBottomBarBgGradient(milestones);
// This will add the reset button at the end of the curveType buttons
@ -107,9 +106,8 @@ ColorToning::ColorToning () : FoldableToolPanel(this, "colortoning", M("TP_COLOR
clCurveEditorG = new CurveEditorGroup (options.lastColorToningCurvesDir, M("TP_COLORTONING_CHROMAC"));
clCurveEditorG->setCurveListener (this);
rtengine::ColorToningParams::getDefaultCLCurve(defaultCurve);
clshape = static_cast<DiagonalCurveEditor*>(clCurveEditorG->addCurve(CT_Diagonal, M("TP_COLORTONING_AB"), irg, false));
clshape->setResetCurve(DiagonalCurveType(defaultCurve.at(0)), defaultCurve);
clshape->setResetCurve(DiagonalCurveType(default_params.clcurve.at(0)), default_params.clcurve);
clshape->setTooltip(M("TP_COLORTONING_CURVEEDITOR_CL_TOOLTIP"));
clshape->setLeftBarColorProvider(this, 1);
@ -127,9 +125,8 @@ ColorToning::ColorToning () : FoldableToolPanel(this, "colortoning", M("TP_COLOR
cl2CurveEditorG = new CurveEditorGroup (options.lastColorToningCurvesDir, M("TP_COLORTONING_CHROMAC"));
cl2CurveEditorG->setCurveListener (this);
rtengine::ColorToningParams::getDefaultCL2Curve(defaultCurve);
cl2shape = static_cast<DiagonalCurveEditor*>(cl2CurveEditorG->addCurve(CT_Diagonal, M("TP_COLORTONING_BY"), iby, false));
cl2shape->setResetCurve(DiagonalCurveType(defaultCurve.at(0)), defaultCurve);
cl2shape->setResetCurve(DiagonalCurveType(default_params.cl2curve.at(0)), default_params.cl2curve);
cl2shape->setTooltip(M("TP_COLORTONING_CURVEEDITOR_CL_TOOLTIP"));
cl2shape->setLeftBarColorProvider(this, 1);

2
rtgui/cropwindow.cc
View File

@ -1047,7 +1047,7 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
if(ipc) {
procparams::ProcParams params;
ipc->getParams(&params);
if(params.raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::none] || params.raw.xtranssensor.method == RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::none]) {
if(params.raw.bayersensor.method == RAWParams::BayerSensor::getMethodString(RAWParams::BayerSensor::Method::NONE) || params.raw.xtranssensor.method == RAWParams::XTransSensor::getMethodString(RAWParams::XTransSensor::Method::NONE)) {
ImageSource *isrc = static_cast<ImageSource*>(ipc->getInitialImage());
isrc->getRawValues(mx, my, params.coarse.rotate, rval, gval, bval);
}

4
rtgui/darkframe.cc
View File

@ -77,7 +77,7 @@ void DarkFrame::read(const rtengine::procparams::ProcParams* pp, const ParamsEdi
dfAuto->set_active( pp->raw.df_autoselect );
if(pedited ) {
dfAuto->set_inconsistent(!pedited->raw.dfAuto );
dfAuto->set_inconsistent(!pedited->raw.df_autoselect );
}
if (Glib::file_test (pp->raw.dark_frame, Glib::FILE_TEST_EXISTS)) {
@ -152,7 +152,7 @@ void DarkFrame::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedit
if (pedited) {
pedited->raw.darkFrame = dfChanged;
pedited->raw.dfAuto = !dfAuto->get_inconsistent();
pedited->raw.df_autoselect = !dfAuto->get_inconsistent();
}
}

4
rtgui/dirpyrdenoise.cc
View File

@ -61,7 +61,7 @@ DirPyrDenoise::DirPyrDenoise () : FoldableToolPanel(this, "dirpyrdenoise", M("TP
NoiscurveEditorG = new CurveEditorGroup (options.lastDenoiseCurvesDir, M("TP_DIRPYRDENOISE_LCURVE"));
//curveEditorG = new CurveEditorGroup (options.lastLabCurvesDir);
NoiscurveEditorG->setCurveListener (this);
rtengine::DirPyrDenoiseParams::getDefaultNoisCurve(defaultCurve);
defaultCurve = rtengine::DirPyrDenoiseParams().lcurve;
lshape = static_cast<FlatCurveEditor*>(NoiscurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
lshape->setIdentityValue(0.);
lshape->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);
@ -145,7 +145,7 @@ DirPyrDenoise::DirPyrDenoise () : FoldableToolPanel(this, "dirpyrdenoise", M("TP
CCcurveEditorG = new CurveEditorGroup (options.lastDenoiseCurvesDir, M("TP_DIRPYRDENOISE_CCCURVE"));
CCcurveEditorG->setCurveListener (this);
rtengine::DirPyrDenoiseParams::getDefaultCCCurve(defaultCurve);
defaultCurve = rtengine::DirPyrDenoiseParams().cccurve;
ccshape = static_cast<FlatCurveEditor*>(CCcurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
ccshape->setIdentityValue(0.);
ccshape->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);

32
rtgui/exportpanel.cc
View File

@ -68,8 +68,8 @@ ExportPanel::ExportPanel () : listener (nullptr)
hb_raw_bayer_method->pack_start (*Gtk::manage (new Gtk::Label ( M ("EXPORT_RAW_DMETHOD") + ": ")), Gtk::PACK_SHRINK, 4);
raw_bayer_method = Gtk::manage (new MyComboBoxText ());
for ( size_t i = 0; i < procparams::RAWParams::BayerSensor::numMethods; i++) {
raw_bayer_method->append (procparams::RAWParams::BayerSensor::methodstring[i]);
for (const auto method_string : RAWParams::BayerSensor::getMethodStrings()) {
raw_bayer_method->append(method_string);
}
raw_bayer_method->set_active (0);
@ -91,8 +91,8 @@ ExportPanel::ExportPanel () : listener (nullptr)
hb_raw_xtrans_method->pack_start (*Gtk::manage (new Gtk::Label ( M ("EXPORT_RAW_DMETHOD") + ": ")), Gtk::PACK_SHRINK, 4);
raw_xtrans_method = Gtk::manage (new MyComboBoxText ());
for ( size_t i = 0; i < procparams::RAWParams::XTransSensor::numMethods; i++) {
raw_xtrans_method->append (procparams::RAWParams::XTransSensor::methodstring[i]);
for (const auto method_string : RAWParams::XTransSensor::getMethodStrings()) {
raw_xtrans_method->append(method_string);
}
raw_xtrans_method->set_active (0);
@ -275,15 +275,15 @@ void ExportPanel::SaveSettingsAsDefault()
//saving Bayer demosaic_method
int currentRow = raw_bayer_method->get_active_row_number();
if ( currentRow >= 0 && currentRow < procparams::RAWParams::BayerSensor::numMethods) {
FE_OPT_STORE_ (options.fastexport_raw_bayer_method, procparams::RAWParams::BayerSensor::methodstring[currentRow]);
if (currentRow >= 0 && currentRow < std::numeric_limits<int>::max()) {
FE_OPT_STORE_ (options.fastexport_raw_bayer_method, procparams::RAWParams::BayerSensor::getMethodStrings()[currentRow]);
}
//saving X-Trans demosaic_method
currentRow = raw_xtrans_method->get_active_row_number();
if ( currentRow >= 0 && currentRow < procparams::RAWParams::XTransSensor::numMethods) {
FE_OPT_STORE_ (options.fastexport_raw_xtrans_method, procparams::RAWParams::XTransSensor::methodstring[currentRow]);
if (currentRow >= 0 && currentRow < std::numeric_limits<int>::max()) {
FE_OPT_STORE_ (options.fastexport_raw_xtrans_method, procparams::RAWParams::XTransSensor::getMethodStrings()[currentRow]);
}
// options.fastexport_icm_input = icm_input ;
@ -337,20 +337,20 @@ void ExportPanel::LoadDefaultSettings()
bypass_raw_ff->set_active (options.fastexport_bypass_raw_ff );
// Bayer demosaic method
raw_bayer_method->set_active (procparams::RAWParams::BayerSensor::numMethods);
raw_bayer_method->set_active(std::numeric_limits<int>::max());
for ( size_t i = 0; i < procparams::RAWParams::BayerSensor::numMethods; i++)
if ( options.fastexport_raw_bayer_method == procparams::RAWParams::BayerSensor::methodstring[i]) {
raw_bayer_method->set_active (i);
for (size_t i = 0; i < RAWParams::BayerSensor::getMethodStrings().size(); ++i)
if (options.fastexport_raw_bayer_method == procparams::RAWParams::BayerSensor::getMethodStrings()[i]) {
raw_bayer_method->set_active(i);
break;
}
// X-Trans demosaic method
raw_xtrans_method->set_active (procparams::RAWParams::XTransSensor::numMethods);
raw_xtrans_method->set_active(std::numeric_limits<int>::max());
for ( size_t i = 0; i < procparams::RAWParams::XTransSensor::numMethods; i++)
if ( options.fastexport_raw_xtrans_method == procparams::RAWParams::XTransSensor::methodstring[i]) {
raw_xtrans_method->set_active (i);
for (size_t i = 0; i < procparams::RAWParams::XTransSensor::getMethodStrings().size(); ++i)
if (options.fastexport_raw_xtrans_method == procparams::RAWParams::XTransSensor::getMethodStrings()[i]) {
raw_xtrans_method->set_active(i);
break;
}

4
rtgui/filebrowser.cc
View File

@ -1021,7 +1021,7 @@ void FileBrowser::pasteProfile ()
for (unsigned int i = 0; i < mselected.size(); i++) {
// copying read only clipboard PartialProfile to a temporary one
rtengine::procparams::PartialProfile cbPartProf = clipboard.getPartialProfile();
const rtengine::procparams::PartialProfile& cbPartProf = clipboard.getPartialProfile();
rtengine::procparams::PartialProfile pastedPartProf(cbPartProf.pparams, cbPartProf.pedited, true);
// applying the PartialProfile to the thumb's ProcParams
@ -1069,7 +1069,7 @@ void FileBrowser::partPasteProfile ()
for (unsigned int i = 0; i < mselected.size(); i++) {
// copying read only clipboard PartialProfile to a temporary one, initialized to the thumb's ProcParams
mselected[i]->thumbnail->createProcParamsForUpdate(false, false); // this can execute customprofilebuilder to generate param file
rtengine::procparams::PartialProfile cbPartProf = clipboard.getPartialProfile();
const rtengine::procparams::PartialProfile& cbPartProf = clipboard.getPartialProfile();
rtengine::procparams::PartialProfile pastedPartProf(&mselected[i]->thumbnail->getProcParams (), nullptr);
// pushing the selected values of the clipboard PartialProfile to the temporary PartialProfile

24
rtgui/flatfield.cc
View File

@ -111,13 +111,14 @@ void FlatField::read(const rtengine::procparams::ProcParams* pp, const ParamsEdi
flatFieldBlurTypeconn.block (true);
//flatFieldBlurType
for( size_t i = 0; i < procparams::RAWParams::numFlatFileBlurTypes; i++)
if( pp->raw.ff_BlurType == procparams::RAWParams::ff_BlurTypestring[i]) {
for (size_t i = 0; i < procparams::RAWParams::getFlatFieldBlurTypeStrings().size(); ++i) {
if (pp->raw.ff_BlurType == procparams::RAWParams::getFlatFieldBlurTypeStrings()[i]) {
flatFieldBlurType->set_active(i);
break;
}
}
if (multiImage || pp->raw.ff_BlurType == procparams::RAWParams::ff_BlurTypestring[procparams::RAWParams::area_ff]) {
if (multiImage || pp->raw.ff_BlurType == procparams::RAWParams::getFlatFieldBlurTypeString(procparams::RAWParams::FlatFieldBlurType::AREA)) {
flatFieldClipControl->show();
} else {
flatFieldClipControl->hide();
@ -135,7 +136,7 @@ void FlatField::read(const rtengine::procparams::ProcParams* pp, const ParamsEdi
flatFieldClipControl->setAutoInconsistent(multiImage && !pedited->raw.ff_AutoClipControl);
if( !pedited->raw.ff_BlurType ) {
flatFieldBlurType->set_active(procparams::RAWParams::numFlatFileBlurTypes); // No name
flatFieldBlurType->set_active(std::numeric_limits<int>::max()); // No name
}
}
@ -216,8 +217,8 @@ void FlatField::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedit
int currentRow = flatFieldBlurType->get_active_row_number();
if( currentRow >= 0 && currentRow < procparams::RAWParams::numFlatFileBlurTypes) {
pp->raw.ff_BlurType = procparams::RAWParams::ff_BlurTypestring[currentRow];
if( currentRow >= 0 && currentRow < std::numeric_limits<int>::max()) {
pp->raw.ff_BlurType = procparams::RAWParams::getFlatFieldBlurTypeStrings()[currentRow];
}
if (pedited) {
@ -226,7 +227,7 @@ void FlatField::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedit
pedited->raw.ff_BlurRadius = flatFieldBlurRadius->getEditedState ();
pedited->raw.ff_clipControl = flatFieldClipControl->getEditedState ();
pedited->raw.ff_AutoClipControl = !flatFieldClipControl->getAutoInconsistent();
pedited->raw.ff_BlurType = flatFieldBlurType->get_active_row_number() != procparams::RAWParams::numFlatFileBlurTypes;
pedited->raw.ff_BlurType = flatFieldBlurType->get_active_row_number() != std::numeric_limits<int>::max();
}
}
@ -336,15 +337,16 @@ void FlatField::flatFieldFile_Reset()
void FlatField::flatFieldBlurTypeChanged ()
{
int curSelection = flatFieldBlurType->get_active_row_number();
const int curSelection = flatFieldBlurType->get_active_row_number();
const RAWParams::FlatFieldBlurType blur_type = RAWParams::FlatFieldBlurType(curSelection);
Glib::ustring s = "";
Glib::ustring s;
if( curSelection >= 0 && curSelection < procparams::RAWParams::numFlatFileBlurTypes) {
if (curSelection >= 0 && curSelection < std::numeric_limits<int>::max()) {
s = flatFieldBlurType->get_active_text();
}
if (multiImage || curSelection == procparams::RAWParams::area_ff) {
if (multiImage || blur_type == procparams::RAWParams::FlatFieldBlurType::AREA) {
flatFieldClipControl->show();
} else {
flatFieldClipControl->hide();

34
rtgui/paramsedited.cc
View File

@ -423,14 +423,14 @@ void ParamsEdited::set (bool v)
raw.xtranssensor.exBlackRed = v;
raw.xtranssensor.exBlackGreen = v;
raw.xtranssensor.exBlackBlue = v;
raw.caCorrection = v;
raw.caBlue = v;
raw.caRed = v;
raw.ca_autocorrect = v;
raw.cablue = v;
raw.cared = v;
raw.hotPixelFilter = v;
raw.deadPixelFilter = v;
raw.hotDeadPixelThresh = v;
raw.hotdeadpix_thresh = v;
raw.darkFrame = v;
raw.dfAuto = v;
raw.df_autoselect = v;
raw.ff_file = v;
raw.ff_AutoSelect = v;
raw.ff_BlurRadius = v;
@ -965,14 +965,14 @@ void ParamsEdited::initFrom (const std::vector<rtengine::procparams::ProcParams>
raw.xtranssensor.exBlackRed = raw.xtranssensor.exBlackRed && p.raw.xtranssensor.blackred == other.raw.xtranssensor.blackred;
raw.xtranssensor.exBlackGreen = raw.xtranssensor.exBlackGreen && p.raw.xtranssensor.blackgreen == other.raw.xtranssensor.blackgreen;
raw.xtranssensor.exBlackBlue = raw.xtranssensor.exBlackBlue && p.raw.xtranssensor.blackblue == other.raw.xtranssensor.blackblue;
raw.caCorrection = raw.caCorrection && p.raw.ca_autocorrect == other.raw.ca_autocorrect;
raw.caRed = raw.caRed && p.raw.cared == other.raw.cared;
raw.caBlue = raw.caBlue && p.raw.cablue == other.raw.cablue;
raw.ca_autocorrect = raw.ca_autocorrect && p.raw.ca_autocorrect == other.raw.ca_autocorrect;
raw.cared = raw.cared && p.raw.cared == other.raw.cared;
raw.cablue = raw.cablue && p.raw.cablue == other.raw.cablue;
raw.hotPixelFilter = raw.hotPixelFilter && p.raw.hotPixelFilter == other.raw.hotPixelFilter;
raw.deadPixelFilter = raw.deadPixelFilter && p.raw.deadPixelFilter == other.raw.deadPixelFilter;
raw.hotDeadPixelThresh = raw.hotDeadPixelThresh && p.raw.hotdeadpix_thresh == other.raw.hotdeadpix_thresh;
raw.hotdeadpix_thresh = raw.hotdeadpix_thresh && p.raw.hotdeadpix_thresh == other.raw.hotdeadpix_thresh;
raw.darkFrame = raw.darkFrame && p.raw.dark_frame == other.raw.dark_frame;
raw.dfAuto = raw.dfAuto && p.raw.df_autoselect == other.raw.df_autoselect;
raw.df_autoselect = raw.df_autoselect && p.raw.df_autoselect == other.raw.df_autoselect;
raw.ff_file = raw.ff_file && p.raw.ff_file == other.raw.ff_file;
raw.ff_AutoSelect = raw.ff_AutoSelect && p.raw.ff_AutoSelect == other.raw.ff_AutoSelect;
raw.ff_BlurRadius = raw.ff_BlurRadius && p.raw.ff_BlurRadius == other.raw.ff_BlurRadius;
@ -2571,15 +2571,15 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.xtranssensor.blackblue = dontforceSet && options.baBehav[ADDSET_RAWEXPOS_BLACKS] ? toEdit.raw.xtranssensor.blackblue + mods.raw.xtranssensor.blackblue : mods.raw.xtranssensor.blackblue;
}
if (raw.caCorrection) {
if (raw.ca_autocorrect) {
toEdit.raw.ca_autocorrect = mods.raw.ca_autocorrect;
}
if (raw.caRed) {
if (raw.cared) {
toEdit.raw.cared = dontforceSet && options.baBehav[ADDSET_RAWCACORR] ? toEdit.raw.cared + mods.raw.cared : mods.raw.cared;
}
if (raw.caBlue) {
if (raw.cablue) {
toEdit.raw.cablue = dontforceSet && options.baBehav[ADDSET_RAWCACORR] ? toEdit.raw.cablue + mods.raw.cablue : mods.raw.cablue;
}
@ -2599,7 +2599,7 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.deadPixelFilter = mods.raw.deadPixelFilter;
}
if (raw.hotDeadPixelThresh) {
if (raw.hotdeadpix_thresh) {
toEdit.raw.hotdeadpix_thresh = mods.raw.hotdeadpix_thresh;
}
@ -2607,7 +2607,7 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.dark_frame = mods.raw.dark_frame;
}
if (raw.dfAuto) {
if (raw.df_autoselect) {
toEdit.raw.df_autoselect = mods.raw.df_autoselect;
}
@ -3062,8 +3062,8 @@ bool RAWParamsEdited::XTransSensor::isUnchanged() const
bool RAWParamsEdited::isUnchanged() const
{
return bayersensor.isUnchanged() && xtranssensor.isUnchanged() && caCorrection && caRed && caBlue && hotPixelFilter && deadPixelFilter && hotDeadPixelThresh && darkFrame
&& dfAuto && ff_file && ff_AutoSelect && ff_BlurRadius && ff_BlurType && exPos && exPreser && ff_AutoClipControl && ff_clipControl;
return bayersensor.isUnchanged() && xtranssensor.isUnchanged() && ca_autocorrect && cared && cablue && hotPixelFilter && deadPixelFilter && hotdeadpix_thresh && darkFrame
&& df_autoselect && ff_file && ff_AutoSelect && ff_BlurRadius && ff_BlurType && exPos && exPreser && ff_AutoClipControl && ff_clipControl;
}
bool LensProfParamsEdited::isUnchanged() const

14
rtgui/paramsedited.h
View File

@ -567,7 +567,6 @@ public:
bool gamma;
bool gampos;
bool slpos;
bool gamfree;
bool freegamma;
};
class WaveletParamsEdited
@ -764,14 +763,14 @@ public:
BayerSensor bayersensor;
XTransSensor xtranssensor;
bool caCorrection;
bool caRed;
bool caBlue;
bool ca_autocorrect;
bool cared;
bool cablue;
bool hotPixelFilter;
bool deadPixelFilter;
bool hotDeadPixelThresh;
bool hotdeadpix_thresh;
bool darkFrame;
bool dfAuto;
bool df_autoselect;
bool ff_file;
bool ff_AutoSelect;
bool ff_BlurRadius;
@ -839,8 +838,5 @@ public:
void set (bool v);
void initFrom (const std::vector<rtengine::procparams::ProcParams>& src);
void combine (rtengine::procparams::ProcParams& toEdit, const rtengine::procparams::ProcParams& mods, bool forceSet);
bool operator== (const ParamsEdited& other);
bool operator!= (const ParamsEdited& other);
};
#endif

10
rtgui/partialpastedlg.cc
View File

@ -943,12 +943,12 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
}
if (!raw_ca_autocorrect->get_active ()) {
filterPE.raw.caCorrection = falsePE.raw.caCorrection;
filterPE.raw.ca_autocorrect = falsePE.raw.ca_autocorrect;
}
if (!raw_caredblue->get_active ()) {
filterPE.raw.caRed = falsePE.raw.caRed;
filterPE.raw.caBlue = falsePE.raw.caBlue;
filterPE.raw.cared = falsePE.raw.cared;
filterPE.raw.cablue = falsePE.raw.cablue;
}
if (!raw_hotpix_filt->get_active ()) {
@ -960,7 +960,7 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
}
if (!raw_deadpix_filt->get_active () && !raw_hotpix_filt->get_active ()) {
filterPE.raw.hotDeadPixelThresh = falsePE.raw.hotDeadPixelThresh;
filterPE.raw.hotdeadpix_thresh = falsePE.raw.hotdeadpix_thresh;
}
if (!df_file->get_active ()) {
@ -968,7 +968,7 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
}
if (!df_AutoSelect->get_active ()) {
filterPE.raw.dfAuto = falsePE.raw.dfAuto;
filterPE.raw.df_autoselect = falsePE.raw.df_autoselect;
}
if (!ff_file->get_active ()) {

11
rtgui/ppversion.h
View File

@ -1,14 +1,15 @@
#ifndef _PPVERSION_
#define _PPVERSION_
#pragma once
// This number has to be incremented whenever the PP3 file format is modified or the behaviour of a tool changes
#define PPVERSION 327
#define PPVERSION 328
#define PPVERSION_AEXP 301 //value of PPVERSION when auto exposure algorithm was modified
/*
Log of version changes
328 2017-11-22
Fix wrong type of ff_clipControl
327 2017-09-15
[Profiles Lens Correction] Added Lensfun
[Profiled Lens Correction] Added Lensfun
326 2015-07-26
[Exposure] Added 'Perceptual' tone curve mode
325 2015-07-23
@ -45,5 +46,3 @@
added [Directional Pyramid Denoising] Method, Redchro, Bluechro
added [RGB Curves] LumaMode
*/
#endif

2
rtgui/preprocess.cc
View File

@ -81,7 +81,7 @@ void PreProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedi
pp->raw.hotdeadpix_thresh = hdThreshold->getIntValue();
if (pedited) {
pedited->raw.hotDeadPixelThresh = hdThreshold->getEditedState ();
pedited->raw.hotdeadpix_thresh = hdThreshold->getEditedState ();
pedited->raw.hotPixelFilter = !hotPixel->get_inconsistent();
pedited->raw.deadPixelFilter = !deadPixel->get_inconsistent();
}

16
rtgui/rawcacorrection.cc
View File

@ -61,9 +61,9 @@ void RAWCACorr::read(const rtengine::procparams::ProcParams* pp, const ParamsEdi
disableListener ();
if(pedited ) {
caAutocorrect->setEdited(pedited->raw.caCorrection);
caRed->setEditedState( pedited->raw.caRed ? Edited : UnEdited );
caBlue->setEditedState( pedited->raw.caBlue ? Edited : UnEdited );
caAutocorrect->setEdited(pedited->raw.ca_autocorrect);
caRed->setEditedState( pedited->raw.cared ? Edited : UnEdited );
caBlue->setEditedState( pedited->raw.cablue ? Edited : UnEdited );
}
// disable Red and Blue sliders when caAutocorrect is enabled
@ -84,9 +84,9 @@ void RAWCACorr::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedit
pp->raw.cablue = caBlue->getValue();
if (pedited) {
pedited->raw.caCorrection = !caAutocorrect->get_inconsistent();
pedited->raw.caRed = caRed->getEditedState ();
pedited->raw.caBlue = caBlue->getEditedState ();
pedited->raw.ca_autocorrect = !caAutocorrect->get_inconsistent();
pedited->raw.cared = caRed->getEditedState ();
pedited->raw.cablue = caBlue->getEditedState ();
}
}
@ -132,8 +132,8 @@ void RAWCACorr::setDefaults(const rtengine::procparams::ProcParams* defParams, c
caBlue->setDefault( defParams->raw.cablue);
if (pedited) {
caRed->setDefaultEditedState( pedited->raw.caRed ? Edited : UnEdited);
caBlue->setDefaultEditedState( pedited->raw.caBlue ? Edited : UnEdited);
caRed->setDefaultEditedState( pedited->raw.cared ? Edited : UnEdited);
caBlue->setDefaultEditedState( pedited->raw.cablue ? Edited : UnEdited);
} else {
caRed->setDefaultEditedState( Irrelevant );
caBlue->setDefaultEditedState( Irrelevant );

8
rtgui/retinex.cc
View File

@ -380,14 +380,15 @@ Retinex::Retinex () : FoldableToolPanel (this, "retinex", M ("TP_RETINEX_LABEL")
Gtk::Grid *tranGrid = Gtk::manage (new Gtk::Grid());
setExpandAlignProperties (tranGrid, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_START);
const RetinexParams default_params;
// Transmission map curve
transmissionCurveEditorG = new CurveEditorGroup (options.lastRetinexDir, M ("TP_RETINEX_TRANSMISSION"));
setExpandAlignProperties (transmissionCurveEditorG, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_START);
transmissionCurveEditorG->setCurveListener (this);
rtengine::RetinexParams::getDefaulttransmissionCurve (defaultCurve);
transmissionShape = static_cast<FlatCurveEditor*> (transmissionCurveEditorG->addCurve (CT_Flat, "", nullptr, false, false));
transmissionShape->setIdentityValue (0.);
transmissionShape->setResetCurve (FlatCurveType (defaultCurve.at (0)), defaultCurve);
transmissionShape->setResetCurve (FlatCurveType (default_params.transmissionCurve.at (0)), default_params.transmissionCurve);
// transmissionShape->setBottomBarBgGradient(milestones);
transmissionCurveEditorG->curveListComplete();
transmissionCurveEditorG->set_tooltip_markup (M ("TP_RETINEX_TRANSMISSION_TOOLTIP"));
@ -439,10 +440,9 @@ Retinex::Retinex () : FoldableToolPanel (this, "retinex", M ("TP_RETINEX_LABEL")
gaintransmissionCurve = new CurveEditorGroup (options.lastRetinexDir, M ("TP_RETINEX_GAINTRANSMISSION"));
setExpandAlignProperties (gaintransmissionCurve, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_START);
gaintransmissionCurve->setCurveListener (this);
rtengine::RetinexParams::getDefaultgaintransmissionCurve (defaultCurve);
gaintransmissionShape = static_cast<FlatCurveEditor*> (gaintransmissionCurve->addCurve (CT_Flat, "", nullptr, false, false));
gaintransmissionShape->setIdentityValue (0.);
gaintransmissionShape->setResetCurve (FlatCurveType (defaultCurve.at (0)), defaultCurve);
gaintransmissionShape->setResetCurve (FlatCurveType (default_params.gaintransmissionCurve.at (0)), default_params.gaintransmissionCurve);
//gaintransmissionShape->setBottomBarBgGradient(milestones);
gaintransmissionCurve->set_tooltip_markup (M ("TP_RETINEX_GAINTRANSMISSION_TOOLTIP"));
gaintransmissionCurve->curveListComplete();

12
rtgui/thresholdadjuster.cc
View File

@ -341,20 +341,20 @@ void ThresholdAdjuster::sendToListener ()
rtengine::procparams::Threshold<double> t = tSelector.getPositions<double>();
if (tSelector.isDouble()) {
adjusterListener->adjusterChanged (this, t.value[0], t.value[1], t.value[2], t.value[3]);
adjusterListener->adjusterChanged2 (this, t.value[0], t.value[1], t.value[2], t.value[3]);
adjusterListener->adjusterChanged (this, t.getBottomLeft(), t.getTopLeft(), t.getBottomRight(), t.getTopRight());
adjusterListener->adjusterChanged2 (this, t.getBottomLeft(), t.getTopLeft(), t.getBottomRight(), t.getTopRight());
} else {
adjusterListener->adjusterChanged (this, t.value[0], t.value[1]);
adjusterListener->adjusterChanged (this, t.getBottomLeft(), t.getTopLeft());
}
} else {
// if precision is equal to 0, then we assume that the listener is waiting for integers
rtengine::procparams::Threshold<int> t = tSelector.getPositions<int>();
if (tSelector.isDouble()) {
adjusterListener->adjusterChanged (this, t.value[0], t.value[1], t.value[2], t.value[3]);
adjusterListener->adjusterChanged2 (this, t.value[0], t.value[1], t.value[2], t.value[3]);
adjusterListener->adjusterChanged (this, t.getBottomLeft(), t.getTopLeft(), t.getBottomRight(), t.getTopRight());
adjusterListener->adjusterChanged2 (this, t.getBottomLeft(), t.getTopLeft(), t.getBottomRight(), t.getTopRight());
} else {
adjusterListener->adjusterChanged (this, t.value[0], t.value[1]);
adjusterListener->adjusterChanged (this, t.getBottomLeft(), t.getTopLeft());
}
}
}

16
rtgui/thresholdselector.h
View File

@ -138,12 +138,12 @@ public:
template <typename T>
void setDefaults (const rtengine::procparams::Threshold<T> &t)
{
defPos[TS_BOTTOMLEFT] = double(t.value[0]); // should we use shapeValue() ?
defPos[TS_TOPLEFT] = double(t.value[1]);
defPos[TS_BOTTOMLEFT] = double(t.getBottomLeft()); // should we use shapeValue() ?
defPos[TS_TOPLEFT] = double(t.getTopLeft());
if (doubleThresh) {
defPos[TS_BOTTOMRIGHT] = double(t.value[2]);
defPos[TS_TOPRIGHT] = double(t.value[3]);
defPos[TS_BOTTOMRIGHT] = double(t.getBottomRight());
defPos[TS_TOPRIGHT] = double(t.getTopRight());
}
}
void setDefaults (double bottom, double top);
@ -151,12 +151,12 @@ public:
template <typename T>
void setPositions (const rtengine::procparams::Threshold<T> &tValues)
{
positions[TS_BOTTOMLEFT] = static_cast<double>(tValues.value[TS_BOTTOMLEFT]);
positions[TS_TOPLEFT] = static_cast<double>(tValues.value[TS_TOPLEFT]);
positions[TS_BOTTOMLEFT] = static_cast<double>(tValues.getBottomLeft());
positions[TS_TOPLEFT] = static_cast<double>(tValues.getTopLeft());
if (tValues.isDouble()) {
positions[TS_BOTTOMRIGHT] = static_cast<double>(tValues.value[TS_BOTTOMRIGHT]);
positions[TS_TOPRIGHT] = static_cast<double>(tValues.value[TS_TOPRIGHT]);
positions[TS_BOTTOMRIGHT] = static_cast<double>(tValues.getBottomRight());
positions[TS_TOPRIGHT] = static_cast<double>(tValues.getTopRight());
}
updateTooltip();

28
rtgui/tonecurve.cc
View File

@ -223,8 +223,8 @@ void ToneCurve::read (const ProcParams* pp, const ParamsEdited* pedited)
shape->setCurve (pp->toneCurve.curve);
shape2->setCurve (pp->toneCurve.curve2);
toneCurveMode->set_active(pp->toneCurve.curveMode);
toneCurveMode2->set_active(pp->toneCurve.curveMode2);
toneCurveMode->set_active(rtengine::toUnderlying(pp->toneCurve.curveMode));
toneCurveMode2->set_active(rtengine::toUnderlying(pp->toneCurve.curveMode2));
if (pedited) {
expcomp->setEditedState (pedited->toneCurve.expcomp ? Edited : UnEdited);
@ -314,33 +314,33 @@ void ToneCurve::write (ProcParams* pp, ParamsEdited* pedited)
int tcMode = toneCurveMode->get_active_row_number();
if (tcMode == 0) {
pp->toneCurve.curveMode = ToneCurveParams::TC_MODE_STD;
pp->toneCurve.curveMode = ToneCurveParams::TcMode::STD;
} else if (tcMode == 1) {
pp->toneCurve.curveMode = ToneCurveParams::TC_MODE_WEIGHTEDSTD;
pp->toneCurve.curveMode = ToneCurveParams::TcMode::WEIGHTEDSTD;
} else if (tcMode == 2) {
pp->toneCurve.curveMode = ToneCurveParams::TC_MODE_FILMLIKE;
pp->toneCurve.curveMode = ToneCurveParams::TcMode::FILMLIKE;
} else if (tcMode == 3) {
pp->toneCurve.curveMode = ToneCurveParams::TC_MODE_SATANDVALBLENDING;
pp->toneCurve.curveMode = ToneCurveParams::TcMode::SATANDVALBLENDING;
} else if (tcMode == 4) {
pp->toneCurve.curveMode = ToneCurveParams::TC_MODE_LUMINANCE;
pp->toneCurve.curveMode = ToneCurveParams::TcMode::LUMINANCE;
} else if (tcMode == 5) {
pp->toneCurve.curveMode = ToneCurveParams::TC_MODE_PERCEPTUAL;
pp->toneCurve.curveMode = ToneCurveParams::TcMode::PERCEPTUAL;
}
tcMode = toneCurveMode2->get_active_row_number();
if (tcMode == 0) {
pp->toneCurve.curveMode2 = ToneCurveParams::TC_MODE_STD;
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::STD;
} else if (tcMode == 1) {
pp->toneCurve.curveMode2 = ToneCurveParams::TC_MODE_WEIGHTEDSTD;
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::WEIGHTEDSTD;
} else if (tcMode == 2) {
pp->toneCurve.curveMode2 = ToneCurveParams::TC_MODE_FILMLIKE;
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::FILMLIKE;
} else if (tcMode == 3) {
pp->toneCurve.curveMode2 = ToneCurveParams::TC_MODE_SATANDVALBLENDING;
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::SATANDVALBLENDING;
} else if (tcMode == 4) {
pp->toneCurve.curveMode2 = ToneCurveParams::TC_MODE_LUMINANCE;
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::LUMINANCE;
} else if (tcMode == 5) {
pp->toneCurve.curveMode2 = ToneCurveParams::TC_MODE_PERCEPTUAL;
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::PERCEPTUAL;
}
if (pedited) {

17
rtgui/wavelet.cc
View File

@ -408,12 +408,11 @@ Wavelet::Wavelet() :
opaCurveEditorG->setCurveListener (this);
std::vector<double> defaultCurve;
const WaveletParams default_params;
rtengine::WaveletParams::getDefaultOpacityCurveRG(defaultCurve);
opacityShapeRG = static_cast<FlatCurveEditor*>(opaCurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
opacityShapeRG->setIdentityValue(0.);
opacityShapeRG->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);
opacityShapeRG->setResetCurve(FlatCurveType(default_params.opacityCurveRG.at(0)), default_params.opacityCurveRG);
opaCurveEditorG->curveListComplete();
opaCurveEditorG->show();
@ -422,10 +421,9 @@ Wavelet::Wavelet() :
opacityCurveEditorG->setCurveListener (this);
rtengine::WaveletParams::getDefaultOpacityCurveBY(defaultCurve);
opacityShapeBY = static_cast<FlatCurveEditor*>(opacityCurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
opacityShapeBY->setIdentityValue(0.);
opacityShapeBY->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);
opacityShapeBY->setResetCurve(FlatCurveType(default_params.opacityCurveBY.at(0)), default_params.opacityCurveBY);
opacityCurveEditorG->curveListComplete();
opacityCurveEditorG->show();
@ -502,11 +500,10 @@ Wavelet::Wavelet() :
// <-- Edge Sharpness Local Contrast curve
CCWcurveEditorG->setCurveListener (this);
rtengine::WaveletParams::getDefaultCCWCurve(defaultCurve);
ccshape = static_cast<FlatCurveEditor*>(CCWcurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
ccshape->setIdentityValue(0.);
ccshape->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);
ccshape->setResetCurve(FlatCurveType(default_params.ccwcurve.at(0)), default_params.ccwcurve);
ccshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_CC_TOOLTIP"));
CCWcurveEditorG->curveListComplete();
@ -781,10 +778,9 @@ Wavelet::Wavelet() :
opacityCurveEditorW->setCurveListener (this);
rtengine::WaveletParams::getDefaultOpacityCurveW(defaultCurve);
opacityShape = static_cast<FlatCurveEditor*>(opacityCurveEditorW->addCurve(CT_Flat, "", nullptr, false, false));
opacityShape->setIdentityValue(0.);
opacityShape->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);
opacityShape->setResetCurve(FlatCurveType(default_params.opacityCurveW.at(0)), default_params.opacityCurveW);
opacityShape->setBottomBarBgGradient(milestones2);
// This will add the reset button at the end of the curveType buttons
@ -798,10 +794,9 @@ Wavelet::Wavelet() :
opacityCurveEditorWL->setCurveListener (this);
rtengine::WaveletParams::getDefaultOpacityCurveWL(defaultCurve);
opacityShapeWL = static_cast<FlatCurveEditor*>(opacityCurveEditorWL->addCurve(CT_Flat, "", nullptr, false, false));
opacityShapeWL->setIdentityValue(0.);
opacityShapeWL->setResetCurve(FlatCurveType(defaultCurve.at(0)), defaultCurve);
opacityShapeWL->setResetCurve(FlatCurveType(default_params.opacityCurveWL.at(0)), default_params.opacityCurveWL);
opacityShapeWL->setTooltip(M("TP_WAVELET_OPACITYWL_TOOLTIP"));
// This will add the reset button at the end of the curveType buttons

202
rtgui/whitebalance.cc
View File

@ -34,7 +34,7 @@
using namespace rtengine;
using namespace rtengine::procparams;
Glib::RefPtr<Gdk::Pixbuf> WhiteBalance::wbPixbufs[rtengine::procparams::WBT_CUSTOM + 1];
Glib::RefPtr<Gdk::Pixbuf> WhiteBalance::wbPixbufs[toUnderlying(WBEntry::Type::CUSTOM) + 1];
/*
Glib::RefPtr<Gdk::Pixbuf> WhiteBalance::wbCameraPB, WhiteBalance::wbAutoPB, WhiteBalance::wbSunPB, WhiteBalance::wbTungstenPB,
WhiteBalance::wbCloudyPB, WhiteBalance::wbShadePB, WhiteBalance::wbFluorescentPB, WhiteBalance::wbLampPB,
@ -43,24 +43,24 @@ Glib::RefPtr<Gdk::Pixbuf> WhiteBalance::wbCameraPB, WhiteBalance::wbAutoPB, Whit
void WhiteBalance::init ()
{
wbPixbufs[WBT_CAMERA] = RTImage::createFromFile ("wb-camera.png");
wbPixbufs[WBT_AUTO] = RTImage::createFromFile ("wb-auto.png");
wbPixbufs[WBT_DAYLIGHT] = RTImage::createFromFile ("wb-sun.png");
wbPixbufs[WBT_CLOUDY] = RTImage::createFromFile ("wb-cloudy.png");
wbPixbufs[WBT_SHADE] = RTImage::createFromFile ("wb-shade.png");
wbPixbufs[WBT_WATER] = RTImage::createFromFile ("wb-water.png");
// wbPixbufs[WBT_WATER2] = RTImage::createFromFile ("wb-water.png");
wbPixbufs[WBT_TUNGSTEN] = RTImage::createFromFile ("wb-tungsten.png");
wbPixbufs[WBT_FLUORESCENT] = RTImage::createFromFile ("wb-fluorescent.png");
wbPixbufs[WBT_LAMP] = RTImage::createFromFile ("wb-lamp.png");
wbPixbufs[WBT_FLASH] = RTImage::createFromFile ("wb-flash.png");
wbPixbufs[WBT_LED] = RTImage::createFromFile ("wb-led.png");
wbPixbufs[WBT_CUSTOM] = RTImage::createFromFile ("wb-custom.png");
wbPixbufs[toUnderlying(WBEntry::Type::CAMERA)] = RTImage::createFromFile ("wb-camera.png");
wbPixbufs[toUnderlying(WBEntry::Type::AUTO)] = RTImage::createFromFile ("wb-auto.png");
wbPixbufs[toUnderlying(WBEntry::Type::DAYLIGHT)] = RTImage::createFromFile ("wb-sun.png");
wbPixbufs[toUnderlying(WBEntry::Type::CLOUDY)] = RTImage::createFromFile ("wb-cloudy.png");
wbPixbufs[toUnderlying(WBEntry::Type::SHADE)] = RTImage::createFromFile ("wb-shade.png");
wbPixbufs[toUnderlying(WBEntry::Type::WATER)] = RTImage::createFromFile ("wb-water.png");
// wbPixbufs[WBEntry::Type::WATER2] = RTImage::createFromFile ("wb-water.png");
wbPixbufs[toUnderlying(WBEntry::Type::TUNGSTEN)] = RTImage::createFromFile ("wb-tungsten.png");
wbPixbufs[toUnderlying(WBEntry::Type::FLUORESCENT)] = RTImage::createFromFile ("wb-fluorescent.png");
wbPixbufs[toUnderlying(WBEntry::Type::LAMP)] = RTImage::createFromFile ("wb-lamp.png");
wbPixbufs[toUnderlying(WBEntry::Type::FLASH)] = RTImage::createFromFile ("wb-flash.png");
wbPixbufs[toUnderlying(WBEntry::Type::LED)] = RTImage::createFromFile ("wb-led.png");
wbPixbufs[toUnderlying(WBEntry::Type::CUSTOM)] = RTImage::createFromFile ("wb-custom.png");
}
void WhiteBalance::cleanup ()
{
for (unsigned int i = 0; i < WBT_CUSTOM + 1; i++) {
for (unsigned int i = 0; i < toUnderlying(WBEntry::Type::CUSTOM) + 1; i++) {
wbPixbufs[i].reset();
}
}
@ -163,68 +163,68 @@ WhiteBalance::WhiteBalance () : FoldableToolPanel(this, "whitebalance", M("TP_WB
// Assign the model to the Combobox
method->set_model(refTreeModel);
enum WBTypes oldType = WBParams::wbEntries[0]->type;
enum WBTypes currType;
WBEntry::Type oldType = WBParams::getWbEntries()[0].type;
WBEntry::Type currType;
Gtk::TreeModel::Row row, childrow;
for (unsigned int i = 0; i < WBParams::wbEntries.size(); i++) {
if (oldType != (currType = WBParams::wbEntries[i]->type)) {
for (unsigned int i = 0; i < WBParams::getWbEntries().size(); i++) {
if (oldType != (currType = WBParams::getWbEntries()[i].type)) {
// New entry type
if (currType == WBT_FLUORESCENT) {
if (currType == WBEntry::Type::FLUORESCENT) {
// Creating the Fluorescent subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbPixbufs[currType];
row[methodColumns.colIcon] = wbPixbufs[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_FLUO_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBT_WATER) {
if (currType == WBEntry::Type::WATER) {
// Creating the under water subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbPixbufs[currType];
row[methodColumns.colIcon] = wbPixbufs[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_WATER_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBT_LAMP) {
if (currType == WBEntry::Type::LAMP) {
// Creating the Lamp subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbPixbufs[currType];
row[methodColumns.colIcon] = wbPixbufs[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_LAMP_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBT_LED) {
if (currType == WBEntry::Type::LED) {
// Creating the LED subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbPixbufs[currType];
row[methodColumns.colIcon] = wbPixbufs[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_LED_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBT_FLASH) {
if (currType == WBEntry::Type::FLASH) {
// Creating the Flash subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbPixbufs[currType];
row[methodColumns.colIcon] = wbPixbufs[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_FLASH_HEADER");
row[methodColumns.colId] = i + 100;
}
}
if (currType == WBT_FLUORESCENT
|| currType == WBT_LAMP
|| currType == WBT_WATER
|| currType == WBT_FLASH
|| currType == WBT_LED
if (currType == WBEntry::Type::FLUORESCENT
|| currType == WBEntry::Type::LAMP
|| currType == WBEntry::Type::WATER
|| currType == WBEntry::Type::FLASH
|| currType == WBEntry::Type::LED
) {
childrow = *(refTreeModel->append(row.children()));
childrow[methodColumns.colIcon] = wbPixbufs[currType];
childrow[methodColumns.colLabel] = WBParams::wbEntries[i]->GUILabel;
childrow[methodColumns.colIcon] = wbPixbufs[toUnderlying(currType)];
childrow[methodColumns.colLabel] = WBParams::getWbEntries()[i].GUILabel;
childrow[methodColumns.colId] = i;
} else {
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbPixbufs[currType];
row[methodColumns.colLabel] = WBParams::wbEntries[i]->GUILabel;
row[methodColumns.colIcon] = wbPixbufs[toUnderlying(currType)];
row[methodColumns.colLabel] = WBParams::getWbEntries()[i].GUILabel;
row[methodColumns.colId] = i;
}
@ -362,12 +362,24 @@ void WhiteBalance::adjusterChanged (Adjuster* a, double newval)
}
Glib::ustring colLabel = row[methodColumns.colLabel];
WBEntry* ppMethod = findWBEntry (row[methodColumns.colLabel], WBLT_GUI);
WBEntry* wbCustom = findWBEntry ("Custom", WBLT_PP);
const std::pair<bool, const WBEntry&> ppMethod = findWBEntry (row[methodColumns.colLabel], WBLT_GUI);
const std::pair<bool, const WBEntry&> wbCustom = findWBEntry ("Custom", WBLT_PP);
if (!ppMethod || (ppMethod->ppLabel != wbCustom->ppLabel && !((a == equal || a == tempBias) && ppMethod->type == WBT_AUTO)) ) {
if (
!ppMethod.first
|| (
ppMethod.second.ppLabel != wbCustom.second.ppLabel
&& !(
(
a == equal
|| a == tempBias
)
&& ppMethod.second.type == WBEntry::Type::AUTO
)
)
) {
methconn.block(true);
opt = setActiveMethod(wbCustom->GUILabel);
opt = setActiveMethod(wbCustom.second.GUILabel);
tempBias->set_sensitive(false);
cache_customWB (tVal, gVal);
@ -429,12 +441,12 @@ void WhiteBalance::optChanged ()
tempBias->setEditedState (UnEdited);
} else {
unsigned int methodId = findWBEntryId (row[methodColumns.colLabel], WBLT_GUI);
WBEntry* currMethod = WBParams::wbEntries[methodId];
const WBEntry& currMethod = WBParams::getWbEntries()[methodId];
tempBias->set_sensitive(currMethod->type == WBT_AUTO);
tempBias->set_sensitive(currMethod.type == WBEntry::Type::AUTO);
switch (currMethod->type) {
case WBT_CAMERA:
switch (currMethod.type) {
case WBEntry::Type::CAMERA:
if (wbp) {
double ctemp, cgreen;
wbp->getCamWB (ctemp, cgreen);
@ -451,7 +463,7 @@ void WhiteBalance::optChanged ()
break;
case WBT_AUTO:
case WBEntry::Type::AUTO:
if (wbp) {
if (batchMode) {
temp->setEditedState (UnEdited);
@ -464,7 +476,7 @@ void WhiteBalance::optChanged ()
break;
case WBT_CUSTOM:
case WBEntry::Type::CUSTOM:
if (custom_temp > 0) {
temp->setValue (temp->getAddMode() ? 0.0 : custom_temp);
green->setValue (green->getAddMode() ? 0.0 : custom_green);
@ -484,19 +496,19 @@ void WhiteBalance::optChanged ()
break;
/* All other solution are the default cases
case WBT_DAYLIGHT:
case WBT_CLOUDY:
case WBT_SHADE:
case WBT_TUNGSTEN:
case WBT_FLUORESCENT:
case WBT_LAMP:
case WBT_FLASH:
case WBT_LED:*/
case WBEntry::Type::DAYLIGHT:
case WBEntry::Type::CLOUDY:
case WBEntry::Type::SHADE:
case WBEntry::Type::TUNGSTEN:
case WBEntry::Type::FLUORESCENT:
case WBEntry::Type::LAMP:
case WBEntry::Type::FLASH:
case WBEntry::Type::LED:*/
default:
// recall custom WB settings if it exists, set to 1.0 otherwise
temp->setValue ( temp->getAddMode() ? 0.0 : (double)(currMethod->temperature));
green->setValue (green->getAddMode() ? 0.0 : (double)(currMethod->green));
equal->setValue (equal->getAddMode() ? 0.0 : (double)(currMethod->equal));
temp->setValue ( temp->getAddMode() ? 0.0 : (double)(currMethod.temperature));
green->setValue (green->getAddMode() ? 0.0 : (double)(currMethod.green));
equal->setValue (equal->getAddMode() ? 0.0 : (double)(currMethod.equal));
if (batchMode) {
temp->setEditedState (Edited);
@ -551,17 +563,21 @@ void WhiteBalance::read (const ProcParams* pp, const ParamsEdited* pedited)
if (pedited && !pedited->wb.method) {
opt = setActiveMethod(M("GENERAL_UNCHANGED"));
} else {
WBEntry* wbValues = findWBEntry(pp->wb.method, WBLT_PP);
const WBEntry& wbValues =
[this, pp]() -> const WBEntry&
{
const std::pair<bool, const WBEntry&> res = findWBEntry(pp->wb.method, WBLT_PP);
return
!res.first
? findWBEntry("Camera", WBLT_PP).second
: res.second;
}();
if (!wbValues) {
wbValues = findWBEntry("Camera", WBLT_PP);
}
opt = setActiveMethod(wbValues->GUILabel);
opt = setActiveMethod(wbValues.GUILabel);
// temperature is reset to the associated temperature, or 0.0 if addMode is set.
switch (wbValues->type) {
case WBT_CUSTOM:
switch (wbValues.type) {
case WBEntry::Type::CUSTOM:
temp->setValue (temp->getAddMode() ? 0.0 : pp->wb.temperature);
green->setValue (green->getAddMode() ? 0.0 : pp->wb.green);
equal->setValue (equal->getAddMode() ? 0.0 : pp->wb.equal);
@ -578,7 +594,7 @@ void WhiteBalance::read (const ProcParams* pp, const ParamsEdited* pedited)
break;
case WBT_CAMERA:
case WBEntry::Type::CAMERA:
if (wbp) {
double ctemp = -1.0;
double cgreen = -1.0;
@ -600,7 +616,7 @@ void WhiteBalance::read (const ProcParams* pp, const ParamsEdited* pedited)
break;
case WBT_AUTO:
case WBEntry::Type::AUTO:
// the equalizer's value is restored for the AutoWB
equal->setValue (equal->getAddMode() ? 0.0 : pp->wb.equal);
tempBias->setValue (tempBias->getAddMode() ? 0.0 : pp->wb.tempBias);
@ -620,18 +636,18 @@ void WhiteBalance::read (const ProcParams* pp, const ParamsEdited* pedited)
/*
All those types are the "default" case:
case WBT_DAYLIGHT:
case WBT_CLOUDY:
case WBT_SHADE:
case WBT_TUNGSTEN:
case WBT_FLUORESCENT:
case WBT_LAMP:
case WBT_FLASH:
case WBT_LED:
case WBEntry::Type::DAYLIGHT:
case WBEntry::Type::CLOUDY:
case WBEntry::Type::SHADE:
case WBEntry::Type::TUNGSTEN:
case WBEntry::Type::FLUORESCENT:
case WBEntry::Type::LAMP:
case WBEntry::Type::FLASH:
case WBEntry::Type::LED:
*/
default:
// Set the associated temperature, or 0.0 if in ADD mode
temp->setValue(temp->getAddMode() ? 0.0 : (double)wbValues->temperature);
temp->setValue(temp->getAddMode() ? 0.0 : (double)wbValues.temperature);
// Set the stored temperature, or 0.0 if in ADD mode
green->setValue(green->getAddMode() ? 0.0 : pp->wb.green);
equal->setValue(equal->getAddMode() ? 0.0 : pp->wb.equal);
@ -648,7 +664,7 @@ void WhiteBalance::read (const ProcParams* pp, const ParamsEdited* pedited)
break;
}
tempBias->set_sensitive(wbValues->type == WBT_AUTO);
tempBias->set_sensitive(wbValues.type == WBEntry::Type::AUTO);
}
methconn.block (false);
@ -668,10 +684,10 @@ void WhiteBalance::write (ProcParams* pp, ParamsEdited* pedited)
pedited->wb.method = row[methodColumns.colLabel] != M("GENERAL_UNCHANGED");
}
WBEntry* ppMethod = findWBEntry (row[methodColumns.colLabel], WBLT_GUI);
const std::pair<bool, const WBEntry&> ppMethod = findWBEntry (row[methodColumns.colLabel], WBLT_GUI);
if (ppMethod) {
pp->wb.method = ppMethod->ppLabel;
if (ppMethod.first) {
pp->wb.method = ppMethod.second.ppLabel;
}
pp->wb.temperature = temp->getIntValue ();
@ -724,7 +740,7 @@ void WhiteBalance::setBatchMode (bool batchMode)
equal->showEditedCB ();
tempBias->showEditedCB ();
Gtk::TreeModel::Row row = *(refTreeModel->append());
row[methodColumns.colId] = WBParams::wbEntries.size();
row[methodColumns.colId] = WBParams::getWbEntries().size();
row[methodColumns.colLabel] = M("GENERAL_UNCHANGED");
}
@ -739,10 +755,10 @@ void WhiteBalance::setWB (int vtemp, double vgreen)
{
methconn.block(true);
WBEntry *wbValues = findWBEntry("Custom", WBLT_PP);
const std::pair<bool, const WBEntry&> wbValues = findWBEntry("Custom", WBLT_PP);
temp->setValue (vtemp);
green->setValue (vgreen);
opt = setActiveMethod(wbValues->GUILabel);
opt = setActiveMethod(wbValues.second.GUILabel);
cache_customWB (vtemp, vgreen); // sequence in which this call is made is important; must be before "method->set_active (2);"
cache_customEqual(equal->getValue());
temp->setEditedState (Edited);
@ -792,10 +808,10 @@ void WhiteBalance::cache_customWB(int temp, double green)
cache_customGreen (green);
}
unsigned int WhiteBalance::findWBEntryId (const Glib::ustring &label, enum WB_LabelType lblType)
unsigned int WhiteBalance::findWBEntryId (const Glib::ustring& label, enum WB_LabelType lblType)
{
for (unsigned int i = 0; i < WBParams::wbEntries.size(); i++) {
if (label == (lblType == WBLT_GUI ? WBParams::wbEntries[i]->GUILabel : WBParams::wbEntries[i]->ppLabel)) {
for (unsigned int i = 0; i < WBParams::getWbEntries().size(); i++) {
if (label == (lblType == WBLT_GUI ? WBParams::getWbEntries()[i].GUILabel : WBParams::getWbEntries()[i].ppLabel)) {
return i;
}
}
@ -803,15 +819,15 @@ unsigned int WhiteBalance::findWBEntryId (const Glib::ustring &label, enum WB_La
return 0; // default to camera wb
}
WBEntry* WhiteBalance::findWBEntry (Glib::ustring label, enum WB_LabelType lblType)
std::pair<bool, const WBEntry&> WhiteBalance::findWBEntry(const Glib::ustring& label, enum WB_LabelType lblType)
{
for (unsigned int i = 0; i < WBParams::wbEntries.size(); i++) {
if (label == (lblType == WBLT_GUI ? WBParams::wbEntries[i]->GUILabel : WBParams::wbEntries[i]->ppLabel)) {
return WBParams::wbEntries[i];
for (unsigned int i = 0; i < WBParams::getWbEntries().size(); ++i) {
if (label == (lblType == WBLT_GUI ? WBParams::getWbEntries()[i].GUILabel : WBParams::getWbEntries()[i].ppLabel)) {
return {true, WBParams::getWbEntries()[i]};
}
}
return nullptr;
return {false, WBParams::getWbEntries()[0]};
}
int WhiteBalance::_setActiveMethod(Glib::ustring &label, Gtk::TreeModel::Children &children)

8
rtgui/whitebalance.h
View File

@ -57,7 +57,7 @@ protected:
}
};
static Glib::RefPtr<Gdk::Pixbuf> wbPixbufs[rtengine::procparams::WBT_CUSTOM + 1];
static Glib::RefPtr<Gdk::Pixbuf> wbPixbufs[rtengine::toUnderlying(rtengine::procparams::WBEntry::Type::CUSTOM) + 1];
Glib::RefPtr<Gtk::TreeStore> refTreeModel;
MethodColumns methodColumns;
MyComboBox* method;
@ -85,9 +85,9 @@ protected:
int setActiveMethod (Glib::ustring label);
int _setActiveMethod (Glib::ustring &label, Gtk::TreeModel::Children &children);
Gtk::TreeModel::Row getActiveMethod ();
unsigned int findWBEntryId (const Glib::ustring &label, enum WB_LabelType lblType = WBLT_GUI);
rtengine::procparams::WBEntry* findWBEntry (Glib::ustring label, enum WB_LabelType lblType = WBLT_GUI);
Gtk::TreeModel::Row getActiveMethod();
unsigned int findWBEntryId (const Glib::ustring& label, enum WB_LabelType lblType = WBLT_GUI);
std::pair<bool, const rtengine::procparams::WBEntry&> findWBEntry (const Glib::ustring& label, enum WB_LabelType lblType = WBLT_GUI);
public:

33
rtgui/xtransprocess.cc
View File

@ -29,11 +29,11 @@ XTransProcess::XTransProcess () : FoldableToolPanel(this, "xtransprocess", M("TP
hb1->pack_start (*Gtk::manage (new Gtk::Label ( M("TP_RAW_DMETHOD") + ": ")), Gtk::PACK_SHRINK, 4);
method = Gtk::manage (new MyComboBoxText ());
for( size_t i = 0; i < procparams::RAWParams::XTransSensor::numMethods; i++) {
for (const auto method_string : RAWParams::XTransSensor::getMethodStrings()) {
const std::string langKey =
[i]() -> std::string
[method_string]() -> std::string
{
const std::string str(procparams::RAWParams::XTransSensor::methodstring[i]);
const std::string str(method_string);
std::string res;
for (const auto& c : str) {
@ -83,10 +83,10 @@ void XTransProcess::read(const rtengine::procparams::ProcParams* pp, const Param
disableListener ();
methodconn.block (true);
method->set_active(procparams::RAWParams::XTransSensor::numMethods);
method->set_active(std::numeric_limits<int>::max());
for( size_t i = 0; i < procparams::RAWParams::XTransSensor::numMethods; i++)
if( pp->raw.xtranssensor.method == procparams::RAWParams::XTransSensor::methodstring[i]) {
for (size_t i = 0; i < RAWParams::XTransSensor::getMethodStrings().size(); ++i)
if( pp->raw.xtranssensor.method == RAWParams::XTransSensor::getMethodStrings()[i]) {
method->set_active(i);
oldSelection = i;
break;
@ -96,7 +96,7 @@ void XTransProcess::read(const rtengine::procparams::ProcParams* pp, const Param
ccSteps->setEditedState (pedited->raw.xtranssensor.ccSteps ? Edited : UnEdited);
if( !pedited->raw.xtranssensor.method ) {
method->set_active(procparams::RAWParams::XTransSensor::numMethods); // No name
method->set_active(std::numeric_limits<int>::max()); // No name
}
}
@ -113,12 +113,12 @@ void XTransProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* p
int currentRow = method->get_active_row_number();
if( currentRow >= 0 && currentRow < procparams::RAWParams::XTransSensor::numMethods) {
pp->raw.xtranssensor.method = procparams::RAWParams::XTransSensor::methodstring[currentRow];
if (currentRow >= 0 && currentRow < std::numeric_limits<int>::max()) {
pp->raw.xtranssensor.method = procparams::RAWParams::XTransSensor::getMethodStrings()[currentRow];
}
if (pedited) {
pedited->raw.xtranssensor.method = method->get_active_row_number() != procparams::RAWParams::XTransSensor::numMethods;
pedited->raw.xtranssensor.method = method->get_active_row_number() != std::numeric_limits<int>::max();
pedited->raw.xtranssensor.ccSteps = ccSteps->getEditedState ();
}
}
@ -126,7 +126,7 @@ void XTransProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* p
void XTransProcess::setBatchMode(bool batchMode)
{
method->append (M("GENERAL_UNCHANGED"));
method->set_active(procparams::RAWParams::XTransSensor::numMethods); // No name
method->set_active(std::numeric_limits<int>::max()); // No name
ToolPanel::setBatchMode (batchMode);
ccSteps->showEditedCB ();
}
@ -153,15 +153,16 @@ void XTransProcess::adjusterChanged (Adjuster* a, double newval)
void XTransProcess::methodChanged ()
{
int curSelection = method->get_active_row_number();
const int curSelection = method->get_active_row_number();
const RAWParams::XTransSensor::Method method = RAWParams::XTransSensor::Method(curSelection);
Glib::ustring methodName = "";
Glib::ustring methodName;
bool ppreq = false;
if( curSelection >= 0 && curSelection < procparams::RAWParams::XTransSensor::numMethods) {
methodName = procparams::RAWParams::XTransSensor::methodstring[curSelection];
if (curSelection >= 0 && curSelection < std::numeric_limits<int>::max()) {
methodName = RAWParams::XTransSensor::getMethodStrings()[curSelection];
if (curSelection == procparams::RAWParams::XTransSensor::mono || oldSelection == procparams::RAWParams::XTransSensor::mono) {
if (method == RAWParams::XTransSensor::Method::MONO || RAWParams::XTransSensor::Method(oldSelection) == RAWParams::XTransSensor::Method::MONO) {
ppreq = true;
}
}