From 200e6dd882603c0caf761a8258add299c425045e Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Tue, 7 Mar 2017 17:38:32 +0100 Subject: [PATCH 01/90] experimental hacks on simpleprocess.cc --- rtengine/simpleprocess.cc | 2486 ++++++++++++++++++++----------------- 1 file changed, 1373 insertions(+), 1113 deletions(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 9f1ca3c5c..e027968a5 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -35,641 +35,729 @@ namespace rtengine { extern const Settings* settings; -IImage16* processImage (ProcessingJob* pjob, int& errorCode, ProgressListener* pl, bool tunnelMetaData, bool flush) -{ +namespace { - errorCode = 0; - - ProcessingJobImpl* job = static_cast(pjob); - - if (pl) { - pl->setProgressStr ("PROGRESSBAR_PROCESSING"); - pl->setProgress (0.0); +class ImageProcessor { +public: + ImageProcessor(ProcessingJob* pjob, int& errorCode, + ProgressListener* pl, bool tunnelMetaData, bool flush): + pjob(pjob), + errorCode(errorCode), + pl(pl), + tunnelMetaData(tunnelMetaData), + flush(flush), + // internal state + ii(nullptr), + imgsrc(nullptr), + fw(-1), + fh(-1), + pp(0, 0, 0, 0, 0) + { } - InitialImage* ii = job->initialImage; + Image16 *operator()(bool fast) + { + if (!fast) { + return normal_pipeline(); + } else { + return fast_pipeline(); + } + } - if (!ii) { - ii = InitialImage::load (job->fname, job->isRaw, &errorCode); - - if (errorCode) { - delete job; +private: + Image16 *normal_pipeline() + { + if (!stage_1()) { return nullptr; } + stage_calc_denoise(); + stage_2(); + stage_3(); + stage_4(); + stage_5(); + stage_6(); + return stage_7(); } - procparams::ProcParams& params = job->pparams; + Image16 *fast_pipeline() + { + ProcessingJobImpl* job = static_cast(pjob); + if (!job->pparams.resize.enabled) { + return normal_pipeline(); + } + + if (!stage_1()) { + return nullptr; + } + stage_2(); + stage_4(); + stage_early_resize(); + stage_calc_denoise(); + stage_3(); + stage_5(); + stage_6(); + return stage_7(); + } - // acquire image from imagesource - ImageSource* imgsrc = ii->getImageSource (); + bool stage_1() + { + errorCode = 0; - int tr = getCoarseBitMask(params.coarse); - int fw, fh; - imgsrc->getFullSize (fw, fh, tr); + ProcessingJobImpl* job = static_cast(pjob); - // check the crop params - if (params.crop.x > fw || params.crop.y > fh) { - // the crop is completely out of the image, so we disable the crop - params.crop.enabled = false; - // and we set the values to the defaults - params.crop.x = 0; - params.crop.y = 0; - params.crop.w = fw; - params.crop.h = fh; - } else { - if (params.crop.x < 0) { + if (pl) { + pl->setProgressStr ("PROGRESSBAR_PROCESSING"); + pl->setProgress (0.0); + } + + ii = job->initialImage; + + if (!ii) { + ii = InitialImage::load (job->fname, job->isRaw, &errorCode); + + if (errorCode) { + delete job; + return false; //return nullptr; + } + } + + procparams::ProcParams& params = job->pparams; + + // acquire image from imagesource + imgsrc = ii->getImageSource (); + + tr = getCoarseBitMask(params.coarse); + imgsrc->getFullSize (fw, fh, tr); + + // check the crop params + if (params.crop.x > fw || params.crop.y > fh) { + // the crop is completely out of the image, so we disable the crop + params.crop.enabled = false; + // and we set the values to the defaults params.crop.x = 0; - } - - if (params.crop.y < 0) { params.crop.y = 0; - } + params.crop.w = fw; + params.crop.h = fh; + } else { + if (params.crop.x < 0) { + params.crop.x = 0; + } - if ((params.crop.x + params.crop.w) > fw) { - // crop overflow in the width dimension ; we trim it - params.crop.w = fw - params.crop.x; - } + if (params.crop.y < 0) { + params.crop.y = 0; + } - if ((params.crop.y + params.crop.h) > fh) { - // crop overflow in the height dimension ; we trim it - params.crop.h = fh - params.crop.y; + if ((params.crop.x + params.crop.w) > fw) { + // crop overflow in the width dimension ; we trim it + params.crop.w = fw - params.crop.x; + } + + if ((params.crop.y + params.crop.h) > fh) { + // crop overflow in the height dimension ; we trim it + params.crop.h = fh - params.crop.y; + } } - } // MyTime t1,t2; // t1.set(); - ImProcFunctions ipf (¶ms, true); + ImProcFunctions ipf (¶ms, true); - PreviewProps pp (0, 0, fw, fh, 1); - imgsrc->preprocess( params.raw, params.lensProf, params.coarse, params.dirpyrDenoise.enabled); + pp = PreviewProps(0, 0, fw, fh, 1); + imgsrc->preprocess( params.raw, params.lensProf, params.coarse, params.dirpyrDenoise.enabled); - if (params.toneCurve.autoexp) {// this enabled HLRecovery - LUTu histRedRaw(256), histGreenRaw(256), histBlueRaw(256); - imgsrc->getRAWHistogram(histRedRaw, histGreenRaw, histBlueRaw); + if (params.toneCurve.autoexp) {// this enabled HLRecovery + LUTu histRedRaw(256), histGreenRaw(256), histBlueRaw(256); + imgsrc->getRAWHistogram(histRedRaw, histGreenRaw, histBlueRaw); - if (ToneCurveParams::HLReconstructionNecessary(histRedRaw, histGreenRaw, histBlueRaw) && !params.toneCurve.hrenabled) { - params.toneCurve.hrenabled = true; - // WARNING: Highlight Reconstruction is being forced 'on', should we force a method here too? + if (ToneCurveParams::HLReconstructionNecessary(histRedRaw, histGreenRaw, histBlueRaw) && !params.toneCurve.hrenabled) { + params.toneCurve.hrenabled = true; + // WARNING: Highlight Reconstruction is being forced 'on', should we force a method here too? + } } - } - if (pl) { - pl->setProgress (0.20); - } + if (pl) { + pl->setProgress (0.20); + } - imgsrc->demosaic( params.raw); + imgsrc->demosaic( params.raw); - if (pl) { - pl->setProgress (0.30); - } + if (pl) { + pl->setProgress (0.30); + } - if(params.retinex.enabled) { //enabled Retinex - LUTf cdcurve (65536, 0); - LUTf mapcurve (65536, 0); - LUTu dummy; - RetinextransmissionCurve dehatransmissionCurve; - RetinexgaintransmissionCurve dehagaintransmissionCurve; - bool dehacontlutili = false; - bool mapcontlutili = false; - bool useHsl = false; + if(params.retinex.enabled) { //enabled Retinex + LUTf cdcurve (65536, 0); + LUTf mapcurve (65536, 0); + LUTu dummy; + RetinextransmissionCurve dehatransmissionCurve; + RetinexgaintransmissionCurve dehagaintransmissionCurve; + bool dehacontlutili = false; + bool mapcontlutili = false; + bool useHsl = false; // multi_array2D conversionBuffer(1, 1); - multi_array2D conversionBuffer(1, 1); - imgsrc->retinexPrepareBuffers(params.icm, params.retinex, conversionBuffer, dummy); - imgsrc->retinexPrepareCurves(params.retinex, cdcurve, mapcurve, dehatransmissionCurve, dehagaintransmissionCurve, dehacontlutili, mapcontlutili, useHsl, dummy, dummy ); - float minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax; - imgsrc->retinex( params.icm, params.retinex, params.toneCurve, cdcurve, mapcurve, dehatransmissionCurve, dehagaintransmissionCurve, conversionBuffer, dehacontlutili, mapcontlutili, useHsl, minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax, dummy); - } - - if (pl) { - pl->setProgress (0.40); - } - - imgsrc->HLRecovery_Global( params.toneCurve ); - - - if (pl) { - pl->setProgress (0.45); - } - - // set the color temperature - ColorTemp currWB = ColorTemp (params.wb.temperature, params.wb.green, params.wb.equal, params.wb.method); - - if (params.wb.method == "Camera") { - currWB = imgsrc->getWB (); - } else if (params.wb.method == "Auto") { - double rm, gm, bm; - imgsrc->getAutoWBMultipliers(rm, gm, bm); - currWB.update(rm, gm, bm, params.wb.equal, params.wb.tempBias); - } - - NoiseCurve noiseLCurve; - NoiseCurve noiseCCurve; - Imagefloat *calclum = nullptr ; - params.dirpyrDenoise.getCurves(noiseLCurve, noiseCCurve); - float autoNR = (float) settings->nrauto;// - float autoNRmax = (float) settings->nrautomax;// - int tilesize; - int overlap; - - if(settings->leveldnti == 0) { - tilesize = 1024; - overlap = 128; - } - - if(settings->leveldnti == 1) { - tilesize = 768; - overlap = 96; - } - - // const int tilesize = 768; - // const int overlap = 96; - int numtiles_W, numtiles_H, tilewidth, tileheight, tileWskip, tileHskip; - ipf.Tile_calc (tilesize, overlap, 2, fw, fh, numtiles_W, numtiles_H, tilewidth, tileheight, tileWskip, tileHskip); - int nbtl = numtiles_W * numtiles_H; - - if((settings->leveldnautsimpl == 1 && params.dirpyrDenoise.Cmethod == "AUT") || (settings->leveldnautsimpl == 0 && params.dirpyrDenoise.C2method == "AUTO")) { - nbtl = 9; - } - - float *ch_M = new float [nbtl];//allocate memory - float *max_r = new float [nbtl]; - float *max_b = new float [nbtl]; - float *min_b = new float [9]; - float *min_r = new float [9]; - float *lumL = new float [nbtl]; - float *chromC = new float [nbtl]; - float *ry = new float [nbtl]; - float *sk = new float [nbtl]; - float *pcsk = new float [nbtl]; - - // printf("expert=%d\n",settings->leveldnautsimpl); - if(settings->leveldnautsimpl == 1 && params.dirpyrDenoise.Cmethod == "PON") { - MyTime t1pone, t2pone; - t1pone.set(); - int crW, crH; - - if(settings->leveldnv == 0) { - crW = 100; - crH = 100; + multi_array2D conversionBuffer(1, 1); + imgsrc->retinexPrepareBuffers(params.icm, params.retinex, conversionBuffer, dummy); + imgsrc->retinexPrepareCurves(params.retinex, cdcurve, mapcurve, dehatransmissionCurve, dehagaintransmissionCurve, dehacontlutili, mapcontlutili, useHsl, dummy, dummy ); + float minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax; + imgsrc->retinex( params.icm, params.retinex, params.toneCurve, cdcurve, mapcurve, dehatransmissionCurve, dehagaintransmissionCurve, conversionBuffer, dehacontlutili, mapcontlutili, useHsl, minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax, dummy); } - if(settings->leveldnv == 1) { - crW = 250; - crH = 250; + if (pl) { + pl->setProgress (0.40); } - if(settings->leveldnv == 2) { - crW = int(tileWskip / 2); - crH = int(tileHskip / 2); + imgsrc->HLRecovery_Global( params.toneCurve ); + + + if (pl) { + pl->setProgress (0.45); } - // if(settings->leveldnv ==2) {crW=int(tileWskip/2);crH=int(1.15f*(tileWskip/2));}//adapted to scale of preview - if(settings->leveldnv == 3) { - crW = tileWskip - 10; - crH = tileHskip - 10; + // set the color temperature + currWB = ColorTemp (params.wb.temperature, params.wb.green, params.wb.equal, params.wb.method); + + if (params.wb.method == "Camera") { + currWB = imgsrc->getWB (); + } else if (params.wb.method == "Auto") { + double rm, gm, bm; + imgsrc->getAutoWBMultipliers(rm, gm, bm); + currWB.update(rm, gm, bm, params.wb.equal, params.wb.tempBias); } - float lowdenoise = 1.f; - int levaut = settings->leveldnaut; + // // AG begin + // baseImg = new Imagefloat (fw, fh); + // imgsrc->getImage (currWB, tr, baseImg, pp, params.toneCurve, params.icm, params.raw); + // // AG end - if(levaut == 1) { //Standard - lowdenoise = 0.7f; + return true; + } + + void stage_calc_denoise() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + calclum = nullptr ; + params.dirpyrDenoise.getCurves(noiseLCurve, noiseCCurve); + autoNR = (float) settings->nrauto;// + autoNRmax = (float) settings->nrautomax;// + + if(settings->leveldnti == 0) { + tilesize = 1024; + overlap = 128; } - // int crW=tileWskip-10;//crop noise width - // int crH=tileHskip-10;//crop noise height + if(settings->leveldnti == 1) { + tilesize = 768; + overlap = 96; + } + + // const int tilesize = 768; + // const int overlap = 96; + int numtiles_W, numtiles_H, tilewidth, tileheight, tileWskip, tileHskip; + ipf.Tile_calc (tilesize, overlap, 2, fw, fh, numtiles_W, numtiles_H, tilewidth, tileheight, tileWskip, tileHskip); + int nbtl = numtiles_W * numtiles_H; + + if((settings->leveldnautsimpl == 1 && params.dirpyrDenoise.Cmethod == "AUT") || (settings->leveldnautsimpl == 0 && params.dirpyrDenoise.C2method == "AUTO")) { + nbtl = 9; + } + + ch_M = new float [nbtl];//allocate memory + max_r = new float [nbtl]; + max_b = new float [nbtl]; + min_b = new float [9]; + min_r = new float [9]; + lumL = new float [nbtl]; + chromC = new float [nbtl]; + ry = new float [nbtl]; + sk = new float [nbtl]; + pcsk = new float [nbtl]; + + // printf("expert=%d\n",settings->leveldnautsimpl); + if(settings->leveldnautsimpl == 1 && params.dirpyrDenoise.Cmethod == "PON") { + MyTime t1pone, t2pone; + t1pone.set(); + int crW, crH; + + if(settings->leveldnv == 0) { + crW = 100; + crH = 100; + } + + if(settings->leveldnv == 1) { + crW = 250; + crH = 250; + } + + if(settings->leveldnv == 2) { + crW = int(tileWskip / 2); + crH = int(tileHskip / 2); + } + + // if(settings->leveldnv ==2) {crW=int(tileWskip/2);crH=int(1.15f*(tileWskip/2));}//adapted to scale of preview + if(settings->leveldnv == 3) { + crW = tileWskip - 10; + crH = tileHskip - 10; + } + + float lowdenoise = 1.f; + int levaut = settings->leveldnaut; + + if(levaut == 1) { //Standard + lowdenoise = 0.7f; + } + + // int crW=tileWskip-10;//crop noise width + // int crH=tileHskip-10;//crop noise height // Imagefloat *origCropPart;//init auto noise // origCropPart = new Imagefloat (crW, crH);//allocate memory - if (params.dirpyrDenoise.enabled) {//evaluate Noise - LUTf gamcurve(65536, 0); - float gam, gamthresh, gamslope; - ipf.RGB_denoise_infoGamCurve(params.dirpyrDenoise, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope); - #pragma omp parallel - { - Imagefloat *origCropPart;//init auto noise - origCropPart = new Imagefloat (crW, crH);//allocate memory - Imagefloat *provicalc = new Imagefloat ((crW + 1) / 2, (crH + 1) / 2); //for denoise curves - int skipP = 1; - #pragma omp for schedule(dynamic) collapse(2) nowait + if (params.dirpyrDenoise.enabled) {//evaluate Noise + LUTf gamcurve(65536, 0); + float gam, gamthresh, gamslope; + ipf.RGB_denoise_infoGamCurve(params.dirpyrDenoise, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope); +#pragma omp parallel + { + Imagefloat *origCropPart;//init auto noise + origCropPart = new Imagefloat (crW, crH);//allocate memory + Imagefloat *provicalc = new Imagefloat ((crW + 1) / 2, (crH + 1) / 2); //for denoise curves + int skipP = 1; +#pragma omp for schedule(dynamic) collapse(2) nowait - for(int wcr = 0; wcr < numtiles_W; wcr++) { - for(int hcr = 0; hcr < numtiles_H; hcr++) { - int beg_tileW = wcr * tileWskip + tileWskip / 2.f - crW / 2.f; - int beg_tileH = hcr * tileHskip + tileHskip / 2.f - crH / 2.f; - PreviewProps ppP (beg_tileW , beg_tileH, crW, crH, skipP); - imgsrc->getImage (currWB, tr, origCropPart, ppP, params.toneCurve, params.icm, params.raw ); + for(int wcr = 0; wcr < numtiles_W; wcr++) { + for(int hcr = 0; hcr < numtiles_H; hcr++) { + int beg_tileW = wcr * tileWskip + tileWskip / 2.f - crW / 2.f; + int beg_tileH = hcr * tileHskip + tileHskip / 2.f - crH / 2.f; + PreviewProps ppP (beg_tileW , beg_tileH, crW, crH, skipP); + imgsrc->getImage (currWB, tr, origCropPart, ppP, params.toneCurve, params.icm, params.raw ); + //baseImg->getStdImage(currWB, tr, origCropPart, ppP, true, params.toneCurve); - // we only need image reduced to 1/4 here - for(int ii = 0; ii < crH; ii += 2) { - for(int jj = 0; jj < crW; jj += 2) { - provicalc->r(ii >> 1, jj >> 1) = origCropPart->r(ii, jj); - provicalc->g(ii >> 1, jj >> 1) = origCropPart->g(ii, jj); - provicalc->b(ii >> 1, jj >> 1) = origCropPart->b(ii, jj); + // we only need image reduced to 1/4 here + for(int ii = 0; ii < crH; ii += 2) { + for(int jj = 0; jj < crW; jj += 2) { + provicalc->r(ii >> 1, jj >> 1) = origCropPart->r(ii, jj); + provicalc->g(ii >> 1, jj >> 1) = origCropPart->g(ii, jj); + provicalc->b(ii >> 1, jj >> 1) = origCropPart->b(ii, jj); + } } - } - imgsrc->convertColorSpace(provicalc, params.icm, currWB);//for denoise luminance curve - float maxr = 0.f; - float maxb = 0.f; - float pondcorrec = 1.0f; - float chaut, redaut, blueaut, maxredaut, maxblueaut, minredaut, minblueaut, chromina, sigma, lumema, sigma_L, redyel, skinc, nsknc; - int Nb; - chaut = 0.f; - redaut = 0.f; - blueaut = 0.f; - maxredaut = 0.f; - maxblueaut = 0.f; - chromina = 0.f; - sigma = 0.f; - ipf.RGB_denoise_info(origCropPart, provicalc, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope, params.dirpyrDenoise, imgsrc->getDirPyrDenoiseExpComp(), chaut, Nb, redaut, blueaut, maxredaut, maxblueaut, minredaut, minblueaut, chromina, sigma, lumema, sigma_L, redyel, skinc, nsknc); - float multip = 1.f; - float adjustr = 1.f; + imgsrc->convertColorSpace(provicalc, params.icm, currWB);//for denoise luminance curve + float maxr = 0.f; + float maxb = 0.f; + float pondcorrec = 1.0f; + float chaut, redaut, blueaut, maxredaut, maxblueaut, minredaut, minblueaut, chromina, sigma, lumema, sigma_L, redyel, skinc, nsknc; + int Nb; + chaut = 0.f; + redaut = 0.f; + blueaut = 0.f; + maxredaut = 0.f; + maxblueaut = 0.f; + chromina = 0.f; + sigma = 0.f; + ipf.RGB_denoise_info(origCropPart, provicalc, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope, params.dirpyrDenoise, imgsrc->getDirPyrDenoiseExpComp(), chaut, Nb, redaut, blueaut, maxredaut, maxblueaut, minredaut, minblueaut, chromina, sigma, lumema, sigma_L, redyel, skinc, nsknc); + float multip = 1.f; + float adjustr = 1.f; - if (params.icm.working == "ProPhoto") { - adjustr = 1.f; // - } else if (params.icm.working == "Adobe RGB") { - adjustr = 1.f / 1.3f; - } else if (params.icm.working == "sRGB") { - adjustr = 1.f / 1.3f; - } else if (params.icm.working == "WideGamut") { - adjustr = 1.f / 1.1f; - } else if (params.icm.working == "Rec2020") { - adjustr = 1.f / 1.1f; - } else if (params.icm.working == "Beta RGB") { - adjustr = 1.f / 1.2f; - } else if (params.icm.working == "BestRGB") { - adjustr = 1.f / 1.2f; - } else if (params.icm.working == "BruceRGB") { - adjustr = 1.f / 1.2f; - } - - if(!imgsrc->isRAW()) { - multip = 2.f; //take into account gamma for TIF / JPG approximate value...not good fot gamma=1 - } - - float maxmax = max(maxredaut, maxblueaut); - float delta; - int mode = 2; - int lissage = settings->leveldnliss; - ipf.calcautodn_info (chaut, delta, Nb, levaut, maxmax, lumema, chromina, mode, lissage, redyel, skinc, nsknc); - - // printf("PROCESS cha=%f red=%f bl=%f redM=%f bluM=%f chrom=%f sigm=%f lum=%f sigL=%f\n",chaut,redaut,blueaut, maxredaut, maxblueaut, chromina, sigma, lumema, sigma_L); - if(maxredaut > maxblueaut) { - maxr = (delta) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); - - if(minblueaut <= minredaut && minblueaut < chaut) { - maxb = (-chaut + minblueaut) / (autoNRmax * multip * adjustr * lowdenoise); + if (params.icm.working == "ProPhoto") { + adjustr = 1.f; // + } else if (params.icm.working == "Adobe RGB") { + adjustr = 1.f / 1.3f; + } else if (params.icm.working == "sRGB") { + adjustr = 1.f / 1.3f; + } else if (params.icm.working == "WideGamut") { + adjustr = 1.f / 1.1f; + } else if (params.icm.working == "Rec2020") { + adjustr = 1.f / 1.1f; + } else if (params.icm.working == "Beta RGB") { + adjustr = 1.f / 1.2f; + } else if (params.icm.working == "BestRGB") { + adjustr = 1.f / 1.2f; + } else if (params.icm.working == "BruceRGB") { + adjustr = 1.f / 1.2f; } + + if(!imgsrc->isRAW()) { + multip = 2.f; //take into account gamma for TIF / JPG approximate value...not good fot gamma=1 + } + + float maxmax = max(maxredaut, maxblueaut); + float delta; + int mode = 2; + int lissage = settings->leveldnliss; + ipf.calcautodn_info (chaut, delta, Nb, levaut, maxmax, lumema, chromina, mode, lissage, redyel, skinc, nsknc); + + // printf("PROCESS cha=%f red=%f bl=%f redM=%f bluM=%f chrom=%f sigm=%f lum=%f sigL=%f\n",chaut,redaut,blueaut, maxredaut, maxblueaut, chromina, sigma, lumema, sigma_L); + if(maxredaut > maxblueaut) { + maxr = (delta) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); + + if(minblueaut <= minredaut && minblueaut < chaut) { + maxb = (-chaut + minblueaut) / (autoNRmax * multip * adjustr * lowdenoise); + } + } else { + maxb = (delta) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); + + if(minredaut <= minblueaut && minredaut < chaut) { + maxr = (-chaut + minredaut) / (autoNRmax * multip * adjustr * lowdenoise); + } + }//maxb mxr - empirical evaluation red / blue + + ch_M[hcr * numtiles_W + wcr] = pondcorrec * chaut / (autoNR * multip * adjustr * lowdenoise); + max_r[hcr * numtiles_W + wcr] = pondcorrec * maxr; + max_b[hcr * numtiles_W + wcr] = pondcorrec * maxb; + lumL[hcr * numtiles_W + wcr] = lumema; + chromC[hcr * numtiles_W + wcr] = chromina; + ry[hcr * numtiles_W + wcr] = redyel; + sk[hcr * numtiles_W + wcr] = skinc; + pcsk[hcr * numtiles_W + wcr] = nsknc; + + } + } + + delete provicalc; + delete origCropPart; + } + + int liss = settings->leveldnliss; //smooth result around mean + + if(liss == 2 || liss == 3) { + // I smooth only mean and not delta (max) + float nchm = 0.f; + float koef = 0.4f; //between 0.1 to 0.9 + + if(liss == 3) { + koef = 0.0f; //quasi auto for mean Ch + } + + for(int wcr = 0; wcr < numtiles_W; wcr++) { + for(int hcr = 0; hcr < numtiles_H; hcr++) { + nchm += ch_M[hcr * numtiles_W + wcr]; + } + } + + nchm /= (numtiles_H * numtiles_W); + + for(int wcr = 0; wcr < numtiles_W; wcr++) { + for(int hcr = 0; hcr < numtiles_H; hcr++) { + ch_M[hcr * numtiles_W + wcr] = nchm + (ch_M[hcr * numtiles_W + wcr] - nchm) * koef; + } + } + } + + if(liss == 3) { //same as auto but with much cells + float MaxR = 0.f; + float MaxB = 0.f; + float MaxRMoy = 0.f; + float MaxBMoy = 0.f; + + for(int k = 0; k < nbtl; k++) { + MaxBMoy += max_b[k]; + MaxRMoy += max_r[k]; + + if(max_r[k] > MaxR) { + MaxR = max_r[k]; + } + + if(max_b[k] > MaxB) { + MaxB = max_b[k]; + } + + } + + MaxBMoy /= nbtl; + MaxRMoy /= nbtl; + + for(int k = 0; k < nbtl; k++) { + if(MaxR > MaxB) { + max_r[k] = MaxRMoy + (MaxR - MaxRMoy) * 0.66f; //#std Dev + //max_b[k]=MinB; + max_b[k] = MaxBMoy + (MaxB - MaxBMoy) * 0.66f; + } else { - maxb = (delta) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); + max_b[k] = MaxBMoy + (MaxB - MaxBMoy) * 0.66f; + //max_r[k]=MinR; + max_r[k] = MaxRMoy + (MaxR - MaxRMoy) * 0.66f; - if(minredaut <= minblueaut && minredaut < chaut) { - maxr = (-chaut + minredaut) / (autoNRmax * multip * adjustr * lowdenoise); + } + } + } + + if (settings->verbose) { + t2pone.set(); + printf("Info denoise ponderated performed in %d usec:\n", t2pone.etime(t1pone)); + } + + } + } + + + if((settings->leveldnautsimpl == 1 && params.dirpyrDenoise.Cmethod == "AUT") || (settings->leveldnautsimpl == 0 && params.dirpyrDenoise.C2method == "AUTO")) { + MyTime t1aue, t2aue; + t1aue.set(); + int crW, crH; + + if(settings->leveldnv == 0) { + crW = 100; + crH = 100; + } + + if(settings->leveldnv == 1) { + crW = 250; + crH = 250; + } + + if(settings->leveldnv == 2) { + crW = int(tileWskip / 2); + crH = int(tileHskip / 2); + } + + // if(settings->leveldnv ==2) {crW=int(tileWskip/2);crH=int(1.15f*(tileWskip/2));}//adapted to scale of preview + if(settings->leveldnv == 3) { + crW = tileWskip - 10; + crH = tileHskip - 10; + } + + float lowdenoise = 1.f; + int levaut = settings->leveldnaut; + + if(levaut == 1) { //Standard + lowdenoise = 0.7f; + } + + if (params.dirpyrDenoise.enabled) {//evaluate Noise + LUTf gamcurve(65536, 0); + float gam, gamthresh, gamslope; + ipf.RGB_denoise_infoGamCurve(params.dirpyrDenoise, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope); + int Nb[9]; + int coordW[3];//coordonate of part of image to mesure noise + int coordH[3]; + int begW = 50; + int begH = 50; + coordW[0] = begW; + coordW[1] = fw / 2 - crW / 2; + coordW[2] = fw - crW - begW; + coordH[0] = begH; + coordH[1] = fh / 2 - crH / 2; + coordH[2] = fh - crH - begH; +#pragma omp parallel + { + Imagefloat *origCropPart;//init auto noise + origCropPart = new Imagefloat (crW, crH);//allocate memory + Imagefloat *provicalc = new Imagefloat ((crW + 1) / 2, (crH + 1) / 2); //for denoise curves + +#pragma omp for schedule(dynamic) collapse(2) nowait + + for(int wcr = 0; wcr <= 2; wcr++) { + for(int hcr = 0; hcr <= 2; hcr++) { + PreviewProps ppP (coordW[wcr] , coordH[hcr], crW, crH, 1); + imgsrc->getImage (currWB, tr, origCropPart, ppP, params.toneCurve, params.icm, params.raw); + //baseImg->getStdImage(currWB, tr, origCropPart, ppP, true, params.toneCurve); + + + // we only need image reduced to 1/4 here + for(int ii = 0; ii < crH; ii += 2) { + for(int jj = 0; jj < crW; jj += 2) { + provicalc->r(ii >> 1, jj >> 1) = origCropPart->r(ii, jj); + provicalc->g(ii >> 1, jj >> 1) = origCropPart->g(ii, jj); + provicalc->b(ii >> 1, jj >> 1) = origCropPart->b(ii, jj); + } } - }//maxb mxr - empirical evaluation red / blue - - ch_M[hcr * numtiles_W + wcr] = pondcorrec * chaut / (autoNR * multip * adjustr * lowdenoise); - max_r[hcr * numtiles_W + wcr] = pondcorrec * maxr; - max_b[hcr * numtiles_W + wcr] = pondcorrec * maxb; - lumL[hcr * numtiles_W + wcr] = lumema; - chromC[hcr * numtiles_W + wcr] = chromina; - ry[hcr * numtiles_W + wcr] = redyel; - sk[hcr * numtiles_W + wcr] = skinc; - pcsk[hcr * numtiles_W + wcr] = nsknc; + imgsrc->convertColorSpace(provicalc, params.icm, currWB);//for denoise luminance curve + int nb = 0; + float chaut = 0.f, redaut = 0.f, blueaut = 0.f, maxredaut = 0.f, maxblueaut = 0.f, minredaut = 0.f, minblueaut = 0.f, chromina = 0.f, sigma = 0.f, lumema = 0.f, sigma_L = 0.f, redyel = 0.f, skinc = 0.f, nsknc = 0.f; + ipf.RGB_denoise_info(origCropPart, provicalc, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope, params.dirpyrDenoise, imgsrc->getDirPyrDenoiseExpComp(), chaut, nb, redaut, blueaut, maxredaut, maxblueaut, minredaut, minblueaut, chromina, sigma, lumema, sigma_L, redyel, skinc, nsknc); + Nb[hcr * 3 + wcr] = nb; + ch_M[hcr * 3 + wcr] = chaut; + max_r[hcr * 3 + wcr] = maxredaut; + max_b[hcr * 3 + wcr] = maxblueaut; + min_r[hcr * 3 + wcr] = minredaut; + min_b[hcr * 3 + wcr] = minblueaut; + lumL[hcr * 3 + wcr] = lumema; + chromC[hcr * 3 + wcr] = chromina; + ry[hcr * 3 + wcr] = redyel; + sk[hcr * 3 + wcr] = skinc; + pcsk[hcr * 3 + wcr] = nsknc; + } } + + delete provicalc; + delete origCropPart; } - - delete provicalc; - delete origCropPart; - } - - int liss = settings->leveldnliss; //smooth result around mean - - if(liss == 2 || liss == 3) { - // I smooth only mean and not delta (max) - float nchm = 0.f; - float koef = 0.4f; //between 0.1 to 0.9 - - if(liss == 3) { - koef = 0.0f; //quasi auto for mean Ch - } - - for(int wcr = 0; wcr < numtiles_W; wcr++) { - for(int hcr = 0; hcr < numtiles_H; hcr++) { - nchm += ch_M[hcr * numtiles_W + wcr]; - } - } - - nchm /= (numtiles_H * numtiles_W); - - for(int wcr = 0; wcr < numtiles_W; wcr++) { - for(int hcr = 0; hcr < numtiles_H; hcr++) { - ch_M[hcr * numtiles_W + wcr] = nchm + (ch_M[hcr * numtiles_W + wcr] - nchm) * koef; - } - } - } - - if(liss == 3) { //same as auto but with much cells + float chM = 0.f; float MaxR = 0.f; float MaxB = 0.f; + float MinR = 100000000.f; + float MinB = 100000000.f; + float maxr = 0.f; + float maxb = 0.f; + float multip = 1.f; + float adjustr = 1.f; + float Max_R[9] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}; + float Max_B[9] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}; + float Min_R[9]; + float Min_B[9]; float MaxRMoy = 0.f; float MaxBMoy = 0.f; + float MinRMoy = 0.f; + float MinBMoy = 0.f; - for(int k = 0; k < nbtl; k++) { - MaxBMoy += max_b[k]; - MaxRMoy += max_r[k]; - - if(max_r[k] > MaxR) { - MaxR = max_r[k]; - } - - if(max_b[k] > MaxB) { - MaxB = max_b[k]; - } - + if (params.icm.working == "ProPhoto") { + adjustr = 1.f; + } else if (params.icm.working == "Adobe RGB") { + adjustr = 1.f / 1.3f; + } else if (params.icm.working == "sRGB") { + adjustr = 1.f / 1.3f; + } else if (params.icm.working == "WideGamut") { + adjustr = 1.f / 1.1f; + } else if (params.icm.working == "Rec2020") { + adjustr = 1.f / 1.1f; + } else if (params.icm.working == "Beta RGB") { + adjustr = 1.f / 1.2f; + } else if (params.icm.working == "BestRGB") { + adjustr = 1.f / 1.2f; + } else if (params.icm.working == "BruceRGB") { + adjustr = 1.f / 1.2f; } - MaxBMoy /= nbtl; - MaxRMoy /= nbtl; + if(!imgsrc->isRAW()) { + multip = 2.f; //take into account gamma for TIF / JPG approximate value...not good fot gamma=1 + } - for(int k = 0; k < nbtl; k++) { - if(MaxR > MaxB) { - max_r[k] = MaxRMoy + (MaxR - MaxRMoy) * 0.66f; //#std Dev - //max_b[k]=MinB; - max_b[k] = MaxBMoy + (MaxB - MaxBMoy) * 0.66f; + float delta[9]; + int mode = 1; + int lissage = settings->leveldnliss; + for(int k = 0; k < 9; k++) { + float maxmax = max(max_r[k], max_b[k]); + ipf.calcautodn_info (ch_M[k], delta[k], Nb[k], levaut, maxmax, lumL[k], chromC[k], mode, lissage, ry[k], sk[k], pcsk[k] ); + // printf("ch_M=%f delta=%f\n",ch_M[k], delta[k]); + } + + for(int k = 0; k < 9; k++) { + if(max_r[k] > max_b[k]) { + //printf("R delta=%f koef=%f\n",delta[k],autoNRmax*multip*adjustr*lowdenoise); + Max_R[k] = (delta[k]) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); + Min_B[k] = -(ch_M[k] - min_b[k]) / (autoNRmax * multip * adjustr * lowdenoise); + Max_B[k] = 0.f; + Min_R[k] = 0.f; } else { - max_b[k] = MaxBMoy + (MaxB - MaxBMoy) * 0.66f; - //max_r[k]=MinR; - max_r[k] = MaxRMoy + (MaxR - MaxRMoy) * 0.66f; - - } - } - } - - if (settings->verbose) { - t2pone.set(); - printf("Info denoise ponderated performed in %d usec:\n", t2pone.etime(t1pone)); - } - - } - } - - - if((settings->leveldnautsimpl == 1 && params.dirpyrDenoise.Cmethod == "AUT") || (settings->leveldnautsimpl == 0 && params.dirpyrDenoise.C2method == "AUTO")) { - MyTime t1aue, t2aue; - t1aue.set(); - int crW, crH; - - if(settings->leveldnv == 0) { - crW = 100; - crH = 100; - } - - if(settings->leveldnv == 1) { - crW = 250; - crH = 250; - } - - if(settings->leveldnv == 2) { - crW = int(tileWskip / 2); - crH = int(tileHskip / 2); - } - - // if(settings->leveldnv ==2) {crW=int(tileWskip/2);crH=int(1.15f*(tileWskip/2));}//adapted to scale of preview - if(settings->leveldnv == 3) { - crW = tileWskip - 10; - crH = tileHskip - 10; - } - - float lowdenoise = 1.f; - int levaut = settings->leveldnaut; - - if(levaut == 1) { //Standard - lowdenoise = 0.7f; - } - - if (params.dirpyrDenoise.enabled) {//evaluate Noise - LUTf gamcurve(65536, 0); - float gam, gamthresh, gamslope; - ipf.RGB_denoise_infoGamCurve(params.dirpyrDenoise, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope); - int Nb[9]; - int coordW[3];//coordonate of part of image to mesure noise - int coordH[3]; - int begW = 50; - int begH = 50; - coordW[0] = begW; - coordW[1] = fw / 2 - crW / 2; - coordW[2] = fw - crW - begW; - coordH[0] = begH; - coordH[1] = fh / 2 - crH / 2; - coordH[2] = fh - crH - begH; - #pragma omp parallel - { - Imagefloat *origCropPart;//init auto noise - origCropPart = new Imagefloat (crW, crH);//allocate memory - Imagefloat *provicalc = new Imagefloat ((crW + 1) / 2, (crH + 1) / 2); //for denoise curves - - #pragma omp for schedule(dynamic) collapse(2) nowait - - for(int wcr = 0; wcr <= 2; wcr++) { - for(int hcr = 0; hcr <= 2; hcr++) { - PreviewProps ppP (coordW[wcr] , coordH[hcr], crW, crH, 1); - imgsrc->getImage (currWB, tr, origCropPart, ppP, params.toneCurve, params.icm, params.raw); - - // we only need image reduced to 1/4 here - for(int ii = 0; ii < crH; ii += 2) { - for(int jj = 0; jj < crW; jj += 2) { - provicalc->r(ii >> 1, jj >> 1) = origCropPart->r(ii, jj); - provicalc->g(ii >> 1, jj >> 1) = origCropPart->g(ii, jj); - provicalc->b(ii >> 1, jj >> 1) = origCropPart->b(ii, jj); - } - } - - imgsrc->convertColorSpace(provicalc, params.icm, currWB);//for denoise luminance curve - int nb = 0; - float chaut = 0.f, redaut = 0.f, blueaut = 0.f, maxredaut = 0.f, maxblueaut = 0.f, minredaut = 0.f, minblueaut = 0.f, chromina = 0.f, sigma = 0.f, lumema = 0.f, sigma_L = 0.f, redyel = 0.f, skinc = 0.f, nsknc = 0.f; - ipf.RGB_denoise_info(origCropPart, provicalc, imgsrc->isRAW(), gamcurve, gam, gamthresh, gamslope, params.dirpyrDenoise, imgsrc->getDirPyrDenoiseExpComp(), chaut, nb, redaut, blueaut, maxredaut, maxblueaut, minredaut, minblueaut, chromina, sigma, lumema, sigma_L, redyel, skinc, nsknc); - Nb[hcr * 3 + wcr] = nb; - ch_M[hcr * 3 + wcr] = chaut; - max_r[hcr * 3 + wcr] = maxredaut; - max_b[hcr * 3 + wcr] = maxblueaut; - min_r[hcr * 3 + wcr] = minredaut; - min_b[hcr * 3 + wcr] = minblueaut; - lumL[hcr * 3 + wcr] = lumema; - chromC[hcr * 3 + wcr] = chromina; - ry[hcr * 3 + wcr] = redyel; - sk[hcr * 3 + wcr] = skinc; - pcsk[hcr * 3 + wcr] = nsknc; + //printf("B delta=%f koef=%f\n",delta[k],autoNRmax*multip*adjustr*lowdenoise); + Max_B[k] = (delta[k]) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); + Min_R[k] = - (ch_M[k] - min_r[k]) / (autoNRmax * multip * adjustr * lowdenoise); + Min_B[k] = 0.f; + Max_R[k] = 0.f; } } - delete provicalc; - delete origCropPart; - } - float chM = 0.f; - float MaxR = 0.f; - float MaxB = 0.f; - float MinR = 100000000.f; - float MinB = 100000000.f; - float maxr = 0.f; - float maxb = 0.f; - float multip = 1.f; - float adjustr = 1.f; - float Max_R[9] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}; - float Max_B[9] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}; - float Min_R[9]; - float Min_B[9]; - float MaxRMoy = 0.f; - float MaxBMoy = 0.f; - float MinRMoy = 0.f; - float MinBMoy = 0.f; + for(int k = 0; k < 9; k++) { + // printf("ch_M= %f Max_R=%f Max_B=%f min_r=%f min_b=%f\n",ch_M[k],Max_R[k], Max_B[k],Min_R[k], Min_B[k]); + chM += ch_M[k]; + MaxBMoy += Max_B[k]; + MaxRMoy += Max_R[k]; + MinRMoy += Min_R[k]; + MinBMoy += Min_B[k]; - if (params.icm.working == "ProPhoto") { - adjustr = 1.f; - } else if (params.icm.working == "Adobe RGB") { - adjustr = 1.f / 1.3f; - } else if (params.icm.working == "sRGB") { - adjustr = 1.f / 1.3f; - } else if (params.icm.working == "WideGamut") { - adjustr = 1.f / 1.1f; - } else if (params.icm.working == "Rec2020") { - adjustr = 1.f / 1.1f; - } else if (params.icm.working == "Beta RGB") { - adjustr = 1.f / 1.2f; - } else if (params.icm.working == "BestRGB") { - adjustr = 1.f / 1.2f; - } else if (params.icm.working == "BruceRGB") { - adjustr = 1.f / 1.2f; - } + if(Max_R[k] > MaxR) { + MaxR = Max_R[k]; + } - if(!imgsrc->isRAW()) { - multip = 2.f; //take into account gamma for TIF / JPG approximate value...not good fot gamma=1 - } + if(Max_B[k] > MaxB) { + MaxB = Max_B[k]; + } - float delta[9]; - int mode = 1; - int lissage = settings->leveldnliss; + if(Min_R[k] < MinR) { + MinR = Min_R[k]; + } - for(int k = 0; k < 9; k++) { - float maxmax = max(max_r[k], max_b[k]); - ipf.calcautodn_info (ch_M[k], delta[k], Nb[k], levaut, maxmax, lumL[k], chromC[k], mode, lissage, ry[k], sk[k], pcsk[k] ); - // printf("ch_M=%f delta=%f\n",ch_M[k], delta[k]); - } + if(Min_B[k] < MinB) { + MinB = Min_B[k]; + } + + } + + chM /= 9; + MaxBMoy /= 9; + MaxRMoy /= 9; + MinBMoy /= 9; + MinRMoy /= 9; + + if(MaxR > MaxB) { + maxr = MaxRMoy + (MaxR - MaxRMoy) * 0.66f; //#std Dev + // maxb=MinB; + maxb = MinBMoy + (MinB - MinBMoy) * 0.66f; - for(int k = 0; k < 9; k++) { - if(max_r[k] > max_b[k]) { - //printf("R delta=%f koef=%f\n",delta[k],autoNRmax*multip*adjustr*lowdenoise); - Max_R[k] = (delta[k]) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); - Min_B[k] = -(ch_M[k] - min_b[k]) / (autoNRmax * multip * adjustr * lowdenoise); - Max_B[k] = 0.f; - Min_R[k] = 0.f; } else { - //printf("B delta=%f koef=%f\n",delta[k],autoNRmax*multip*adjustr*lowdenoise); - Max_B[k] = (delta[k]) / ((autoNRmax * multip * adjustr * lowdenoise) / 2.f); - Min_R[k] = - (ch_M[k] - min_r[k]) / (autoNRmax * multip * adjustr * lowdenoise); - Min_B[k] = 0.f; - Max_R[k] = 0.f; + maxb = MaxBMoy + (MaxB - MaxBMoy) * 0.66f; + // maxr=MinR; + maxr = MinRMoy + (MinR - MinRMoy) * 0.66f; + } - } - - for(int k = 0; k < 9; k++) { - // printf("ch_M= %f Max_R=%f Max_B=%f min_r=%f min_b=%f\n",ch_M[k],Max_R[k], Max_B[k],Min_R[k], Min_B[k]); - chM += ch_M[k]; - MaxBMoy += Max_B[k]; - MaxRMoy += Max_R[k]; - MinRMoy += Min_R[k]; - MinBMoy += Min_B[k]; - - if(Max_R[k] > MaxR) { - MaxR = Max_R[k]; - } - - if(Max_B[k] > MaxB) { - MaxB = Max_B[k]; - } - - if(Min_R[k] < MinR) { - MinR = Min_R[k]; - } - - if(Min_B[k] < MinB) { - MinB = Min_B[k]; - } - - } - - chM /= 9; - MaxBMoy /= 9; - MaxRMoy /= 9; - MinBMoy /= 9; - MinRMoy /= 9; - - if(MaxR > MaxB) { - maxr = MaxRMoy + (MaxR - MaxRMoy) * 0.66f; //#std Dev - // maxb=MinB; - maxb = MinBMoy + (MinB - MinBMoy) * 0.66f; - - } else { - maxb = MaxBMoy + (MaxB - MaxBMoy) * 0.66f; - // maxr=MinR; - maxr = MinRMoy + (MinR - MinRMoy) * 0.66f; - - } // printf("SIMPL cha=%f red=%f bl=%f \n",chM,maxr,maxb); - params.dirpyrDenoise.chroma = chM / (autoNR * multip * adjustr); - params.dirpyrDenoise.redchro = maxr; - params.dirpyrDenoise.bluechro = maxb; + params.dirpyrDenoise.chroma = chM / (autoNR * multip * adjustr); + params.dirpyrDenoise.redchro = maxr; + params.dirpyrDenoise.bluechro = maxb; + } + + if (settings->verbose) { + t2aue.set(); + printf("Info denoise auto performed in %d usec:\n", t2aue.etime(t1aue)); + } + + //end evaluate noise } - if (settings->verbose) { - t2aue.set(); - printf("Info denoise auto performed in %d usec:\n", t2aue.etime(t1aue)); + // return true; + } + + void stage_2() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + baseImg = new Imagefloat (fw, fh); + imgsrc->getImage (currWB, tr, baseImg, pp, params.toneCurve, params.icm, params.raw); + + if (pl) { + pl->setProgress (0.50); } - //end evaluate noise - } - - - - - - Imagefloat* baseImg = new Imagefloat (fw, fh); - imgsrc->getImage (currWB, tr, baseImg, pp, params.toneCurve, params.icm, params.raw); - - if (pl) { - pl->setProgress (0.50); - } - // LUTf Noisecurve (65536,0); //!!!// auto exposure!!! - double expcomp = params.toneCurve.expcomp; - int bright = params.toneCurve.brightness; - int contr = params.toneCurve.contrast; - int black = params.toneCurve.black; - int hlcompr = params.toneCurve.hlcompr; - int hlcomprthresh = params.toneCurve.hlcomprthresh; + expcomp = params.toneCurve.expcomp; + bright = params.toneCurve.brightness; + contr = params.toneCurve.contrast; + black = params.toneCurve.black; + hlcompr = params.toneCurve.hlcompr; + hlcomprthresh = params.toneCurve.hlcomprthresh; - if (params.toneCurve.autoexp) { - LUTu aehist; - int aehistcompr; - imgsrc->getAutoExpHistogram (aehist, aehistcompr); - ipf.getAutoExp (aehist, aehistcompr, imgsrc->getDefGain(), params.toneCurve.clip, expcomp, bright, contr, black, hlcompr, hlcomprthresh); + + if (params.toneCurve.autoexp) { + LUTu aehist; + int aehistcompr; + imgsrc->getAutoExpHistogram (aehist, aehistcompr); + ipf.getAutoExp (aehist, aehistcompr, imgsrc->getDefGain(), params.toneCurve.clip, expcomp, bright, contr, black, hlcompr, hlcomprthresh); + } + + // at this stage, we can flush the raw data to free up quite an important amount of memory + // commented out because it makes the application crash when batch processing... + // TODO: find a better place to flush rawData and rawRGB + if(flush) { + imgsrc->flushRawData(); + imgsrc->flushRGB(); + } } - // at this stage, we can flush the raw data to free up quite an important amount of memory - // commented out because it makes the application crash when batch processing... - // TODO: find a better place to flush rawData and rawRGB - if(flush) { - imgsrc->flushRawData(); - imgsrc->flushRGB(); - } - - // perform luma/chroma denoise + void stage_3() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + // perform luma/chroma denoise // CieImage *cieView; // NoisCurve noiseLCurve; // bool lldenoiseutili=false; @@ -677,604 +765,776 @@ IImage16* processImage (ProcessingJob* pjob, int& errorCode, ProgressListener* p // params.dirpyrDenoise.getCurves(noiseLCurve, lldenoiseutili); // if (params.dirpyrDenoise.enabled && lldenoiseutili) { - DirPyrDenoiseParams denoiseParams = params.dirpyrDenoise; // make a copy because we cheat here + DirPyrDenoiseParams denoiseParams = params.dirpyrDenoise; // make a copy because we cheat here - if(denoiseParams.Lmethod == "CUR") { - if(noiseLCurve) { - denoiseParams.luma = 0.5f; - } else { - denoiseParams.luma = 0.0f; + if(denoiseParams.Lmethod == "CUR") { + if(noiseLCurve) { + denoiseParams.luma = 0.5f; + } else { + denoiseParams.luma = 0.0f; + } + } else if(denoiseParams.Lmethod == "SLI") { + noiseLCurve.Reset(); } - } else if(denoiseParams.Lmethod == "SLI") { - noiseLCurve.Reset(); + + if (denoiseParams.enabled && (noiseLCurve || noiseCCurve )) { + // we only need image reduced to 1/4 here + calclum = new Imagefloat ((fw + 1) / 2, (fh + 1) / 2); //for luminance denoise curve +#pragma omp parallel for + + for(int ii = 0; ii < fh; ii += 2) { + for(int jj = 0; jj < fw; jj += 2) { + calclum->r(ii >> 1, jj >> 1) = baseImg->r(ii, jj); + calclum->g(ii >> 1, jj >> 1) = baseImg->g(ii, jj); + calclum->b(ii >> 1, jj >> 1) = baseImg->b(ii, jj); + } + } + + imgsrc->convertColorSpace(calclum, params.icm, currWB); + } + + if (denoiseParams.enabled) { + // CurveFactory::denoiseLL(lldenoiseutili, denoiseParams.lcurve, Noisecurve,1); + //denoiseParams.getCurves(noiseLCurve); +// ipf.RGB_denoise(baseImg, baseImg, calclum, imgsrc->isRAW(), denoiseParams, params.defringe, imgsrc->getDirPyrDenoiseExpComp(), noiseLCurve, lldenoiseutili); + float chaut, redaut, blueaut, maxredaut, maxblueaut, nresi, highresi; + int kall = 2; + ipf.RGB_denoise(kall, baseImg, baseImg, calclum, ch_M, max_r, max_b, imgsrc->isRAW(), denoiseParams, imgsrc->getDirPyrDenoiseExpComp(), noiseLCurve, noiseCCurve, chaut, redaut, blueaut, maxredaut, maxblueaut, nresi, highresi); + + } + +// delete calclum; + delete [] ch_M; + delete [] max_r; + delete [] max_b; + delete [] min_r; + delete [] min_b; + delete [] lumL; + delete [] chromC; + delete [] ry; + delete [] sk; + delete [] pcsk; + + // imgsrc->convertColorSpace(baseImg, params.icm, currWB); + + // // perform first analysis + // hist16 (65536); + + // ipf.firstAnalysis (baseImg, params, hist16); } - if (denoiseParams.enabled && (noiseLCurve || noiseCCurve )) { - // we only need image reduced to 1/4 here - calclum = new Imagefloat ((fw + 1) / 2, (fh + 1) / 2); //for luminance denoise curve - #pragma omp parallel for - for(int ii = 0; ii < fh; ii += 2) { - for(int jj = 0; jj < fw; jj += 2) { - calclum->r(ii >> 1, jj >> 1) = baseImg->r(ii, jj); - calclum->g(ii >> 1, jj >> 1) = baseImg->g(ii, jj); - calclum->b(ii >> 1, jj >> 1) = baseImg->b(ii, jj); + void stage_4() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + imgsrc->convertColorSpace(baseImg, params.icm, currWB); + + // perform first analysis + hist16 (65536); + + ipf.firstAnalysis (baseImg, params, hist16); + + // perform transform (excepted resizing) + if (ipf.needsTransform()) { + Imagefloat* trImg = new Imagefloat (fw, fh); + ipf.transform (baseImg, trImg, 0, 0, 0, 0, fw, fh, fw, fh, imgsrc->getMetaData()->getFocalLen(), imgsrc->getMetaData()->getFocalLen35mm(), + imgsrc->getMetaData()->getFocusDist(), imgsrc->getRotateDegree(), true); + delete baseImg; + baseImg = trImg; + } + } + + void stage_5() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + if (params.dirpyrequalizer.cbdlMethod == "bef" && params.dirpyrequalizer.enabled && !params.colorappearance.enabled) { + const int W = baseImg->getWidth(); + const int H = baseImg->getHeight(); + LabImage labcbdl(W, H); + ipf.rgb2lab(*baseImg, labcbdl, params.icm.working); + ipf.dirpyrequalizer (&labcbdl, 1); + ipf.lab2rgb(labcbdl, *baseImg, params.icm.working); + } + + // update blurmap + SHMap* shmap = nullptr; + + if (params.sh.enabled) { + shmap = new SHMap (fw, fh, true); + double radius = sqrt (double(fw * fw + fh * fh)) / 2.0; + double shradius = params.sh.radius; + + if (!params.sh.hq) { + shradius *= radius / 1800.0; + } + + shmap->update (baseImg, shradius, ipf.lumimul, params.sh.hq, 1); + } + + // RGB processing + + curve1(65536); + curve2(65536); + curve(65536, 0); + satcurve(65536, 0); + lhskcurve(65536, 0); + lumacurve(32770, 0); // lumacurve[32768] and lumacurve[32769] will be set to 32768 and 32769 later to allow linear interpolation + clcurve(65536, 0); + wavclCurve(65536, 0); + + //if(params.blackwhite.enabled) params.toneCurve.hrenabled=false; + + CurveFactory::complexCurve (expcomp, black / 65535.0, hlcompr, hlcomprthresh, params.toneCurve.shcompr, bright, contr, + params.toneCurve.curveMode, params.toneCurve.curve, params.toneCurve.curveMode2, params.toneCurve.curve2, + hist16, curve1, curve2, curve, dummy, customToneCurve1, customToneCurve2 ); + + CurveFactory::RGBCurve (params.rgbCurves.rcurve, rCurve, 1); + CurveFactory::RGBCurve (params.rgbCurves.gcurve, gCurve, 1); + CurveFactory::RGBCurve (params.rgbCurves.bcurve, bCurve, 1); + + bool opautili = false; + + if(params.colorToning.enabled) { + TMatrix wprof = iccStore->workingSpaceMatrix (params.icm.working); + double wp[3][3] = { + {wprof[0][0], wprof[0][1], wprof[0][2]}, + {wprof[1][0], wprof[1][1], wprof[1][2]}, + {wprof[2][0], wprof[2][1], wprof[2][2]} + }; + TMatrix wiprof = iccStore->workingSpaceInverseMatrix (params.icm.working); + double wip[3][3] = { + {wiprof[0][0], wiprof[0][1], wiprof[0][2]}, + {wiprof[1][0], wiprof[1][1], wiprof[1][2]}, + {wiprof[2][0], wiprof[2][1], wiprof[2][2]} + }; + params.colorToning.getCurves(ctColorCurve, ctOpacityCurve, wp, wip, opautili); + clToningcurve (65536, 0); + CurveFactory::curveToning(params.colorToning.clcurve, clToningcurve, 1); + cl2Toningcurve (65536, 0); + CurveFactory::curveToning(params.colorToning.cl2curve, cl2Toningcurve, 1); + } + + labView = new LabImage (fw, fh); + + if(params.blackwhite.enabled) { + CurveFactory::curveBW (params.blackwhite.beforeCurve, params.blackwhite.afterCurve, hist16, dummy, customToneCurvebw1, customToneCurvebw2, 1); + } + + double rrm, ggm, bbm; + float autor, autog, autob; + float satLimit = float(params.colorToning.satProtectionThreshold) / 100.f * 0.7f + 0.3f; + float satLimitOpacity = 1.f - (float(params.colorToning.saturatedOpacity) / 100.f); + + if(params.colorToning.enabled && params.colorToning.autosat) { //for colortoning evaluation of saturation settings + float moyS = 0.f; + float eqty = 0.f; + ipf.moyeqt (baseImg, moyS, eqty);//return image : mean saturation and standard dev of saturation + float satp = ((moyS + 1.5f * eqty) - 0.3f) / 0.7f; //1.5 sigma ==> 93% pixels with high saturation -0.3 / 0.7 convert to Hombre scale + + if(satp >= 0.92f) { + satp = 0.92f; //avoid values too high (out of gamut) + } + + if(satp <= 0.15f) { + satp = 0.15f; //avoid too low values + } + + satLimit = 100.f * satp; + + satLimitOpacity = 100.f * (moyS - 0.85f * eqty); //-0.85 sigma==>20% pixels with low saturation + } + + autor = -9000.f; // This will ask to compute the "auto" values for the B&W tool (have to be inferior to -5000) + DCPProfile::ApplyState as; + DCPProfile *dcpProf = imgsrc->getDCP(params.icm, currWB, as); + + LUTu histToneCurve; + + ipf.rgbProc (baseImg, labView, nullptr, curve1, curve2, curve, shmap, params.toneCurve.saturation, rCurve, gCurve, bCurve, satLimit , satLimitOpacity, ctColorCurve, ctOpacityCurve, opautili, clToningcurve, cl2Toningcurve, customToneCurve1, customToneCurve2, customToneCurvebw1, customToneCurvebw2, rrm, ggm, bbm, autor, autog, autob, expcomp, hlcompr, hlcomprthresh, dcpProf, as, histToneCurve); + + if (settings->verbose) { + printf("Output image / Auto B&W coefs: R=%.2f G=%.2f B=%.2f\n", autor, autog, autob); + } + + // if clut was used and size of clut cache == 1 we free the memory used by the clutstore (default clut cache size = 1 for 32 bit OS) + if ( params.filmSimulation.enabled && !params.filmSimulation.clutFilename.empty() && options.clutCacheSize == 1) { + CLUTStore::getInstance().clearCache(); + } + + // freeing up some memory + customToneCurve1.Reset(); + customToneCurve2.Reset(); + ctColorCurve.Reset(); + ctOpacityCurve.Reset(); + noiseLCurve.Reset(); + noiseCCurve.Reset(); + customToneCurvebw1.Reset(); + customToneCurvebw2.Reset(); + + // Freeing baseImg because not used anymore + delete baseImg; + baseImg = nullptr; + + if (shmap) { + delete shmap; + } + + shmap = nullptr; + + if (pl) { + pl->setProgress (0.55); + } + } + + void stage_6() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + // start tile processing...??? + + + if(params.labCurve.contrast != 0) { //only use hist16 for contrast + hist16.clear(); + +#ifdef _OPENMP +#pragma omp parallel +#endif + { + LUTu hist16thr (hist16.getSize()); // one temporary lookup table per thread + hist16thr.clear(); +#ifdef _OPENMP +#pragma omp for schedule(static) nowait +#endif + + for (int i = 0; i < fh; i++) + for (int j = 0; j < fw; j++) { + hist16thr[(int)((labView->L[i][j]))]++; + } + +#pragma omp critical + { + hist16 += hist16thr; + } } } - imgsrc->convertColorSpace(calclum, params.icm, currWB); - } + bool utili; + CurveFactory::complexLCurve (params.labCurve.brightness, params.labCurve.contrast, params.labCurve.lcurve, hist16, lumacurve, dummy, 1, utili); - if (denoiseParams.enabled) { - // CurveFactory::denoiseLL(lldenoiseutili, denoiseParams.lcurve, Noisecurve,1); - //denoiseParams.getCurves(noiseLCurve); -// ipf.RGB_denoise(baseImg, baseImg, calclum, imgsrc->isRAW(), denoiseParams, params.defringe, imgsrc->getDirPyrDenoiseExpComp(), noiseLCurve, lldenoiseutili); - float chaut, redaut, blueaut, maxredaut, maxblueaut, nresi, highresi; - int kall = 2; - ipf.RGB_denoise(kall, baseImg, baseImg, calclum, ch_M, max_r, max_b, imgsrc->isRAW(), denoiseParams, imgsrc->getDirPyrDenoiseExpComp(), noiseLCurve, noiseCCurve, chaut, redaut, blueaut, maxredaut, maxblueaut, nresi, highresi); + bool clcutili; + CurveFactory::curveCL(clcutili, params.labCurve.clcurve, clcurve, 1); - } + bool ccutili, cclutili; + CurveFactory::complexsgnCurve (autili, butili, ccutili, cclutili, params.labCurve.acurve, params.labCurve.bcurve, params.labCurve.cccurve, + params.labCurve.lccurve, curve1, curve2, satcurve, lhskcurve, 1); -// delete calclum; - delete [] ch_M; - delete [] max_r; - delete [] max_b; - delete [] min_r; - delete [] min_b; - delete [] lumL; - delete [] chromC; - delete [] ry; - delete [] sk; - delete [] pcsk; + ipf.chromiLuminanceCurve (nullptr, 1, labView, labView, curve1, curve2, satcurve, lhskcurve, clcurve, lumacurve, utili, autili, butili, ccutili, cclutili, clcutili, dummy, dummy); - imgsrc->convertColorSpace(baseImg, params.icm, currWB); - - // perform first analysis - LUTu hist16 (65536); - - ipf.firstAnalysis (baseImg, params, hist16); - - // perform transform (excepted resizing) - if (ipf.needsTransform()) { - Imagefloat* trImg = new Imagefloat (fw, fh); - ipf.transform (baseImg, trImg, 0, 0, 0, 0, fw, fh, fw, fh, imgsrc->getMetaData()->getFocalLen(), imgsrc->getMetaData()->getFocalLen35mm(), - imgsrc->getMetaData()->getFocusDist(), imgsrc->getRotateDegree(), true); - delete baseImg; - baseImg = trImg; - } - - - if (params.dirpyrequalizer.cbdlMethod == "bef" && params.dirpyrequalizer.enabled && !params.colorappearance.enabled) { - const int W = baseImg->getWidth(); - const int H = baseImg->getHeight(); - LabImage labcbdl(W, H); - ipf.rgb2lab(*baseImg, labcbdl, params.icm.working); - ipf.dirpyrequalizer (&labcbdl, 1); - ipf.lab2rgb(labcbdl, *baseImg, params.icm.working); - } - - // update blurmap - SHMap* shmap = nullptr; - - if (params.sh.enabled) { - shmap = new SHMap (fw, fh, true); - double radius = sqrt (double(fw * fw + fh * fh)) / 2.0; - double shradius = params.sh.radius; - - if (!params.sh.hq) { - shradius *= radius / 1800.0; + if((params.colorappearance.enabled && !params.colorappearance.tonecie) || (!params.colorappearance.enabled)) { + ipf.EPDToneMap(labView, 5, 1); } - shmap->update (baseImg, shradius, ipf.lumimul, params.sh.hq, 1); + + ipf.vibrance(labView); + + if((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) { + ipf.impulsedenoise (labView); + } + + // for all treatments Defringe, Sharpening, Contrast detail ,Microcontrast they are activated if "CIECAM" function are disabled + + if((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) { + ipf.defringe (labView); + } + + if (params.sharpenEdge.enabled) { + ipf.MLsharpen(labView); + } + + if (params.sharpenMicro.enabled) { + if((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) { + ipf.MLmicrocontrast (labView); //!params.colorappearance.sharpcie + } + } + + if(((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) && params.sharpening.enabled) { + + float **buffer = new float*[fh]; + + for (int i = 0; i < fh; i++) { + buffer[i] = new float[fw]; + } + + ipf.sharpening (labView, (float**)buffer, params.sharpening); + + for (int i = 0; i < fh; i++) { + delete [] buffer[i]; + } + + delete [] buffer; + } + + WaveletParams WaveParams = params.wavelet; + WavCurve wavCLVCurve; + WavOpacityCurveRG waOpacityCurveRG; + WavOpacityCurveBY waOpacityCurveBY; + WavOpacityCurveW waOpacityCurveW; + WavOpacityCurveWL waOpacityCurveWL; + + params.wavelet.getCurves(wavCLVCurve, waOpacityCurveRG, waOpacityCurveBY, waOpacityCurveW, waOpacityCurveWL ); + + + // directional pyramid wavelet + if(params.dirpyrequalizer.cbdlMethod == "aft") { + if((params.colorappearance.enabled && !settings->autocielab) || !params.colorappearance.enabled) { + ipf.dirpyrequalizer (labView, 1); //TODO: this is the luminance tonecurve, not the RGB one + } + } + + bool wavcontlutili = false; + + CurveFactory::curveWavContL(wavcontlutili, params.wavelet.wavclCurve, wavclCurve,/* hist16C, dummy,*/ 1); + + if(params.wavelet.enabled) { + ipf.ip_wavelet(labView, labView, 2, WaveParams, wavCLVCurve, waOpacityCurveRG, waOpacityCurveBY, waOpacityCurveW, waOpacityCurveWL, wavclCurve, wavcontlutili, 1); + } + + wavCLVCurve.Reset(); + + //Colorappearance and tone-mapping associated + + int f_w = 1, f_h = 1; + int begh = 0, endh = fh; + + if(params.colorappearance.tonecie || params.colorappearance.enabled) { + f_w = fw; + f_h = fh; + } + + CieImage *cieView = new CieImage (f_w, (f_h)); + begh = 0; + endh = fh; + CurveFactory::curveLightBrightColor ( + params.colorappearance.curve, + params.colorappearance.curve2, + params.colorappearance.curve3, + hist16, dummy, + dummy, dummy, + customColCurve1, + customColCurve2, + customColCurve3, + 1); + + if(params.colorappearance.enabled) { + double adap; + float fnum = imgsrc->getMetaData()->getFNumber ();// F number + float fiso = imgsrc->getMetaData()->getISOSpeed () ;// ISO + float fspeed = imgsrc->getMetaData()->getShutterSpeed () ;//speed + float fcomp = imgsrc->getMetaData()->getExpComp ();//compensation + - + + if(fnum < 0.3f || fiso < 5.f || fspeed < 0.00001f) { + adap = 2000.; + }//if no exif data or wrong + else { + float E_V = fcomp + log2 ((fnum * fnum) / fspeed / (fiso / 100.f)); + E_V += params.toneCurve.expcomp;// exposure compensation in tonecurve ==> direct EV + E_V += log2(params.raw.expos);// exposure raw white point ; log2 ==> linear to EV + adap = powf(2.f, E_V - 3.f); //cd / m2 + } + + LUTf CAMBrightCurveJ; + LUTf CAMBrightCurveQ; + float CAMMean = NAN; + + if (params.sharpening.enabled) { + if(settings->ciecamfloat) { + float d; + ipf.ciecam_02float (cieView, float(adap), begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, d, 1, 1); + } else { + double dd; + ipf.ciecam_02 (cieView, adap, begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, dd, 1, 1); + } + } else { + if(settings->ciecamfloat) { + float d; + ipf.ciecam_02float (cieView, float(adap), begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, d, 1, 1); + } else { + double dd; + ipf.ciecam_02 (cieView, adap, begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, dd, 1, 1); + } + } + } + + delete cieView; + cieView = nullptr; + + + + + // end tile processing...??? + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + if (pl) { + pl->setProgress (0.60); + } } - // RGB processing + Image16 *stage_7() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + int imw, imh; + double tmpScale = ipf.resizeScale(¶ms, fw, fh, imw, imh); + bool labResize = params.resize.enabled && params.resize.method != "Nearest" && tmpScale != 1.0; + LabImage *tmplab; - LUTf curve1 (65536); - LUTf curve2 (65536); - LUTf curve (65536, 0); - LUTf satcurve (65536, 0); - LUTf lhskcurve (65536, 0); - LUTf lumacurve(32770, 0); // lumacurve[32768] and lumacurve[32769] will be set to 32768 and 32769 later to allow linear interpolation - LUTf clcurve (65536, 0); + // crop and convert to rgb16 + int cx = 0, cy = 0, cw = labView->W, ch = labView->H; + + if (params.crop.enabled) { + cx = params.crop.x; + cy = params.crop.y; + cw = params.crop.w; + ch = params.crop.h; + + if(labResize) { // crop lab data + tmplab = new LabImage(cw, ch); + + for(int row = 0; row < ch; row++) { + for(int col = 0; col < cw; col++) { + tmplab->L[row][col] = labView->L[row + cy][col + cx]; + tmplab->a[row][col] = labView->a[row + cy][col + cx]; + tmplab->b[row][col] = labView->b[row + cy][col + cx]; + } + } + + delete labView; + labView = tmplab; + cx = 0; + cy = 0; + } + } + + if (labResize) { // resize lab data + // resize image + tmplab = new LabImage(imw, imh); + ipf.Lanczos (labView, tmplab, tmpScale); + delete labView; + labView = tmplab; + cw = labView->W; + ch = labView->H; + + if(params.prsharpening.enabled) { + for(int i = 0; i < ch; i++) + for(int j = 0; j < cw; j++) { + labView->L[i][j] = labView->L[i][j] < 0.f ? 0.f : labView->L[i][j]; + } + + float **buffer = new float*[ch]; + + for (int i = 0; i < ch; i++) { + buffer[i] = new float[cw]; + } + + ipf.sharpening (labView, (float**)buffer, params.prsharpening); + + for (int i = 0; i < ch; i++) { + delete [] buffer[i]; + } + + delete [] buffer; + } + } + + Image16* readyImg = nullptr; + cmsHPROFILE jprof = nullptr; + bool customGamma = false; + bool useLCMS = false; + bool bwonly = params.blackwhite.enabled && !params.colorToning.enabled && !autili && !butili ; + + if(params.icm.gamma != "default" || params.icm.freegamma) { // if select gamma output between BT709, sRGB, linear, low, high, 2.2 , 1.8 + + GammaValues ga; + // if(params.blackwhite.enabled) params.toneCurve.hrenabled=false; + readyImg = ipf.lab2rgb16 (labView, cx, cy, cw, ch, params.icm, bwonly, &ga); + customGamma = true; + + //or selected Free gamma + useLCMS = false; + + if ((jprof = iccStore->createCustomGammaOutputProfile (params.icm, ga)) == nullptr) { + useLCMS = true; + } + + } else { + // if Default gamma mode: we use the profile selected in the "Output profile" combobox; + // gamma come from the selected profile, otherwise it comes from "Free gamma" tool + + readyImg = ipf.lab2rgb16 (labView, cx, cy, cw, ch, params.icm, bwonly); + + if (settings->verbose) { + printf("Output profile_: \"%s\"\n", params.icm.output.c_str()); + } + } + + delete labView; + labView = nullptr; + + + + if(bwonly) { //force BW r=g=b + if (settings->verbose) { + printf("Force BW\n"); + } + + for (int ccw = 0; ccw < cw; ccw++) { + for (int cch = 0; cch < ch; cch++) { + readyImg->r(cch, ccw) = readyImg->g(cch, ccw); + readyImg->b(cch, ccw) = readyImg->g(cch, ccw); + } + } + } + + if (pl) { + pl->setProgress (0.70); + } + + if (tmpScale != 1.0 && params.resize.method == "Nearest") { // resize rgb data (gamma applied) + Image16* tempImage = new Image16 (imw, imh); + ipf.resize (readyImg, tempImage, tmpScale); + delete readyImg; + readyImg = tempImage; + } + + if (tunnelMetaData) { + readyImg->setMetadata (ii->getMetaData()->getExifData ()); + } else { + readyImg->setMetadata (ii->getMetaData()->getExifData (), params.exif, params.iptc); + } + + + // Setting the output curve to readyImg + if (customGamma) { + if (!useLCMS) { + // use corrected sRGB profile in order to apply a good TRC if present, otherwise use LCMS2 profile generated by lab2rgb16 w/ gamma + ProfileContent pc(jprof); + readyImg->setOutputProfile (pc.data, pc.length); + } + } else { + // use the selected output profile if present, otherwise use LCMS2 profile generate by lab2rgb16 w/ gamma + + if (params.icm.output != "" && params.icm.output != ColorManagementParams::NoICMString) { + + // if iccStore->getProfile send back an object, then iccStore->getContent will do too + cmsHPROFILE jprof = iccStore->getProfile(params.icm.output); //get outProfile + + if (jprof == nullptr) { + if (settings->verbose) { + printf("\"%s\" ICC output profile not found!\n - use LCMS2 substitution\n", params.icm.output.c_str()); + } + } else { + if (settings->verbose) { + printf("Using \"%s\" output profile\n", params.icm.output.c_str()); + } + + ProfileContent pc = iccStore->getContent (params.icm.output); + readyImg->setOutputProfile (pc.data, pc.length); + } + } else { + // No ICM + readyImg->setOutputProfile (nullptr, 0); + } + } + +// t2.set(); +// if( settings->verbose ) +// printf("Total:- %d usec\n", t2.etime(t1)); + + if (!job->initialImage) { + ii->decreaseRef (); + } + + delete job; + + if (pl) { + pl->setProgress (0.75); + } + + /* curve1.reset();curve2.reset(); + curve.reset(); + satcurve.reset(); + lhskcurve.reset(); + + rCurve.reset(); + gCurve.reset(); + bCurve.reset(); + hist16.reset(); + hist16C.reset(); + */ + return readyImg; + } + + void stage_early_resize() + { + ProcessingJobImpl* job = static_cast(pjob); + procparams::ProcParams& params = job->pparams; + ImProcFunctions ipf (¶ms, true); + + int imw, imh; + double tmpScale = ipf.resizeScale(¶ms, fw, fh, imw, imh); + // bool resize = params.resize.enabled; + + LabImage *tmplab = new LabImage(fw, fh); + ipf.rgb2lab(*baseImg, *tmplab, params.icm.working); + + // crop and convert to rgb16 + int cx = 0, cy = 0, cw = fw, ch = fh; + + if (params.crop.enabled) { + cx = params.crop.x; + cy = params.crop.y; + cw = params.crop.w; + ch = params.crop.h; + + LabImage *cropped = new LabImage(cw, ch); + + for(int row = 0; row < ch; row++) { + for(int col = 0; col < cw; col++) { + cropped->L[row][col] = tmplab->L[row + cy][col + cx]; + cropped->a[row][col] = tmplab->a[row + cy][col + cx]; + cropped->b[row][col] = tmplab->b[row + cy][col + cx]; + } + } + + delete tmplab; + tmplab = cropped; + cx = 0; + cy = 0; + + params.crop.enabled = false; + } + + if (params.resize.enabled) { + // resize image + LabImage *resized = new LabImage(imw, imh); + ipf.Lanczos(tmplab, resized, tmpScale); + delete tmplab; + tmplab = resized; + params.resize.enabled = false; + + if (params.prsharpening.enabled) { + params.sharpening = params.prsharpening; + } + + params.wavelet.strength = + int(float(params.wavelet.strength) * tmpScale); + params.dirpyrDenoise.luma *= tmpScale; + // params.dirpyrDenoise.smethod = "shal"; + + fw = imw; + fh = imh; + } + + delete baseImg; + baseImg = new Imagefloat(fw, fh); + ipf.lab2rgb(*tmplab, *baseImg, params.icm.working); + delete tmplab; + } + +private: + ProcessingJob* pjob; + int& errorCode; + ProgressListener* pl; + bool tunnelMetaData; + bool flush; + + // internal state + InitialImage *ii; + ImageSource *imgsrc; + int fw; + int fh; + + int tr; + PreviewProps pp; + + NoiseCurve noiseLCurve; + NoiseCurve noiseCCurve; + Imagefloat *calclum; + float autoNR; + float autoNRmax; + int tilesize; + int overlap; + + float *ch_M; + float *max_r; + float *max_b; + float *min_b; + float *min_r; + float *lumL; + float *chromC; + float *ry; + float *sk; + float *pcsk; + + double expcomp; + int bright; + int contr; + int black; + int hlcompr; + int hlcomprthresh; + + ColorTemp currWB; + Imagefloat *baseImg; + LabImage* labView; + + LUTu hist16; + + LUTf curve1; + LUTf curve2; + LUTf curve; + LUTf satcurve; + LUTf lhskcurve; + LUTf lumacurve; + LUTf clcurve; LUTf clToningcurve; LUTf cl2Toningcurve; - LUTf wavclCurve (65536, 0); + LUTf wavclCurve; LUTf rCurve; LUTf gCurve; LUTf bCurve; LUTu dummy; - + ToneCurve customToneCurve1, customToneCurve2; ColorGradientCurve ctColorCurve; OpacityCurve ctOpacityCurve; ColorAppearance customColCurve1, customColCurve2, customColCurve3 ; ToneCurve customToneCurvebw1; ToneCurve customToneCurvebw2; - //if(params.blackwhite.enabled) params.toneCurve.hrenabled=false; - CurveFactory::complexCurve (expcomp, black / 65535.0, hlcompr, hlcomprthresh, params.toneCurve.shcompr, bright, contr, - params.toneCurve.curveMode, params.toneCurve.curve, params.toneCurve.curveMode2, params.toneCurve.curve2, - hist16, curve1, curve2, curve, dummy, customToneCurve1, customToneCurve2 ); + bool autili, butili; +}; - CurveFactory::RGBCurve (params.rgbCurves.rcurve, rCurve, 1); - CurveFactory::RGBCurve (params.rgbCurves.gcurve, gCurve, 1); - CurveFactory::RGBCurve (params.rgbCurves.bcurve, bCurve, 1); +} // namespace - bool opautili = false; - if(params.colorToning.enabled) { - TMatrix wprof = iccStore->workingSpaceMatrix (params.icm.working); - double wp[3][3] = { - {wprof[0][0], wprof[0][1], wprof[0][2]}, - {wprof[1][0], wprof[1][1], wprof[1][2]}, - {wprof[2][0], wprof[2][1], wprof[2][2]} - }; - TMatrix wiprof = iccStore->workingSpaceInverseMatrix (params.icm.working); - double wip[3][3] = { - {wiprof[0][0], wiprof[0][1], wiprof[0][2]}, - {wiprof[1][0], wiprof[1][1], wiprof[1][2]}, - {wiprof[2][0], wiprof[2][1], wiprof[2][2]} - }; - params.colorToning.getCurves(ctColorCurve, ctOpacityCurve, wp, wip, opautili); - clToningcurve (65536, 0); - CurveFactory::curveToning(params.colorToning.clcurve, clToningcurve, 1); - cl2Toningcurve (65536, 0); - CurveFactory::curveToning(params.colorToning.cl2curve, cl2Toningcurve, 1); - } - - LabImage* labView = new LabImage (fw, fh); - - if(params.blackwhite.enabled) { - CurveFactory::curveBW (params.blackwhite.beforeCurve, params.blackwhite.afterCurve, hist16, dummy, customToneCurvebw1, customToneCurvebw2, 1); - } - - double rrm, ggm, bbm; - float autor, autog, autob; - float satLimit = float(params.colorToning.satProtectionThreshold) / 100.f * 0.7f + 0.3f; - float satLimitOpacity = 1.f - (float(params.colorToning.saturatedOpacity) / 100.f); - - if(params.colorToning.enabled && params.colorToning.autosat) { //for colortoning evaluation of saturation settings - float moyS = 0.f; - float eqty = 0.f; - ipf.moyeqt (baseImg, moyS, eqty);//return image : mean saturation and standard dev of saturation - float satp = ((moyS + 1.5f * eqty) - 0.3f) / 0.7f; //1.5 sigma ==> 93% pixels with high saturation -0.3 / 0.7 convert to Hombre scale - - if(satp >= 0.92f) { - satp = 0.92f; //avoid values too high (out of gamut) - } - - if(satp <= 0.15f) { - satp = 0.15f; //avoid too low values - } - - satLimit = 100.f * satp; - - satLimitOpacity = 100.f * (moyS - 0.85f * eqty); //-0.85 sigma==>20% pixels with low saturation - } - - autor = -9000.f; // This will ask to compute the "auto" values for the B&W tool (have to be inferior to -5000) - DCPProfile::ApplyState as; - DCPProfile *dcpProf = imgsrc->getDCP(params.icm, currWB, as); - - LUTu histToneCurve; - - ipf.rgbProc (baseImg, labView, nullptr, curve1, curve2, curve, shmap, params.toneCurve.saturation, rCurve, gCurve, bCurve, satLimit , satLimitOpacity, ctColorCurve, ctOpacityCurve, opautili, clToningcurve, cl2Toningcurve, customToneCurve1, customToneCurve2, customToneCurvebw1, customToneCurvebw2, rrm, ggm, bbm, autor, autog, autob, expcomp, hlcompr, hlcomprthresh, dcpProf, as, histToneCurve); - - if (settings->verbose) { - printf("Output image / Auto B&W coefs: R=%.2f G=%.2f B=%.2f\n", autor, autog, autob); - } - - // if clut was used and size of clut cache == 1 we free the memory used by the clutstore (default clut cache size = 1 for 32 bit OS) - if ( params.filmSimulation.enabled && !params.filmSimulation.clutFilename.empty() && options.clutCacheSize == 1) { - CLUTStore::getInstance().clearCache(); - } - - // freeing up some memory - customToneCurve1.Reset(); - customToneCurve2.Reset(); - ctColorCurve.Reset(); - ctOpacityCurve.Reset(); - noiseLCurve.Reset(); - noiseCCurve.Reset(); - customToneCurvebw1.Reset(); - customToneCurvebw2.Reset(); - - // Freeing baseImg because not used anymore - delete baseImg; - baseImg = nullptr; - - if (shmap) { - delete shmap; - } - - shmap = nullptr; - - if (pl) { - pl->setProgress (0.55); - } - - //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - // start tile processing...??? - - - if(params.labCurve.contrast != 0) { //only use hist16 for contrast - hist16.clear(); - -#ifdef _OPENMP - #pragma omp parallel -#endif - { - LUTu hist16thr (hist16.getSize()); // one temporary lookup table per thread - hist16thr.clear(); -#ifdef _OPENMP - #pragma omp for schedule(static) nowait -#endif - - for (int i = 0; i < fh; i++) - for (int j = 0; j < fw; j++) { - hist16thr[(int)((labView->L[i][j]))]++; - } - - #pragma omp critical - { - hist16 += hist16thr; - } - } - } - - bool utili; - CurveFactory::complexLCurve (params.labCurve.brightness, params.labCurve.contrast, params.labCurve.lcurve, hist16, lumacurve, dummy, 1, utili); - - bool clcutili; - CurveFactory::curveCL(clcutili, params.labCurve.clcurve, clcurve, 1); - - bool autili, butili, ccutili, cclutili; - CurveFactory::complexsgnCurve (autili, butili, ccutili, cclutili, params.labCurve.acurve, params.labCurve.bcurve, params.labCurve.cccurve, - params.labCurve.lccurve, curve1, curve2, satcurve, lhskcurve, 1); - - ipf.chromiLuminanceCurve (nullptr, 1, labView, labView, curve1, curve2, satcurve, lhskcurve, clcurve, lumacurve, utili, autili, butili, ccutili, cclutili, clcutili, dummy, dummy); - - if((params.colorappearance.enabled && !params.colorappearance.tonecie) || (!params.colorappearance.enabled)) { - ipf.EPDToneMap(labView, 5, 1); - } - - - ipf.vibrance(labView); - - if((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) { - ipf.impulsedenoise (labView); - } - - // for all treatments Defringe, Sharpening, Contrast detail ,Microcontrast they are activated if "CIECAM" function are disabled - - if((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) { - ipf.defringe (labView); - } - - if (params.sharpenEdge.enabled) { - ipf.MLsharpen(labView); - } - - if (params.sharpenMicro.enabled) { - if((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) { - ipf.MLmicrocontrast (labView); //!params.colorappearance.sharpcie - } - } - - if(((params.colorappearance.enabled && !settings->autocielab) || (!params.colorappearance.enabled)) && params.sharpening.enabled) { - - float **buffer = new float*[fh]; - - for (int i = 0; i < fh; i++) { - buffer[i] = new float[fw]; - } - - ipf.sharpening (labView, (float**)buffer, params.sharpening); - - for (int i = 0; i < fh; i++) { - delete [] buffer[i]; - } - - delete [] buffer; - } - - WaveletParams WaveParams = params.wavelet; - WavCurve wavCLVCurve; - WavOpacityCurveRG waOpacityCurveRG; - WavOpacityCurveBY waOpacityCurveBY; - WavOpacityCurveW waOpacityCurveW; - WavOpacityCurveWL waOpacityCurveWL; - - params.wavelet.getCurves(wavCLVCurve, waOpacityCurveRG, waOpacityCurveBY, waOpacityCurveW, waOpacityCurveWL ); - - - // directional pyramid wavelet - if(params.dirpyrequalizer.cbdlMethod == "aft") { - if((params.colorappearance.enabled && !settings->autocielab) || !params.colorappearance.enabled) { - ipf.dirpyrequalizer (labView, 1); //TODO: this is the luminance tonecurve, not the RGB one - } - } - - bool wavcontlutili = false; - - CurveFactory::curveWavContL(wavcontlutili, params.wavelet.wavclCurve, wavclCurve,/* hist16C, dummy,*/ 1); - - if(params.wavelet.enabled) { - ipf.ip_wavelet(labView, labView, 2, WaveParams, wavCLVCurve, waOpacityCurveRG, waOpacityCurveBY, waOpacityCurveW, waOpacityCurveWL, wavclCurve, wavcontlutili, 1); - } - - wavCLVCurve.Reset(); - - //Colorappearance and tone-mapping associated - - int f_w = 1, f_h = 1; - int begh = 0, endh = fh; - - if(params.colorappearance.tonecie || params.colorappearance.enabled) { - f_w = fw; - f_h = fh; - } - - CieImage *cieView = new CieImage (f_w, (f_h)); - begh = 0; - endh = fh; - CurveFactory::curveLightBrightColor ( - params.colorappearance.curve, - params.colorappearance.curve2, - params.colorappearance.curve3, - hist16, dummy, - dummy, dummy, - customColCurve1, - customColCurve2, - customColCurve3, - 1); - - if(params.colorappearance.enabled) { - double adap; - float fnum = imgsrc->getMetaData()->getFNumber ();// F number - float fiso = imgsrc->getMetaData()->getISOSpeed () ;// ISO - float fspeed = imgsrc->getMetaData()->getShutterSpeed () ;//speed - float fcomp = imgsrc->getMetaData()->getExpComp ();//compensation + - - - if(fnum < 0.3f || fiso < 5.f || fspeed < 0.00001f) { - adap = 2000.; - }//if no exif data or wrong - else { - float E_V = fcomp + log2 ((fnum * fnum) / fspeed / (fiso / 100.f)); - E_V += params.toneCurve.expcomp;// exposure compensation in tonecurve ==> direct EV - E_V += log2(params.raw.expos);// exposure raw white point ; log2 ==> linear to EV - adap = powf(2.f, E_V - 3.f); //cd / m2 - } - - LUTf CAMBrightCurveJ; - LUTf CAMBrightCurveQ; - float CAMMean = NAN; - - if (params.sharpening.enabled) { - if(settings->ciecamfloat) { - float d; - ipf.ciecam_02float (cieView, float(adap), begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, d, 1, 1); - } else { - double dd; - ipf.ciecam_02 (cieView, adap, begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, dd, 1, 1); - } - } else { - if(settings->ciecamfloat) { - float d; - ipf.ciecam_02float (cieView, float(adap), begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, d, 1, 1); - } else { - double dd; - ipf.ciecam_02 (cieView, adap, begh, endh, 1, 2, labView, ¶ms, customColCurve1, customColCurve2, customColCurve3, dummy, dummy, CAMBrightCurveJ, CAMBrightCurveQ, CAMMean, 5, 1, true, dd, 1, 1); - } - } - } - - delete cieView; - cieView = nullptr; - - - - - // end tile processing...??? - //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - - if (pl) { - pl->setProgress (0.60); - } - - int imw, imh; - double tmpScale = ipf.resizeScale(¶ms, fw, fh, imw, imh); - bool labResize = params.resize.enabled && params.resize.method != "Nearest" && tmpScale != 1.0; - LabImage *tmplab; - - // crop and convert to rgb16 - int cx = 0, cy = 0, cw = labView->W, ch = labView->H; - - if (params.crop.enabled) { - cx = params.crop.x; - cy = params.crop.y; - cw = params.crop.w; - ch = params.crop.h; - - if(labResize) { // crop lab data - tmplab = new LabImage(cw, ch); - - for(int row = 0; row < ch; row++) { - for(int col = 0; col < cw; col++) { - tmplab->L[row][col] = labView->L[row + cy][col + cx]; - tmplab->a[row][col] = labView->a[row + cy][col + cx]; - tmplab->b[row][col] = labView->b[row + cy][col + cx]; - } - } - - delete labView; - labView = tmplab; - cx = 0; - cy = 0; - } - } - - if (labResize) { // resize lab data - // resize image - tmplab = new LabImage(imw, imh); - ipf.Lanczos (labView, tmplab, tmpScale); - delete labView; - labView = tmplab; - cw = labView->W; - ch = labView->H; - - if(params.prsharpening.enabled) { - for(int i = 0; i < ch; i++) - for(int j = 0; j < cw; j++) { - labView->L[i][j] = labView->L[i][j] < 0.f ? 0.f : labView->L[i][j]; - } - - float **buffer = new float*[ch]; - - for (int i = 0; i < ch; i++) { - buffer[i] = new float[cw]; - } - - ipf.sharpening (labView, (float**)buffer, params.prsharpening); - - for (int i = 0; i < ch; i++) { - delete [] buffer[i]; - } - - delete [] buffer; - } - } - - Image16* readyImg = nullptr; - cmsHPROFILE jprof = nullptr; - bool customGamma = false; - bool useLCMS = false; - bool bwonly = params.blackwhite.enabled && !params.colorToning.enabled && !autili && !butili ; - - if(params.icm.gamma != "default" || params.icm.freegamma) { // if select gamma output between BT709, sRGB, linear, low, high, 2.2 , 1.8 - - GammaValues ga; - // if(params.blackwhite.enabled) params.toneCurve.hrenabled=false; - readyImg = ipf.lab2rgb16 (labView, cx, cy, cw, ch, params.icm, bwonly, &ga); - customGamma = true; - - //or selected Free gamma - useLCMS = false; - - if ((jprof = iccStore->createCustomGammaOutputProfile (params.icm, ga)) == nullptr) { - useLCMS = true; - } - - } else { - // if Default gamma mode: we use the profile selected in the "Output profile" combobox; - // gamma come from the selected profile, otherwise it comes from "Free gamma" tool - - readyImg = ipf.lab2rgb16 (labView, cx, cy, cw, ch, params.icm, bwonly); - - if (settings->verbose) { - printf("Output profile_: \"%s\"\n", params.icm.output.c_str()); - } - } - - delete labView; - labView = nullptr; - - - - if(bwonly) { //force BW r=g=b - if (settings->verbose) { - printf("Force BW\n"); - } - - for (int ccw = 0; ccw < cw; ccw++) { - for (int cch = 0; cch < ch; cch++) { - readyImg->r(cch, ccw) = readyImg->g(cch, ccw); - readyImg->b(cch, ccw) = readyImg->g(cch, ccw); - } - } - } - - if (pl) { - pl->setProgress (0.70); - } - - if (tmpScale != 1.0 && params.resize.method == "Nearest") { // resize rgb data (gamma applied) - Image16* tempImage = new Image16 (imw, imh); - ipf.resize (readyImg, tempImage, tmpScale); - delete readyImg; - readyImg = tempImage; - } - - if (tunnelMetaData) { - readyImg->setMetadata (ii->getMetaData()->getExifData ()); - } else { - readyImg->setMetadata (ii->getMetaData()->getExifData (), params.exif, params.iptc); - } - - - // Setting the output curve to readyImg - if (customGamma) { - if (!useLCMS) { - // use corrected sRGB profile in order to apply a good TRC if present, otherwise use LCMS2 profile generated by lab2rgb16 w/ gamma - ProfileContent pc(jprof); - readyImg->setOutputProfile (pc.data, pc.length); - } - } else { - // use the selected output profile if present, otherwise use LCMS2 profile generate by lab2rgb16 w/ gamma - - if (params.icm.output != "" && params.icm.output != ColorManagementParams::NoICMString) { - - // if iccStore->getProfile send back an object, then iccStore->getContent will do too - cmsHPROFILE jprof = iccStore->getProfile(params.icm.output); //get outProfile - - if (jprof == nullptr) { - if (settings->verbose) { - printf("\"%s\" ICC output profile not found!\n - use LCMS2 substitution\n", params.icm.output.c_str()); - } - } else { - if (settings->verbose) { - printf("Using \"%s\" output profile\n", params.icm.output.c_str()); - } - - ProfileContent pc = iccStore->getContent (params.icm.output); - readyImg->setOutputProfile (pc.data, pc.length); - } - } else { - // No ICM - readyImg->setOutputProfile (nullptr, 0); - } - } - -// t2.set(); -// if( settings->verbose ) -// printf("Total:- %d usec\n", t2.etime(t1)); - - if (!job->initialImage) { - ii->decreaseRef (); - } - - delete job; - - if (pl) { - pl->setProgress (0.75); - } - - /* curve1.reset();curve2.reset(); - curve.reset(); - satcurve.reset(); - lhskcurve.reset(); - - rCurve.reset(); - gCurve.reset(); - bCurve.reset(); - hist16.reset(); - hist16C.reset(); - */ - return readyImg; +IImage16* processImage (ProcessingJob* pjob, int& errorCode, ProgressListener* pl, bool tunnelMetaData, bool flush) +{ + ImageProcessor proc(pjob, errorCode, pl, tunnelMetaData, flush); + return proc(true); } void batchProcessingThread (ProcessingJob* job, BatchProcessingListener* bpl, bool tunnelMetaData) From 93296cff17d93b14b033ee63164a68eb72632bbd Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Wed, 8 Mar 2017 00:50:50 +0100 Subject: [PATCH 02/90] continuing with my experiments on an alternative "fast export" --- rtengine/processingjob.cc | 8 ++++---- rtengine/processingjob.h | 9 ++++---- rtengine/rtengine.h | 4 ++-- rtengine/simpleprocess.cc | 43 +++++++++++++++++++-------------------- rtgui/batchqueue.cc | 9 ++++++-- rtgui/filebrowser.cc | 6 +++++- rtgui/filecatalog.cc | 4 ++-- rtgui/main.cc | 8 +++++++- 8 files changed, 53 insertions(+), 38 deletions(-) diff --git a/rtengine/processingjob.cc b/rtengine/processingjob.cc index 612edc2a2..a377e3963 100644 --- a/rtengine/processingjob.cc +++ b/rtengine/processingjob.cc @@ -21,16 +21,16 @@ namespace rtengine { -ProcessingJob* ProcessingJob::create (const Glib::ustring& fname, bool isRaw, const procparams::ProcParams& pparams) +ProcessingJob* ProcessingJob::create (const Glib::ustring& fname, bool isRaw, const procparams::ProcParams& pparams, bool fast) { - return new ProcessingJobImpl (fname, isRaw, pparams); + return new ProcessingJobImpl (fname, isRaw, pparams, fast); } -ProcessingJob* ProcessingJob::create (InitialImage* initialImage, const procparams::ProcParams& pparams) +ProcessingJob* ProcessingJob::create (InitialImage* initialImage, const procparams::ProcParams& pparams, bool fast) { - return new ProcessingJobImpl (initialImage, pparams); + return new ProcessingJobImpl (initialImage, pparams, fast); } void ProcessingJob::destroy (ProcessingJob* job) diff --git a/rtengine/processingjob.h b/rtengine/processingjob.h index 2de426a31..fd3fe82a8 100644 --- a/rtengine/processingjob.h +++ b/rtengine/processingjob.h @@ -32,12 +32,13 @@ public: bool isRaw; InitialImage* initialImage; procparams::ProcParams pparams; + bool fast; - ProcessingJobImpl (const Glib::ustring& fn, bool iR, const procparams::ProcParams& pp) - : fname(fn), isRaw(iR), initialImage(nullptr), pparams(pp) {} + ProcessingJobImpl (const Glib::ustring& fn, bool iR, const procparams::ProcParams& pp, bool ff) + : fname(fn), isRaw(iR), initialImage(nullptr), pparams(pp), fast(ff) {} - ProcessingJobImpl (InitialImage* iImage, const procparams::ProcParams& pp) - : fname(""), isRaw(true), initialImage(iImage), pparams(pp) + ProcessingJobImpl (InitialImage* iImage, const procparams::ProcParams& pp, bool ff) + : fname(""), isRaw(true), initialImage(iImage), pparams(pp), fast(ff) { iImage->increaseRef(); } diff --git a/rtengine/rtengine.h b/rtengine/rtengine.h index fc793dd71..4cb672e15 100644 --- a/rtengine/rtengine.h +++ b/rtengine/rtengine.h @@ -468,7 +468,7 @@ public: * @param isRaw shall be true if it is a raw file * @param pparams is a struct containing the processing parameters * @return an object containing the data above. It can be passed to the functions that do the actual image processing. */ - static ProcessingJob* create (const Glib::ustring& fname, bool isRaw, const procparams::ProcParams& pparams); + static ProcessingJob* create (const Glib::ustring& fname, bool isRaw, const procparams::ProcParams& pparams, bool fast=false); /** Creates a processing job from a file name. This function always succeeds. It only stores the data into the ProcessingJob class, it does not load * the image thus it returns immediately. This function increases the reference count of the initialImage. If you decide not the process the image you @@ -477,7 +477,7 @@ public: * @param initialImage is a loaded and pre-processed initial image * @param pparams is a struct containing the processing parameters * @return an object containing the data above. It can be passed to the functions that do the actual image processing. */ - static ProcessingJob* create (InitialImage* initialImage, const procparams::ProcParams& pparams); + static ProcessingJob* create (InitialImage* initialImage, const procparams::ProcParams& pparams, bool fast=false); /** Cancels and destroys a processing job. The reference count of the corresponding initialImage (if any) is decreased. After the call of this function the ProcessingJob instance * gets invalid, you must not use it any more. Dont call this function while the job is being processed. diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index e027968a5..677f912fc 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -41,7 +41,7 @@ class ImageProcessor { public: ImageProcessor(ProcessingJob* pjob, int& errorCode, ProgressListener* pl, bool tunnelMetaData, bool flush): - pjob(pjob), + job(static_cast(pjob)), errorCode(errorCode), pl(pl), tunnelMetaData(tunnelMetaData), @@ -55,9 +55,9 @@ public: { } - Image16 *operator()(bool fast) + Image16 *operator()() { - if (!fast) { + if (!job->fast) { return normal_pipeline(); } else { return fast_pipeline(); @@ -81,21 +81,28 @@ private: Image16 *fast_pipeline() { - ProcessingJobImpl* job = static_cast(pjob); if (!job->pparams.resize.enabled) { return normal_pipeline(); } + + pl = nullptr; if (!stage_1()) { return nullptr; } + stage_calc_denoise(); + printf("after calc denoise\n"); fflush(stdout); stage_2(); stage_4(); + printf("after 4\n"); fflush(stdout); stage_early_resize(); - stage_calc_denoise(); + printf("after early resize\n"); fflush(stdout); stage_3(); + printf("after 3\n"); fflush(stdout); stage_5(); + printf("after 5\n"); fflush(stdout); stage_6(); + printf("after 6\n"); fflush(stdout); return stage_7(); } @@ -103,8 +110,6 @@ private: { errorCode = 0; - ProcessingJobImpl* job = static_cast(pjob); - if (pl) { pl->setProgressStr ("PROGRESSBAR_PROCESSING"); pl->setProgress (0.0); @@ -235,7 +240,6 @@ private: void stage_calc_denoise() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -714,7 +718,6 @@ private: void stage_2() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -753,7 +756,6 @@ private: void stage_3() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -826,7 +828,6 @@ private: void stage_4() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -849,7 +850,6 @@ private: void stage_5() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -994,7 +994,6 @@ private: void stage_6() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -1192,7 +1191,6 @@ private: Image16 *stage_7() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -1389,7 +1387,6 @@ private: void stage_early_resize() { - ProcessingJobImpl* job = static_cast(pjob); procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -1435,14 +1432,16 @@ private: tmplab = resized; params.resize.enabled = false; - if (params.prsharpening.enabled) { - params.sharpening = params.prsharpening; - } - + params.sharpening = params.prsharpening; params.wavelet.strength = int(float(params.wavelet.strength) * tmpScale); params.dirpyrDenoise.luma *= tmpScale; - // params.dirpyrDenoise.smethod = "shal"; + params.dirpyrDenoise.smethod = "shal"; + + for (int i = 0; i < 6; ++i) { + auto &n = params.dirpyrequalizer.mult[i]; + n = 1.0 + (n - 1.0) * tmpScale; + } fw = imw; fh = imh; @@ -1455,7 +1454,7 @@ private: } private: - ProcessingJob* pjob; + ProcessingJobImpl* job; int& errorCode; ProgressListener* pl; bool tunnelMetaData; @@ -1534,7 +1533,7 @@ private: IImage16* processImage (ProcessingJob* pjob, int& errorCode, ProgressListener* pl, bool tunnelMetaData, bool flush) { ImageProcessor proc(pjob, errorCode, pl, tunnelMetaData, flush); - return proc(true); + return proc(); } void batchProcessingThread (ProcessingJob* job, BatchProcessingListener* bpl, bool tunnelMetaData) diff --git a/rtgui/batchqueue.cc b/rtgui/batchqueue.cc index 7bd53c444..1f2dac51d 100644 --- a/rtgui/batchqueue.cc +++ b/rtgui/batchqueue.cc @@ -34,6 +34,9 @@ #include "guiutils.h" #include "rtimage.h" #include + +#include "../rtengine/processingjob.h" + using namespace std; using namespace rtengine; @@ -227,7 +230,7 @@ bool BatchQueue::saveBatchQueue () // The column's header is mandatory (the first line will be skipped when loaded) file << "input image full path|param file full path|output image full path|file format|jpeg quality|jpeg subsampling|" - << "png bit depth|png compression|tiff bit depth|uncompressed tiff|save output params|force format options|" + << "png bit depth|png compression|tiff bit depth|uncompressed tiff|save output params|force format options|fast export|" << std::endl; // method is already running with entryLock, so no need to lock again @@ -242,6 +245,7 @@ bool BatchQueue::saveBatchQueue () << saveFormat.pngBits << '|' << saveFormat.pngCompression << '|' << saveFormat.tiffBits << '|' << saveFormat.tiffUncompressed << '|' << saveFormat.saveParams << '|' << entry->forceFormatOpts << '|' + << static_cast(entry->job)->fast << '|' << std::endl; } } @@ -308,6 +312,7 @@ bool BatchQueue::loadBatchQueue () const auto tiffUncompressed = nextIntOr (options.saveFormat.tiffUncompressed); const auto saveParams = nextIntOr (options.saveFormat.saveParams); const auto forceFormatOpts = nextIntOr (options.forceFormatOpts); + const auto fast = nextIntOr(false); rtengine::procparams::ProcParams pparams; @@ -319,7 +324,7 @@ bool BatchQueue::loadBatchQueue () if (!thumb) continue; - auto job = rtengine::ProcessingJob::create (source, thumb->getType () == FT_Raw, pparams); + auto job = rtengine::ProcessingJob::create (source, thumb->getType () == FT_Raw, pparams, fast); auto prevh = getMaxThumbnailHeight (); auto prevw = prevh; diff --git a/rtgui/filebrowser.cc b/rtgui/filebrowser.cc index 5cbb5255b..24d1d8541 100644 --- a/rtgui/filebrowser.cc +++ b/rtgui/filebrowser.cc @@ -389,6 +389,7 @@ FileBrowser::FileBrowser () untrash->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_Delete, Gdk::SHIFT_MASK, Gtk::ACCEL_VISIBLE); open->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_Return, (Gdk::ModifierType)0, Gtk::ACCEL_VISIBLE); develop->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_B, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE); + developfast->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_B, Gdk::CONTROL_MASK | Gdk::SHIFT_MASK, Gtk::ACCEL_VISIBLE); copyprof->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_C, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE); pasteprof->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_V, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE); partpasteprof->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_V, Gdk::CONTROL_MASK | Gdk::SHIFT_MASK, Gtk::ACCEL_VISIBLE); @@ -1139,9 +1140,12 @@ bool FileBrowser::keyPressed (GdkEventKey* event) } else if (event->keyval == GDK_KEY_Delete && shift) { menuItemActivated (untrash); return true; - } else if ((event->keyval == GDK_KEY_B || event->keyval == GDK_KEY_b) && ctrl) { + } else if ((event->keyval == GDK_KEY_B || event->keyval == GDK_KEY_b) && ctrl && !shift) { menuItemActivated (develop); return true; + } else if ((event->keyval == GDK_KEY_B || event->keyval == GDK_KEY_b) && ctrl && shift) { + menuItemActivated (developfast); + return true; } else if ((event->keyval == GDK_KEY_A || event->keyval == GDK_KEY_a) && ctrl) { menuItemActivated (selall); return true; diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index a876dd54e..99c190cde 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -1094,7 +1094,7 @@ void FileCatalog::developRequested (std::vector tbe, bool fas // controlling time and resource consuming tasks // and also those which effect is not pronounced after reducing the image size // TODO!!! could expose selections below via preferences - if (fastmode) { + if (fastmode && false) { if (options.fastexport_bypass_sharpening ) { params.sharpening.enabled = false; } @@ -1187,7 +1187,7 @@ void FileCatalog::developRequested (std::vector tbe, bool fas params.resize.height = options.fastexport_resize_height ; } - rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params); + rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params, fastmode); int pw; int ph = BatchQueue::calcMaxThumbnailHeight(); diff --git a/rtgui/main.cc b/rtgui/main.cc index ee3d3210e..7e11825a2 100644 --- a/rtgui/main.cc +++ b/rtgui/main.cc @@ -83,6 +83,8 @@ Glib::ustring fname_to_utf8 (const char* fname) #endif } +bool fast_export = false; + } // This recursive mutex will be used by gdk_threads_enter/leave instead of a simple mutex @@ -537,6 +539,10 @@ int processLineParams( int argc, char **argv ) compression = -1; break; + case 'f': + fast_export = true; + break; + case 'c': // MUST be last option while (iArg + 1 < argc) { iArg++; @@ -845,7 +851,7 @@ int processLineParams( int argc, char **argv ) continue; } - job = rtengine::ProcessingJob::create (ii, currentParams); + job = rtengine::ProcessingJob::create (ii, currentParams, fast_export); if( !job ) { errors++; From 44505ccb0844a6ef9823cdbd82cca2ca299161fc Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Wed, 8 Mar 2017 22:55:08 +0100 Subject: [PATCH 03/90] some enhancements of the Fast Export functionality - remember fast export options across RT sessions - added option to use a dedicated "Fast Export" pipeline, trading speed for quality (resizes early instead of at the end) --- rtdata/languages/default | 2 + rtengine/processingjob.h | 2 + rtengine/rtengine.h | 2 + rtengine/simpleprocess.cc | 86 ++++++++------------------------------- rtgui/batchqueue.cc | 4 +- rtgui/exportpanel.cc | 64 +++++++++++++++++++---------- rtgui/exportpanel.h | 1 + rtgui/filecatalog.cc | 8 ++-- rtgui/options.cc | 5 +++ rtgui/options.h | 1 + 10 files changed, 76 insertions(+), 99 deletions(-) diff --git a/rtdata/languages/default b/rtdata/languages/default index 31b14aa2f..f47d09e5d 100644 --- a/rtdata/languages/default +++ b/rtdata/languages/default @@ -80,6 +80,8 @@ EXPORT_BYPASS_SHARPENEDGE;Bypass Edge Sharpening EXPORT_BYPASS_SHARPENING;Bypass Sharpening EXPORT_BYPASS_SHARPENMICRO;Bypass Microcontrast EXPORT_BYPASS_SH_HQ;Bypass Sharp Mask Shadows/Highlights +EXPORT_USE_FAST_PIPELINE;Enable Special "Fast-Export" Processing Pipeline +EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. EXPORT_FASTEXPORTOPTIONS;Fast Export Options EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. EXPORT_MAXHEIGHT;Maximum height: diff --git a/rtengine/processingjob.h b/rtengine/processingjob.h index fd3fe82a8..c7f49192e 100644 --- a/rtengine/processingjob.h +++ b/rtengine/processingjob.h @@ -49,6 +49,8 @@ public: initialImage->decreaseRef(); } } + + bool fastPipeline() const { return fast; } }; } diff --git a/rtengine/rtengine.h b/rtengine/rtengine.h index 4cb672e15..7449dbd0d 100644 --- a/rtengine/rtengine.h +++ b/rtengine/rtengine.h @@ -483,6 +483,8 @@ public: * gets invalid, you must not use it any more. Dont call this function while the job is being processed. * @param job is the job to destroy */ static void destroy (ProcessingJob* job); + + virtual bool fastPipeline() const = 0; }; /** This function performs all the image processinf steps corresponding to the given ProcessingJob. It returns when it is ready, so it can be slow. diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 677f912fc..3b450c492 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -67,16 +67,12 @@ public: private: Image16 *normal_pipeline() { - if (!stage_1()) { + if (!stage_init()) { return nullptr; } - stage_calc_denoise(); - stage_2(); - stage_3(); - stage_4(); - stage_5(); - stage_6(); - return stage_7(); + stage_denoise(); + stage_transform(); + return stage_finish(); } Image16 *fast_pipeline() @@ -87,26 +83,16 @@ private: pl = nullptr; - if (!stage_1()) { + if (!stage_init()) { return nullptr; } - stage_calc_denoise(); - printf("after calc denoise\n"); fflush(stdout); - stage_2(); - stage_4(); - printf("after 4\n"); fflush(stdout); + stage_transform(); stage_early_resize(); - printf("after early resize\n"); fflush(stdout); - stage_3(); - printf("after 3\n"); fflush(stdout); - stage_5(); - printf("after 5\n"); fflush(stdout); - stage_6(); - printf("after 6\n"); fflush(stdout); - return stage_7(); + stage_denoise(); + return stage_finish(); } - bool stage_1() + bool stage_init() { errorCode = 0; @@ -230,19 +216,6 @@ private: currWB.update(rm, gm, bm, params.wb.equal, params.wb.tempBias); } - // // AG begin - // baseImg = new Imagefloat (fw, fh); - // imgsrc->getImage (currWB, tr, baseImg, pp, params.toneCurve, params.icm, params.raw); - // // AG end - - return true; - } - - void stage_calc_denoise() - { - procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); - calclum = nullptr ; params.dirpyrDenoise.getCurves(noiseLCurve, noiseCCurve); autoNR = (float) settings->nrauto;// @@ -713,14 +686,6 @@ private: //end evaluate noise } - // return true; - } - - void stage_2() - { - procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); - baseImg = new Imagefloat (fw, fh); imgsrc->getImage (currWB, tr, baseImg, pp, params.toneCurve, params.icm, params.raw); @@ -752,9 +717,11 @@ private: imgsrc->flushRawData(); imgsrc->flushRGB(); } + + return true; } - void stage_3() + void stage_denoise() { procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -816,17 +783,9 @@ private: delete [] ry; delete [] sk; delete [] pcsk; - - // imgsrc->convertColorSpace(baseImg, params.icm, currWB); - - // // perform first analysis - // hist16 (65536); - - // ipf.firstAnalysis (baseImg, params, hist16); } - - void stage_4() + void stage_transform() { procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -848,7 +807,7 @@ private: } } - void stage_5() + Image16 *stage_finish() { procparams::ProcParams& params = job->pparams; ImProcFunctions ipf (¶ms, true); @@ -990,13 +949,7 @@ private: if (pl) { pl->setProgress (0.55); } - } - void stage_6() - { - procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); - //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // start tile processing...??? @@ -1187,13 +1140,7 @@ private: if (pl) { pl->setProgress (0.60); } - } - Image16 *stage_7() - { - procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); - int imw, imh; double tmpScale = ipf.resizeScale(¶ms, fw, fh, imw, imh); bool labResize = params.resize.enabled && params.resize.method != "Nearest" && tmpScale != 1.0; @@ -1392,12 +1339,10 @@ private: int imw, imh; double tmpScale = ipf.resizeScale(¶ms, fw, fh, imw, imh); - // bool resize = params.resize.enabled; LabImage *tmplab = new LabImage(fw, fh); ipf.rgb2lab(*baseImg, *tmplab, params.icm.working); - // crop and convert to rgb16 int cx = 0, cy = 0, cw = fw, ch = fh; if (params.crop.enabled) { @@ -1438,9 +1383,10 @@ private: params.dirpyrDenoise.luma *= tmpScale; params.dirpyrDenoise.smethod = "shal"; + const double dirpyreq_scale = min(tmpScale * 1.5, 1.0); for (int i = 0; i < 6; ++i) { auto &n = params.dirpyrequalizer.mult[i]; - n = 1.0 + (n - 1.0) * tmpScale; + n = 1.0 + (n - 1.0) * dirpyreq_scale; } fw = imw; diff --git a/rtgui/batchqueue.cc b/rtgui/batchqueue.cc index 1f2dac51d..a02046e01 100644 --- a/rtgui/batchqueue.cc +++ b/rtgui/batchqueue.cc @@ -35,8 +35,6 @@ #include "rtimage.h" #include -#include "../rtengine/processingjob.h" - using namespace std; using namespace rtengine; @@ -245,7 +243,7 @@ bool BatchQueue::saveBatchQueue () << saveFormat.pngBits << '|' << saveFormat.pngCompression << '|' << saveFormat.tiffBits << '|' << saveFormat.tiffUncompressed << '|' << saveFormat.saveParams << '|' << entry->forceFormatOpts << '|' - << static_cast(entry->job)->fast << '|' + << entry->job->fastPipeline() << '|' << std::endl; } } diff --git a/rtgui/exportpanel.cc b/rtgui/exportpanel.cc index 3f7be7ab4..fe18cdef7 100644 --- a/rtgui/exportpanel.cc +++ b/rtgui/exportpanel.cc @@ -39,6 +39,8 @@ ExportPanel::ExportPanel () : listener (nullptr) pack_start(*labExportTitle, Gtk::PACK_SHRINK, 4); bypass_ALL = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_ALL"))); + use_fast_pipeline = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_USE_FAST_PIPELINE"))); + use_fast_pipeline->set_tooltip_text(M("EXPORT_USE_FAST_PIPELINE_TIP")); bypass_sharpening = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENING"))); bypass_sharpenEdge = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENEDGE"))); bypass_sharpenMicro = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENMICRO"))); @@ -96,6 +98,7 @@ ExportPanel::ExportPanel () : listener (nullptr) // ---------------------------------------------------------------- // start global packing + pack_start(*use_fast_pipeline , Gtk::PACK_SHRINK, 4); pack_start(*bypass_ALL , Gtk::PACK_SHRINK, 4); pack_start(*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 4); pack_start(*bypass_sharpening , Gtk::PACK_SHRINK, 4); @@ -224,40 +227,48 @@ void ExportPanel::FastExportPressed () void ExportPanel::SaveSettingsAsDefault() { + bool changed = false; +#define FE_OPT_STORE_(n, v) \ + do { \ + if (n != v) { \ + n = v; \ + changed = true; \ + } \ + } while (false) // Save fast export settings to options - options.fastexport_bypass_sharpening = bypass_sharpening->get_active (); - options.fastexport_bypass_sharpenEdge = bypass_sharpenEdge->get_active (); - options.fastexport_bypass_sharpenMicro = bypass_sharpenMicro->get_active (); + FE_OPT_STORE_(options.fastexport_bypass_sharpening, bypass_sharpening->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_sharpenEdge, bypass_sharpenEdge->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_sharpenMicro, bypass_sharpenMicro->get_active ()); //options.fastexport_bypass_lumaDenoise = bypass_lumaDenoise->get_active (); //options.fastexport_bypass_colorDenoise = bypass_colorDenoise->get_active (); - options.fastexport_bypass_defringe = bypass_defringe->get_active (); - options.fastexport_bypass_dirpyrDenoise = bypass_dirpyrDenoise->get_active (); - options.fastexport_bypass_sh_hq = bypass_sh_hq->get_active (); - options.fastexport_bypass_dirpyrequalizer = bypass_dirpyrequalizer->get_active (); - options.fastexport_bypass_wavelet = bypass_wavelet->get_active (); + FE_OPT_STORE_(options.fastexport_bypass_defringe, bypass_defringe->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_dirpyrDenoise, bypass_dirpyrDenoise->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_sh_hq, bypass_sh_hq->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_dirpyrequalizer, bypass_dirpyrequalizer->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_wavelet, bypass_wavelet->get_active ()); //options.fastexport_bypass_raw_bayer_all_enhance = bypass_raw_all_enhance->get_active (); - options.fastexport_bypass_raw_bayer_dcb_iterations = bypass_raw_bayer_dcb_iterations->get_active (); - options.fastexport_bypass_raw_bayer_dcb_enhance = bypass_raw_bayer_dcb_enhance->get_active (); - options.fastexport_bypass_raw_bayer_lmmse_iterations = bypass_raw_bayer_lmmse_iterations->get_active(); - options.fastexport_bypass_raw_bayer_linenoise = bypass_raw_bayer_linenoise->get_active (); - options.fastexport_bypass_raw_bayer_greenthresh = bypass_raw_bayer_greenthresh->get_active (); - options.fastexport_bypass_raw_ccSteps = bypass_raw_ccSteps->get_active (); - options.fastexport_bypass_raw_ca = bypass_raw_ca->get_active (); - options.fastexport_bypass_raw_df = bypass_raw_df->get_active (); - options.fastexport_bypass_raw_ff = bypass_raw_ff->get_active (); + FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_dcb_iterations, bypass_raw_bayer_dcb_iterations->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_dcb_enhance, bypass_raw_bayer_dcb_enhance->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_lmmse_iterations, bypass_raw_bayer_lmmse_iterations->get_active()); + FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_linenoise, bypass_raw_bayer_linenoise->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_greenthresh, bypass_raw_bayer_greenthresh->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_raw_ccSteps, bypass_raw_ccSteps->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_raw_ca, bypass_raw_ca->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_raw_df, bypass_raw_df->get_active ()); + FE_OPT_STORE_(options.fastexport_bypass_raw_ff, bypass_raw_ff->get_active ()); //saving Bayer demosaic_method int currentRow = raw_bayer_method->get_active_row_number(); if( currentRow >= 0 && currentRow < procparams::RAWParams::BayerSensor::numMethods) { - options.fastexport_raw_bayer_method = procparams::RAWParams::BayerSensor::methodstring[currentRow]; + FE_OPT_STORE_(options.fastexport_raw_bayer_method, procparams::RAWParams::BayerSensor::methodstring[currentRow]); } //saving X-Trans demosaic_method currentRow = raw_xtrans_method->get_active_row_number(); if( currentRow >= 0 && currentRow < procparams::RAWParams::XTransSensor::numMethods) { - options.fastexport_raw_xtrans_method = procparams::RAWParams::XTransSensor::methodstring[currentRow]; + FE_OPT_STORE_(options.fastexport_raw_xtrans_method, procparams::RAWParams::XTransSensor::methodstring[currentRow]); } // options.fastexport_icm_input = icm_input ; @@ -269,9 +280,16 @@ void ExportPanel::SaveSettingsAsDefault() // options.fastexport_resize_appliesTo = resize_appliesTo; // options.fastexport_resize_dataspec = resize_dataspec ; - options.fastexport_resize_method = "Lanczos"; - options.fastexport_resize_width = MaxWidth->get_value_as_int (); - options.fastexport_resize_height = MaxHeight->get_value_as_int (); + FE_OPT_STORE_(options.fastexport_resize_method, "Lanczos"); + FE_OPT_STORE_(options.fastexport_resize_width, MaxWidth->get_value_as_int ()); + FE_OPT_STORE_(options.fastexport_resize_height, MaxHeight->get_value_as_int ()); + + FE_OPT_STORE_(options.fastexport_use_fast_pipeline, use_fast_pipeline->get_active()); +#undef FE_OPT_STORE_ + + if (changed) { + Options::save(); + } } void ExportPanel::LoadDefaultSettings() @@ -327,6 +345,8 @@ void ExportPanel::LoadDefaultSettings() MaxWidth->set_value(options.fastexport_resize_width); MaxHeight->set_value(options.fastexport_resize_height); + + use_fast_pipeline->set_active(options.fastexport_use_fast_pipeline); } void ExportPanel::LoadSettings() diff --git a/rtgui/exportpanel.h b/rtgui/exportpanel.h index 840a4638d..ce7639921 100644 --- a/rtgui/exportpanel.h +++ b/rtgui/exportpanel.h @@ -38,6 +38,7 @@ protected: //Gtk::CheckButton* enabled; Gtk::CheckButton* bypass_ALL; + Gtk::CheckButton* use_fast_pipeline; Gtk::CheckButton* bypass_sharpenEdge; Gtk::CheckButton* bypass_sharpenMicro; Gtk::CheckButton* bypass_sharpening; diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index 99c190cde..68219d745 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -1094,7 +1094,7 @@ void FileCatalog::developRequested (std::vector tbe, bool fas // controlling time and resource consuming tasks // and also those which effect is not pronounced after reducing the image size // TODO!!! could expose selections below via preferences - if (fastmode && false) { + if (fastmode) { if (options.fastexport_bypass_sharpening ) { params.sharpening.enabled = false; } @@ -1183,11 +1183,11 @@ void FileCatalog::developRequested (std::vector tbe, bool fas params.resize.appliesTo = options.fastexport_resize_appliesTo ; params.resize.method = options.fastexport_resize_method ; params.resize.dataspec = options.fastexport_resize_dataspec ; - params.resize.width = options.fastexport_resize_width ; - params.resize.height = options.fastexport_resize_height ; + params.resize.width = rtengine::min(params.resize.width, options.fastexport_resize_width) ; + params.resize.height = rtengine::min(params.resize.height, options.fastexport_resize_height) ; } - rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params, fastmode); + rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params, fastmode && options.fastexport_use_fast_pipeline); int pw; int ph = BatchQueue::calcMaxThumbnailHeight(); diff --git a/rtgui/options.cc b/rtgui/options.cc index 2f71a7106..9a8b5e08b 100644 --- a/rtgui/options.cc +++ b/rtgui/options.cc @@ -480,6 +480,7 @@ void Options::setDefaults () fastexport_resize_dataspec = 3; fastexport_resize_width = 900; fastexport_resize_height = 900; + fastexport_use_fast_pipeline = false; clutsDir = "./cluts"; @@ -1784,6 +1785,9 @@ int Options::readFromFile (Glib::ustring fname) if (keyFile.has_key ("Fast Export", "fastexport_resize_height" )) { fastexport_resize_height = keyFile.get_integer ("Fast Export", "fastexport_resize_height" ); } + if (keyFile.has_key ("Fast Export", "fastexport_use_fast_pipeline" )) { + fastexport_use_fast_pipeline = keyFile.get_integer ("Fast Export", "fastexport_use_fast_pipeline" ); + } } if (keyFile.has_group ("Dialogs")) { @@ -2142,6 +2146,7 @@ int Options::saveToFile (Glib::ustring fname) keyFile.set_integer ("Fast Export", "fastexport_resize_dataspec", fastexport_resize_dataspec ); keyFile.set_integer ("Fast Export", "fastexport_resize_width", fastexport_resize_width ); keyFile.set_integer ("Fast Export", "fastexport_resize_height", fastexport_resize_height ); + keyFile.set_integer ("Fast Export", "fastexport_use_fast_pipeline", fastexport_use_fast_pipeline ); keyFile.set_string ("Dialogs", "LastIccDir", lastIccDir); keyFile.set_string ("Dialogs", "LastDarkframeDir", lastDarkframeDir); diff --git a/rtgui/options.h b/rtgui/options.h index efc649417..b853c07f6 100644 --- a/rtgui/options.h +++ b/rtgui/options.h @@ -279,6 +279,7 @@ public: int fastexport_resize_dataspec; int fastexport_resize_width; int fastexport_resize_height; + bool fastexport_use_fast_pipeline; // Dialog settings Glib::ustring lastIccDir; From 64661e1a2711ce38ef7c85baea49d81f2892ada1 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Thu, 9 Mar 2017 00:05:27 +0100 Subject: [PATCH 04/90] set dirpyrDenoise.median=false in the fast export pipeline --- rtengine/simpleprocess.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 3b450c492..774ee6c5c 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1382,6 +1382,7 @@ private: int(float(params.wavelet.strength) * tmpScale); params.dirpyrDenoise.luma *= tmpScale; params.dirpyrDenoise.smethod = "shal"; + params.dirpyrDenoise.median = false; const double dirpyreq_scale = min(tmpScale * 1.5, 1.0); for (int i = 0; i < 6; ++i) { From 359b4136b52f90c431665ccd36fdfcb98ef9edcc Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Fri, 10 Mar 2017 10:53:10 +0100 Subject: [PATCH 05/90] do not use the hard-coded (i.e. not user-selectable) fast export options if the new fast pipeline is selected --- rtengine/simpleprocess.cc | 2 +- rtgui/filecatalog.cc | 52 ++++++++++++++++++++++----------------- 2 files changed, 30 insertions(+), 24 deletions(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 774ee6c5c..f10378a07 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1381,8 +1381,8 @@ private: params.wavelet.strength = int(float(params.wavelet.strength) * tmpScale); params.dirpyrDenoise.luma *= tmpScale; + params.dirpyrDenoise.smethod = "shal"; - params.dirpyrDenoise.median = false; const double dirpyreq_scale = min(tmpScale * 1.5, 1.0); for (int i = 0; i < 6; ++i) { diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index 68219d745..a5b3cdb85 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -1129,25 +1129,27 @@ void FileCatalog::developRequested (std::vector tbe, bool fas params.wavelet.enabled = false; } - //if (options.fastexport_bypass_raw_bayer_all_enhance ) params.raw.bayersensor.all_enhance = false; - if (options.fastexport_bypass_raw_bayer_dcb_iterations ) { - params.raw.bayersensor.dcb_iterations = 0; - } + if (!options.fastexport_use_fast_pipeline) { + //if (options.fastexport_bypass_raw_bayer_all_enhance ) params.raw.bayersensor.all_enhance = false; + if (options.fastexport_bypass_raw_bayer_dcb_iterations ) { + params.raw.bayersensor.dcb_iterations = 0; + } - if (options.fastexport_bypass_raw_bayer_dcb_enhance ) { - params.raw.bayersensor.dcb_enhance = false; - } + if (options.fastexport_bypass_raw_bayer_dcb_enhance ) { + params.raw.bayersensor.dcb_enhance = false; + } - if (options.fastexport_bypass_raw_bayer_lmmse_iterations) { - params.raw.bayersensor.lmmse_iterations = 0; - } + if (options.fastexport_bypass_raw_bayer_lmmse_iterations) { + params.raw.bayersensor.lmmse_iterations = 0; + } - if (options.fastexport_bypass_raw_bayer_linenoise ) { - params.raw.bayersensor.linenoise = 0; - } + if (options.fastexport_bypass_raw_bayer_linenoise ) { + params.raw.bayersensor.linenoise = 0; + } - if (options.fastexport_bypass_raw_bayer_greenthresh ) { - params.raw.bayersensor.greenthresh = 0; + if (options.fastexport_bypass_raw_bayer_greenthresh ) { + params.raw.bayersensor.greenthresh = 0; + } } if (options.fastexport_bypass_raw_ccSteps ) { @@ -1170,14 +1172,18 @@ void FileCatalog::developRequested (std::vector tbe, bool fas params.raw.ff_file = ""; } - params.raw.bayersensor.method = options.fastexport_raw_bayer_method ; - params.raw.xtranssensor.method = options.fastexport_raw_xtrans_method; - params.icm.input = options.fastexport_icm_input ; - params.icm.working = options.fastexport_icm_working ; - params.icm.output = options.fastexport_icm_output ; - params.icm.outputIntent = options.fastexport_icm_outputIntent ; - params.icm.outputBPC = options.fastexport_icm_outputBPC ; - params.icm.gamma = options.fastexport_icm_gamma ; + + if (!options.fastexport_use_fast_pipeline) { + params.raw.bayersensor.method = options.fastexport_raw_bayer_method ; + params.raw.xtranssensor.method = options.fastexport_raw_xtrans_method; + params.icm.input = options.fastexport_icm_input ; + params.icm.working = options.fastexport_icm_working ; + params.icm.output = options.fastexport_icm_output ; + params.icm.outputIntent = options.fastexport_icm_outputIntent ; + params.icm.outputBPC = options.fastexport_icm_outputBPC ; + params.icm.gamma = options.fastexport_icm_gamma ; + } + params.resize.enabled = options.fastexport_resize_enabled ; params.resize.scale = options.fastexport_resize_scale ; params.resize.appliesTo = options.fastexport_resize_appliesTo ; From f42710f594a9cd545865e100e802b98c4be4d7e5 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sun, 12 Mar 2017 20:52:32 +0100 Subject: [PATCH 06/90] properly rescale the impulseDenoise settings in the fast pipeline --- rtengine/simpleprocess.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index f10378a07..c0e0c05bd 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1378,10 +1378,14 @@ private: params.resize.enabled = false; params.sharpening = params.prsharpening; + params.impulseDenoise.thresh = + int(float(params.impulseDenoise.thresh) * tmpScale); + if (tmpScale < 0.5) { + params.impulseDenoise.enabled = false; + } params.wavelet.strength = int(float(params.wavelet.strength) * tmpScale); params.dirpyrDenoise.luma *= tmpScale; - params.dirpyrDenoise.smethod = "shal"; const double dirpyreq_scale = min(tmpScale * 1.5, 1.0); From 5a38d0610d92a24331c7d489e6cf38b15854bd2a Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sun, 12 Mar 2017 21:03:49 +0100 Subject: [PATCH 07/90] fix for resizing bug in fast-export mode --- rtgui/filecatalog.cc | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index a5b3cdb85..b9818a839 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -1183,14 +1183,20 @@ void FileCatalog::developRequested (std::vector tbe, bool fas params.icm.outputBPC = options.fastexport_icm_outputBPC ; params.icm.gamma = options.fastexport_icm_gamma ; } + + if (params.resize.enabled) { + params.resize.width = rtengine::min(params.resize.width, options.fastexport_resize_width) ; + params.resize.height = rtengine::min(params.resize.height, options.fastexport_resize_height) ; + } else { + params.resize.width = options.fastexport_resize_width; + params.resize.height = options.fastexport_resize_height; + } params.resize.enabled = options.fastexport_resize_enabled ; params.resize.scale = options.fastexport_resize_scale ; params.resize.appliesTo = options.fastexport_resize_appliesTo ; params.resize.method = options.fastexport_resize_method ; params.resize.dataspec = options.fastexport_resize_dataspec ; - params.resize.width = rtengine::min(params.resize.width, options.fastexport_resize_width) ; - params.resize.height = rtengine::min(params.resize.height, options.fastexport_resize_height) ; } rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params, fastmode && options.fastexport_use_fast_pipeline); From d18ce59132fb630f267f54aabbb84dca20cc51b8 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sun, 12 Mar 2017 21:13:54 +0100 Subject: [PATCH 08/90] some further tweaks to the fast pipeline --- rtengine/simpleprocess.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index c0e0c05bd..06f25d512 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1386,7 +1386,7 @@ private: params.wavelet.strength = int(float(params.wavelet.strength) * tmpScale); params.dirpyrDenoise.luma *= tmpScale; - params.dirpyrDenoise.smethod = "shal"; + //params.dirpyrDenoise.smethod = "shal"; const double dirpyreq_scale = min(tmpScale * 1.5, 1.0); for (int i = 0; i < 6; ++i) { From 6f08233c6f95ff0d66a9abae4daaa8cd710c9633 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Mon, 13 Mar 2017 14:00:37 +0100 Subject: [PATCH 09/90] further adjustments of processing parameters for the fast export pipeline --- rtengine/simpleprocess.cc | 84 +++++++++++++++++++++++++++------------ 1 file changed, 59 insertions(+), 25 deletions(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 06f25d512..50dbedbd0 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1369,34 +1369,18 @@ private: params.crop.enabled = false; } - if (params.resize.enabled) { - // resize image - LabImage *resized = new LabImage(imw, imh); - ipf.Lanczos(tmplab, resized, tmpScale); - delete tmplab; - tmplab = resized; - params.resize.enabled = false; + assert(params.resize.enabled); - params.sharpening = params.prsharpening; - params.impulseDenoise.thresh = - int(float(params.impulseDenoise.thresh) * tmpScale); - if (tmpScale < 0.5) { - params.impulseDenoise.enabled = false; - } - params.wavelet.strength = - int(float(params.wavelet.strength) * tmpScale); - params.dirpyrDenoise.luma *= tmpScale; - //params.dirpyrDenoise.smethod = "shal"; + // resize image + LabImage *resized = new LabImage(imw, imh); + ipf.Lanczos(tmplab, resized, tmpScale); + delete tmplab; + tmplab = resized; - const double dirpyreq_scale = min(tmpScale * 1.5, 1.0); - for (int i = 0; i < 6; ++i) { - auto &n = params.dirpyrequalizer.mult[i]; - n = 1.0 + (n - 1.0) * dirpyreq_scale; - } + adjust_procparams(tmpScale); - fw = imw; - fh = imh; - } + fw = imw; + fh = imh; delete baseImg; baseImg = new Imagefloat(fw, fh); @@ -1404,6 +1388,56 @@ private: delete tmplab; } + void adjust_procparams(double scale_factor) + { + procparams::ProcParams& params = job->pparams; + procparams::ProcParams defaultparams; + +#define ADJUST_RADIUS_(n, f) \ + do { \ + auto delta = (params. n - defaultparams. n) * f; \ + params. n = defaultparams. n + delta; \ + } while (false) + + params.resize.enabled = false; + + if (params.prsharpening.enabled) { + params.sharpening = params.prsharpening; + } else { + ADJUST_RADIUS_(sharpening.radius, scale_factor); + } + params.impulseDenoise.thresh = + int(float(params.impulseDenoise.thresh) * scale_factor); + if (scale_factor < 0.5) { + params.impulseDenoise.enabled = false; + } + params.wavelet.strength = + int(float(params.wavelet.strength) * scale_factor); + params.dirpyrDenoise.luma *= scale_factor; + //params.dirpyrDenoise.smethod = "shal"; + for (auto &p : params.dirpyrDenoise.lcurve) { + p *= scale_factor; + } + for (auto &p : params.dirpyrDenoise.cccurve) { + p *= scale_factor; + } + + params.epd.scale *= scale_factor; + params.epd.edgeStopping *= scale_factor; + + const double dirpyreq_scale = min(scale_factor * 1.5, 1.0); + for (int i = 0; i < 6; ++i) { + ADJUST_RADIUS_(dirpyrequalizer.mult[i], dirpyreq_scale); + // auto &n = params.dirpyrequalizer.mult[i]; + // n = 1.0 + (n - 1.0) * dirpyreq_scale; + } + + ADJUST_RADIUS_(defringe.radius, scale_factor); + ADJUST_RADIUS_(sh.radius, scale_factor); + +#undef ADJUST_RADIUS_ + } + private: ProcessingJobImpl* job; int& errorCode; From 7a69ff84a476539b533254d3d69b1754cb49f8d0 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Mon, 13 Mar 2017 15:12:00 +0100 Subject: [PATCH 10/90] use 1-pass method for X-trans demosaic in the fast pipeline As suggested by @heckflosse --- rtengine/simpleprocess.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 50dbedbd0..fd06df66b 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1435,6 +1435,14 @@ private: ADJUST_RADIUS_(defringe.radius, scale_factor); ADJUST_RADIUS_(sh.radius, scale_factor); + 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]; + } + #undef ADJUST_RADIUS_ } From f99da0c1ef5fe45a875402e6bc7c5f09047ec4d0 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Mon, 13 Mar 2017 16:39:10 +0100 Subject: [PATCH 11/90] use radio buttons to select between normal and custom pipeline for Fast Export as suggested by @michaelezra --- rtdata/languages/default | 5 +- rtgui/exportpanel.cc | 51 ++++++++++++++------ rtgui/exportpanel.h | 5 +- rtgui/filecatalog.cc | 102 +++++++++++++++++++-------------------- 4 files changed, 94 insertions(+), 69 deletions(-) diff --git a/rtdata/languages/default b/rtdata/languages/default index 7ae4d2165..35a10b6d7 100644 --- a/rtdata/languages/default +++ b/rtdata/languages/default @@ -89,7 +89,10 @@ EXPORT_BYPASS_SHARPENEDGE;Bypass Edge Sharpening EXPORT_BYPASS_SHARPENING;Bypass Sharpening EXPORT_BYPASS_SHARPENMICRO;Bypass Microcontrast EXPORT_BYPASS_SH_HQ;Bypass Sharp Mask Shadows/Highlights -EXPORT_USE_FAST_PIPELINE;Enable Special "Fast-Export" Processing Pipeline +EXPORT_PIPELINE;Processing pipeline +EXPORT_BYPASS;Processing steps to bypass +EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. EXPORT_FASTEXPORTOPTIONS;Fast Export Options EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. diff --git a/rtgui/exportpanel.cc b/rtgui/exportpanel.cc index fe18cdef7..53d93f8ba 100644 --- a/rtgui/exportpanel.cc +++ b/rtgui/exportpanel.cc @@ -38,8 +38,11 @@ ExportPanel::ExportPanel () : listener (nullptr) labExportTitle->set_alignment(Gtk::ALIGN_START); pack_start(*labExportTitle, Gtk::PACK_SHRINK, 4); + Gtk::RadioButton::Group pipeline_group; + use_fast_pipeline = Gtk::manage ( new Gtk::RadioButton (pipeline_group, M("EXPORT_USE_FAST_PIPELINE"))); + use_normal_pipeline = Gtk::manage ( new Gtk::RadioButton (pipeline_group, M("EXPORT_USE_NORMAL_PIPELINE"))); + bypass_box = Gtk::manage(new Gtk::VBox()); bypass_ALL = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_ALL"))); - use_fast_pipeline = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_USE_FAST_PIPELINE"))); use_fast_pipeline->set_tooltip_text(M("EXPORT_USE_FAST_PIPELINE_TIP")); bypass_sharpening = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENING"))); bypass_sharpenEdge = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENEDGE"))); @@ -98,19 +101,28 @@ ExportPanel::ExportPanel () : listener (nullptr) // ---------------------------------------------------------------- // start global packing + Gtk::HBox* lblbox = Gtk::manage (new Gtk::HBox ()); + lblbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_PIPELINE"))), Gtk::PACK_SHRINK, 4); + pack_start (*lblbox, Gtk::PACK_SHRINK, 4); pack_start(*use_fast_pipeline , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_ALL , Gtk::PACK_SHRINK, 4); - pack_start(*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 4); - pack_start(*bypass_sharpening , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_sharpenEdge , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_sharpenMicro , Gtk::PACK_SHRINK, 4); + pack_start(*use_normal_pipeline , Gtk::PACK_SHRINK, 4); + + bypass_box->pack_start(*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 4); + lblbox = Gtk::manage (new Gtk::HBox ()); + lblbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_BYPASS"))), Gtk::PACK_SHRINK, 4); + bypass_box->pack_start (*lblbox, Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_ALL , Gtk::PACK_SHRINK, 4); + // bypass_box->pack_start(*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_sharpening , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_sharpenEdge , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_sharpenMicro , Gtk::PACK_SHRINK, 4); //pack_start(*bypass_lumaDenoise , Gtk::PACK_SHRINK, 4); //pack_start(*bypass_colorDenoise , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_defringe , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_dirpyrDenoise, Gtk::PACK_SHRINK, 4); - pack_start(*bypass_sh_hq , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_dirpyrequalizer , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_wavelet , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_defringe , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_dirpyrDenoise, Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_sh_hq , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_dirpyrequalizer , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_wavelet , Gtk::PACK_SHRINK, 4); bayerFrameVBox->pack_start(*hb_raw_bayer_method, Gtk::PACK_SHRINK, 4); //bayerFrameVBox->pack_start(*bypass_raw_all_enhance , Gtk::PACK_SHRINK, 4); @@ -124,12 +136,14 @@ ExportPanel::ExportPanel () : listener (nullptr) xtransFrameVBox->pack_start(*hb_raw_xtrans_method, Gtk::PACK_SHRINK, 4); xtransFrame->add(*xtransFrameVBox); - pack_start(*bypass_raw_ccSteps , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_raw_ca , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_raw_ccSteps , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_raw_ca , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_raw_df , Gtk::PACK_SHRINK, 4); - pack_start(*bypass_raw_ff , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_raw_df , Gtk::PACK_SHRINK, 4); + bypass_box->pack_start(*bypass_raw_ff , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_box, Gtk::PACK_SHRINK); + pack_start (*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 2); // Resize options @@ -179,6 +193,7 @@ ExportPanel::ExportPanel () : listener (nullptr) pack_start(*vboxpe, Gtk::PACK_SHRINK, 0); + use_fast_pipeline->signal_toggled().connect(sigc::mem_fun(*this, &ExportPanel::use_fast_pipeline_toggled)); btnFastExport->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::FastExportPressed) ); //btnExportLoadSettings->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::LoadSettings) ); //btnExportSaveSettings->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::SaveSettings) ); @@ -347,6 +362,7 @@ void ExportPanel::LoadDefaultSettings() MaxHeight->set_value(options.fastexport_resize_height); use_fast_pipeline->set_active(options.fastexport_use_fast_pipeline); + bypass_box->set_sensitive(!options.fastexport_use_fast_pipeline); } void ExportPanel::LoadSettings() @@ -428,6 +444,11 @@ void ExportPanel::bypassALL_Toggled() bypass_raw_ffConn.block (false); } +void ExportPanel::use_fast_pipeline_toggled() +{ + bypass_box->set_sensitive(!use_fast_pipeline->get_active()); +} + /* fastexport_bypass_sharpening fastexport_bypass_sharpenEdge diff --git a/rtgui/exportpanel.h b/rtgui/exportpanel.h index ce7639921..db4431ca5 100644 --- a/rtgui/exportpanel.h +++ b/rtgui/exportpanel.h @@ -36,9 +36,11 @@ class ExportPanel : public Gtk::VBox protected: + Gtk::VBox *bypass_box; //Gtk::CheckButton* enabled; + Gtk::RadioButton* use_fast_pipeline; + Gtk::RadioButton* use_normal_pipeline; Gtk::CheckButton* bypass_ALL; - Gtk::CheckButton* use_fast_pipeline; Gtk::CheckButton* bypass_sharpenEdge; Gtk::CheckButton* bypass_sharpenMicro; Gtk::CheckButton* bypass_sharpening; @@ -106,6 +108,7 @@ protected: ExportPanelListener* listener; void bypassALL_Toggled(); + void use_fast_pipeline_toggled(); void SaveSettingsAsDefault(); void LoadDefaultSettings(); void LoadSettings(); diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index b9818a839..cdba10316 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -1095,41 +1095,41 @@ void FileCatalog::developRequested (std::vector tbe, bool fas // and also those which effect is not pronounced after reducing the image size // TODO!!! could expose selections below via preferences if (fastmode) { - if (options.fastexport_bypass_sharpening ) { - params.sharpening.enabled = false; - } - - if (options.fastexport_bypass_sharpenEdge ) { - params.sharpenEdge.enabled = false; - } - - if (options.fastexport_bypass_sharpenMicro ) { - params.sharpenMicro.enabled = false; - } - - //if (options.fastexport_bypass_lumaDenoise ) params.lumaDenoise.enabled = false; - //if (options.fastexport_bypass_colorDenoise ) params.colorDenoise.enabled = false; - if (options.fastexport_bypass_defringe ) { - params.defringe.enabled = false; - } - - if (options.fastexport_bypass_dirpyrDenoise ) { - params.dirpyrDenoise.enabled = false; - } - - if (options.fastexport_bypass_sh_hq ) { - params.sh.hq = false; - } - - if (options.fastexport_bypass_dirpyrequalizer ) { - params.dirpyrequalizer.enabled = false; - } - - if (options.fastexport_bypass_wavelet ) { - params.wavelet.enabled = false; - } - if (!options.fastexport_use_fast_pipeline) { + if (options.fastexport_bypass_sharpening ) { + params.sharpening.enabled = false; + } + + if (options.fastexport_bypass_sharpenEdge ) { + params.sharpenEdge.enabled = false; + } + + if (options.fastexport_bypass_sharpenMicro ) { + params.sharpenMicro.enabled = false; + } + + //if (options.fastexport_bypass_lumaDenoise ) params.lumaDenoise.enabled = false; + //if (options.fastexport_bypass_colorDenoise ) params.colorDenoise.enabled = false; + if (options.fastexport_bypass_defringe ) { + params.defringe.enabled = false; + } + + if (options.fastexport_bypass_dirpyrDenoise ) { + params.dirpyrDenoise.enabled = false; + } + + if (options.fastexport_bypass_sh_hq ) { + params.sh.hq = false; + } + + if (options.fastexport_bypass_dirpyrequalizer ) { + params.dirpyrequalizer.enabled = false; + } + + if (options.fastexport_bypass_wavelet ) { + params.wavelet.enabled = false; + } + //if (options.fastexport_bypass_raw_bayer_all_enhance ) params.raw.bayersensor.all_enhance = false; if (options.fastexport_bypass_raw_bayer_dcb_iterations ) { params.raw.bayersensor.dcb_iterations = 0; @@ -1150,30 +1150,28 @@ void FileCatalog::developRequested (std::vector tbe, bool fas if (options.fastexport_bypass_raw_bayer_greenthresh ) { params.raw.bayersensor.greenthresh = 0; } - } - if (options.fastexport_bypass_raw_ccSteps ) { - params.raw.bayersensor.ccSteps = params.raw.xtranssensor.ccSteps = 0; - } + if (options.fastexport_bypass_raw_ccSteps ) { + params.raw.bayersensor.ccSteps = params.raw.xtranssensor.ccSteps = 0; + } - if (options.fastexport_bypass_raw_ca ) { - params.raw.ca_autocorrect = false; - params.raw.cared = 0; - params.raw.cablue = 0; - } + if (options.fastexport_bypass_raw_ca ) { + params.raw.ca_autocorrect = false; + params.raw.cared = 0; + params.raw.cablue = 0; + } - if (options.fastexport_bypass_raw_df ) { - params.raw.df_autoselect = false; - params.raw.dark_frame = ""; - } + if (options.fastexport_bypass_raw_df ) { + params.raw.df_autoselect = false; + params.raw.dark_frame = ""; + } - if (options.fastexport_bypass_raw_ff ) { - params.raw.ff_AutoSelect = false; - params.raw.ff_file = ""; - } + if (options.fastexport_bypass_raw_ff ) { + params.raw.ff_AutoSelect = false; + params.raw.ff_file = ""; + } - if (!options.fastexport_use_fast_pipeline) { params.raw.bayersensor.method = options.fastexport_raw_bayer_method ; params.raw.xtranssensor.method = options.fastexport_raw_xtrans_method; params.icm.input = options.fastexport_icm_input ; From e0d9090420d2463a4a56ff75f4947a51481aff5b Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Mon, 13 Mar 2017 23:24:12 +0100 Subject: [PATCH 12/90] Changed "Processing profile operations -> Custom Profile Builder" to "Reset to default profile" The behaviour has changed slightly, so that clicking the menu item now resets to the default processing profile specified in the preferences. If this involves calling the custom profile builder, the behaviour is the same as before. But this is a bit more general, in that it might also simply reapply the static default profile, or regenerate the dynamic one (depending on the user's settings) --- rtdata/languages/default | 2 +- rtgui/filebrowser.cc | 8 ++++---- rtgui/filebrowser.h | 2 +- rtgui/thumbnail.cc | 13 +++++++++---- rtgui/thumbnail.h | 2 +- 5 files changed, 16 insertions(+), 11 deletions(-) diff --git a/rtdata/languages/default b/rtdata/languages/default index ec61230ff..9eba08b80 100644 --- a/rtdata/languages/default +++ b/rtdata/languages/default @@ -117,7 +117,7 @@ FILEBROWSER_DELETEDLGMSG;Are you sure you want to delete the selected %1 FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? FILEBROWSER_EMPTYTRASH;Empty trash FILEBROWSER_EMPTYTRASHHINT;Permanently delete the files from trash. -FILEBROWSER_EXEC_CPB;Custom Profile Builder +FILEBROWSER_RESETDEFAULTPROFILE;Reset to default FILEBROWSER_EXTPROGMENU;Open with FILEBROWSER_FLATFIELD;Flat-Field FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory diff --git a/rtgui/filebrowser.cc b/rtgui/filebrowser.cc index 5cbb5255b..3e8b2e7cf 100644 --- a/rtgui/filebrowser.cc +++ b/rtgui/filebrowser.cc @@ -340,7 +340,7 @@ FileBrowser::FileBrowser () p++; submenuProfileOperations->attach (*Gtk::manage(applypartprof = new Gtk::MenuItem (M("FILEBROWSER_APPLYPROFILE_PARTIAL"))), 0, 1, p, p + 1); p++; - submenuProfileOperations->attach (*Gtk::manage(execcustprof = new Gtk::MenuItem (M("FILEBROWSER_EXEC_CPB"))), 0, 1, p, p + 1); + submenuProfileOperations->attach (*Gtk::manage(resetdefaultprof = new Gtk::MenuItem (M("FILEBROWSER_RESETDEFAULTPROFILE"))), 0, 1, p, p + 1); p++; submenuProfileOperations->attach (*Gtk::manage(clearprof = new Gtk::MenuItem (M("FILEBROWSER_CLEARPROFILE"))), 0, 1, p, p + 1); p++; @@ -358,7 +358,7 @@ FileBrowser::FileBrowser () p++; pmenu->attach (*Gtk::manage(applypartprof = new Gtk::MenuItem (M("FILEBROWSER_APPLYPROFILE_PARTIAL"))), 0, 1, p, p + 1); p++; - pmenu->attach (*Gtk::manage(execcustprof = new Gtk::MenuItem (M("FILEBROWSER_EXEC_CPB"))), 0, 1, p, p + 1); + pmenu->attach (*Gtk::manage(resetdefaultprof = new Gtk::MenuItem (M("FILEBROWSER_RESETDEFAULTPROFILE"))), 0, 1, p, p + 1); p++; pmenu->attach (*Gtk::manage(clearprof = new Gtk::MenuItem (M("FILEBROWSER_CLEARPROFILE"))), 0, 1, p, p + 1); p++; @@ -427,7 +427,7 @@ FileBrowser::FileBrowser () partpasteprof->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), partpasteprof)); applyprof->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), applyprof)); applypartprof->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), applypartprof)); - execcustprof->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), execcustprof)); + resetdefaultprof->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), resetdefaultprof)); clearprof->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), clearprof)); cachemenu->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), cachemenu)); @@ -960,7 +960,7 @@ void FileBrowser::menuItemActivated (Gtk::MenuItem* m) } queue_draw (); - } else if (m == execcustprof) { + } else if (m == resetdefaultprof) { if (!mselected.empty() && bppcl) { bppcl->beginBatchPParamsChange(mselected.size()); } diff --git a/rtgui/filebrowser.h b/rtgui/filebrowser.h index fdb08ba24..a7474d989 100644 --- a/rtgui/filebrowser.h +++ b/rtgui/filebrowser.h @@ -110,7 +110,7 @@ protected: Gtk::MenuItem* partpasteprof; Gtk::MenuItem* applyprof; Gtk::MenuItem* applypartprof; - Gtk::MenuItem* execcustprof; + Gtk::MenuItem* resetdefaultprof; Gtk::MenuItem* clearprof; Gtk::MenuItem* cachemenu; Gtk::MenuItem* clearFromCache; diff --git a/rtgui/thumbnail.cc b/rtgui/thumbnail.cc index 62f543d4a..16f03761b 100644 --- a/rtgui/thumbnail.cc +++ b/rtgui/thumbnail.cc @@ -198,14 +198,13 @@ const ProcParams& Thumbnail::getProcParamsU () * The loaded profile may be partial, but it return a complete ProcParams (i.e. without ParamsEdited) * * @param returnParams Ask to return a pointer to a ProcParams object if true - * @param forceCPB True if the Custom Profile Builder has to be invoked, False if the CPB has to be invoked if the profile doesn't - * exist yet. It depends on other conditions too + * @param force True if the profile has to be re-generated even if it already exists * @param flaggingMode True if the ProcParams will be created because the file browser is being flagging an image * (rang, to trash, color labels). This parameter is passed to the CPB. * * @return Return a pointer to a ProcPamas structure to be updated if returnParams is true and if everything went fine, NULL otherwise. */ -rtengine::procparams::ProcParams* Thumbnail::createProcParamsForUpdate(bool returnParams, bool forceCPB, bool flaggingMode) +rtengine::procparams::ProcParams* Thumbnail::createProcParamsForUpdate(bool returnParams, bool force, bool flaggingMode) { static int index = 0; // Will act as unique identifier during the session @@ -217,7 +216,7 @@ rtengine::procparams::ProcParams* Thumbnail::createProcParamsForUpdate(bool retu const CacheImageData* cfs = getCacheImageData(); Glib::ustring defaultPparamsPath = options.findProfilePath(defProf); - const bool create = (!hasProcParams() || forceCPB); + const bool create = (!hasProcParams() || force); const Glib::ustring outFName = (options.paramsLoadLocation == PLL_Input) ? @@ -239,6 +238,12 @@ rtengine::procparams::ProcParams* Thumbnail::createProcParamsForUpdate(bool retu if (!err) { loadProcParams(); } + } else if (create && + defProf != DEFPROFILE_DYNAMIC && defProf != DEFPROFILE_INTERNAL){ + const PartialProfile *p = profileStore.getProfile(defProf); + if (p && !p->pparams->save(outFName)) { + loadProcParams(); + } } if (!options.CPBPath.empty() && !defaultPparamsPath.empty() && create && cfs && cfs->exifValid) { diff --git a/rtgui/thumbnail.h b/rtgui/thumbnail.h index 8c7691ed2..e5b6a72b2 100644 --- a/rtgui/thumbnail.h +++ b/rtgui/thumbnail.h @@ -87,7 +87,7 @@ public: const rtengine::procparams::ProcParams& getProcParamsU (); // Unprotected version // Use this to create params on demand for update ; if flaggingMode=true, the procparams is created for a file being flagged (inTrash, rank, colorLabel) - rtengine::procparams::ProcParams* createProcParamsForUpdate (bool returnParams, bool forceCPB, bool flaggingMode = false); + rtengine::procparams::ProcParams* createProcParamsForUpdate (bool returnParams, bool force, bool flaggingMode = false); void setProcParams (const rtengine::procparams::ProcParams& pp, ParamsEdited* pe = nullptr, int whoChangedIt = -1, bool updateCacheNow = true); void clearProcParams (int whoClearedIt = -1); From a3adf8fb07fdd2dd46f5e1b4ea65427f9c968a46 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Tue, 14 Mar 2017 11:48:51 +0100 Subject: [PATCH 13/90] code cleanup after feedback by @Floessie --- rtengine/rtengine.h | 1 + rtengine/simpleprocess.cc | 71 +++++++++++++--------------- rtgui/filecatalog.cc | 97 +++++++++++++++++++-------------------- 3 files changed, 81 insertions(+), 88 deletions(-) diff --git a/rtengine/rtengine.h b/rtengine/rtengine.h index 7449dbd0d..4a87414b8 100644 --- a/rtengine/rtengine.h +++ b/rtengine/rtengine.h @@ -461,6 +461,7 @@ class ProcessingJob { public: + virtual ~ProcessingJob() {} /** Creates a processing job from a file name. This function always succeeds. It only stores the data into the ProcessingJob class, it does not load * the image thus it returns immediately. diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index fd06df66b..4a6c7a695 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -37,6 +37,14 @@ extern const Settings* settings; namespace { +template +void adjust_radius(const T &default_param, double scale_factor, T ¶m) +{ + const double delta = (param - default_param) * scale_factor; + param = default_param + delta; +} + + class ImageProcessor { public: ImageProcessor(ProcessingJob* pjob, int& errorCode, @@ -1338,20 +1346,18 @@ private: ImProcFunctions ipf (¶ms, true); int imw, imh; - double tmpScale = ipf.resizeScale(¶ms, fw, fh, imw, imh); + double scale_factor = ipf.resizeScale(¶ms, fw, fh, imw, imh); - LabImage *tmplab = new LabImage(fw, fh); + std::unique_ptr tmplab(new LabImage(fw, fh)); ipf.rgb2lab(*baseImg, *tmplab, params.icm.working); - int cx = 0, cy = 0, cw = fw, ch = fh; - if (params.crop.enabled) { - cx = params.crop.x; - cy = params.crop.y; - cw = params.crop.w; - ch = params.crop.h; + int cx = params.crop.x; + int cy = params.crop.y; + int cw = params.crop.w; + int ch = params.crop.h; - LabImage *cropped = new LabImage(cw, ch); + std::unique_ptr cropped(new LabImage(cw, ch)); for(int row = 0; row < ch; row++) { for(int col = 0; col < cw; col++) { @@ -1361,23 +1367,20 @@ private: } } - delete tmplab; - tmplab = cropped; - cx = 0; - cy = 0; - + tmplab.swap(cropped); params.crop.enabled = false; } assert(params.resize.enabled); // resize image - LabImage *resized = new LabImage(imw, imh); - ipf.Lanczos(tmplab, resized, tmpScale); - delete tmplab; - tmplab = resized; + { + std::unique_ptr resized(new LabImage(imw, imh)); + ipf.Lanczos(tmplab.get(), resized.get(), scale_factor); + tmplab.swap(resized); + } - adjust_procparams(tmpScale); + adjust_procparams(scale_factor); fw = imw; fh = imh; @@ -1385,34 +1388,26 @@ private: delete baseImg; baseImg = new Imagefloat(fw, fh); ipf.lab2rgb(*tmplab, *baseImg, params.icm.working); - delete tmplab; } void adjust_procparams(double scale_factor) { - procparams::ProcParams& params = job->pparams; + procparams::ProcParams ¶ms = job->pparams; procparams::ProcParams defaultparams; -#define ADJUST_RADIUS_(n, f) \ - do { \ - auto delta = (params. n - defaultparams. n) * f; \ - params. n = defaultparams. n + delta; \ - } while (false) - params.resize.enabled = false; if (params.prsharpening.enabled) { params.sharpening = params.prsharpening; } else { - ADJUST_RADIUS_(sharpening.radius, scale_factor); + adjust_radius(defaultparams.sharpening.radius, scale_factor, + params.sharpening.radius); } - params.impulseDenoise.thresh = - int(float(params.impulseDenoise.thresh) * scale_factor); + params.impulseDenoise.thresh *= scale_factor; if (scale_factor < 0.5) { params.impulseDenoise.enabled = false; } - params.wavelet.strength = - int(float(params.wavelet.strength) * scale_factor); + params.wavelet.strength *= scale_factor; params.dirpyrDenoise.luma *= scale_factor; //params.dirpyrDenoise.smethod = "shal"; for (auto &p : params.dirpyrDenoise.lcurve) { @@ -1427,13 +1422,13 @@ private: const double dirpyreq_scale = min(scale_factor * 1.5, 1.0); for (int i = 0; i < 6; ++i) { - ADJUST_RADIUS_(dirpyrequalizer.mult[i], dirpyreq_scale); - // auto &n = params.dirpyrequalizer.mult[i]; - // n = 1.0 + (n - 1.0) * dirpyreq_scale; + adjust_radius(defaultparams.dirpyrequalizer.mult[i], dirpyreq_scale, + params.dirpyrequalizer.mult[i]); } - ADJUST_RADIUS_(defringe.radius, scale_factor); - ADJUST_RADIUS_(sh.radius, scale_factor); + adjust_radius(defaultparams.defringe.radius, scale_factor, + params.defringe.radius); + adjust_radius(defaultparams.sh.radius, scale_factor, params.sh.radius); if (params.raw.xtranssensor.method == procparams::RAWParams::XTransSensor::methodstring[ @@ -1442,8 +1437,6 @@ private: procparams::RAWParams::XTransSensor::methodstring[ procparams::RAWParams::XTransSensor::onePass]; } - -#undef ADJUST_RADIUS_ } private: diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index cdba10316..96a04ba0b 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -1096,105 +1096,104 @@ void FileCatalog::developRequested (std::vector tbe, bool fas // TODO!!! could expose selections below via preferences if (fastmode) { if (!options.fastexport_use_fast_pipeline) { - if (options.fastexport_bypass_sharpening ) { - params.sharpening.enabled = false; + if (options.fastexport_bypass_sharpening) { + params.sharpening.enabled = false; } - if (options.fastexport_bypass_sharpenEdge ) { - params.sharpenEdge.enabled = false; + if (options.fastexport_bypass_sharpenEdge) { + params.sharpenEdge.enabled = false; } - if (options.fastexport_bypass_sharpenMicro ) { - params.sharpenMicro.enabled = false; + if (options.fastexport_bypass_sharpenMicro) { + params.sharpenMicro.enabled = false; } - //if (options.fastexport_bypass_lumaDenoise ) params.lumaDenoise.enabled = false; - //if (options.fastexport_bypass_colorDenoise ) params.colorDenoise.enabled = false; - if (options.fastexport_bypass_defringe ) { - params.defringe.enabled = false; + //if (options.fastexport_bypass_lumaDenoise) params.lumaDenoise.enabled = false; + //if (options.fastexport_bypass_colorDenoise) params.colorDenoise.enabled = false; + if (options.fastexport_bypass_defringe) { + params.defringe.enabled = false; } - if (options.fastexport_bypass_dirpyrDenoise ) { - params.dirpyrDenoise.enabled = false; + if (options.fastexport_bypass_dirpyrDenoise) { + params.dirpyrDenoise.enabled = false; } - if (options.fastexport_bypass_sh_hq ) { - params.sh.hq = false; + if (options.fastexport_bypass_sh_hq) { + params.sh.hq = false; } - if (options.fastexport_bypass_dirpyrequalizer ) { - params.dirpyrequalizer.enabled = false; + if (options.fastexport_bypass_dirpyrequalizer) { + params.dirpyrequalizer.enabled = false; } - if (options.fastexport_bypass_wavelet ) { - params.wavelet.enabled = false; + if (options.fastexport_bypass_wavelet) { + params.wavelet.enabled = false; } - //if (options.fastexport_bypass_raw_bayer_all_enhance ) params.raw.bayersensor.all_enhance = false; - if (options.fastexport_bypass_raw_bayer_dcb_iterations ) { - params.raw.bayersensor.dcb_iterations = 0; + //if (options.fastexport_bypass_raw_bayer_all_enhance) params.raw.bayersensor.all_enhance = false; + if (options.fastexport_bypass_raw_bayer_dcb_iterations) { + params.raw.bayersensor.dcb_iterations = 0; } - if (options.fastexport_bypass_raw_bayer_dcb_enhance ) { - params.raw.bayersensor.dcb_enhance = false; + if (options.fastexport_bypass_raw_bayer_dcb_enhance) { + params.raw.bayersensor.dcb_enhance = false; } if (options.fastexport_bypass_raw_bayer_lmmse_iterations) { - params.raw.bayersensor.lmmse_iterations = 0; + params.raw.bayersensor.lmmse_iterations = 0; } - if (options.fastexport_bypass_raw_bayer_linenoise ) { - params.raw.bayersensor.linenoise = 0; + if (options.fastexport_bypass_raw_bayer_linenoise) { + params.raw.bayersensor.linenoise = 0; } - if (options.fastexport_bypass_raw_bayer_greenthresh ) { - params.raw.bayersensor.greenthresh = 0; + if (options.fastexport_bypass_raw_bayer_greenthresh) { + params.raw.bayersensor.greenthresh = 0; } - if (options.fastexport_bypass_raw_ccSteps ) { + if (options.fastexport_bypass_raw_ccSteps) { params.raw.bayersensor.ccSteps = params.raw.xtranssensor.ccSteps = 0; } - if (options.fastexport_bypass_raw_ca ) { + if (options.fastexport_bypass_raw_ca) { params.raw.ca_autocorrect = false; params.raw.cared = 0; params.raw.cablue = 0; } - if (options.fastexport_bypass_raw_df ) { - params.raw.df_autoselect = false; + if (options.fastexport_bypass_raw_df) { + params.raw.df_autoselect = false; params.raw.dark_frame = ""; } - if (options.fastexport_bypass_raw_ff ) { - params.raw.ff_AutoSelect = false; + if (options.fastexport_bypass_raw_ff) { + params.raw.ff_AutoSelect = false; params.raw.ff_file = ""; } - - params.raw.bayersensor.method = options.fastexport_raw_bayer_method ; + params.raw.bayersensor.method = options.fastexport_raw_bayer_method; params.raw.xtranssensor.method = options.fastexport_raw_xtrans_method; - params.icm.input = options.fastexport_icm_input ; - params.icm.working = options.fastexport_icm_working ; - params.icm.output = options.fastexport_icm_output ; - params.icm.outputIntent = options.fastexport_icm_outputIntent ; - params.icm.outputBPC = options.fastexport_icm_outputBPC ; - params.icm.gamma = options.fastexport_icm_gamma ; + params.icm.input = options.fastexport_icm_input; + params.icm.working = options.fastexport_icm_working; + params.icm.output = options.fastexport_icm_output; + params.icm.outputIntent = options.fastexport_icm_outputIntent; + params.icm.outputBPC = options.fastexport_icm_outputBPC; + params.icm.gamma = options.fastexport_icm_gamma; } if (params.resize.enabled) { - params.resize.width = rtengine::min(params.resize.width, options.fastexport_resize_width) ; - params.resize.height = rtengine::min(params.resize.height, options.fastexport_resize_height) ; + params.resize.width = rtengine::min(params.resize.width, options.fastexport_resize_width); + params.resize.height = rtengine::min(params.resize.height, options.fastexport_resize_height); } else { params.resize.width = options.fastexport_resize_width; params.resize.height = options.fastexport_resize_height; } - params.resize.enabled = options.fastexport_resize_enabled ; - params.resize.scale = options.fastexport_resize_scale ; - params.resize.appliesTo = options.fastexport_resize_appliesTo ; - params.resize.method = options.fastexport_resize_method ; - params.resize.dataspec = options.fastexport_resize_dataspec ; + params.resize.enabled = options.fastexport_resize_enabled; + params.resize.scale = options.fastexport_resize_scale; + params.resize.appliesTo = options.fastexport_resize_appliesTo; + params.resize.method = options.fastexport_resize_method; + params.resize.dataspec = options.fastexport_resize_dataspec; } rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (fbe->filename, th->getType() == FT_Raw, params, fastmode && options.fastexport_use_fast_pipeline); From 656fe0a022700bffacff26991da1f386799617e5 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Tue, 14 Mar 2017 15:13:16 +0100 Subject: [PATCH 14/90] use move assignment instead of std::unique_ptr::swap (better readability) --- rtengine/simpleprocess.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 4a6c7a695..1315fb061 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1367,7 +1367,7 @@ private: } } - tmplab.swap(cropped); + tmplab = std::move(cropped); params.crop.enabled = false; } @@ -1377,7 +1377,7 @@ private: { std::unique_ptr resized(new LabImage(imw, imh)); ipf.Lanczos(tmplab.get(), resized.get(), scale_factor); - tmplab.swap(resized); + tmplab = std::move(resized); } adjust_procparams(scale_factor); From 416fc6c92f8fea41fc9f2a12e0805c0b13b0251d Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Wed, 15 Mar 2017 09:12:09 +0100 Subject: [PATCH 15/90] move all procparams tweaks to adjust_procparams `params.crop.enabled=false` was still in `stage_early_resize` --- rtengine/simpleprocess.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 1315fb061..9fe4ca731 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1368,7 +1368,6 @@ private: } tmplab = std::move(cropped); - params.crop.enabled = false; } assert(params.resize.enabled); @@ -1396,6 +1395,7 @@ private: procparams::ProcParams defaultparams; params.resize.enabled = false; + params.crop.enabled = false; if (params.prsharpening.enabled) { params.sharpening = params.prsharpening; From 83c6453b4492187ee0aeb1897f52d5c2e556dc4f Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Wed, 15 Mar 2017 14:04:03 +0100 Subject: [PATCH 16/90] minor tweaking to the tonemapping procparams in fast export mode --- rtengine/simpleprocess.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 9fe4ca731..bd8dc0e23 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1418,7 +1418,7 @@ private: } params.epd.scale *= scale_factor; - params.epd.edgeStopping *= scale_factor; + //params.epd.edgeStopping *= scale_factor; const double dirpyreq_scale = min(scale_factor * 1.5, 1.0); for (int i = 0; i < 6; ++i) { From c8a6253e432c3f5c8d1a58a51ff628d12c4d82aa Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Thu, 16 Mar 2017 09:06:47 +0100 Subject: [PATCH 17/90] save fast export options also when clicking on the "fast export" menu item --- rtgui/filebrowser.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/rtgui/filebrowser.cc b/rtgui/filebrowser.cc index 24d1d8541..70c019942 100644 --- a/rtgui/filebrowser.cc +++ b/rtgui/filebrowser.cc @@ -768,6 +768,12 @@ void FileBrowser::menuItemActivated (Gtk::MenuItem* m) else if (m == develop) { tbl->developRequested (mselected, false); } else if (m == developfast) { + if (exportPanel) { + // force saving export panel settings + exportPanel->setExportPanelListener(nullptr); + exportPanel->FastExportPressed(); + exportPanel->setExportPanelListener(this); + } tbl->developRequested (mselected, true); } From f5798946ef708e0f4b35cd8e09882da257e4f1ce Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Thu, 16 Mar 2017 11:43:37 +0100 Subject: [PATCH 18/90] fixed bug in disabling the "bypass" checkboxes when fast export is selected --- rtgui/exportpanel.cc | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/rtgui/exportpanel.cc b/rtgui/exportpanel.cc index 53d93f8ba..72cf30fdd 100644 --- a/rtgui/exportpanel.cc +++ b/rtgui/exportpanel.cc @@ -361,8 +361,12 @@ void ExportPanel::LoadDefaultSettings() MaxWidth->set_value(options.fastexport_resize_width); MaxHeight->set_value(options.fastexport_resize_height); - use_fast_pipeline->set_active(options.fastexport_use_fast_pipeline); - bypass_box->set_sensitive(!options.fastexport_use_fast_pipeline); + if (options.fastexport_use_fast_pipeline) { + use_fast_pipeline->set_active(true); + bypass_box->set_sensitive(false); + } else { + use_normal_pipeline->set_active(true); + } } void ExportPanel::LoadSettings() From fa433648cd9f5bc4078b530c994d43c22f021261 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Fri, 24 Mar 2017 14:52:31 +0100 Subject: [PATCH 19/90] make "Processing profiles -> Reset to default" work also when the default is "(Neutral)" --- rtgui/thumbnail.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/rtgui/thumbnail.cc b/rtgui/thumbnail.cc index 658721ebc..0bbefa298 100644 --- a/rtgui/thumbnail.cc +++ b/rtgui/thumbnail.cc @@ -238,8 +238,7 @@ rtengine::procparams::ProcParams* Thumbnail::createProcParamsForUpdate(bool retu if (!err) { loadProcParams(); } - } else if (create && - defProf != DEFPROFILE_DYNAMIC && defProf != DEFPROFILE_INTERNAL){ + } else if (create && defProf != DEFPROFILE_DYNAMIC) { const PartialProfile *p = profileStore.getProfile(defProf); if (p && !p->pparams->save(outFName)) { loadProcParams(); From b37c436ebbda21efc792861a9fce92e09d3a05e8 Mon Sep 17 00:00:00 2001 From: TooWaBoo Date: Sun, 26 Mar 2017 12:45:02 +0200 Subject: [PATCH 20/90] Update Deutsch --- rtdata/languages/Deutsch | 237 +++++++++++++++++++-------------------- 1 file changed, 117 insertions(+), 120 deletions(-) diff --git a/rtdata/languages/Deutsch b/rtdata/languages/Deutsch index ebc0297c8..c9b8e3d04 100644 --- a/rtdata/languages/Deutsch +++ b/rtdata/languages/Deutsch @@ -36,6 +36,7 @@ #35 2017-02-18 AWB bias (TooWaBoo) RT 5.0 r1 #36 2017-02-23 Korrekturen (TooWaBoo) RT 5.0 r1 #37 2017-03-06 Dynamisches Profil (TooWaBoo) +#38 2017-03-26 Pixel Shift (TooWaBoo) ABOUT_TAB_BUILD;Version ABOUT_TAB_CREDITS;Danksagungen @@ -112,7 +113,7 @@ EXPORT_BYPASS_DIRPYRDENOISE;Rauschreduzierung überspringen EXPORT_BYPASS_DIRPYREQUALIZER;Detailebenenkontrast überspringen EXPORT_BYPASS_EQUALIZER;Waveletebenen überspringen EXPORT_BYPASS_RAW_CA;CA-Korrektur überspringen [RAW] -EXPORT_BYPASS_RAW_CCSTEPS;Falschfarbenunterdrückung überspringen\n[RAW] +EXPORT_BYPASS_RAW_CCSTEPS;Falschfarbenreduzierung überspringen\n[RAW] EXPORT_BYPASS_RAW_DCB_ENHANCE;DCB-Verbesserungsstufen überspringen\n[RAW] EXPORT_BYPASS_RAW_DCB_ITERATIONS;DCB-Interationen überspringen [RAW] EXPORT_BYPASS_RAW_DF;Dunkelbild überspringen [RAW] @@ -202,6 +203,7 @@ FILEBROWSER_RANK3_TOOLTIP;Bewertung 3 ***\nTaste: Umschalt + 3 FILEBROWSER_RANK4_TOOLTIP;Bewertung 4 ****\nTaste: Umschalt + 4 FILEBROWSER_RANK5_TOOLTIP;Bewertung 5 *****\nTaste: Umschalt + 5 FILEBROWSER_RENAMEDLGLABEL;Datei umbenennen +FILEBROWSER_RESETDEFAULTPROFILE;Profil auf Vorgabe zurücksetzen FILEBROWSER_SELECTDARKFRAME;Dunkelbild wählen... FILEBROWSER_SELECTFLATFIELD;Weißbild wählen... FILEBROWSER_SHOWCOLORLABEL1HINT;Nur rot markierte Bilder anzeigen\nTaste: Alt + 1 @@ -390,14 +392,14 @@ HISTORY_MSG_110;(Skalieren) - Anwenden auf: HISTORY_MSG_111;(L*a*b*) - Farbverschiebung\nvermeiden HISTORY_MSG_112;--unused-- HISTORY_MSG_113;(L*a*b*) - Hautfarbtöne\nschützen -HISTORY_MSG_114;(Sensor Bayer-Matrix)\nFarbinterpolation\nDCB-Iterationen -HISTORY_MSG_115;(Sensor-Matrix)\nFarbinterpolation\nFalschfarbenunterdrückung -HISTORY_MSG_116;(Sensor Bayer-Matrix)\nFarbinterpolation\nDCB-Verbesserung -HISTORY_MSG_117;(Sensor Bayer-Matrix)\nChromatische Aberration\nRot -HISTORY_MSG_118;(Sensor Bayer-Matrix)\nChromatische Aberration\nBlau -HISTORY_MSG_119;(Sensor Bayer-Matrix)\nVorverarbeitung\nZeilenrauschfilter -HISTORY_MSG_120;(Sensor Bayer-Matrix)\nVorverarbeitung\nGrün-Ausgleich -HISTORY_MSG_121;(Sensor Bayer-Matrix)\nChromatische Aberration\nAutomatische Korrektur +HISTORY_MSG_114;(Sensor-Matrix)\nFarbinterpolation\nDCB-Iterationen +HISTORY_MSG_115;(Sensor-Matrix)\nFarbinterpolation\nFalschfarbenreduzierung +HISTORY_MSG_116;(Sensor-Matrix)\nFarbinterpolation\nDCB-Verbesserung +HISTORY_MSG_117;(Sensor-Matrix)\nChromatische Aberration\nRot +HISTORY_MSG_118;(Sensor-Matrix)\nChromatische Aberration\nBlau +HISTORY_MSG_119;(Sensor-Matrix)\nVorverarbeitung\nZeilenrauschfilter +HISTORY_MSG_120;(Sensor-Matrix)\nVorverarbeitung\nGrün-Ausgleich +HISTORY_MSG_121;(Sensor-Matrix)\nChromatische Aberration\nAutomatische Korrektur HISTORY_MSG_122;(Dunkelbild)\nAutomatische Auswahl HISTORY_MSG_123;(Dunkelbild) - Datei HISTORY_MSG_124;(Weißpunkt)\nKorrekturfaktor @@ -413,11 +415,11 @@ HISTORY_MSG_133;(Farbmanagement)\nAusgabeprofil\nAusgabe-Gamma HISTORY_MSG_134;(Farbmanagement)\nAusgabeprofil\nGamma HISTORY_MSG_135;(Farbmanagement)\nAusgabeprofil\nFreies Gamma HISTORY_MSG_136;(Farbmanagement)\nAusgabeprofil\nGradient (linear) -HISTORY_MSG_137;(Sensor Bayer-Matrix)\nSchwarzpunkt - Grün 1 -HISTORY_MSG_138;(Sensor Bayer-Matrix)\nSchwarzpunkt - Rot -HISTORY_MSG_139;(Sensor Bayer-Matrix)\nSchwarzpunkt - Blau -HISTORY_MSG_140;(Sensor Bayer-Matrix)\nSchwarzpunkt - Grün 2 -HISTORY_MSG_141;(Sensor Bayer-Matrix)\nSchwarzpunkt\nGrün-Werte angleichen +HISTORY_MSG_137;(Sensor-Matrix)\nSchwarzpunkt - Grün 1 +HISTORY_MSG_138;(Sensor-Matrix)\nSchwarzpunkt - Rot +HISTORY_MSG_139;(Sensor-Matrix)\nSchwarzpunkt - Blau +HISTORY_MSG_140;(Sensor-Matrix)\nSchwarzpunkt - Grün 2 +HISTORY_MSG_141;(Sensor-Matrix)\nSchwarzpunkt\nGrün-Werte angleichen HISTORY_MSG_142;(Kantenschärfung)\nIterationen HISTORY_MSG_143;(Kantenschärfung)\nIntensität HISTORY_MSG_144;(Mikrokontrast)\nIntensität @@ -480,7 +482,7 @@ HISTORY_MSG_200;(CIECAM02)\nDynamikkompression HISTORY_MSG_201;(Rauschreduzierung)\nDelta-Chrominanz\nRot / Grün HISTORY_MSG_202;(Rauschreduzierung)\nDelta-Chrominanz\nBlau / Gelb HISTORY_MSG_203;(Rauschreduzierung)\nMethode -HISTORY_MSG_204;(Sensor Bayer-Matrix)\nFarbinterpolation\nLMMSE-Verbesserung +HISTORY_MSG_204;(Sensor-Matrix)\nFarbinterpolation\nLMMSE-Verbesserung HISTORY_MSG_205;(CIECAM02)\nBetrachtungsbed.\nHot / Bad-Pixelfilter HISTORY_MSG_206;(CIECAM02) - Szene\nAuto-Leuchtstärke HISTORY_MSG_207;(Farbsaum entfernen)\nFarbtonkurve @@ -565,9 +567,9 @@ HISTORY_MSG_286;(Rauschreduzierung)\nMediantyp HISTORY_MSG_287;(Rauschreduzierung)\nMedianiterationen HISTORY_MSG_288;(Weißbild)\nKontrolle zu heller Bereiche HISTORY_MSG_289;(Weißbild)\nAuto-Kontrolle zu\nheller Bereiche -HISTORY_MSG_290;(Sensor X-Trans-Matrix)\nSchwarzpunkt - Rot -HISTORY_MSG_291;(Sensor X-Trans-Matrix)\nSchwarzpunkt - Grün -HISTORY_MSG_292;(Sensor X-Trans-Matrix)\nSchwarzpunkt - Blau +HISTORY_MSG_290;(Sensor-Matrix)\nSchwarzpunkt - Rot +HISTORY_MSG_291;(Sensor-Matrix)\nSchwarzpunkt - Grün +HISTORY_MSG_292;(Sensor-Matrix)\nSchwarzpunkt - Blau HISTORY_MSG_293;(Filmsimulation) HISTORY_MSG_294;(Filmsimulation)\nIntensität HISTORY_MSG_295;(Filmsimulation) - Film @@ -720,6 +722,36 @@ HISTORY_MSG_441;(Retinex) - Einstellungen\nVerstärkung und Ausgleich\nTransmiss HISTORY_MSG_442;(Retinex) - Einstellungen\nTransmission - Skalierung HISTORY_MSG_443;(Farbmanagement)\nAusgabeprofil\nSchwarzpunkt-Kompensation HISTORY_MSG_444;(Weißabgleich)\nAWB-Temperatur-Korrektur +HISTORY_MSG_445;(Sensor-Matrix)\nFarbinterpolation\nUnterbild +HISTORY_MSG_446;EvPixelShiftMotion +HISTORY_MSG_447;EvPixelShiftMotionCorrection +HISTORY_MSG_448;EvPixelShiftStddevFactorGreen +HISTORY_MSG_449;(Sensor-Matrix)\nFarbinterpolation\nISO-Anpassung +HISTORY_MSG_450;EvPixelShiftNreadIso +HISTORY_MSG_451;EvPixelShiftPrnu +HISTORY_MSG_452;(Sensor-Matrix)\nFarbinterpolation\nBewegungsmaske\nanzeigen +HISTORY_MSG_453;(Sensor-Matrix)\nFarbinterpolation\nNur Maske anzeigen +HISTORY_MSG_454;EvPixelShiftAutomatic +HISTORY_MSG_455;EvPixelShiftNonGreenHorizontal +HISTORY_MSG_456;EvPixelShiftNonGreenVertical +HISTORY_MSG_457;(Sensor-Matrix)\nFarbinterpolation\nBewegung im Rot/Blau-\nKanal erkennen +HISTORY_MSG_458;EvPixelShiftStddevFactorRed +HISTORY_MSG_459;EvPixelShiftStddevFactorBlue +HISTORY_MSG_460;EvPixelShiftGreenAmaze +HISTORY_MSG_461;EvPixelShiftNonGreenAmaze +HISTORY_MSG_462;(Sensor-Matrix)\nFarbinterpolation\nBewegung im Grün-\nKanal erkennen +HISTORY_MSG_463;EvPixelShiftRedBlueWeight +HISTORY_MSG_464;(Sensor-Matrix)\nFarbinterpolation\nUnschärfebewegungsmaske +HISTORY_MSG_465;(Sensor-Matrix)\nFarbinterpolation\nUnschärferadius +HISTORY_MSG_466;EvPixelShiftSum +HISTORY_MSG_467;EvPixelShiftExp0 +HISTORY_MSG_468;(Sensor-Matrix)\nFarbinterpolation\nLücken in der Bewegungs-\nmaske erkennen +HISTORY_MSG_469;(Sensor-Matrix)\nFarbinterpolation\nMedian +HISTORY_MSG_470;EvPixelShiftMedian3 +HISTORY_MSG_471;(Sensor-Matrix)\nFarbinterpolation\nBewegungskorrektur +HISTORY_MSG_472;(Sensor-Matrix)\nFarbinterpolation\nWeicher Übergang +HISTORY_MSG_473;(Sensor-Matrix)\nFarbinterpolation\nLMMSE für Bewegungs-\nteile verwenden +HISTORY_MSG_474;(Sensor-Matrix)\nFarbinterpolation\nFrame-Helligkeit angleichen HISTORY_NEWSNAPSHOT;Hinzufügen HISTORY_NEWSNAPSHOT_TOOLTIP;Taste: Alt + s HISTORY_SNAPSHOT;Schnappschuss @@ -909,7 +941,8 @@ PARTIALPASTE_RAWGROUP;RAW PARTIALPASTE_RAW_DCBENHANCE;Farbinterpolation: DCB-Verbesserung PARTIALPASTE_RAW_DCBITERATIONS;Farbinterpolation: Anzahl der DCB-Iterationen PARTIALPASTE_RAW_DMETHOD;Farbinterpolation: Methode -PARTIALPASTE_RAW_FALSECOLOR;Farbinterpolation: Falschfarbenunterdrückung +PARTIALPASTE_RAW_FALSECOLOR;Farbinterpolation: Falschfarbenreduzierung +PARTIALPASTE_RAW_IMAGENUM;Farbinterpolation: Unterbild PARTIALPASTE_RAW_LMMSEITERATIONS;Farbinterpolation: LMMSE-Verbesserungsstufen PARTIALPASTE_RESIZE;Skalieren PARTIALPASTE_RETINEX;Retinex (Bildschleier entfernen) @@ -1173,7 +1206,7 @@ PROGRESSBAR_SNAPSHOT_ADDED;Schnappschuss hinzugefügt PROGRESSDLG_PROFILECHANGEDINBROWSER;Profil wurde in der Dateiverwaltung geändert QINFO_ISO;ISO QINFO_NOEXIF;Keine Exif-Daten vorhanden. -SAVEDLG_AUTOSUFFIX;Suffix anfügen, falls unter dem Namen bereits eine Datei existiert +SAVEDLG_AUTOSUFFIX;Suffix anfügen, wenn die Datei bereits existiert SAVEDLG_FILEFORMAT;Dateiformat SAVEDLG_FORCEFORMATOPTS;Erzwinge Speicheroptionen SAVEDLG_JPEGQUAL;JPEG-Qualität @@ -1690,21 +1723,82 @@ TP_RAWEXPOS_LINEAR;Korrekturfaktor TP_RAWEXPOS_PRESER;Weißpunkt: Lichter schützen TP_RAWEXPOS_RGB;Rot, Grün, Blau TP_RAWEXPOS_TWOGREEN;Grün-Werte automatisch angleichen +TP_RAW_1PASSMEDIUM;1-Pass (Medium) +TP_RAW_3PASSBEST;3-Pass (Beste) +TP_RAW_AHD;AHD +TP_RAW_AMAZE;AMaZE +TP_RAW_DCB;DCB TP_RAW_DCBENHANCE;DCB-Verbesserung TP_RAW_DCBITERATIONS;Anzahl der DCB-Iterationen TP_RAW_DMETHOD;Methode TP_RAW_DMETHOD_PROGRESSBAR;%1 verarbeitet TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaikoptimierung -TP_RAW_DMETHOD_TOOLTIP;Hinweis: IGV und LMMSE ist speziell für Bilder\nmit hohen ISO-Werten reserviert und verbessert\ndie Rauschreduzierung. -TP_RAW_FALSECOLOR;Falschfarbenunterdrückung +TP_RAW_DMETHOD_TOOLTIP;IGV und LMMSE sind speziel für High-ISO-Aufnahmen um die\nRauschreduzierung zu unterstützen ohne zu Maze-Mustern,\nPosterisierung oder einem ausgewaschenen Look zu führen.\n\nPixel Shift ist für “Pentax Pixel Shift“-Dateien. Für "Nicht-Pixel-\nShift"-Dateien wird automatisch AMaZE verwendet. +TP_RAW_EAHD;EAHD +TP_RAW_FALSECOLOR;Falschfarbenreduzierung +TP_RAW_FAST;Schnell TP_RAW_HD;Schwelle TP_RAW_HD_TOOLTIP;Je niedriger der Wert, umso empfindlicher reagiert\ndie “Hot / Dead-Pixel-Erkennung“.\nIst die Empfindlichkeit zu hoch, können Artefakte\nentstehen. Erhöhen Sie in diesem Fall die Schwelle,\nbis die Artefakte verschwinden. +TP_RAW_HPHD;HPHD +TP_RAW_IGV;IGV +TP_RAW_IMAGENUM;Unterbild +TP_RAW_IMAGENUM_TOOLTIP;Einige RAW-Formate beinhalten möglicherweise mehrere\nUnterbilder (HDR, Pixel-Shift, Dual Pixel, Dual Sensitivity).\nWählen Sie das passende Unterbild aus.\n\nIst die Bildnummer größer als die Anzahl\nder Unterbilder wird das letzte Unterbild benutzt. TP_RAW_LABEL;Farbinterpolation +TP_RAW_LMMSE;LMMSE TP_RAW_LMMSEITERATIONS;LMMSE-Verbesserungsstufen TP_RAW_LMMSE_TOOLTIP;Fügt Gamma (Stufe 1), Median (Stufe 2-4)\nund Optimierung (Stufe 5-6) zur Minimierung\nvon Artefakten hinzu und verbessert das\nSignalrauschverhältnis. +TP_RAW_MONO;Mono +TP_RAW_NONE;Keine +TP_RAW_PIXELSHIFT;Pixel Shift +TP_RAW_PIXELSHIFTADAPTIVE;Adaptive Erkennung +TP_RAW_PIXELSHIFTBLUR;Unschärfebewegungsmaske +TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Unschärfebewegungsmaske +TP_RAW_PIXELSHIFTEPERISO;ISO-Anpassung +TP_RAW_PIXELSHIFTEPERISO_TOOLTIP;Der Standardwert (0.0) empfiehlt sich für die Basis-ISO.\nErhöhen Sie den Wert, um die Bewegungserkennung für höhere ISO-Werte zu verbessern.\nErhöhen Sie den Wert nur in kleinen Schritten und achten Sie dabei auf die Bewegungsmaske. +TP_RAW_PIXELSHIFTEQUALBRIGHT;Frame-Helligkeit angleichen +TP_RAW_PIXELSHIFTEQUALBRIGHT_TOOLTIP;Gleicht die Helligkeit der Frames an den aktuellen Frame an.\n\nSind überbelichtete Bereiche vorhanden wählen Sie den hellsten Frame aus um\nMagenta-Farbstiche zu vermeiden oder aktivieren Sie die Bewegungskorrektur. +TP_RAW_PIXELSHIFTEXP0;Experimentell +TP_RAW_PIXELSHIFTGREEN;Bewegung im Grün-Kanal erkennen +TP_RAW_PIXELSHIFTHOLEFILL;Lücken in der Bewegungsmaske erkennen +TP_RAW_PIXELSHIFTHOLEFILL_TOOLTIP;Lücken in der Bewegungsmaske erkennen +TP_RAW_PIXELSHIFTLMMSE;LMMSE für Bewegungsteile verwenden +TP_RAW_PIXELSHIFTLMMSE_TOOLTIP;LMMSE anstatt AMaZE für bewegte Bildanteile verwenden.\nSinnvoll bei High-ISO-Aufnahmen. +TP_RAW_PIXELSHIFTMASKTHRESHOLD;3x3 new threshold +TP_RAW_PIXELSHIFTMEDIAN;Median +TP_RAW_PIXELSHIFTMEDIAN3;Aktuellen Frame vom Median ausschließen. +TP_RAW_PIXELSHIFTMEDIAN3_TOOLTIP;Schließt den aktuellen Frame vom Median aus.\nNützlich, wenn sich bewegte Objekte im Frame 2\nund 3 überlappen. +TP_RAW_PIXELSHIFTMEDIAN_TOOLTIP;Verwenden Sie den Median aller Frames anstelle des\nausgewählten Frames für Regionen mit Bewegung.\nEntfernt Objekte, die an verschiedenen Stellen in allen\nFrames vorkommen. Erzeugt einen Bewegungseffekt\nauf langsame (überlappende) Objekte. +TP_RAW_PIXELSHIFTMM_AUTO;Automatisch +TP_RAW_PIXELSHIFTMM_CUSTOM;Benutzerdefiniert +TP_RAW_PIXELSHIFTMM_OFF;Aus +TP_RAW_PIXELSHIFTMOTION;Motion detection level (deprecated) +TP_RAW_PIXELSHIFTMOTIONCORRECTION;Green motion correction size +TP_RAW_PIXELSHIFTMOTIONCORRECTION_TOOLTIP;1 = 2 Pixel\n3 = 3x3 Raster\n5 = 5x5 Raster +TP_RAW_PIXELSHIFTMOTIONMETHOD;Bewegungskorrektur +TP_RAW_PIXELSHIFTMOTION_TOOLTIP;0 = Keine Bewegungserkennung\n1 - 99 = Bewegung wird entsprechend dem Wert erkannt.\nHöhere Werte erhöhen die Trefferquote\n100 = Der mit AMaZE interpolierte Frame wird verwendet. +TP_RAW_PIXELSHIFTNONGREENAMAZE;Check red/blue amaze +TP_RAW_PIXELSHIFTNONGREENCROSS;Bewegung im Rot/Blau-Kanal erkennen +TP_RAW_PIXELSHIFTNONGREENCROSS2;Check green amaze +TP_RAW_PIXELSHIFTNONGREENHORIZONTAL;Check red/blue horizontal +TP_RAW_PIXELSHIFTNONGREENVERTICAL;Check red/blue vertical +TP_RAW_PIXELSHIFTNREADISO;nRead +TP_RAW_PIXELSHIFTPRNU;PRNU (%) +TP_RAW_PIXELSHIFTREDBLUEWEIGHT;Red&Blue weight +TP_RAW_PIXELSHIFTSHOWMOTION;Bewegungsmaske anzeigen +TP_RAW_PIXELSHIFTSHOWMOTIONMASKONLY;Nur Maske anzeigen +TP_RAW_PIXELSHIFTSHOWMOTIONMASKONLY_TOOLTIP;Zeigt die Bewegungsmaske ohne Bild. +TP_RAW_PIXELSHIFTSHOWMOTION_TOOLTIP;Überlagert das Bild mit einer Maske um die\nBereiche mit Bewegung hervorzuheben. +TP_RAW_PIXELSHIFTSIGMA;Unschärferadius +TP_RAW_PIXELSHIFTSIGMA_TOOLTIP;Der Standard-Radius von 1,0 passt in der Regel für die Basis-ISO.\nErhöhen Sie den Wert für High-ISO-Aufnahmen, 5,0 ist ein guter\nAusgangspunkt für High-ISO-Aufnahmen. Achten Sie auf die\nBewegungsmaske, während Sie den Wert ändern. +TP_RAW_PIXELSHIFTSMOOTH;Weicher Übergang +TP_RAW_PIXELSHIFTSMOOTH_TOOLTIP;Weicher Übergang zwischen Bereichen mit und ohne Bewegung.\n0 = Aus\n1 = AMaZE/LMMSE oder Median +TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue +TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green +TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red TP_RAW_SENSOR_BAYER_LABEL;Sensor mit Bayer-Matrix -TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;Mit “3-pass“ erzielt man die besten Ergebnisse\n(empfohlen bei Bildern mit niedrigen ISO-Werten).\n\nBei hohen ISO-Werten unterscheidet sich “1-pass“\nkaum gegenüber “3-pass“, ist aber deutlich schneller. +TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;Mit “3-Pass“ erzielt man die besten Ergebnisse\n(empfohlen bei Bildern mit niedrigen ISO-Werten).\n\nBei hohen ISO-Werten unterscheidet sich “1-Pass“\nkaum gegenüber “3-Pass“, ist aber deutlich schneller. TP_RAW_SENSOR_XTRANS_LABEL;Sensor mit X-Trans-Matrix +TP_RAW_VNG4;VNG4 TP_RESIZE_APPLIESTO;Anwenden auf: TP_RESIZE_CROPPEDAREA;Ausschnitt TP_RESIZE_FITBOX;Begrenzungsrahmen @@ -2083,100 +2177,3 @@ ZOOMPANEL_ZOOMFITCROPSCREEN;Ausschnitt an Bildschirm anpassen\nTaste: Alt ZOOMPANEL_ZOOMFITSCREEN;An Bildschirm anpassen\nTaste: f ZOOMPANEL_ZOOMIN;Hineinzoomen\nTaste: + ZOOMPANEL_ZOOMOUT;Herauszoomen\nTaste: - - -!!!!!!!!!!!!!!!!!!!!!!!!! -! Untranslated keys follow; remove the ! prefix after an entry is translated. -!!!!!!!!!!!!!!!!!!!!!!!!! - -!HISTORY_MSG_445;Raw Sub-Image -!HISTORY_MSG_446;EvPixelShiftMotion -!HISTORY_MSG_447;EvPixelShiftMotionCorrection -!HISTORY_MSG_448;EvPixelShiftStddevFactorGreen -!HISTORY_MSG_449;PS ISO adaption -!HISTORY_MSG_450;EvPixelShiftNreadIso -!HISTORY_MSG_451;EvPixelShiftPrnu -!HISTORY_MSG_452;PS Show motion -!HISTORY_MSG_453;PS Show mask only -!HISTORY_MSG_454;EvPixelShiftAutomatic -!HISTORY_MSG_455;EvPixelShiftNonGreenHorizontal -!HISTORY_MSG_456;EvPixelShiftNonGreenVertical -!HISTORY_MSG_457;PS Check red/blue -!HISTORY_MSG_458;EvPixelShiftStddevFactorRed -!HISTORY_MSG_459;EvPixelShiftStddevFactorBlue -!HISTORY_MSG_460;EvPixelShiftGreenAmaze -!HISTORY_MSG_461;EvPixelShiftNonGreenAmaze -!HISTORY_MSG_462;PS Check green -!HISTORY_MSG_463;EvPixelShiftRedBlueWeight -!HISTORY_MSG_464;PS Blur motion mask -!HISTORY_MSG_465;PS Blur radius -!HISTORY_MSG_466;EvPixelShiftSum -!HISTORY_MSG_467;EvPixelShiftExp0 -!HISTORY_MSG_468;PS Fill holes -!HISTORY_MSG_469;PS Median -!HISTORY_MSG_470;EvPixelShiftMedian3 -!HISTORY_MSG_471;PS Motion correction -!HISTORY_MSG_472;PS Smooth transitions -!HISTORY_MSG_473;PS Use lmmse -!HISTORY_MSG_474;PS Equalize -!PARTIALPASTE_RAW_IMAGENUM;Sub-image -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd -!TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv -!TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) -!TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection -!TP_RAW_PIXELSHIFTBLUR;Blur motion mask -!TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask -!TP_RAW_PIXELSHIFTEPERISO;ISO adaption -!TP_RAW_PIXELSHIFTEPERISO_TOOLTIP;The default value (0.0) should work fine for base ISO.\nIncrease the value to improve motion detection for higher ISO.\nIncrease in small steps and watch the motion mask while increasing. -!TP_RAW_PIXELSHIFTEQUALBRIGHT;Equalize brightness of frames -!TP_RAW_PIXELSHIFTEQUALBRIGHT_TOOLTIP;Equalize the brightness of the frames to the brightness of the selected frame.\nIf there are overexposed areas in the frames select the brightest frame to avoid magenta colour cast in overexposed areas or enable motion correction. -!TP_RAW_PIXELSHIFTEXP0;Experimental -!TP_RAW_PIXELSHIFTGREEN;Check green channel for motion -!TP_RAW_PIXELSHIFTHOLEFILL;Fill holes in motion mask -!TP_RAW_PIXELSHIFTHOLEFILL_TOOLTIP;Fill holes in motion mask -!TP_RAW_PIXELSHIFTLMMSE;Use lmmse for motion parts -!TP_RAW_PIXELSHIFTLMMSE_TOOLTIP;Use lmmse instead of amaze for motion areas.\nUseful for High ISO images. -!TP_RAW_PIXELSHIFTMASKTHRESHOLD;3x3 new threshold -!TP_RAW_PIXELSHIFTMEDIAN;Median -!TP_RAW_PIXELSHIFTMEDIAN3;Exclude selected frame from median -!TP_RAW_PIXELSHIFTMEDIAN3_TOOLTIP;Excludes selected frame from median.\nUseful if moving objects overlap in frame 2 and 3 -!TP_RAW_PIXELSHIFTMEDIAN_TOOLTIP;Use median of all frames instead of selected frame for regions with motion.\nRemoves objects which are at different places in all frames.\nGives motion effect on slow moving (overlapping) objects. -!TP_RAW_PIXELSHIFTMM_AUTO;Automatic -!TP_RAW_PIXELSHIFTMM_CUSTOM;Custom -!TP_RAW_PIXELSHIFTMM_OFF;Off -!TP_RAW_PIXELSHIFTMOTION;Motion detection level (deprecated) -!TP_RAW_PIXELSHIFTMOTIONCORRECTION;Green motion correction size -!TP_RAW_PIXELSHIFTMOTIONCORRECTION_TOOLTIP;1 = 2 pixels\n3 = 3x3 grid\n5 = 5x5 grid -!TP_RAW_PIXELSHIFTMOTIONMETHOD;Motion Correction -!TP_RAW_PIXELSHIFTMOTION_TOOLTIP;0 means no motion detection\n1 - 99 means motion will be detected according to this value. Increase value to increase detection rate\n100 means the Amaze demosaiced frame will be used -!TP_RAW_PIXELSHIFTNONGREENAMAZE;Check red/blue amaze -!TP_RAW_PIXELSHIFTNONGREENCROSS;Check red/blue channels for motion -!TP_RAW_PIXELSHIFTNONGREENCROSS2;Check green amaze -!TP_RAW_PIXELSHIFTNONGREENHORIZONTAL;Check red/blue horizontal -!TP_RAW_PIXELSHIFTNONGREENVERTICAL;Check red/blue vertical -!TP_RAW_PIXELSHIFTNREADISO;nRead -!TP_RAW_PIXELSHIFTPRNU;PRNU (%) -!TP_RAW_PIXELSHIFTREDBLUEWEIGHT;Red&Blue weight -!TP_RAW_PIXELSHIFTSHOWMOTION;Show motion -!TP_RAW_PIXELSHIFTSHOWMOTIONMASKONLY;Show mask only -!TP_RAW_PIXELSHIFTSHOWMOTIONMASKONLY_TOOLTIP;Shows the motion mask without the image -!TP_RAW_PIXELSHIFTSHOWMOTION_TOOLTIP;Overlays the image with a mask showing the regions with motion -!TP_RAW_PIXELSHIFTSIGMA;Blur radius -!TP_RAW_PIXELSHIFTSIGMA_TOOLTIP;Default radius of 1.0 usually fits good for base ISO. Increase value for high ISO shots,\n5.0 is a good starting point for high ISO shots.\nWatch motion mask while changing the value. -!TP_RAW_PIXELSHIFTSMOOTH;Smooth transitions -!TP_RAW_PIXELSHIFTSMOOTH_TOOLTIP;Smooth transitions between areas with and without motion.\nSet to 0 to disable smooth transitions\nSet to 1 to get Amaze/lmmse or Median -!TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue -!TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green -!TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 From dc4b62e2537d84a734140ceaedcef299ddb56125 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sun, 26 Mar 2017 19:20:36 +0200 Subject: [PATCH 21/90] fix bug in preview when LCP distortion correction is on and the image is flipped Candidate fix for #3778 --- rtengine/dcrop.cc | 41 ++++++++++++++++++++++---------------- rtengine/rawimagesource.cc | 8 ++++---- 2 files changed, 28 insertions(+), 21 deletions(-) diff --git a/rtengine/dcrop.cc b/rtengine/dcrop.cc index 4e944d9fd..7b4862ea0 100644 --- a/rtengine/dcrop.cc +++ b/rtengine/dcrop.cc @@ -1079,8 +1079,11 @@ void Crop::freeAll () namespace { -bool check_need_larger_crop_for_lcp_distortion(const ProcParams ¶ms) +bool check_need_larger_crop_for_lcp_distortion(int fw, int fh, int x, int y, int w, int h, const ProcParams ¶ms) { + if (x == 0 && y == 0 && w == fw && h == fh) { + return false; + } return (params.lensProf.lcpFile.length() > 0 && params.lensProf.useDist); } @@ -1134,29 +1137,33 @@ bool Crop::setCropSizes (int rcx, int rcy, int rcw, int rch, int skip, bool inte // determine which part of the source image is required to compute the crop rectangle int orx, ory, orw, orh; + orx = bx1; + ory = by1; + orw = bw; + orh = bh; ProcParams& params = parent->params; + parent->ipf.transCoord (parent->fw, parent->fh, bx1, by1, bw, bh, orx, ory, orw, orh); + + if (check_need_larger_crop_for_lcp_distortion(parent->fw, parent->fh, orx, ory, orw, orh, parent->params)) { + double dW = double(parent->fw) * 0.15 / skip; // TODO - this is hardcoded ATM! + double dH = double(parent->fh) * 0.15 / skip; // this is an estimate of the max + // distortion relative to the image + // size. BUT IS 15% REALLY ENOUGH? + // In fact, is there a better way?? + orw = min(int(orw + dW), parent->fw); + orh = min(int(orh + dH), parent->fh); + orx = max(int(orx - dW/2.0), 0); + ory = max(int(ory - dH/2.0), 0); + } + PreviewProps cp (orx, ory, orw, orh, skip); int orW, orH; parent->imgsrc->getSize (cp, orW, orH); - if (check_need_larger_crop_for_lcp_distortion(parent->params)) { - int fW, fH; - parent->imgsrc->getFullSize(fW, fH); - double dW = double(fW) * 0.15; // TODO - this is hardcoded ATM! - double dH = double(fH) * 0.15; // this is an estimate of the max - // distortion relative to the image - // size. BUT IS 15% REALLY ENOUGH? - // In fact, is there a better way?? - orW = min(int(orW + dW), fW); - orH = min(int(orH + dH), fH); - trafx = max(int(orx - dW/2.0), 0); - trafy = max(int(ory - dH/2.0), 0); - } else { - trafx = orx; - trafy = ory; - } + trafx = orx; + trafy = ory; int cw = skips(bw, skip); int ch = skips(bh, skip); diff --git a/rtengine/rawimagesource.cc b/rtengine/rawimagesource.cc index df14ddcb2..4aaacd4b0 100644 --- a/rtengine/rawimagesource.cc +++ b/rtengine/rawimagesource.cc @@ -543,17 +543,17 @@ void RawImageSource::transformRect (PreviewProps pp, int tran, int &ssx1, int &s int ppx = pp_x, ppy = pp_y; if (tran & TR_HFLIP) { - ppx = sw - pp_x - pp_width; + ppx = max(sw - pp_x - pp_width, 0); } if (tran & TR_VFLIP) { - ppy = sh - pp_y - pp_height; + ppy = max(sh - pp_y - pp_height, 0); } int sx1 = ppx; // assuming it's >=0 int sy1 = ppy; // assuming it's >=0 - int sx2 = max(ppx + pp_width, w - 1); - int sy2 = max(ppy + pp_height, h - 1); + int sx2 = min(ppx + pp_width, w - 1); + int sy2 = min(ppy + pp_height, h - 1); if ((tran & TR_ROT) == TR_R180) { sx1 = max(w - ppx - pp_width, 0); From 1dedefda2a71f05f16a03b6787f0d7d82ba8e252 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Sun, 26 Mar 2017 23:04:36 +0200 Subject: [PATCH 22/90] Don't use camconst.json for already demosaiced DNG files from some Pentax cameras (files have been generated by DxO) --- rtengine/dcraw.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/dcraw.cc b/rtengine/dcraw.cc index c1d2e670a..ec54b9fcf 100644 --- a/rtengine/dcraw.cc +++ b/rtengine/dcraw.cc @@ -9492,7 +9492,7 @@ dng_skip: adobe_coeff (make, model); if(!strncmp(make, "Samsung", 7) && !strncmp(model, "NX1",3)) adobe_coeff (make, model); - if(!strncmp(make, "Pentax", 6) && (!strncmp(model, "K10D",4) || !strncmp(model, "K-70",4) || !strncmp(model, "K-1",3))) + if((!strncmp(make, "Pentax", 6) && (!strncmp(model, "K10D",4) || !strncmp(model, "K-70",4) || !strncmp(model, "K-1",3))) && filters != 0) adobe_coeff (make, model); if(!strncmp(make, "Leica", 5) && !strncmp(model, "Q",1)) adobe_coeff (make, model); From 52e8668aee35e028b009e3e0f97be9bf116f4a15 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 27 Mar 2017 15:31:32 +0200 Subject: [PATCH 23/90] Hide some raw tools for predemosaiced raw files (mraw, sraw, predemosaiced DNG) --- rtgui/toolpanelcoord.cc | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/rtgui/toolpanelcoord.cc b/rtgui/toolpanelcoord.cc index 43393d90b..cacbee99d 100644 --- a/rtgui/toolpanelcoord.cc +++ b/rtgui/toolpanelcoord.cc @@ -317,9 +317,18 @@ void ToolPanelCoordinator::imageTypeChanged(bool isRaw, bool isBayer, bool isXtr if (isBayer) { sensorxtrans->FoldableToolPanel::hide(); sensorbayer->FoldableToolPanel::show(); + preprocess->FoldableToolPanel::show(); + flatfield->FoldableToolPanel::show(); } else if (isXtrans) { sensorxtrans->FoldableToolPanel::show(); sensorbayer->FoldableToolPanel::hide(); + preprocess->FoldableToolPanel::show(); + flatfield->FoldableToolPanel::show(); + } else { + sensorbayer->FoldableToolPanel::hide(); + sensorxtrans->FoldableToolPanel::hide(); + preprocess->FoldableToolPanel::hide(); + flatfield->FoldableToolPanel::hide(); } } else { rawPanelSW->set_sensitive(false); From d4f0aa559668e42826dfeacff83194dfb3e00408 Mon Sep 17 00:00:00 2001 From: Morgan Hardwood Date: Mon, 27 Mar 2017 20:42:04 +0200 Subject: [PATCH 24/90] Set EPD tone mapping Scale to 0.1 to better match preview to output. --- rtgui/epd.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtgui/epd.cc b/rtgui/epd.cc index 15f15f607..995da43a4 100644 --- a/rtgui/epd.cc +++ b/rtgui/epd.cc @@ -31,7 +31,7 @@ EdgePreservingDecompositionUI::EdgePreservingDecompositionUI () : FoldableToolPa strength = Gtk::manage(new Adjuster (M("TP_EPD_STRENGTH"), -1.0, 2.0, 0.01, 0.5)); gamma = Gtk::manage(new Adjuster (M("TP_EPD_GAMMA"), 0.8, 1.5, 0.01, 1.)); edgeStopping = Gtk::manage(new Adjuster (M("TP_EPD_EDGESTOPPING"), 0.1, 4.0, 0.01, 1.4)); - scale = Gtk::manage(new Adjuster (M("TP_EPD_SCALE"), 0.1, 10.0, 0.01, 0.3)); + scale = Gtk::manage(new Adjuster (M("TP_EPD_SCALE"), 0.1, 10.0, 0.01, 0.1)); reweightingIterates = Gtk::manage(new Adjuster (M("TP_EPD_REWEIGHTINGITERATES"), 0, 9, 1, 0)); strength->setAdjusterListener(this); From 68b19868369f3188132996eaafcff49dd7bc971b Mon Sep 17 00:00:00 2001 From: Morgan Hardwood Date: Mon, 27 Mar 2017 20:58:39 +0200 Subject: [PATCH 25/90] Set EPD tone mapping Edge Stopping to 0.5 to better match preview to output. --- rtgui/epd.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtgui/epd.cc b/rtgui/epd.cc index 995da43a4..d7848aee0 100644 --- a/rtgui/epd.cc +++ b/rtgui/epd.cc @@ -30,7 +30,7 @@ EdgePreservingDecompositionUI::EdgePreservingDecompositionUI () : FoldableToolPa strength = Gtk::manage(new Adjuster (M("TP_EPD_STRENGTH"), -1.0, 2.0, 0.01, 0.5)); gamma = Gtk::manage(new Adjuster (M("TP_EPD_GAMMA"), 0.8, 1.5, 0.01, 1.)); - edgeStopping = Gtk::manage(new Adjuster (M("TP_EPD_EDGESTOPPING"), 0.1, 4.0, 0.01, 1.4)); + edgeStopping = Gtk::manage(new Adjuster (M("TP_EPD_EDGESTOPPING"), 0.1, 4.0, 0.01, 0.5)); scale = Gtk::manage(new Adjuster (M("TP_EPD_SCALE"), 0.1, 10.0, 0.01, 0.1)); reweightingIterates = Gtk::manage(new Adjuster (M("TP_EPD_REWEIGHTINGITERATES"), 0, 9, 1, 0)); From 76f16eb3a77f7e2497212e9bdfbdf7bbad190437 Mon Sep 17 00:00:00 2001 From: Morgan Hardwood Date: Mon, 27 Mar 2017 21:37:07 +0200 Subject: [PATCH 26/90] Set EPD tone mapping Edge Stopping and Scale to better match preview to output. Third time lucky. --- rtengine/procparams.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rtengine/procparams.cc b/rtengine/procparams.cc index 9da09998d..8edf53f8c 100644 --- a/rtengine/procparams.cc +++ b/rtengine/procparams.cc @@ -1168,8 +1168,8 @@ void ProcParams::setDefaults () epd.enabled = false; epd.strength = 0.5; epd.gamma = 1.0; - epd.edgeStopping = 1.4; - epd.scale = 0.3; + epd.edgeStopping = 0.5; + epd.scale = 0.1; epd.reweightingIterates = 0; sh.enabled = false; From 209ea3533b3176444848314b1ce468dd30db938a Mon Sep 17 00:00:00 2001 From: Hombre Date: Tue, 28 Mar 2017 00:02:10 +0200 Subject: [PATCH 27/90] Adding PixelShift to PartialPaste window + small bugfixs (issue #3489) --- rtdata/languages/Francais | 7 ++-- rtdata/languages/default | 5 +-- rtengine/pixelshift.cc | 6 ++-- rtengine/procparams.cc | 24 +++++++------- rtengine/procparams.h | 4 +-- rtgui/bayerprocess.cc | 18 +++++----- rtgui/paramsedited.cc | 18 +++++----- rtgui/paramsedited.h | 4 +-- rtgui/partialpastedlg.cc | 69 ++++++++++++++++++++++++++++++--------- rtgui/partialpastedlg.h | 6 ++-- rtgui/profilepanel.cc | 2 ++ 11 files changed, 104 insertions(+), 59 deletions(-) diff --git a/rtdata/languages/Francais b/rtdata/languages/Francais index c8f1c8891..b0fdf3c0d 100644 --- a/rtdata/languages/Francais +++ b/rtdata/languages/Francais @@ -853,8 +853,8 @@ PARTIALPASTE_PREPROCESS_HOTPIXFILT;Filtrage des pixels chauds PARTIALPASTE_PREPROCESS_LINEDENOISE;Filtre de bruit de ligne PARTIALPASTE_PRSHARPENING;Netteté post-redim. PARTIALPASTE_RAWCACORR_AUTO;Corr. auto. de l'aberr. chromatique -PARTIALPASTE_RAWCACORR_CABLUE;Aberr. chromatique bleu -PARTIALPASTE_RAWCACORR_CARED;Aberr. chromatique rouge +PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;Force aberr. chromatique auto +PARTIALPASTE_RAWCACORR_CAREDBLUE;Aberr. chromatique rouge et bleu PARTIALPASTE_RAWEXPOS_BLACK;Niveaux de noir PARTIALPASTE_RAWEXPOS_LINEAR;Correction du point blanc PARTIALPASTE_RAWEXPOS_PRESER;Préservation des hautes humières @@ -864,6 +864,7 @@ PARTIALPASTE_RAW_DCBITERATIONS;Nombre d'itération de DCB PARTIALPASTE_RAW_DMETHOD;Algorithme de dématriçage PARTIALPASTE_RAW_FALSECOLOR;Nbr d'itération des fausses couleurs PARTIALPASTE_RAW_LMMSEITERATIONS;Niveau d'amélioration LMMSE +PARTIALPASTE_RAW_PIXELSHIFT;PixelShift PARTIALPASTE_RESIZE;Redimentionnement PARTIALPASTE_RETINEX;Retinex PARTIALPASTE_RGBCURVES;Courbes RVB @@ -1629,7 +1630,7 @@ TP_PRSHARPENING_TOOLTIP;Augmente la netteté de l'image après le redimentionnem TP_RAWCACORR_AUTO;Correction automatique TP_RAWCACORR_CABLUE;Bleu TP_RAWCACORR_CARED;Rouge -TP_RAWCACORR_CASTR;force +TP_RAWCACORR_CASTR;Force TP_RAWEXPOS_BLACKS;Niveaux de noir TP_RAWEXPOS_BLACK_0;Vert 1 (maître) TP_RAWEXPOS_BLACK_1;Rouge diff --git a/rtdata/languages/default b/rtdata/languages/default index 849d9a66b..1ca41739a 100644 --- a/rtdata/languages/default +++ b/rtdata/languages/default @@ -895,8 +895,8 @@ PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter PARTIALPASTE_PRSHARPENING;Post-resize sharpening PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -PARTIALPASTE_RAWCACORR_CABLUE;CA blue -PARTIALPASTE_RAWCACORR_CARED;CA red +PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue PARTIALPASTE_RAWEXPOS_BLACK;Black levels PARTIALPASTE_RAWEXPOS_LINEAR;White point correction PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -907,6 +907,7 @@ PARTIALPASTE_RAW_DMETHOD;Demosaic method PARTIALPASTE_RAW_FALSECOLOR;False color suppression PARTIALPASTE_RAW_IMAGENUM;Sub-image PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +PARTIALPASTE_RAW_PIXELSHIFT;PixelShift PARTIALPASTE_RESIZE;Resize PARTIALPASTE_RETINEX;Retinex PARTIALPASTE_RGBCURVES;RGB curves diff --git a/rtengine/pixelshift.cc b/rtengine/pixelshift.cc index 0986844f5..44e765e41 100644 --- a/rtengine/pixelshift.cc +++ b/rtengine/pixelshift.cc @@ -332,7 +332,7 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA } else if(bayerParams.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::Off) { bayerParams.pixelShiftMotion = 0; bayerParams.pixelShiftAutomatic = false; - bayerParams.pixelshiftShowMotion = false; + bayerParams.pixelShiftShowMotion = false; } if((bayerParams.pixelShiftMotion > 0 || bayerParams.pixelShiftAutomatic)) { @@ -454,8 +454,8 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA } const int motion = bayerParams.pixelShiftMotion; - const bool showMotion = bayerParams.pixelshiftShowMotion; - const bool showOnlyMask = bayerParams.pixelshiftShowMotionMaskOnly && showMotion; + const bool showMotion = bayerParams.pixelShiftShowMotion; + const bool showOnlyMask = bayerParams.pixelShiftShowMotionMaskOnly && showMotion; const RAWParams::BayerSensor::ePSMotionCorrection gridSize_ = bayerParams.pixelShiftMotionCorrection; const bool adaptive = bayerParams.pixelShiftAutomatic; #ifdef PIXELSHIFTDEV diff --git a/rtengine/procparams.cc b/rtengine/procparams.cc index 8edf53f8c..35d690eb4 100644 --- a/rtengine/procparams.cc +++ b/rtengine/procparams.cc @@ -945,8 +945,8 @@ void RAWParams::setDefaults() deadPixelFilter = false; hotdeadpix_thresh = 100; bayersensor.setPixelShiftDefaults(); - bayersensor.pixelshiftShowMotion = false; - bayersensor.pixelshiftShowMotionMaskOnly = false; + bayersensor.pixelShiftShowMotion = false; + bayersensor.pixelShiftShowMotionMaskOnly = false; } @@ -3451,12 +3451,12 @@ int ProcParams::save (const Glib::ustring &fname, const Glib::ustring &fname2, b keyFile.set_double ("RAW Bayer", "PixelShiftRedBlueWeight", raw.bayersensor.pixelShiftRedBlueWeight ); } - if (!pedited || pedited->raw.bayersensor.pixelshiftShowMotion) { - keyFile.set_boolean ("RAW Bayer", "PixelShiftShowMotion", raw.bayersensor.pixelshiftShowMotion ); + if (!pedited || pedited->raw.bayersensor.pixelShiftShowMotion) { + keyFile.set_boolean ("RAW Bayer", "PixelShiftShowMotion", raw.bayersensor.pixelShiftShowMotion ); } - if (!pedited || pedited->raw.bayersensor.pixelshiftShowMotionMaskOnly) { - keyFile.set_boolean ("RAW Bayer", "PixelShiftShowMotionMaskOnly", raw.bayersensor.pixelshiftShowMotionMaskOnly ); + if (!pedited || pedited->raw.bayersensor.pixelShiftShowMotionMaskOnly) { + keyFile.set_boolean ("RAW Bayer", "PixelShiftShowMotionMaskOnly", raw.bayersensor.pixelShiftShowMotionMaskOnly ); } if (!pedited || pedited->raw.bayersensor.pixelShiftAutomatic) { @@ -7680,18 +7680,18 @@ int ProcParams::load (const Glib::ustring &fname, ParamsEdited* pedited) } if (keyFile.has_key ("RAW Bayer", "PixelShiftShowMotion")) { - raw.bayersensor.pixelshiftShowMotion = keyFile.get_boolean("RAW Bayer", "PixelShiftShowMotion"); + raw.bayersensor.pixelShiftShowMotion = keyFile.get_boolean("RAW Bayer", "PixelShiftShowMotion"); if (pedited) { - pedited->raw.bayersensor.pixelshiftShowMotion = true; + pedited->raw.bayersensor.pixelShiftShowMotion = true; } } if (keyFile.has_key ("RAW Bayer", "PixelShiftShowMotionMaskOnly")) { - raw.bayersensor.pixelshiftShowMotionMaskOnly = keyFile.get_boolean("RAW Bayer", "PixelShiftShowMotionMaskOnly"); + raw.bayersensor.pixelShiftShowMotionMaskOnly = keyFile.get_boolean("RAW Bayer", "PixelShiftShowMotionMaskOnly"); if (pedited) { - pedited->raw.bayersensor.pixelshiftShowMotionMaskOnly = true; + pedited->raw.bayersensor.pixelShiftShowMotionMaskOnly = true; } } @@ -8264,8 +8264,8 @@ bool ProcParams::operator== (const ProcParams& other) && raw.bayersensor.pixelShiftSigma == other.raw.bayersensor.pixelShiftSigma && raw.bayersensor.pixelShiftSum == other.raw.bayersensor.pixelShiftSum && raw.bayersensor.pixelShiftRedBlueWeight == other.raw.bayersensor.pixelShiftRedBlueWeight - && raw.bayersensor.pixelshiftShowMotion == other.raw.bayersensor.pixelshiftShowMotion - && raw.bayersensor.pixelshiftShowMotionMaskOnly == other.raw.bayersensor.pixelshiftShowMotionMaskOnly + && raw.bayersensor.pixelShiftShowMotion == other.raw.bayersensor.pixelShiftShowMotion + && raw.bayersensor.pixelShiftShowMotionMaskOnly == other.raw.bayersensor.pixelShiftShowMotionMaskOnly && raw.bayersensor.pixelShiftAutomatic == other.raw.bayersensor.pixelShiftAutomatic && raw.bayersensor.pixelShiftNonGreenHorizontal == other.raw.bayersensor.pixelShiftNonGreenHorizontal && raw.bayersensor.pixelShiftNonGreenVertical == other.raw.bayersensor.pixelShiftNonGreenVertical diff --git a/rtengine/procparams.h b/rtengine/procparams.h index c83856870..a2c2bf5a4 100644 --- a/rtengine/procparams.h +++ b/rtengine/procparams.h @@ -1221,8 +1221,8 @@ public: double pixelShiftSigma; double pixelShiftSum; double pixelShiftRedBlueWeight; - bool pixelshiftShowMotion; - bool pixelshiftShowMotionMaskOnly; + bool pixelShiftShowMotion; + bool pixelShiftShowMotionMaskOnly; bool pixelShiftAutomatic; bool pixelShiftNonGreenHorizontal; bool pixelShiftNonGreenVertical; diff --git a/rtgui/bayerprocess.cc b/rtgui/bayerprocess.cc index ba7cfa8e8..bc2809971 100644 --- a/rtgui/bayerprocess.cc +++ b/rtgui/bayerprocess.cc @@ -357,11 +357,11 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params dcbIterations->setValue (pp->raw.bayersensor.dcb_iterations); dcbEnhance->setValue (pp->raw.bayersensor.dcb_enhance); - pixelShiftShowMotion->setValue (pp->raw.bayersensor.pixelshiftShowMotion); + pixelShiftShowMotion->setValue (pp->raw.bayersensor.pixelShiftShowMotion); if (!batchMode) { - pixelShiftShowMotionMaskOnly->set_sensitive (pp->raw.bayersensor.pixelshiftShowMotion); + pixelShiftShowMotionMaskOnly->set_sensitive (pp->raw.bayersensor.pixelShiftShowMotion); } - pixelShiftShowMotionMaskOnly->setValue (pp->raw.bayersensor.pixelshiftShowMotionMaskOnly); + pixelShiftShowMotionMaskOnly->setValue (pp->raw.bayersensor.pixelShiftShowMotionMaskOnly); pixelShiftHoleFill->setValue (pp->raw.bayersensor.pixelShiftHoleFill); pixelShiftMedian->setValue (pp->raw.bayersensor.pixelShiftMedian); pixelShiftGreen->setValue (pp->raw.bayersensor.pixelShiftGreen); @@ -412,8 +412,8 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params ccSteps->setEditedState (pedited->raw.bayersensor.ccSteps ? Edited : UnEdited); dcbIterations->setEditedState ( pedited->raw.bayersensor.dcbIterations ? Edited : UnEdited); dcbEnhance->setEdited (pedited->raw.bayersensor.dcbEnhance); - pixelShiftShowMotion->setEdited (pedited->raw.bayersensor.pixelshiftShowMotion); - pixelShiftShowMotionMaskOnly->setEdited (pedited->raw.bayersensor.pixelshiftShowMotionMaskOnly); + pixelShiftShowMotion->setEdited (pedited->raw.bayersensor.pixelShiftShowMotion); + pixelShiftShowMotionMaskOnly->setEdited (pedited->raw.bayersensor.pixelShiftShowMotionMaskOnly); pixelShiftHoleFill->setEdited (pedited->raw.bayersensor.pixelShiftHoleFill); pixelShiftMedian->setEdited(pedited->raw.bayersensor.pixelShiftMedian); pixelShiftGreen->setEdited (pedited->raw.bayersensor.pixelShiftGreen); @@ -515,8 +515,8 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe pp->raw.bayersensor.pixelShiftMotionCorrectionMethod = (RAWParams::BayerSensor::ePSMotionCorrectionMethod)pixelShiftMotionMethod->get_active_row_number(); pp->raw.bayersensor.pixelShiftEperIso = pixelShiftEperIso->getValue(); pp->raw.bayersensor.pixelShiftSigma = pixelShiftSigma->getValue(); - pp->raw.bayersensor.pixelshiftShowMotion = pixelShiftShowMotion->getLastActive (); - pp->raw.bayersensor.pixelshiftShowMotionMaskOnly = pixelShiftShowMotionMaskOnly->getLastActive (); + pp->raw.bayersensor.pixelShiftShowMotion = pixelShiftShowMotion->getLastActive (); + pp->raw.bayersensor.pixelShiftShowMotionMaskOnly = pixelShiftShowMotionMaskOnly->getLastActive (); pp->raw.bayersensor.pixelShiftHoleFill = pixelShiftHoleFill->getLastActive (); pp->raw.bayersensor.pixelShiftMedian = pixelShiftMedian->getLastActive (); pp->raw.bayersensor.pixelShiftGreen = pixelShiftGreen->getLastActive (); @@ -566,8 +566,8 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe pedited->raw.bayersensor.pixelShiftMotionCorrectionMethod = pixelShiftMotionMethod->get_active_text() != M("GENERAL_UNCHANGED"); pedited->raw.bayersensor.pixelShiftEperIso = pixelShiftEperIso->getEditedState (); pedited->raw.bayersensor.pixelShiftSigma = pixelShiftSigma->getEditedState (); - pedited->raw.bayersensor.pixelshiftShowMotion = !pixelShiftShowMotion->get_inconsistent(); - pedited->raw.bayersensor.pixelshiftShowMotionMaskOnly = !pixelShiftShowMotionMaskOnly->get_inconsistent(); + pedited->raw.bayersensor.pixelShiftShowMotion = !pixelShiftShowMotion->get_inconsistent(); + pedited->raw.bayersensor.pixelShiftShowMotionMaskOnly = !pixelShiftShowMotionMaskOnly->get_inconsistent(); pedited->raw.bayersensor.pixelShiftHoleFill = !pixelShiftHoleFill->get_inconsistent(); pedited->raw.bayersensor.pixelShiftMedian = !pixelShiftMedian->get_inconsistent(); pedited->raw.bayersensor.pixelShiftGreen = !pixelShiftGreen->get_inconsistent(); diff --git a/rtgui/paramsedited.cc b/rtgui/paramsedited.cc index 4d05158c0..7afcc43d3 100644 --- a/rtgui/paramsedited.cc +++ b/rtgui/paramsedited.cc @@ -383,8 +383,8 @@ void ParamsEdited::set (bool v) raw.bayersensor.pixelShiftSigma = v; raw.bayersensor.pixelShiftSum = v; raw.bayersensor.pixelShiftRedBlueWeight = v; - raw.bayersensor.pixelshiftShowMotion = v; - raw.bayersensor.pixelshiftShowMotionMaskOnly = v; + raw.bayersensor.pixelShiftShowMotion = v; + raw.bayersensor.pixelShiftShowMotionMaskOnly = v; raw.bayersensor.pixelShiftAutomatic = v; raw.bayersensor.pixelShiftNonGreenHorizontal = v; raw.bayersensor.pixelShiftNonGreenVertical = v; @@ -909,8 +909,8 @@ void ParamsEdited::initFrom (const std::vector raw.bayersensor.pixelShiftSigma = raw.bayersensor.pixelShiftSigma && p.raw.bayersensor.pixelShiftSigma == other.raw.bayersensor.pixelShiftSigma; raw.bayersensor.pixelShiftSum = raw.bayersensor.pixelShiftSum && p.raw.bayersensor.pixelShiftSum == other.raw.bayersensor.pixelShiftSum; raw.bayersensor.pixelShiftRedBlueWeight = raw.bayersensor.pixelShiftRedBlueWeight && p.raw.bayersensor.pixelShiftRedBlueWeight == other.raw.bayersensor.pixelShiftRedBlueWeight; - raw.bayersensor.pixelshiftShowMotion = raw.bayersensor.pixelshiftShowMotion && p.raw.bayersensor.pixelshiftShowMotion == other.raw.bayersensor.pixelshiftShowMotion; - raw.bayersensor.pixelshiftShowMotionMaskOnly = raw.bayersensor.pixelshiftShowMotionMaskOnly && p.raw.bayersensor.pixelshiftShowMotionMaskOnly == other.raw.bayersensor.pixelshiftShowMotionMaskOnly; + raw.bayersensor.pixelShiftShowMotion = raw.bayersensor.pixelShiftShowMotion && p.raw.bayersensor.pixelShiftShowMotion == other.raw.bayersensor.pixelShiftShowMotion; + raw.bayersensor.pixelShiftShowMotionMaskOnly = raw.bayersensor.pixelShiftShowMotionMaskOnly && p.raw.bayersensor.pixelShiftShowMotionMaskOnly == other.raw.bayersensor.pixelShiftShowMotionMaskOnly; raw.bayersensor.pixelShiftAutomatic = raw.bayersensor.pixelShiftAutomatic && p.raw.bayersensor.pixelShiftAutomatic == other.raw.bayersensor.pixelShiftAutomatic; raw.bayersensor.pixelShiftNonGreenHorizontal = raw.bayersensor.pixelShiftNonGreenHorizontal && p.raw.bayersensor.pixelShiftNonGreenHorizontal == other.raw.bayersensor.pixelShiftNonGreenHorizontal; raw.bayersensor.pixelShiftNonGreenVertical = raw.bayersensor.pixelShiftNonGreenVertical && p.raw.bayersensor.pixelShiftNonGreenVertical == other.raw.bayersensor.pixelShiftNonGreenVertical; @@ -2390,12 +2390,12 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten toEdit.raw.bayersensor.pixelShiftRedBlueWeight = mods.raw.bayersensor.pixelShiftRedBlueWeight; } - if (raw.bayersensor.pixelshiftShowMotion) { - toEdit.raw.bayersensor.pixelshiftShowMotion = mods.raw.bayersensor.pixelshiftShowMotion; + if (raw.bayersensor.pixelShiftShowMotion) { + toEdit.raw.bayersensor.pixelShiftShowMotion = mods.raw.bayersensor.pixelShiftShowMotion; } - if (raw.bayersensor.pixelshiftShowMotionMaskOnly) { - toEdit.raw.bayersensor.pixelshiftShowMotionMaskOnly = mods.raw.bayersensor.pixelshiftShowMotionMaskOnly; + if (raw.bayersensor.pixelShiftShowMotionMaskOnly) { + toEdit.raw.bayersensor.pixelShiftShowMotionMaskOnly = mods.raw.bayersensor.pixelShiftShowMotionMaskOnly; } if (raw.bayersensor.pixelShiftAutomatic) { @@ -2969,7 +2969,7 @@ bool RAWParamsEdited::BayerSensor::isUnchanged() const { return method && imageNum && dcbIterations && dcbEnhance && lmmseIterations/*&& allEnhance*/ && greenEq && pixelShiftMotion && pixelShiftMotionCorrection && pixelShiftMotionCorrectionMethod && pixelShiftStddevFactorGreen && pixelShiftStddevFactorRed && pixelShiftStddevFactorBlue && pixelShiftEperIso - && pixelShiftNreadIso && pixelShiftPrnu && pixelShiftSigma && pixelShiftSum && pixelShiftRedBlueWeight && pixelshiftShowMotion && pixelshiftShowMotionMaskOnly + && pixelShiftNreadIso && pixelShiftPrnu && pixelShiftSigma && pixelShiftSum && pixelShiftRedBlueWeight && pixelShiftShowMotion && pixelShiftShowMotionMaskOnly && pixelShiftAutomatic && pixelShiftNonGreenHorizontal && pixelShiftNonGreenVertical && pixelShiftHoleFill && pixelShiftMedian && pixelShiftMedian3 && pixelShiftNonGreenCross && pixelShiftNonGreenCross2 && pixelShiftNonGreenAmaze && pixelShiftGreen && pixelShiftBlur && pixelShiftSmooth && pixelShiftExp0 && pixelShiftLmmse && pixelShiftEqualBright && linenoise && exBlack0 && exBlack1 && exBlack2 && exBlack3 && exTwoGreen; } diff --git a/rtgui/paramsedited.h b/rtgui/paramsedited.h index fc69a1e48..0840f7aa1 100644 --- a/rtgui/paramsedited.h +++ b/rtgui/paramsedited.h @@ -704,8 +704,8 @@ public: bool pixelShiftSigma; bool pixelShiftSum; bool pixelShiftRedBlueWeight; - bool pixelshiftShowMotion; - bool pixelshiftShowMotionMaskOnly; + bool pixelShiftShowMotion; + bool pixelShiftShowMotionMaskOnly; bool pixelShiftAutomatic; bool pixelShiftNonGreenHorizontal; bool pixelShiftNonGreenVertical; diff --git a/rtgui/partialpastedlg.cc b/rtgui/partialpastedlg.cc index 7cf7de15e..13f91fc7b 100644 --- a/rtgui/partialpastedlg.cc +++ b/rtgui/partialpastedlg.cc @@ -104,14 +104,15 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren raw_preser = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWEXPOS_PRESER"))); raw_black = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWEXPOS_BLACK"))); raw_ca_autocorrect = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_AUTO"))); - raw_cared = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_CARED"))); - raw_cablue = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_CABLUE"))); + raw_caredblue = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_CAREDBLUE"))); + raw_caautostrength = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH"))); raw_hotpix_filt = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_PREPROCESS_HOTPIXFILT"))); raw_deadpix_filt = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_PREPROCESS_DEADPIXFILT"))); raw_linenoise = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_PREPROCESS_LINEDENOISE"))); raw_greenthresh = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_PREPROCESS_GREENEQUIL"))); raw_method = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAW_DMETHOD"))); raw_imagenum = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAW_IMAGENUM"))); + raw_pixelshift = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAW_PIXELSHIFT"))); raw_ccSteps = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAW_FALSECOLOR"))); raw_dcb_iterations = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAW_DCBITERATIONS"))); raw_dcb_enhance = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAW_DCBENHANCE"))); @@ -202,6 +203,7 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren vboxes[6]->pack_start (*hseps[6], Gtk::PACK_SHRINK, 2); vboxes[6]->pack_start (*raw_method, Gtk::PACK_SHRINK, 2); vboxes[6]->pack_start (*raw_imagenum, Gtk::PACK_SHRINK, 2); + vboxes[6]->pack_start (*raw_pixelshift, Gtk::PACK_SHRINK, 2); vboxes[6]->pack_start (*raw_ccSteps, Gtk::PACK_SHRINK, 2); vboxes[6]->pack_start (*raw_dcb_iterations, Gtk::PACK_SHRINK, 2); vboxes[6]->pack_start (*raw_dcb_enhance, Gtk::PACK_SHRINK, 2); @@ -227,8 +229,8 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren vboxes[6]->pack_start (*ff_ClipControl, Gtk::PACK_SHRINK, 2); vboxes[6]->pack_start (*Gtk::manage (new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 0); vboxes[6]->pack_start (*raw_ca_autocorrect, Gtk::PACK_SHRINK, 2); - vboxes[6]->pack_start (*raw_cared, Gtk::PACK_SHRINK, 2); - vboxes[6]->pack_start (*raw_cablue, Gtk::PACK_SHRINK, 2); + vboxes[6]->pack_start (*raw_caredblue, Gtk::PACK_SHRINK, 2); + vboxes[6]->pack_start (*raw_caautostrength, Gtk::PACK_SHRINK, 2); //META vboxes[7]->pack_start (*meta, Gtk::PACK_SHRINK, 2); @@ -347,13 +349,14 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren raw_dcb_enhanceConn = raw_dcb_enhance->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); //raw_all_enhanceConn = raw_all_enhance->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_lmmse_iterationsConn = raw_lmmse_iterations->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); + raw_pixelshiftConn = raw_pixelshift->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_exposConn = raw_expos->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_preserConn = raw_preser->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_blackConn = raw_black->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_ca_autocorrectConn = raw_ca_autocorrect->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); - raw_caredConn = raw_cared->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); - raw_cablueConn = raw_cablue->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); + raw_caredblueConn = raw_caredblue->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); + raw_caautostrengthConn = raw_caautostrength->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_hotpix_filtConn = raw_hotpix_filt->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_deadpix_filtConn = raw_deadpix_filt->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_linenoiseConn = raw_linenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); @@ -427,12 +430,13 @@ void PartialPasteDlg::rawToggled () raw_dcb_enhanceConn.block (true); //raw_all_enhanceConn.block (true); raw_lmmse_iterationsConn.block (true); + raw_pixelshiftConn.block (true); raw_exposConn.block (true); raw_preserConn.block (true); raw_blackConn.block (true); raw_ca_autocorrectConn.block (true); - raw_caredConn.block (true); - raw_cablueConn.block (true); + raw_caredblueConn.block (true); + raw_caautostrengthConn.block (true); raw_hotpix_filtConn.block (true); raw_deadpix_filtConn.block (true); raw_linenoiseConn.block (true); @@ -453,13 +457,14 @@ void PartialPasteDlg::rawToggled () raw_dcb_iterations->set_active (raw->get_active ()); raw_dcb_enhance->set_active (raw->get_active ()); raw_lmmse_iterations->set_active (raw->get_active ()); + raw_pixelshift->set_active (raw->get_active ()); //raw_all_enhance->set_active (raw->get_active ()); raw_expos->set_active (raw->get_active ()); raw_preser->set_active (raw->get_active ()); raw_black->set_active (raw->get_active ()); raw_ca_autocorrect->set_active (raw->get_active ()); - raw_cared->set_active (raw->get_active ()); - raw_cablue->set_active (raw->get_active ()); + raw_caredblue->set_active (raw->get_active ()); + raw_caautostrength->set_active (raw->get_active ()); raw_hotpix_filt->set_active (raw->get_active ()); raw_deadpix_filt->set_active (raw->get_active ()); raw_linenoise->set_active (raw->get_active ()); @@ -478,13 +483,14 @@ void PartialPasteDlg::rawToggled () raw_dcb_iterationsConn.block (false); raw_dcb_enhanceConn.block (false); //raw_all_enhanceConn.block (false); + raw_pixelshiftConn.block (false); raw_lmmse_iterationsConn.block (false); raw_exposConn.block (false); raw_preserConn.block (false); raw_blackConn.block (false); raw_ca_autocorrectConn.block (false); - raw_caredConn.block (false); - raw_cablueConn.block (false); + raw_caredblueConn.block (false); + raw_caautostrengthConn.block (false); raw_hotpix_filtConn.block (false); raw_deadpix_filtConn.block (false); raw_linenoiseConn.block (false); @@ -886,6 +892,38 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param filterPE.raw.xtranssensor.exBlackBlue = falsePE.raw.xtranssensor.exBlackBlue; } + if (!raw_pixelshift->get_active ()) { + filterPE.raw.bayersensor.pixelShiftAutomatic = falsePE.raw.bayersensor.pixelShiftAutomatic; + filterPE.raw.bayersensor.pixelShiftBlur = falsePE.raw.bayersensor.pixelShiftBlur; + filterPE.raw.bayersensor.pixelShiftEperIso = falsePE.raw.bayersensor.pixelShiftEperIso; + filterPE.raw.bayersensor.pixelShiftEqualBright = falsePE.raw.bayersensor.pixelShiftEqualBright; + filterPE.raw.bayersensor.pixelShiftExp0 = falsePE.raw.bayersensor.pixelShiftExp0; + filterPE.raw.bayersensor.pixelShiftGreen = falsePE.raw.bayersensor.pixelShiftGreen; + filterPE.raw.bayersensor.pixelShiftHoleFill = falsePE.raw.bayersensor.pixelShiftHoleFill; + filterPE.raw.bayersensor.pixelShiftLmmse = falsePE.raw.bayersensor.pixelShiftLmmse; + filterPE.raw.bayersensor.pixelShiftMedian = falsePE.raw.bayersensor.pixelShiftMedian; + filterPE.raw.bayersensor.pixelShiftMedian3 = falsePE.raw.bayersensor.pixelShiftMedian3; + filterPE.raw.bayersensor.pixelShiftMotion = falsePE.raw.bayersensor.pixelShiftMotion; + filterPE.raw.bayersensor.pixelShiftMotionCorrection = falsePE.raw.bayersensor.pixelShiftMotionCorrection; + filterPE.raw.bayersensor.pixelShiftMotionCorrectionMethod = falsePE.raw.bayersensor.pixelShiftMotionCorrectionMethod; + filterPE.raw.bayersensor.pixelShiftNonGreenAmaze = falsePE.raw.bayersensor.pixelShiftNonGreenAmaze; + filterPE.raw.bayersensor.pixelShiftNonGreenCross = falsePE.raw.bayersensor.pixelShiftNonGreenCross; + filterPE.raw.bayersensor.pixelShiftNonGreenCross2 = falsePE.raw.bayersensor.pixelShiftNonGreenCross2; + filterPE.raw.bayersensor.pixelShiftNonGreenHorizontal = falsePE.raw.bayersensor.pixelShiftNonGreenHorizontal; + filterPE.raw.bayersensor.pixelShiftNonGreenVertical = falsePE.raw.bayersensor.pixelShiftNonGreenVertical; + filterPE.raw.bayersensor.pixelShiftNreadIso = falsePE.raw.bayersensor.pixelShiftNreadIso; + filterPE.raw.bayersensor.pixelShiftPrnu = falsePE.raw.bayersensor.pixelShiftPrnu; + filterPE.raw.bayersensor.pixelShiftRedBlueWeight = falsePE.raw.bayersensor.pixelShiftRedBlueWeight; + filterPE.raw.bayersensor.pixelShiftSigma = falsePE.raw.bayersensor.pixelShiftSigma; + filterPE.raw.bayersensor.pixelShiftSmooth = falsePE.raw.bayersensor.pixelShiftSmooth; + filterPE.raw.bayersensor.pixelShiftStddevFactorBlue = falsePE.raw.bayersensor.pixelShiftStddevFactorBlue; + filterPE.raw.bayersensor.pixelShiftStddevFactorGreen = falsePE.raw.bayersensor.pixelShiftStddevFactorGreen; + filterPE.raw.bayersensor.pixelShiftStddevFactorRed = falsePE.raw.bayersensor.pixelShiftStddevFactorRed; + filterPE.raw.bayersensor.pixelShiftSum = falsePE.raw.bayersensor.pixelShiftSum; + filterPE.raw.bayersensor.pixelShiftShowMotion = falsePE.raw.bayersensor.pixelShiftShowMotion; + filterPE.raw.bayersensor.pixelShiftShowMotionMaskOnly = falsePE.raw.bayersensor.pixelShiftShowMotionMaskOnly; + } + if (!raw_linenoise->get_active ()) { filterPE.raw.bayersensor.linenoise = falsePE.raw.bayersensor.linenoise; } @@ -906,12 +944,13 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param filterPE.raw.caCorrection = falsePE.raw.caCorrection; } - if (!raw_cared->get_active ()) { + if (!raw_caredblue->get_active ()) { filterPE.raw.caRed = falsePE.raw.caRed; + filterPE.raw.caBlue = falsePE.raw.caBlue; } - if (!raw_cablue->get_active ()) { - filterPE.raw.caBlue = falsePE.raw.caBlue; + if (!raw_caautostrength->get_active ()) { + filterPE.raw.caAutoStrength = falsePE.raw.caAutoStrength; } if (!raw_hotpix_filt->get_active ()) { diff --git a/rtgui/partialpastedlg.h b/rtgui/partialpastedlg.h index 177b0b720..438744863 100644 --- a/rtgui/partialpastedlg.h +++ b/rtgui/partialpastedlg.h @@ -100,8 +100,9 @@ public: Gtk::CheckButton* raw_preser; Gtk::CheckButton* raw_black; Gtk::CheckButton* raw_ca_autocorrect; - Gtk::CheckButton* raw_cared; + Gtk::CheckButton* raw_caredblue; Gtk::CheckButton* raw_cablue; + Gtk::CheckButton* raw_caautostrength; Gtk::CheckButton* raw_hotpix_filt; Gtk::CheckButton* raw_deadpix_filt; Gtk::CheckButton* raw_linenoise; @@ -112,6 +113,7 @@ public: Gtk::CheckButton* raw_dcb_iterations; Gtk::CheckButton* raw_dcb_enhance; Gtk::CheckButton* raw_lmmse_iterations; + Gtk::CheckButton* raw_pixelshift; Gtk::CheckButton* df_file; Gtk::CheckButton* df_AutoSelect; @@ -130,7 +132,7 @@ public: sigc::connection coarserotConn, finerotConn, cropConn, resizeConn, prsharpeningConn, perspectiveConn, commonTransConn; sigc::connection exifchConn, iptcConn, icmConn; sigc::connection df_fileConn, df_AutoSelectConn, ff_fileConn, ff_AutoSelectConn, ff_BlurRadiusConn, ff_BlurTypeConn, ff_ClipControlConn; - sigc::connection raw_caredConn, raw_cablueConn, raw_ca_autocorrectConn, raw_hotpix_filtConn, raw_deadpix_filtConn, raw_linenoiseConn, raw_greenthreshConn, raw_ccStepsConn, raw_methodConn, raw_imagenumConn, raw_dcb_iterationsConn, raw_lmmse_iterationsConn, raw_dcb_enhanceConn, raw_exposConn, raw_preserConn, raw_blackConn; + sigc::connection raw_caredblueConn, raw_caautostrengthConn, raw_ca_autocorrectConn, raw_hotpix_filtConn, raw_deadpix_filtConn, raw_linenoiseConn, raw_greenthreshConn, raw_ccStepsConn, raw_methodConn, raw_imagenumConn, raw_dcb_iterationsConn, raw_lmmse_iterationsConn, raw_pixelshiftConn, raw_dcb_enhanceConn, raw_exposConn, raw_preserConn, raw_blackConn; public: PartialPasteDlg (const Glib::ustring &title, Gtk::Window* parent); diff --git a/rtgui/profilepanel.cc b/rtgui/profilepanel.cc index 939739805..b988418f0 100644 --- a/rtgui/profilepanel.cc +++ b/rtgui/profilepanel.cc @@ -295,6 +295,8 @@ void ProfilePanel::save_clicked (GdkEventButton* event) do { if (dialog.run() == Gtk::RESPONSE_OK) { + dialog.hide(); + std::string fname = dialog.get_filename(); Glib::ustring ext = getExtension (fname); From 8bfe14da09b68e83264bdbb75e33e6a952bc7c64 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Tue, 28 Mar 2017 08:35:06 +0200 Subject: [PATCH 28/90] do not touch the chroma denoise curve in the fast export pipeline (no need to) --- rtengine/simpleprocess.cc | 3 --- 1 file changed, 3 deletions(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index 360b892c4..c49535a3c 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -1414,9 +1414,6 @@ private: for (auto &p : params.dirpyrDenoise.lcurve) { p *= scale_factor; } - for (auto &p : params.dirpyrDenoise.cccurve) { - p *= scale_factor; - } params.epd.scale *= scale_factor; //params.epd.edgeStopping *= scale_factor; From 45a66e980f01c760928e370314b4bb0bf815fc01 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Tue, 28 Mar 2017 14:01:19 +0200 Subject: [PATCH 29/90] Fix some uninitialized variables found by valgrind; also fixes #3786 --- rtgui/dirpyrdenoise.cc | 2 +- rtgui/lensprofile.cc | 2 +- rtgui/partialpastedlg.cc | 10 ---------- rtgui/retinex.cc | 2 +- 4 files changed, 3 insertions(+), 13 deletions(-) diff --git a/rtgui/dirpyrdenoise.cc b/rtgui/dirpyrdenoise.cc index bd673e5c3..1fe86c2ca 100644 --- a/rtgui/dirpyrdenoise.cc +++ b/rtgui/dirpyrdenoise.cc @@ -26,7 +26,7 @@ using namespace rtengine; using namespace rtengine::procparams; extern Options options; -DirPyrDenoise::DirPyrDenoise () : FoldableToolPanel(this, "dirpyrdenoise", M("TP_DIRPYRDENOISE_LABEL"), true, true), lastenhance(false) +DirPyrDenoise::DirPyrDenoise () : FoldableToolPanel(this, "dirpyrdenoise", M("TP_DIRPYRDENOISE_LABEL"), true, true), lastenhance(false), lastmedian(false), lastautochroma(false) { std::vector milestones; CurveListener::setMulti(true); diff --git a/rtgui/lensprofile.cc b/rtgui/lensprofile.cc index 71c54e2b5..2f4526cad 100644 --- a/rtgui/lensprofile.cc +++ b/rtgui/lensprofile.cc @@ -26,7 +26,7 @@ using namespace rtengine; using namespace rtengine::procparams; -LensProfilePanel::LensProfilePanel () : FoldableToolPanel(this, "lensprof", M("TP_LENSPROFILE_LABEL")) +LensProfilePanel::LensProfilePanel () : FoldableToolPanel(this, "lensprof", M("TP_LENSPROFILE_LABEL")), isRaw(true) { hbLCPFile = Gtk::manage(new Gtk::HBox()); diff --git a/rtgui/partialpastedlg.cc b/rtgui/partialpastedlg.cc index 13f91fc7b..90a168066 100644 --- a/rtgui/partialpastedlg.cc +++ b/rtgui/partialpastedlg.cc @@ -105,7 +105,6 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren raw_black = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWEXPOS_BLACK"))); raw_ca_autocorrect = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_AUTO"))); raw_caredblue = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_CAREDBLUE"))); - raw_caautostrength = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH"))); raw_hotpix_filt = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_PREPROCESS_HOTPIXFILT"))); raw_deadpix_filt = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_PREPROCESS_DEADPIXFILT"))); raw_linenoise = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_PREPROCESS_LINEDENOISE"))); @@ -230,7 +229,6 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren vboxes[6]->pack_start (*Gtk::manage (new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 0); vboxes[6]->pack_start (*raw_ca_autocorrect, Gtk::PACK_SHRINK, 2); vboxes[6]->pack_start (*raw_caredblue, Gtk::PACK_SHRINK, 2); - vboxes[6]->pack_start (*raw_caautostrength, Gtk::PACK_SHRINK, 2); //META vboxes[7]->pack_start (*meta, Gtk::PACK_SHRINK, 2); @@ -356,7 +354,6 @@ PartialPasteDlg::PartialPasteDlg (const Glib::ustring &title, Gtk::Window* paren raw_blackConn = raw_black->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_ca_autocorrectConn = raw_ca_autocorrect->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_caredblueConn = raw_caredblue->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); - raw_caautostrengthConn = raw_caautostrength->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_hotpix_filtConn = raw_hotpix_filt->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_deadpix_filtConn = raw_deadpix_filt->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); raw_linenoiseConn = raw_linenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*raw, &Gtk::CheckButton::set_inconsistent), true)); @@ -436,7 +433,6 @@ void PartialPasteDlg::rawToggled () raw_blackConn.block (true); raw_ca_autocorrectConn.block (true); raw_caredblueConn.block (true); - raw_caautostrengthConn.block (true); raw_hotpix_filtConn.block (true); raw_deadpix_filtConn.block (true); raw_linenoiseConn.block (true); @@ -464,7 +460,6 @@ void PartialPasteDlg::rawToggled () raw_black->set_active (raw->get_active ()); raw_ca_autocorrect->set_active (raw->get_active ()); raw_caredblue->set_active (raw->get_active ()); - raw_caautostrength->set_active (raw->get_active ()); raw_hotpix_filt->set_active (raw->get_active ()); raw_deadpix_filt->set_active (raw->get_active ()); raw_linenoise->set_active (raw->get_active ()); @@ -490,7 +485,6 @@ void PartialPasteDlg::rawToggled () raw_blackConn.block (false); raw_ca_autocorrectConn.block (false); raw_caredblueConn.block (false); - raw_caautostrengthConn.block (false); raw_hotpix_filtConn.block (false); raw_deadpix_filtConn.block (false); raw_linenoiseConn.block (false); @@ -949,10 +943,6 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param filterPE.raw.caBlue = falsePE.raw.caBlue; } - if (!raw_caautostrength->get_active ()) { - filterPE.raw.caAutoStrength = falsePE.raw.caAutoStrength; - } - if (!raw_hotpix_filt->get_active ()) { filterPE.raw.hotPixelFilter = falsePE.raw.hotPixelFilter; } diff --git a/rtgui/retinex.cc b/rtgui/retinex.cc index b81e8f579..4686e325e 100644 --- a/rtgui/retinex.cc +++ b/rtgui/retinex.cc @@ -8,7 +8,7 @@ using namespace rtengine; using namespace rtengine::procparams; -Retinex::Retinex () : FoldableToolPanel(this, "retinex", M("TP_RETINEX_LABEL"), false, true) +Retinex::Retinex () : FoldableToolPanel(this, "retinex", M("TP_RETINEX_LABEL"), false, true), lastmedianmap(false) { CurveListener::setMulti(true); std::vector defaultCurve; From d003a9e81f67e24980feedd00039538da0aba99b Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 30 Mar 2017 01:09:01 +0200 Subject: [PATCH 30/90] Fix compile warnings in pixelshift.cc --- rtengine/pixelshift.cc | 26 +++++++++++++++++--------- 1 file changed, 17 insertions(+), 9 deletions(-) diff --git a/rtengine/pixelshift.cc b/rtengine/pixelshift.cc index 44e765e41..744950ba8 100644 --- a/rtengine/pixelshift.cc +++ b/rtengine/pixelshift.cc @@ -456,9 +456,9 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA const int motion = bayerParams.pixelShiftMotion; const bool showMotion = bayerParams.pixelShiftShowMotion; const bool showOnlyMask = bayerParams.pixelShiftShowMotionMaskOnly && showMotion; - const RAWParams::BayerSensor::ePSMotionCorrection gridSize_ = bayerParams.pixelShiftMotionCorrection; const bool adaptive = bayerParams.pixelShiftAutomatic; #ifdef PIXELSHIFTDEV + const RAWParams::BayerSensor::ePSMotionCorrection gridSize_ = bayerParams.pixelShiftMotionCorrection; const bool detectMotion = bayerParams.pixelShiftMotion > 0; float stddevFactorGreen = bayerParams.pixelShiftStddevFactorGreen; float stddevFactorRed = bayerParams.pixelShiftStddevFactorRed; @@ -475,25 +475,25 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA const float redBlueWeight = 0.7f + 1.f; #endif float eperIso = bayerParams.pixelShiftEperIso; - const bool checkNonGreenHorizontal = bayerParams.pixelShiftNonGreenHorizontal; - const bool checkNonGreenVertical = bayerParams.pixelShiftNonGreenVertical; const bool checkNonGreenCross = bayerParams.pixelShiftNonGreenCross; - const bool checkNonGreenAmaze = bayerParams.pixelShiftNonGreenAmaze; - const bool checkNonGreenCross2 = bayerParams.pixelShiftNonGreenCross2; const bool checkGreen = bayerParams.pixelShiftGreen; const float greenWeight = 2.f; const bool blurMap = bayerParams.pixelShiftBlur; const float sigma = bayerParams.pixelShiftSigma; #ifdef PIXELSHIFTDEV + const bool checkNonGreenHorizontal = bayerParams.pixelShiftNonGreenHorizontal; + const bool checkNonGreenVertical = bayerParams.pixelShiftNonGreenVertical; + const bool checkNonGreenAmaze = bayerParams.pixelShiftNonGreenAmaze; + const bool checkNonGreenCross2 = bayerParams.pixelShiftNonGreenCross2; const float threshold = bayerParams.pixelShiftSum + 9.f; + const bool experimental0 = bayerParams.pixelShiftExp0; + const bool automatic = bayerParams.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::Automatic; #else constexpr float threshold = 3.f + 9.f; #endif - const bool experimental0 = bayerParams.pixelShiftExp0; const bool holeFill = bayerParams.pixelShiftHoleFill; const bool equalBrightness = bayerParams.pixelShiftEqualBright; const bool smoothTransitions = blurMap && bayerParams.pixelShiftSmoothFactor > 0. && !showOnlyMask; - const bool automatic = bayerParams.pixelShiftMotionCorrectionMethod == RAWParams::BayerSensor::Automatic; const float smoothFactor = 1.0 - bayerParams.pixelShiftSmoothFactor; static const float nReadK3II[] = { 3.4f, // ISO 100 @@ -606,8 +606,10 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA } +#ifdef PIXELSHIFTDEV const bool skip = (gridSize_ == RAWParams::BayerSensor::ePSMotionCorrection::Grid1x2); int gridSize = 1; + bool nOf3x3 = false; switch (gridSize_) { @@ -632,6 +634,9 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA gridSize = 1; nOf3x3 = true; } +#else + const bool nOf3x3 = true; +#endif if(adaptive && blurMap && nOf3x3 && smoothFactor == 0.f && !showMotion) { if(plistener) { @@ -707,9 +712,10 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA // If the values of two corresponding green pixels differ my more then motionThreshold %, the pixel will be treated as a badGreen pixel const float motionThreshold = 1.f - (motion / 100.f); // For shades of green motion indicators +#ifdef PIXELSHIFTDEV const float blendFactor = ((adaptive || motion == 0.f) ? 1.f : 1.f / (1.f - motionThreshold)); - - unsigned int offsX = 0, offsY = 0; +#endif + int offsX = 0, offsY = 0; if(!bayerParams.pixelShiftMedian || !adaptive) { // We have to adjust the offsets for the selected subframe we use for areas with motion @@ -860,9 +866,11 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, const RA #endif for(int i = winy + border - offsY; i < winh - (border + offsY); ++i) { +#ifdef PIXELSHIFTDEV float *greenDest = green[i + offsY]; float *redDest = red[i + offsY]; float *blueDest = blue[i + offsY]; +#endif int j = winx + border - offsX; #ifdef PIXELSHIFTDEV From 08c1066e1aa107503ca2b8d043de4b4fb975777f Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 30 Mar 2017 17:21:27 +0200 Subject: [PATCH 31/90] Fix all warnings in curves.cc --- rtengine/LUT.h | 2 +- rtengine/curves.cc | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/rtengine/LUT.h b/rtengine/LUT.h index d83a431ca..eb22ff7f9 100644 --- a/rtengine/LUT.h +++ b/rtengine/LUT.h @@ -579,7 +579,7 @@ public: numVals = std::min(numVals, passThrough.getSize()); float mult = dest.size - 1; - for (int i = 0; i < numVals; i++) { + for (unsigned int i = 0; i < numVals; i++) { int hi = (int)(mult * passThrough[i]); dest[hi] += this->data[i] ; } diff --git a/rtengine/curves.cc b/rtengine/curves.cc index 8f2aa03d3..3096f19f4 100644 --- a/rtengine/curves.cc +++ b/rtengine/curves.cc @@ -45,7 +45,7 @@ using namespace std; namespace rtengine { -Curve::Curve () : N(0), ppn(0), x(nullptr), y(nullptr), mc(0.0), mfc(0.0), msc(0.0), mhc(0.0), ypp(nullptr), x1(0.0), y1(0.0), x2(0.0), y2(0.0), x3(0.0), y3(0.0), firstPointIncluded(false), increment(0.0), nbr_points(0), hashSize(1000 /* has to be initialized to the maximum value */) {} +Curve::Curve () : N(0), ppn(0), x(nullptr), y(nullptr), mc(0.0), mfc(0.0), msc(0.0), mhc(0.0), hashSize(1000 /* has to be initialized to the maximum value */), ypp(nullptr), x1(0.0), y1(0.0), x2(0.0), y2(0.0), x3(0.0), y3(0.0), firstPointIncluded(false), increment(0.0), nbr_points(0) {} void Curve::AddPolygons () { @@ -104,7 +104,7 @@ void Curve::fillHash() milestone = 0.; polyIter = 0; - for (unsigned int i = 0; i < (hashSize + 1);) { + for (unsigned int i = 0; i < hashSize + 1u;) { while(poly_x[polyIter] < (milestone + increment)) { ++polyIter; } @@ -1376,7 +1376,7 @@ void ColorGradientCurve::SetXYZ(const Curve *pCurve, const double xyz_rgb[3][3], } float r, g, b, xx, yy, zz; - float lr1, lr2; + float lr1, lr2 = 0.f; int upperBound = lut1.getUpperBound(); if (pCurve->isIdentity()) { @@ -1765,7 +1765,7 @@ float PerceptualToneCurve::get_curve_val(float x, float range[2], float lut[], s int idx = (int)xm; - if (idx >= lut_size - 1) { + if (idx >= static_cast(lut_size) - 1) { return lut[lut_size - 1]; } @@ -1790,7 +1790,7 @@ float PerceptualToneCurve::calculateToneCurveContrastValue() const const float xd = 0.07; const float tx[] = { 0.30, 0.35, 0.40, 0.45 }; // we only look in the midtone range - for (int i = 0; i < sizeof(tx) / sizeof(tx[0]); i++) { + for (size_t i = 0; i < sizeof(tx) / sizeof(tx[0]); i++) { float x0 = tx[i] - xd; float y0 = CurveFactory::gamma2(lutToneCurve[CurveFactory::igamma2(x0) * 65535.f] / 65535.f) - k * x0; float x1 = tx[i] + xd; @@ -1807,7 +1807,7 @@ float PerceptualToneCurve::calculateToneCurveContrastValue() const { const float tx[] = { 0.20, 0.25, 0.50, 0.55 }; // we only look in the midtone range - for (int i = 0; i < sizeof(tx) / sizeof(tx[0]); i++) { + for (size_t i = 0; i < sizeof(tx) / sizeof(tx[0]); i++) { float x0 = tx[i] - xd; float y0 = CurveFactory::gamma2(lutToneCurve[CurveFactory::igamma2(x0) * 65535.f] / 65535.f) - k * x0; float x1 = tx[i] + xd; From 0c536e26601eae225970ebecfba88ff00175e99e Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 30 Mar 2017 17:33:05 +0200 Subject: [PATCH 32/90] Fix all warnings in diagonalcurves.cc --- rtengine/diagonalcurves.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rtengine/diagonalcurves.cc b/rtengine/diagonalcurves.cc index 2178e3dac..9ab17a0f4 100644 --- a/rtengine/diagonalcurves.cc +++ b/rtengine/diagonalcurves.cc @@ -241,8 +241,8 @@ void DiagonalCurve::NURBS_set () nbr_points = (int)(((double)(ppn + N - 2) * sc_length[i / 3] ) / total_length); if (nbr_points < 0) { - for(size_t it = 0; it < sc_x.size(); it += 3) { - printf("sc_length[%zu/3]=%f \n", it, sc_length[it / 3]); + for(unsigned int it = 0; it < sc_x.size(); it += 3) { // used unsigned int instead of size_t to avoid %zu in printf + printf("sc_length[%u/3]=%f \n", it, sc_length[it / 3]); } printf("NURBS diagonal curve: error detected!\n i=%u nbr_points=%d ppn=%d N=%d sc_length[i/3]=%f total_length=%f", i, nbr_points, ppn, N, sc_length[i / 3], total_length); From 348b393583f5f010193f13ac47c685915127203b Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 30 Mar 2017 17:46:00 +0200 Subject: [PATCH 33/90] Fix all warnings in color.cc --- rtengine/color.cc | 35 +++-------------------------------- 1 file changed, 3 insertions(+), 32 deletions(-) diff --git a/rtengine/color.cc b/rtengine/color.cc index 5cf1d45b1..b67343b82 100644 --- a/rtengine/color.cc +++ b/rtengine/color.cc @@ -1530,18 +1530,8 @@ void Color::interpolateRGBColor (float realL, float iplow, float iphigh, int alg int toDo, const double xyz_rgb[3][3], const double rgb_xyz[3][3], float &ro, float &go, float &bo) { float X1, Y1, Z1, X2, Y2, Z2, X, Y, Z, XL, YL, ZL; - float L1, L2, LL, a_1, b_1, a_2, b_2, a, b, a_L, b_L; - float c1, c2, h1, h2, cL, hL; - float RR, GG, BB; - float Lr; - float slc = 0.f; - float hh = 0.f; - float ll = 0.f; - float sh = 0.f; - bool LCH = false; + float L1, L2, LL, a_1 = 0.f, b_1 = 0.f, a_2, b_2, a_L, b_L; - float ha, hb, hc, ba; - float c_1, h_1; // converting color 1 to Lab (image) Color::rgbxyz(r1, g1, b1, X1, Y1, Z1, xyz_rgb); @@ -1566,19 +1556,16 @@ void Color::interpolateRGBColor (float realL, float iplow, float iphigh, int alg X2 = x2; Y2 = y2; Z2 = z2; - float c_2, h_2; if(algm == 1 ) { Color::XYZ2Lab(X2, Y2, Z2, L2, a_2, b_2); //Color::Lab2Lch(a_2, b_2, c_2, h_2) ; } - float bal, balH, cal, calH, calm; - bal = balH = balance; + float cal, calH, calm; cal = calH = calm = 1.f - chromat; float med = 1.f; float medH = 0.f; - float medL = (iphigh + iplow) / 2.f; float calan; calan = chromat; @@ -1589,19 +1576,6 @@ void Color::interpolateRGBColor (float realL, float iplow, float iphigh, int alg if(twoc == 0) { // 2 colours calan = chromat; - //calculate new balance in function of (arbitrary) "med".. I hope no error !! - if (realL > iplow && realL <= med) { - bal = realL * balance / (iplow - med) - med * balance / (iplow - med); - } else if (realL <= iplow) { - bal = realL * balance / iplow; - } - - if (realL > medH && realL <= iphigh) { - balH = realL * balance / (iphigh - medH) - medH * balance / (iphigh - medH); - } else if (realL > iphigh) { - balH = realL * balance * (iphigh - 1.f) - balance * (iphigh - 1.f); - } - //calculate new balance chroma if (realL > iplow && realL <= med) { cal = realL * calan / (iplow - med) - med * calan / (iplow - med); @@ -1616,8 +1590,7 @@ void Color::interpolateRGBColor (float realL, float iplow, float iphigh, int alg } } - float hX = 0.f; - float hLL, hH, ccL, ccH, llH, aaH, bbH; + float aaH, bbH; if(algm <= 1) { if(twoc == 0 && metchrom == 3) { // 2 colours only with special "ab" @@ -1639,8 +1612,6 @@ void Color::interpolateRGBColor (float realL, float iplow, float iphigh, int alg b_1 = b_1 + (b_2 - b_1) * calby * balance; } } - } else { - h1 = hX; } Color::Lab2XYZ(L1, a_1, b_1, X, Y, Z); From f0b7547cbb1295489277587702a5c085aed0550e Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 30 Mar 2017 18:23:18 +0200 Subject: [PATCH 34/90] Fix all warnings in rawimage.cc --- rtengine/rawimage.cc | 48 ++++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/rtengine/rawimage.cc b/rtengine/rawimage.cc index 2cd1abf5f..f3252b06b 100644 --- a/rtengine/rawimage.cc +++ b/rtengine/rawimage.cc @@ -25,9 +25,9 @@ RawImage::RawImage( const Glib::ustring &name ) : data(nullptr) , prefilters(0) , filename(name) + , rotate_deg(0) , profile_data(nullptr) , allocation(nullptr) - , rotate_deg(0) { memset(maximum_c4, 0, sizeof(maximum_c4)); RT_matrix_from_constant = 0; @@ -84,9 +84,9 @@ eSensorType RawImage::getSensorType() */ void RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, float *cblack_, bool forceAutoWB) { - unsigned row, col, x, y, c, sum[8]; - unsigned W = this->get_width(); - unsigned H = this->get_height(); + unsigned sum[8], c; + unsigned W = this->get_width(); + unsigned H = this->get_height(); float val; double dsum[8], dmin, dmax; @@ -118,7 +118,7 @@ void RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, float *cblac dsum[FC(1, 0) + 4] += (int)(((W + 1) / 2) * (H / 2)); dsum[FC(1, 1) + 4] += (int)((W / 2) * (H / 2)); - #pragma omp parallel private(val,row,col,x,y) + #pragma omp parallel private(val) { double dsumthr[8]; memset(dsumthr, 0, sizeof dsumthr); @@ -135,15 +135,15 @@ void RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, float *cblac float *tempdata = data[0]; #pragma omp for nowait - for (row = 0; row < H; row += 8) { - int ymax = row + 8 < H ? row + 8 : H; + for (size_t row = 0; row < H; row += 8) { + size_t ymax = row + 8 < H ? row + 8 : H; - for (col = 0; col < W ; col += 8) { - int xmax = col + 8 < W ? col + 8 : W; + for (size_t col = 0; col < W ; col += 8) { + size_t xmax = col + 8 < W ? col + 8 : W; memset(sum, 0, sizeof sum); - for (y = row; y < ymax; y++) - for (x = col; x < xmax; x++) { + for (size_t y = row; y < ymax; y++) + for (size_t x = col; x < xmax; x++) { int c = FC(y, x); val = tempdata[y * W + x]; @@ -204,13 +204,13 @@ skip_block2: #pragma omp for nowait - for (int row = 0; row < H; row += 8) - for (int col = 0; col < W ; col += 8) + for (size_t row = 0; row < H; row += 8) + for (size_t col = 0; col < W ; col += 8) { memset(sum, 0, sizeof sum); - for (int y = row; y < row + 8 && y < H; y++) - for (int x = col; x < col + 8 && x < W; x++) { + for (size_t y = row; y < row + 8 && y < H; y++) + for (size_t x = col; x < col + 8 && x < W; x++) { int c = XTRANSFC(y, x); float val = data[y][x]; @@ -248,12 +248,12 @@ skip_block3: pre_mul_[c] = 1; } } else { - for (row = 0; row < H; row += 8) - for (col = 0; col < W ; col += 8) { + for (size_t row = 0; row < H; row += 8) + for (size_t col = 0; col < W ; col += 8) { memset(sum, 0, sizeof sum); - for (y = row; y < row + 8 && y < H; y++) - for (x = col; x < col + 8 && x < W; x++) + for (size_t y = row; y < row + 8 && y < H; y++) + for (size_t x = col; x < col + 8 && x < W; x++) for (int c = 0; c < 3; c++) { if (this->isBayer()) { c = FC(y, x); @@ -294,8 +294,8 @@ skip_block: } else { memset(sum, 0, sizeof sum); - for (row = 0; row < 8; row++) - for (col = 0; col < 8; col++) { + for (size_t row = 0; row < 8; row++) + for (size_t col = 0; col < 8; col++) { int c = FC(row, col); if ((val = white[row][col] - cblack_[c]) > 0) { @@ -604,7 +604,7 @@ int RawImage::loadRaw (bool loadData, unsigned int imageNum, bool closeFile, Pro if(tiff_bps > 0 && maximum_c4[i] > 0 && !isFoveon()) { unsigned compare = ((uint64_t)1 << tiff_bps) - 1; // use uint64_t to avoid overflow if tiff_bps == 32 - while(maximum_c4[i] > compare) { + while(static_cast(maximum_c4[i]) > compare) { maximum_c4[i] >>= 1; } } @@ -632,7 +632,7 @@ int RawImage::loadRaw (bool loadData, unsigned int imageNum, bool closeFile, Pro } for (int c = 0; c < 4; c++) { - if (cblack[c] < black_c4[c]) { + if (static_cast(cblack[c]) < black_c4[c]) { cblack[c] = black_c4[c]; } } @@ -1074,7 +1074,7 @@ DCraw::dcraw_coeff_overrides(const char make[], const char model[], const int is char name[strlen(make) + strlen(model) + 32]; sprintf(name, "%s %s", make, model); - for (int i = 0; i < sizeof table / sizeof(table[0]); i++) { + for (size_t i = 0; i < sizeof table / sizeof(table[0]); i++) { if (strcasecmp(name, table[i].prefix) == 0) { *black_level = table[i].black_level; *white_level = table[i].white_level; From cd93dab966b1e21d0ca62207d9307ce93910df46 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 30 Mar 2017 20:33:50 +0200 Subject: [PATCH 35/90] Fix all warnings in imagedata.cc --- rtengine/imagedata.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rtengine/imagedata.cc b/rtengine/imagedata.cc index fa3651571..de5988d9b 100644 --- a/rtengine/imagedata.cc +++ b/rtengine/imagedata.cc @@ -331,7 +331,7 @@ void ImageData::extractInfo () if (mnote->getTag ("LensData")) { std::string ldata = mnote->getTag ("LensData")->valueToString (); - int pos; + size_t pos; if (ldata.size() > 10 && (pos = ldata.find ("Lens = ")) != Glib::ustring::npos) { lens = ldata.substr (pos + 7); @@ -339,7 +339,7 @@ void ImageData::extractInfo () if (lens.compare (0, 7, "Unknown")) { lensOk = true; } else { - int pos = lens.find("$FL$"); // is there a placeholder for focallength? + size_t pos = lens.find("$FL$"); // is there a placeholder for focallength? if(pos != Glib::ustring::npos) { // then fill in focallength lens = lens.replace(pos, 4, exif->getTag ("FocalLength")->valueToString ()); From bdcc4ab37e2eb50a0ce6927a8dd3efadee966460 Mon Sep 17 00:00:00 2001 From: Desmis Date: Fri, 31 Mar 2017 12:57:07 +0200 Subject: [PATCH 36/90] clean iptransform ipresize ipvibrance --- rtengine/ipresize.cc | 155 +++++++++---------- rtengine/iptransform.cc | 326 ++++++++++++++++++++-------------------- rtengine/ipvibrance.cc | 137 ++++++++--------- 3 files changed, 310 insertions(+), 308 deletions(-) diff --git a/rtengine/ipresize.cc b/rtengine/ipresize.cc index d3845ed8b..dde43fe6c 100644 --- a/rtengine/ipresize.cc +++ b/rtengine/ipresize.cc @@ -27,28 +27,29 @@ # include #endif + namespace rtengine { -static inline float Lanc(float x, float a) +static inline float Lanc (float x, float a) { if (x * x < 1e-6f) { return 1.0f; } else if (x * x > a * a) { return 0.0f; } else { - x = static_cast(rtengine::RT_PI) * x; - return a * xsinf(x) * xsinf(x / a) / (x * x); + x = static_cast (rtengine::RT_PI) * x; + return a * xsinf (x) * xsinf (x / a) / (x * x); } } -void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) +void ImProcFunctions::Lanczos (const Image16* src, Image16* dst, float scale) { const float delta = 1.0f / scale; const float a = 3.0f; - const float sc = min(scale, 1.0f); - const int support = static_cast(2.0f * a / sc) + 1; + const float sc = min (scale, 1.0f); + const int support = static_cast (2.0f * a / sc) + 1; #pragma omp parallel { @@ -67,7 +68,7 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) for (int j = 0; j < dst->getWidth(); j++) { // x coord of the center of pixel on src image - float x0 = (static_cast(j) + 0.5f) * delta - 0.5f; + float x0 = (static_cast (j) + 0.5f) * delta - 0.5f; // weights for interpolation in horisontal direction float * w = wwh + j * support; @@ -75,14 +76,14 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) // sum of weights used for normalization float ws = 0.0f; - jj0[j] = max(0, static_cast(floorf(x0 - a / sc)) + 1); - jj1[j] = min(src->getWidth(), static_cast(floorf(x0 + a / sc)) + 1); + jj0[j] = max (0, static_cast (floorf (x0 - a / sc)) + 1); + jj1[j] = min (src->getWidth(), static_cast (floorf (x0 + a / sc)) + 1); // calculate weights for (int jj = jj0[j]; jj < jj1[j]; jj++) { int k = jj - jj0[j]; - float z = sc * (x0 - static_cast(jj)); - w[k] = Lanc(z, a); + float z = sc * (x0 - static_cast (jj)); + w[k] = Lanc (z, a); ws += w[k]; } @@ -98,7 +99,7 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) for (int i = 0; i < dst->getHeight(); i++) { // y coord of the center of pixel on src image - float y0 = (static_cast(i) + 0.5f) * delta - 0.5f; + float y0 = (static_cast (i) + 0.5f) * delta - 0.5f; // weights for interpolation in y direction float w[support]; @@ -106,14 +107,14 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) // sum of weights used for normalization float ws = 0.0f; - int ii0 = max(0, static_cast(floorf(y0 - a / sc)) + 1); - int ii1 = min(src->getHeight(), static_cast(floorf(y0 + a / sc)) + 1); + int ii0 = max (0, static_cast (floorf (y0 - a / sc)) + 1); + int ii1 = min (src->getHeight(), static_cast (floorf (y0 + a / sc)) + 1); // calculate weights for vertical interpolation for (int ii = ii0; ii < ii1; ii++) { int k = ii - ii0; - float z = sc * (y0 - static_cast(ii)); - w[k] = Lanc(z, a); + float z = sc * (y0 - static_cast (ii)); + w[k] = Lanc (z, a); ws += w[k]; } @@ -130,9 +131,9 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) for (int ii = ii0; ii < ii1; ii++) { int k = ii - ii0; - r += w[k] * src->r(ii, j); - g += w[k] * src->g(ii, j); - b += w[k] * src->b(ii, j); + r += w[k] * src->r (ii, j); + g += w[k] * src->g (ii, j); + b += w[k] * src->b (ii, j); } lr[j] = r; @@ -141,7 +142,7 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) } // Do horizontal interpolation - for(int j = 0; j < dst->getWidth(); j++) { + for (int j = 0; j < dst->getWidth(); j++) { float * wh = wwh + support * j; @@ -155,9 +156,9 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) b += wh[k] * lb[jj]; } - dst->r(i, j) = CLIP(static_cast(r)); - dst->g(i, j) = CLIP(static_cast(g)); - dst->b(i, j) = CLIP(static_cast(b)); + dst->r (i, j) = CLIP (static_cast (r)); + dst->g (i, j) = CLIP (static_cast (g)); + dst->b (i, j) = CLIP (static_cast (b)); } } @@ -171,12 +172,12 @@ void ImProcFunctions::Lanczos(const Image16* src, Image16* dst, float scale) } -SSEFUNCTION void ImProcFunctions::Lanczos(const LabImage* src, LabImage* dst, float scale) +SSEFUNCTION void ImProcFunctions::Lanczos (const LabImage* src, LabImage* dst, float scale) { const float delta = 1.0f / scale; const float a = 3.0f; - const float sc = min(scale, 1.0f); - const int support = static_cast(2.0f * a / sc) + 1; + const float sc = min (scale, 1.0f); + const int support = static_cast (2.0f * a / sc) + 1; // storage for precomputed parameters for horizontal interpolation float * wwh = new float[support * dst->W]; @@ -187,7 +188,7 @@ SSEFUNCTION void ImProcFunctions::Lanczos(const LabImage* src, LabImage* dst, fl for (int j = 0; j < dst->W; j++) { // x coord of the center of pixel on src image - float x0 = (static_cast(j) + 0.5f) * delta - 0.5f; + float x0 = (static_cast (j) + 0.5f) * delta - 0.5f; // weights for interpolation in horizontal direction float * w = wwh + j * support; @@ -195,14 +196,14 @@ SSEFUNCTION void ImProcFunctions::Lanczos(const LabImage* src, LabImage* dst, fl // sum of weights used for normalization float ws = 0.0f; - jj0[j] = max(0, static_cast(floorf(x0 - a / sc)) + 1); - jj1[j] = min(src->W, static_cast(floorf(x0 + a / sc)) + 1); + jj0[j] = max (0, static_cast (floorf (x0 - a / sc)) + 1); + jj1[j] = min (src->W, static_cast (floorf (x0 + a / sc)) + 1); // calculate weights for (int jj = jj0[j]; jj < jj1[j]; jj++) { int k = jj - jj0[j]; - float z = sc * (x0 - static_cast(jj)); - w[k] = Lanc(z, a); + float z = sc * (x0 - static_cast (jj)); + w[k] = Lanc (z, a); ws += w[k]; } @@ -230,19 +231,19 @@ SSEFUNCTION void ImProcFunctions::Lanczos(const LabImage* src, LabImage* dst, fl for (int i = 0; i < dst->H; i++) { // y coord of the center of pixel on src image - float y0 = (static_cast(i) + 0.5f) * delta - 0.5f; + float y0 = (static_cast (i) + 0.5f) * delta - 0.5f; // sum of weights used for normalization float ws = 0.0f; - int ii0 = max(0, static_cast(floorf(y0 - a / sc)) + 1); - int ii1 = min(src->H, static_cast(floorf(y0 + a / sc)) + 1); + int ii0 = max (0, static_cast (floorf (y0 - a / sc)) + 1); + int ii1 = min (src->H, static_cast (floorf (y0 + a / sc)) + 1); // calculate weights for vertical interpolation for (int ii = ii0; ii < ii1; ii++) { int k = ii - ii0; - float z = sc * (y0 - static_cast(ii)); - w[k] = Lanc(z, a); + float z = sc * (y0 - static_cast (ii)); + w[k] = Lanc (z, a); ws += w[k]; } @@ -263,15 +264,15 @@ SSEFUNCTION void ImProcFunctions::Lanczos(const LabImage* src, LabImage* dst, fl for (int ii = ii0; ii < ii1; ii++) { int k = ii - ii0; - wkv = _mm_set1_ps(w[k]); - Lv += wkv * LVFU(src->L[ii][j]); - av += wkv * LVFU(src->a[ii][j]); - bv += wkv * LVFU(src->b[ii][j]); + wkv = _mm_set1_ps (w[k]); + Lv += wkv * LVFU (src->L[ii][j]); + av += wkv * LVFU (src->a[ii][j]); + bv += wkv * LVFU (src->b[ii][j]); } - STVF(lL[j], Lv); - STVF(la[j], av); - STVF(lb[j], bv); + STVF (lL[j], Lv); + STVF (la[j], av); + STVF (lb[j], bv); } #else @@ -295,7 +296,7 @@ SSEFUNCTION void ImProcFunctions::Lanczos(const LabImage* src, LabImage* dst, fl } // Do horizontal interpolation - for(int j = 0; j < dst->W; j++) { + for (int j = 0; j < dst->W; j++) { float * wh = wwh + support * j; @@ -348,35 +349,35 @@ float ImProcFunctions::resizeScale (const ProcParams* params, int fw, int fh, in refh = fh; } - switch(params->resize.dataspec) { - case (1): - // Width - dScale = (double)params->resize.width / (double)refw; - break; - - case (2): - // Height - dScale = (double)params->resize.height / (double)refh; - break; - - case (3): - - // FitBox - if ((double)refw / (double)refh > (double)params->resize.width / (double)params->resize.height) { + switch (params->resize.dataspec) { + case (1): + // Width dScale = (double)params->resize.width / (double)refw; - } else { + break; + + case (2): + // Height dScale = (double)params->resize.height / (double)refh; - } + break; - break; + case (3): - default: - // Scale - dScale = params->resize.scale; - break; + // FitBox + if ((double)refw / (double)refh > (double)params->resize.width / (double)params->resize.height) { + dScale = (double)params->resize.width / (double)refw; + } else { + dScale = (double)params->resize.height / (double)refh; + } + + break; + + default: + // Scale + dScale = params->resize.scale; + break; } - if (fabs(dScale - 1.0) <= 1e-5) { + if (fabs (dScale - 1.0) <= 1e-5) { return 1.0; } @@ -388,8 +389,8 @@ float ImProcFunctions::resizeScale (const ProcParams* params, int fw, int fh, in imh = refh; } - imw = (int)( (double)imw * dScale + 0.5 ); - imh = (int)( (double)imh * dScale + 0.5 ); + imw = (int) ( (double)imw * dScale + 0.5 ); + imh = (int) ( (double)imh * dScale + 0.5 ); return (float)dScale; } @@ -399,8 +400,8 @@ void ImProcFunctions::resize (Image16* src, Image16* dst, float dScale) time_t t1 = clock(); #endif - if(params->resize.method != "Nearest" ) { - Lanczos(src, dst, dScale); + if (params->resize.method != "Nearest" ) { + Lanczos (src, dst, dScale); } else { // Nearest neighbour algorithm #ifdef _OPENMP @@ -409,14 +410,14 @@ void ImProcFunctions::resize (Image16* src, Image16* dst, float dScale) for (int i = 0; i < dst->getHeight(); i++) { int sy = i / dScale; - sy = LIM(sy, 0, src->getHeight() - 1); + sy = LIM (sy, 0, src->getHeight() - 1); for (int j = 0; j < dst->getWidth(); j++) { int sx = j / dScale; - sx = LIM(sx, 0, src->getWidth() - 1); - dst->r(i, j) = src->r(sy, sx); - dst->g(i, j) = src->g(sy, sx); - dst->b(i, j) = src->b(sy, sx); + sx = LIM (sx, 0, src->getWidth() - 1); + dst->r (i, j) = src->r (sy, sx); + dst->g (i, j) = src->g (sy, sx); + dst->b (i, j) = src->b (sy, sx); } } } @@ -424,7 +425,7 @@ void ImProcFunctions::resize (Image16* src, Image16* dst, float dScale) #ifdef PROFILE time_t t2 = clock(); std::cout << "Resize: " << params->resize.method << ": " - << (float)(t2 - t1) / CLOCKS_PER_SEC << std::endl; + << (float) (t2 - t1) / CLOCKS_PER_SEC << std::endl; #endif } diff --git a/rtengine/iptransform.cc b/rtengine/iptransform.cc index abbb5d77d..04ba4966d 100644 --- a/rtengine/iptransform.cc +++ b/rtengine/iptransform.cc @@ -25,22 +25,23 @@ #include "rt_math.h" #include "sleef.c" + using namespace std; namespace { -float pow3(float x) +float pow3 (float x) { return x * x * x; } -float pow4(float x) +float pow4 (float x) { return (x * x) * (x * x); } -float pown(float x, int n) +float pown (float x, int n) { switch (n) { @@ -51,47 +52,47 @@ float pown(float x, int n) return x * x; case 4: - return pow4(x); + return pow4 (x); case 6: - return (x * x) * pow4(x); + return (x * x) * pow4 (x); case 8: - return pow4(x) * pow4(x); + return pow4 (x) * pow4 (x); default: - return pow_F(x, n); + return pow_F (x, n); } } -float normn(float a, float b, int n) +float normn (float a, float b, int n) { switch (n) { case 2: - return sqrtf(a * a + b * b); + return sqrtf (a * a + b * b); case 4: - return sqrtf(sqrtf(pow4(a) + pow4(b))); + return sqrtf (sqrtf (pow4 (a) + pow4 (b))); case 6: - return sqrtf(xcbrtf(pow3(a) * pow3(a) + pow3(b) * pow3(b))); + return sqrtf (xcbrtf (pow3 (a) * pow3 (a) + pow3 (b) * pow3 (b))); case 8: - return sqrtf(sqrtf(sqrtf(pow4(a) * pow4(a) + pow4(b) * pow4(b)))); + return sqrtf (sqrtf (sqrtf (pow4 (a) * pow4 (a) + pow4 (b) * pow4 (b)))); default: - return pow_F(pown(a, n) + pown(b, n), 1.f / n); + return pow_F (pown (a, n) + pown (b, n), 1.f / n); } } -void correct_distortion(const rtengine::LCPMapper *lcp, double &x, double &y, - int cx, int cy) +void correct_distortion (const rtengine::LCPMapper *lcp, double &x, double &y, + int cx, int cy) { - assert(lcp); - + assert (lcp); + x += cx; y += cy; - lcp->correctDistortion(x, y); + lcp->correctDistortion (x, y); x -= cx; y -= cy; } @@ -127,26 +128,26 @@ bool ImProcFunctions::transCoord (int W, int H, const std::vector &src, double oW = W, oH = H; double w2 = (double) oW / 2.0 - 0.5; double h2 = (double) oH / 2.0 - 0.5; - double maxRadius = sqrt( (double)( oW * oW + oH * oH ) ) / 2; + double maxRadius = sqrt ( (double) ( oW * oW + oH * oH ) ) / 2; // auxiliary variables for distortion correction bool needsDist = needsDistortion(); // for performance double distAmount = params->distortion.amount; // auxiliary variables for rotation - double cost = cos(params->rotate.degree * rtengine::RT_PI / 180.0); - double sint = sin(params->rotate.degree * rtengine::RT_PI / 180.0); + double cost = cos (params->rotate.degree * rtengine::RT_PI / 180.0); + double sint = sin (params->rotate.degree * rtengine::RT_PI / 180.0); // auxiliary variables for vertical perspective correction double vpdeg = params->perspective.vertical / 100.0 * 45.0; double vpalpha = (90.0 - vpdeg) / 180.0 * rtengine::RT_PI; - double vpteta = fabs(vpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((vpdeg > 0 ? 1.0 : -1.0) * sqrt((-oW * oW * tan(vpalpha) * tan(vpalpha) + (vpdeg > 0 ? 1.0 : -1.0) * oW * tan(vpalpha) * sqrt(16 * maxRadius * maxRadius + oW * oW * tan(vpalpha) * tan(vpalpha))) / (maxRadius * maxRadius * 8))); + double vpteta = fabs (vpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((vpdeg > 0 ? 1.0 : -1.0) * sqrt ((-oW * oW * tan (vpalpha) * tan (vpalpha) + (vpdeg > 0 ? 1.0 : -1.0) * oW * tan (vpalpha) * sqrt (16 * maxRadius * maxRadius + oW * oW * tan (vpalpha) * tan (vpalpha))) / (maxRadius * maxRadius * 8))); double vpcospt = (vpdeg >= 0 ? 1.0 : -1.0) * cos (vpteta), vptanpt = tan (vpteta); // auxiliary variables for horizontal perspective correction double hpdeg = params->perspective.horizontal / 100.0 * 45.0; double hpalpha = (90.0 - hpdeg) / 180.0 * rtengine::RT_PI; - double hpteta = fabs(hpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((hpdeg > 0 ? 1.0 : -1.0) * sqrt((-oH * oH * tan(hpalpha) * tan(hpalpha) + (hpdeg > 0 ? 1.0 : -1.0) * oH * tan(hpalpha) * sqrt(16 * maxRadius * maxRadius + oH * oH * tan(hpalpha) * tan(hpalpha))) / (maxRadius * maxRadius * 8))); + double hpteta = fabs (hpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((hpdeg > 0 ? 1.0 : -1.0) * sqrt ((-oH * oH * tan (hpalpha) * tan (hpalpha) + (hpdeg > 0 ? 1.0 : -1.0) * oH * tan (hpalpha) * sqrt (16 * maxRadius * maxRadius + oH * oH * tan (hpalpha) * tan (hpalpha))) / (maxRadius * maxRadius * 8))); double hpcospt = (hpdeg >= 0 ? 1.0 : -1.0) * cos (hpteta), hptanpt = tan (hpteta); double ascale = ascaleDef > 0 ? ascaleDef : (params->commonTrans.autofill ? getTransformAutoFill (oW, oH, pLCPMap) : 1.0); @@ -155,7 +156,7 @@ bool ImProcFunctions::transCoord (int W, int H, const std::vector &src, double x_d = src[i].x, y_d = src[i].y; if (pLCPMap && params->lensProf.useDist) { - correct_distortion(pLCPMap, x_d, y_d, 0, 0); + correct_distortion (pLCPMap, x_d, y_d, 0, 0); } y_d = ascale * (y_d - h2); @@ -179,25 +180,25 @@ bool ImProcFunctions::transCoord (int W, int H, const std::vector &src, double s = 1; if (needsDist) { - double r = sqrt(Dx * Dx + Dy * Dy) / maxRadius; // sqrt is slow + double r = sqrt (Dx * Dx + Dy * Dy) / maxRadius; // sqrt is slow s = 1.0 - distAmount + distAmount * r ; } // LCP CA is not reflected in preview (and very small), so don't add it here - red.push_back (Coord2D(Dx * (s + params->cacorrection.red) + w2, Dy * (s + params->cacorrection.red) + h2)); - green.push_back (Coord2D(Dx * s + w2, Dy * s + h2)); - blue.push_back (Coord2D(Dx * (s + params->cacorrection.blue) + w2, Dy * (s + params->cacorrection.blue) + h2)); + red.push_back (Coord2D (Dx * (s + params->cacorrection.red) + w2, Dy * (s + params->cacorrection.red) + h2)); + green.push_back (Coord2D (Dx * s + w2, Dy * s + h2)); + blue.push_back (Coord2D (Dx * (s + params->cacorrection.blue) + w2, Dy * (s + params->cacorrection.blue) + h2)); } // Clip all points and track if they were any corrections for (size_t i = 0; i < src.size(); i++) { - red[i].x = CLIPTOC(red[i].x, 0, W - 1, clipped); - red[i].y = CLIPTOC(red[i].y, 0, H - 1, clipped); - green[i].x = CLIPTOC(green[i].x, 0, W - 1, clipped); - green[i].y = CLIPTOC(green[i].y, 0, H - 1, clipped); - blue[i].x = CLIPTOC(blue[i].x, 0, W - 1, clipped); - blue[i].y = CLIPTOC(blue[i].y, 0, H - 1, clipped); + red[i].x = CLIPTOC (red[i].x, 0, W - 1, clipped); + red[i].y = CLIPTOC (red[i].y, 0, H - 1, clipped); + green[i].x = CLIPTOC (green[i].x, 0, W - 1, clipped); + green[i].y = CLIPTOC (green[i].y, 0, H - 1, clipped); + blue[i].x = CLIPTOC (blue[i].x, 0, W - 1, clipped); + blue[i].y = CLIPTOC (blue[i].y, 0, H - 1, clipped); } return clipped; @@ -264,7 +265,7 @@ bool ImProcFunctions::transCoord (int W, int H, int x, int y, int w, int h, int& x1d = transCorners[i].x; } - int x1v = (int)(x1d); + int x1v = (int) (x1d); double y1d = transCorners[0].y; @@ -273,7 +274,7 @@ bool ImProcFunctions::transCoord (int W, int H, int x, int y, int w, int h, int& y1d = transCorners[i].y; } - int y1v = (int)(y1d); + int y1v = (int) (y1d); double x2d = transCorners[0].x; @@ -282,7 +283,7 @@ bool ImProcFunctions::transCoord (int W, int H, int x, int y, int w, int h, int& x2d = transCorners[i].x; } - int x2v = (int)ceil(x2d); + int x2v = (int)ceil (x2d); double y2d = transCorners[0].y; @@ -291,7 +292,7 @@ bool ImProcFunctions::transCoord (int W, int H, int x, int y, int w, int h, int& y2d = transCorners[i].y; } - int y2v = (int)ceil(y2d); + int y2v = (int)ceil (y2d); xv = x1v; yv = y1v; @@ -308,17 +309,17 @@ void ImProcFunctions::transform (Imagefloat* original, Imagefloat* transformed, LCPMapper *pLCPMap = nullptr; if (needsLCP()) { // don't check focal length to allow distortion correction for lenses without chip - LCPProfile *pLCPProf = lcpStore->getProfile(params->lensProf.lcpFile); + LCPProfile *pLCPProf = lcpStore->getProfile (params->lensProf.lcpFile); if (pLCPProf) { - pLCPMap = new LCPMapper(pLCPProf, focalLen, focalLen35mm, - focusDist, 0, false, - params->lensProf.useDist, - oW, oH, params->coarse, rawRotationDeg); + pLCPMap = new LCPMapper (pLCPProf, focalLen, focalLen35mm, + focusDist, 0, false, + params->lensProf.useDist, + oW, oH, params->coarse, rawRotationDeg); } } - if (!(needsCA() || needsDistortion() || needsRotation() || needsPerspective() || needsLCP()) && (needsVignetting() || needsPCVignetting() || needsGradient())) { + if (! (needsCA() || needsDistortion() || needsRotation() || needsPerspective() || needsLCP()) && (needsVignetting() || needsPCVignetting() || needsGradient())) { transformLuminanceOnly (original, transformed, cx, cy, oW, oH, fW, fH); } else if (!needsCA() && scale != 1) { transformPreview (original, transformed, cx, cy, sx, sy, oW, oH, fW, fH, pLCPMap); @@ -332,7 +333,7 @@ void ImProcFunctions::transform (Imagefloat* original, Imagefloat* transformed, } // helper function -void ImProcFunctions::calcVignettingParams(int oW, int oH, const VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul) +void ImProcFunctions::calcVignettingParams (int oW, int oH, const VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul) { // vignette center is a point with coordinates between -1 and +1 double x = vignetting.centerX / 100.0; @@ -343,12 +344,12 @@ void ImProcFunctions::calcVignettingParams(int oW, int oH, const VignettingParam h2 = (double) oH / 2.0 - 0.5 + y * oH; // max vignette radius in pixels - maxRadius = sqrt( (double)( oW * oW + oH * oH ) ) / 2.; + maxRadius = sqrt ( (double) ( oW * oW + oH * oH ) ) / 2.; // vignette variables with applied strength - v = 1.0 + vignetting.strength * fabs(vignetting.amount) * 3.0 / 400.0; + v = 1.0 + vignetting.strength * fabs (vignetting.amount) * 3.0 / 400.0; b = 1.0 + vignetting.radius * 7.0 / 100.0; - mul = (1.0 - v) / tanh(b); + mul = (1.0 - v) / tanh (b); } struct grad_params { @@ -359,7 +360,7 @@ struct grad_params { float top_edge_0; int h; }; -static void calcGradientParams(int oW, int oH, const GradientParams& gradient, struct grad_params& gp) +static void calcGradientParams (int oW, int oH, const GradientParams& gradient, struct grad_params& gp) { int w = oW; int h = oH; @@ -371,7 +372,7 @@ static void calcGradientParams(int oW, int oH, const GradientParams& gradient, s //fprintf(stderr, "%f %f %f %f %f %d %d\n", gradient_stops, gradient_span, gradient_center_x, gradient_center_y, gradient_angle, w, h); // make 0.0 <= gradient_angle < 2 * rtengine::RT_PI - gradient_angle = fmod(gradient_angle, 2 * rtengine::RT_PI); + gradient_angle = fmod (gradient_angle, 2 * rtengine::RT_PI); if (gradient_angle < 0.0) { gradient_angle += 2.0 * rtengine::RT_PI; @@ -381,21 +382,21 @@ static void calcGradientParams(int oW, int oH, const GradientParams& gradient, s gp.transpose = false; gp.angle_is_zero = false; gp.h = h; - double cosgrad = cos(gradient_angle); + double cosgrad = cos (gradient_angle); - if (fabs(cosgrad) < 0.707) { + if (fabs (cosgrad) < 0.707) { // we transpose to avoid division by zero at 90 degrees // (actually we could transpose only for 90 degrees, but this way we avoid // division with extremely small numbers gp.transpose = true; gradient_angle += 0.5 * rtengine::RT_PI; - cosgrad = cos(gradient_angle); + cosgrad = cos (gradient_angle); double gxc = gradient_center_x; gradient_center_x = 1.0 - gradient_center_y; gradient_center_y = gxc; } - gradient_angle = fmod(gradient_angle, 2 * rtengine::RT_PI); + gradient_angle = fmod (gradient_angle, 2 * rtengine::RT_PI); if (gradient_angle > 0.5 * rtengine::RT_PI && gradient_angle < rtengine::RT_PI) { gradient_angle += rtengine::RT_PI; @@ -405,7 +406,7 @@ static void calcGradientParams(int oW, int oH, const GradientParams& gradient, s gp.bright_top = true; } - if (fabs(gradient_angle) < 0.001 || fabs(gradient_angle - 2 * rtengine::RT_PI) < 0.001) { + if (fabs (gradient_angle) < 0.001 || fabs (gradient_angle - 2 * rtengine::RT_PI) < 0.001) { gradient_angle = 0; gp.angle_is_zero = true; } @@ -420,7 +421,7 @@ static void calcGradientParams(int oW, int oH, const GradientParams& gradient, s h = tmp; } - gp.scale = 1.0 / pow(2, gradient_stops); + gp.scale = 1.0 / pow (2, gradient_stops); if (gp.bright_top) { gp.topmul = 1.0; @@ -430,10 +431,10 @@ static void calcGradientParams(int oW, int oH, const GradientParams& gradient, s gp.botmul = 1.0; } - gp.ta = tan(gradient_angle); + gp.ta = tan (gradient_angle); gp.xc = w * gradient_center_x; gp.yc = h * gradient_center_y; - gp.ys = sqrt((float)h * h + (float)w * w) * (gradient_span / cos(gradient_angle)); + gp.ys = sqrt ((float)h * h + (float)w * w) * (gradient_span / cos (gradient_angle)); gp.ys_inv = 1.0 / gp.ys; gp.top_edge_0 = gp.yc - gp.ys / 2.0; @@ -443,18 +444,17 @@ static void calcGradientParams(int oW, int oH, const GradientParams& gradient, s } } -static float calcGradientFactor(const struct grad_params& gp, int x, int y) +static float calcGradientFactor (const struct grad_params& gp, int x, int y) { if (gp.angle_is_zero) { int gy = gp.transpose ? x : y; - int gx = gp.transpose ? y : x; if (gy < gp.top_edge_0) { return gp.topmul; } else if (gy >= gp.top_edge_0 + gp.ys) { return gp.botmul; } else { - float val = ((float)(gy - gp.top_edge_0) * gp.ys_inv); + float val = ((float) (gy - gp.top_edge_0) * gp.ys_inv); if (gp.bright_top) { val = 1.f - val; @@ -463,9 +463,9 @@ static float calcGradientFactor(const struct grad_params& gp, int x, int y) val *= rtengine::RT_PI_F_2; if (gp.scale < 1.f) { - val = pow3(xsinf(val)); + val = pow3 (xsinf (val)); } else { - val = 1.f - pow3(xcosf(val)); + val = 1.f - pow3 (xcosf (val)); } return gp.scale + val * (1.0 - gp.scale); @@ -480,16 +480,16 @@ static float calcGradientFactor(const struct grad_params& gp, int x, int y) } else if (gy >= top_edge + gp.ys) { return gp.botmul; } else { - float val = ((float)(gy - top_edge) * gp.ys_inv); + float val = ((float) (gy - top_edge) * gp.ys_inv); val = gp.bright_top ? 1.f - val : val; val *= rtengine::RT_PI_F_2; if (gp.scale < 1.f) { - val = pow3(xsinf(val)); + val = pow3 (xsinf (val)); } else { - val = 1.f - pow3(xcosf(val)); + val = 1.f - pow3 (xcosf (val)); } return gp.scale + val * (1.0 - gp.scale); @@ -507,7 +507,7 @@ struct pcv_params { float scale; float fadeout_mul; }; -static void calcPCVignetteParams(int fW, int fH, int oW, int oH, const PCVignetteParams& pcvignette, const CropParams &crop, struct pcv_params& pcv) +static void calcPCVignetteParams (int fW, int fH, int oW, int oH, const PCVignetteParams& pcvignette, const CropParams &crop, struct pcv_params& pcv) { // ellipse formula: (x/a)^2 + (y/b)^2 = 1 @@ -528,49 +528,49 @@ static void calcPCVignetteParams(int fW, int fH, int oW, int oH, const PCVignett pcv.h = oH; } - pcv.fadeout_mul = 1.0 / (0.05 * sqrtf(oW * oW + oH * oH)); + pcv.fadeout_mul = 1.0 / (0.05 * sqrtf (oW * oW + oH * oH)); float short_side = (pcv.w < pcv.h) ? pcv.w : pcv.h; float long_side = (pcv.w > pcv.h) ? pcv.w : pcv.h; pcv.sep = 2; pcv.sepmix = 0; - pcv.oe_a = sqrt(2.0) * long_side * 0.5; + pcv.oe_a = sqrt (2.0) * long_side * 0.5; pcv.oe_b = pcv.oe_a * short_side / long_side; - pcv.ie_mul = (1.0 / sqrt(2.0)) * (1.0 - pcv.feather); + pcv.ie_mul = (1.0 / sqrt (2.0)) * (1.0 - pcv.feather); pcv.is_super_ellipse_mode = false; pcv.is_portrait = (pcv.w < pcv.h); if (roundness < 0.5) { // make super-ellipse of higher and higher degree pcv.is_super_ellipse_mode = true; - float sepf = 2 + 4 * powf(1.0 - 2 * roundness, 1.3); // gamma 1.3 used to balance the effect in the 0.0...0.5 roundness range + float sepf = 2 + 4 * powf (1.0 - 2 * roundness, 1.3); // gamma 1.3 used to balance the effect in the 0.0...0.5 roundness range pcv.sep = ((int)sepf) & ~0x1; pcv.sepmix = (sepf - pcv.sep) * 0.5; // 0.0 to 1.0 - pcv.oe1_a = powf(2.0, 1.0 / pcv.sep) * long_side * 0.5; + pcv.oe1_a = powf (2.0, 1.0 / pcv.sep) * long_side * 0.5; pcv.oe1_b = pcv.oe1_a * short_side / long_side; - pcv.ie1_mul = (1.0 / powf(2.0, 1.0 / pcv.sep)) * (1.0 - pcv.feather); - pcv.oe2_a = powf(2.0, 1.0 / (pcv.sep + 2)) * long_side * 0.5; + pcv.ie1_mul = (1.0 / powf (2.0, 1.0 / pcv.sep)) * (1.0 - pcv.feather); + pcv.oe2_a = powf (2.0, 1.0 / (pcv.sep + 2)) * long_side * 0.5; pcv.oe2_b = pcv.oe2_a * short_side / long_side; - pcv.ie2_mul = (1.0 / powf(2.0, 1.0 / (pcv.sep + 2))) * (1.0 - pcv.feather); + pcv.ie2_mul = (1.0 / powf (2.0, 1.0 / (pcv.sep + 2))) * (1.0 - pcv.feather); } if (roundness > 0.5) { // scale from fitted ellipse towards circle - float rad = sqrtf(pcv.w * pcv.w + pcv.h * pcv.h) / 2.0; + float rad = sqrtf (pcv.w * pcv.w + pcv.h * pcv.h) / 2.0; float diff_a = rad - pcv.oe_a; float diff_b = rad - pcv.oe_b; pcv.oe_a = pcv.oe_a + diff_a * 2 * (roundness - 0.5); pcv.oe_b = pcv.oe_b + diff_b * 2 * (roundness - 0.5); } - pcv.scale = powf(2, -pcvignette.strength); + pcv.scale = powf (2, -pcvignette.strength); if (pcvignette.strength >= 6.0) { pcv.scale = 0.0; } } -static float calcPCVignetteFactor(const struct pcv_params& pcv, int x, int y) +static float calcPCVignetteFactor (const struct pcv_params& pcv, int x, int y) { float fo = 1.f; @@ -592,25 +592,25 @@ static float calcPCVignetteFactor(const struct pcv_params& pcv, int x, int y) dist_y = 0; } - fo = sqrtf(dist_x * dist_x + dist_y * dist_y) * pcv.fadeout_mul; + fo = sqrtf (dist_x * dist_x + dist_y * dist_y) * pcv.fadeout_mul; if (fo >= 1.f) { return 1.f; } } - float a = fabs((x - pcv.x1) - pcv.w * 0.5f); - float b = fabs((y - pcv.y1) - pcv.h * 0.5f); + float a = fabs ((x - pcv.x1) - pcv.w * 0.5f); + float b = fabs ((y - pcv.y1) - pcv.h * 0.5f); - if(pcv.is_portrait) { - std::swap(a, b); + if (pcv.is_portrait) { + std::swap (a, b); } - float dist = normn(a, b, 2); + float dist = normn (a, b, 2); float dist_oe, dist_ie; float2 sincosval; - if(dist == 0.0f) { + if (dist == 0.0f) { sincosval.y = 1.0f; // cos sincosval.x = 0.0f; // sin } else { @@ -619,14 +619,14 @@ static float calcPCVignetteFactor(const struct pcv_params& pcv, int x, int y) } if (pcv.is_super_ellipse_mode) { - float dist_oe1 = pcv.oe1_a * pcv.oe1_b / normn(pcv.oe1_b * sincosval.y, pcv.oe1_a * sincosval.x, pcv.sep); - float dist_oe2 = pcv.oe2_a * pcv.oe2_b / normn(pcv.oe2_b * sincosval.y, pcv.oe2_a * sincosval.x, pcv.sep + 2); + float dist_oe1 = pcv.oe1_a * pcv.oe1_b / normn (pcv.oe1_b * sincosval.y, pcv.oe1_a * sincosval.x, pcv.sep); + float dist_oe2 = pcv.oe2_a * pcv.oe2_b / normn (pcv.oe2_b * sincosval.y, pcv.oe2_a * sincosval.x, pcv.sep + 2); float dist_ie1 = pcv.ie1_mul * dist_oe1; float dist_ie2 = pcv.ie2_mul * dist_oe2; dist_oe = dist_oe1 * (1.f - pcv.sepmix) + dist_oe2 * pcv.sepmix; dist_ie = dist_ie1 * (1.f - pcv.sepmix) + dist_ie2 * pcv.sepmix; } else { - dist_oe = pcv.oe_a * pcv.oe_b / sqrtf(SQR(pcv.oe_b * sincosval.y) + SQR(pcv.oe_a * sincosval.x)); + dist_oe = pcv.oe_a * pcv.oe_b / sqrtf (SQR (pcv.oe_b * sincosval.y) + SQR (pcv.oe_a * sincosval.x)); dist_ie = pcv.ie_mul * dist_oe; } @@ -642,9 +642,9 @@ static float calcPCVignetteFactor(const struct pcv_params& pcv, int x, int y) val = rtengine::RT_PI_F_2 * (dist - dist_ie) / (dist_oe - dist_ie); if (pcv.scale < 1.f) { - val = pow4(xcosf(val)); + val = pow4 (xcosf (val)); } else { - val = 1 - pow4(xsinf(val)); + val = 1 - pow4 (xsinf (val)); } val = pcv.scale + val * (1.f - pcv.scale); @@ -667,20 +667,20 @@ void ImProcFunctions::transformLuminanceOnly (Imagefloat* original, Imagefloat* double vig_w2, vig_h2, maxRadius, v, b, mul; if (applyVignetting) { - calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); + calcVignettingParams (oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); } struct grad_params gp; if (applyGradient) { - calcGradientParams(oW, oH, params->gradient, gp); + calcGradientParams (oW, oH, params->gradient, gp); } struct pcv_params pcv; if (applyPCVignetting) { //fprintf(stderr, "%d %d | %d %d | %d %d | %d %d [%d %d]\n", fW, fH, oW, oH, transformed->getWidth(), transformed->getHeight(), cx, cy, params->crop.w, params->crop.h); - calcPCVignetteParams(fW, fH, oW, oH, params->pcvignette, params->crop, pcv); + calcPCVignetteParams (fW, fH, oW, oH, params->pcvignette, params->crop, pcv); } bool darkening = (params->vignetting.amount <= 0.0); @@ -694,26 +694,26 @@ void ImProcFunctions::transformLuminanceOnly (Imagefloat* original, Imagefloat* if (applyVignetting) { double vig_x_d = (double) (x + cx) - vig_w2 ; - double r = sqrt(vig_x_d * vig_x_d + vig_y_d * vig_y_d); + double r = sqrt (vig_x_d * vig_x_d + vig_y_d * vig_y_d); - if(darkening) { - factor /= std::max(v + mul * tanh (b * (maxRadius - r) / maxRadius), 0.001); + if (darkening) { + factor /= std::max (v + mul * tanh (b * (maxRadius - r) / maxRadius), 0.001); } else { factor = v + mul * tanh (b * (maxRadius - r) / maxRadius); } } if (applyGradient) { - factor *= calcGradientFactor(gp, cx + x, cy + y); + factor *= calcGradientFactor (gp, cx + x, cy + y); } if (applyPCVignetting) { - factor *= calcPCVignetteFactor(pcv, cx + x, cy + y); + factor *= calcPCVignetteFactor (pcv, cx + x, cy + y); } - transformed->r(y, x) = original->r(y, x) * factor; - transformed->g(y, x) = original->g(y, x) * factor; - transformed->b(y, x) = original->b(y, x) * factor; + transformed->r (y, x) = original->r (y, x) * factor; + transformed->g (y, x) = original->g (y, x) * factor; + transformed->b (y, x) = original->b (y, x) * factor; } } } @@ -726,18 +726,18 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr double h2 = (double) oH / 2.0 - 0.5; double vig_w2, vig_h2, maxRadius, v, b, mul; - calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); + calcVignettingParams (oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); struct grad_params gp; if (needsGradient()) { - calcGradientParams(oW, oH, params->gradient, gp); + calcGradientParams (oW, oH, params->gradient, gp); } struct pcv_params pcv; if (needsPCVignetting()) { - calcPCVignetteParams(fW, fH, oW, oH, params->pcvignette, params->crop, pcv); + calcPCVignetteParams (fW, fH, oW, oH, params->pcvignette, params->crop, pcv); } float** chOrig[3]; @@ -761,21 +761,21 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr double distAmount = params->distortion.amount; // auxiliary variables for rotation - double cost = cos(params->rotate.degree * rtengine::RT_PI / 180.0); - double sint = sin(params->rotate.degree * rtengine::RT_PI / 180.0); + double cost = cos (params->rotate.degree * rtengine::RT_PI / 180.0); + double sint = sin (params->rotate.degree * rtengine::RT_PI / 180.0); // auxiliary variables for vertical perspective correction double vpdeg = params->perspective.vertical / 100.0 * 45.0; double vpalpha = (90.0 - vpdeg) / 180.0 * rtengine::RT_PI; - double vpteta = fabs(vpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((vpdeg > 0 ? 1.0 : -1.0) * sqrt((-SQR(oW * tan(vpalpha)) + (vpdeg > 0 ? 1.0 : -1.0) * - oW * tan(vpalpha) * sqrt(SQR(4 * maxRadius) + SQR(oW * tan(vpalpha)))) / (SQR(maxRadius) * 8))); + double vpteta = fabs (vpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((vpdeg > 0 ? 1.0 : -1.0) * sqrt ((-SQR (oW * tan (vpalpha)) + (vpdeg > 0 ? 1.0 : -1.0) * + oW * tan (vpalpha) * sqrt (SQR (4 * maxRadius) + SQR (oW * tan (vpalpha)))) / (SQR (maxRadius) * 8))); double vpcospt = (vpdeg >= 0 ? 1.0 : -1.0) * cos (vpteta), vptanpt = tan (vpteta); // auxiliary variables for horizontal perspective correction double hpdeg = params->perspective.horizontal / 100.0 * 45.0; double hpalpha = (90.0 - hpdeg) / 180.0 * rtengine::RT_PI; - double hpteta = fabs(hpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((hpdeg > 0 ? 1.0 : -1.0) * sqrt((-SQR(oH * tan(hpalpha)) + (hpdeg > 0 ? 1.0 : -1.0) * - oH * tan(hpalpha) * sqrt(SQR(4 * maxRadius) + SQR(oH * tan(hpalpha)))) / (SQR(maxRadius) * 8))); + double hpteta = fabs (hpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((hpdeg > 0 ? 1.0 : -1.0) * sqrt ((-SQR (oH * tan (hpalpha)) + (hpdeg > 0 ? 1.0 : -1.0) * + oH * tan (hpalpha) * sqrt (SQR (4 * maxRadius) + SQR (oH * tan (hpalpha)))) / (SQR (maxRadius) * 8))); double hpcospt = (hpdeg >= 0 ? 1.0 : -1.0) * cos (hpteta), hptanpt = tan (hpteta); double ascale = params->commonTrans.autofill ? getTransformAutoFill (oW, oH, true /*fullImage*/ ? pLCPMap : nullptr) : 1.0; @@ -799,13 +799,13 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr double x_d = x, y_d = y; if (enableLCPDist) { - correct_distortion(pLCPMap, x_d, y_d, cx, cy); // must be first transform + correct_distortion (pLCPMap, x_d, y_d, cx, cy); // must be first transform } x_d = ascale * (x_d + cx - w2); // centering x coord & scale y_d = ascale * (y_d + cy - h2); // centering y coord & scale - double vig_x_d, vig_y_d; + double vig_x_d = 0., vig_y_d = 0.; if (needsVignetting()) { vig_x_d = ascale * (x + cx - vig_w2); // centering x coord & scale @@ -830,16 +830,16 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr double s = 1; if (needsDist) { - double r = sqrt(Dxc * Dxc + Dyc * Dyc) / maxRadius; // sqrt is slow + double r = sqrt (Dxc * Dxc + Dyc * Dyc) / maxRadius; // sqrt is slow s = 1.0 - distAmount + distAmount * r ; } - double r2; + double r2 = 0.; if (needsVignetting()) { double vig_Dx = vig_x_d * cost - vig_y_d * sint; double vig_Dy = vig_x_d * sint + vig_y_d * cost; - r2 = sqrt(vig_Dx * vig_Dx + vig_Dy * vig_Dy); + r2 = sqrt (vig_Dx * vig_Dx + vig_Dy * vig_Dy); } for (int c = 0; c < (enableCA ? 3 : 1); c++) { @@ -852,7 +852,7 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr // LCP CA if (enableLCPCA) { - pLCPMap->correctCA(Dx, Dy, c); + pLCPMap->correctCA (Dx, Dy, c); } // Extract integer and fractions of source screen coordinates @@ -870,41 +870,41 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr double vignmul = 1.0; if (needsVignetting()) { - if(darkening) { - vignmul /= std::max(v + mul * tanh (b * (maxRadius - s * r2) / maxRadius), 0.001); + if (darkening) { + vignmul /= std::max (v + mul * tanh (b * (maxRadius - s * r2) / maxRadius), 0.001); } else { vignmul *= (v + mul * tanh (b * (maxRadius - s * r2) / maxRadius)); } } if (needsGradient()) { - vignmul *= calcGradientFactor(gp, cx + x, cy + y); + vignmul *= calcGradientFactor (gp, cx + x, cy + y); } if (needsPCVignetting()) { - vignmul *= calcPCVignetteFactor(pcv, cx + x, cy + y); + vignmul *= calcPCVignetteFactor (pcv, cx + x, cy + y); } if (yc > 0 && yc < original->getHeight() - 2 && xc > 0 && xc < original->getWidth() - 2) { // all interpolation pixels inside image if (enableCA) { - interpolateTransformChannelsCubic (chOrig[c], xc - 1, yc - 1, Dx, Dy, &(chTrans[c][y][x]), vignmul); + interpolateTransformChannelsCubic (chOrig[c], xc - 1, yc - 1, Dx, Dy, & (chTrans[c][y][x]), vignmul); } else { - interpolateTransformCubic (original, xc - 1, yc - 1, Dx, Dy, &(transformed->r(y, x)), &(transformed->g(y, x)), &(transformed->b(y, x)), vignmul); + interpolateTransformCubic (original, xc - 1, yc - 1, Dx, Dy, & (transformed->r (y, x)), & (transformed->g (y, x)), & (transformed->b (y, x)), vignmul); } } else { // edge pixels - int y1 = LIM(yc, 0, original->getHeight() - 1); - int y2 = LIM(yc + 1, 0, original->getHeight() - 1); - int x1 = LIM(xc, 0, original->getWidth() - 1); - int x2 = LIM(xc + 1, 0, original->getWidth() - 1); + int y1 = LIM (yc, 0, original->getHeight() - 1); + int y2 = LIM (yc + 1, 0, original->getHeight() - 1); + int x1 = LIM (xc, 0, original->getWidth() - 1); + int x2 = LIM (xc + 1, 0, original->getWidth() - 1); if (enableCA) { chTrans[c][y][x] = vignmul * (chOrig[c][y1][x1] * (1.0 - Dx) * (1.0 - Dy) + chOrig[c][y1][x2] * Dx * (1.0 - Dy) + chOrig[c][y2][x1] * (1.0 - Dx) * Dy + chOrig[c][y2][x2] * Dx * Dy); } else { - transformed->r(y, x) = vignmul * (original->r(y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->r(y1, x2) * Dx * (1.0 - Dy) + original->r(y2, x1) * (1.0 - Dx) * Dy + original->r(y2, x2) * Dx * Dy); - transformed->g(y, x) = vignmul * (original->g(y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->g(y1, x2) * Dx * (1.0 - Dy) + original->g(y2, x1) * (1.0 - Dx) * Dy + original->g(y2, x2) * Dx * Dy); - transformed->b(y, x) = vignmul * (original->b(y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->b(y1, x2) * Dx * (1.0 - Dy) + original->b(y2, x1) * (1.0 - Dx) * Dy + original->b(y2, x2) * Dx * Dy); + transformed->r (y, x) = vignmul * (original->r (y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->r (y1, x2) * Dx * (1.0 - Dy) + original->r (y2, x1) * (1.0 - Dx) * Dy + original->r (y2, x2) * Dx * Dy); + transformed->g (y, x) = vignmul * (original->g (y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->g (y1, x2) * Dx * (1.0 - Dy) + original->g (y2, x1) * (1.0 - Dx) * Dy + original->g (y2, x2) * Dx * Dy); + transformed->b (y, x) = vignmul * (original->b (y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->b (y1, x2) * Dx * (1.0 - Dy) + original->b (y2, x1) * (1.0 - Dx) * Dy + original->b (y2, x2) * Dx * Dy); } } } else { @@ -912,9 +912,9 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr // not valid (source pixel x,y not inside source image, etc.) chTrans[c][y][x] = 0; } else { - transformed->r(y, x) = 0; - transformed->g(y, x) = 0; - transformed->b(y, x) = 0; + transformed->r (y, x) = 0; + transformed->g (y, x) = 0; + transformed->b (y, x) = 0; } } } @@ -930,18 +930,18 @@ void ImProcFunctions::transformPreview (Imagefloat* original, Imagefloat* transf double h2 = (double) oH / 2.0 - 0.5; double vig_w2, vig_h2, maxRadius, v, b, mul; - calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); + calcVignettingParams (oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); struct grad_params gp; if (needsGradient()) { - calcGradientParams(oW, oH, params->gradient, gp); + calcGradientParams (oW, oH, params->gradient, gp); } struct pcv_params pcv; if (needsPCVignetting()) { - calcPCVignetteParams(fW, fH, oW, oH, params->pcvignette, params->crop, pcv); + calcPCVignetteParams (fW, fH, oW, oH, params->pcvignette, params->crop, pcv); } // auxiliary variables for distortion correction @@ -949,19 +949,19 @@ void ImProcFunctions::transformPreview (Imagefloat* original, Imagefloat* transf double distAmount = params->distortion.amount; // auxiliary variables for rotation - double cost = cos(params->rotate.degree * rtengine::RT_PI / 180.0); - double sint = sin(params->rotate.degree * rtengine::RT_PI / 180.0); + double cost = cos (params->rotate.degree * rtengine::RT_PI / 180.0); + double sint = sin (params->rotate.degree * rtengine::RT_PI / 180.0); // auxiliary variables for vertical perspective correction double vpdeg = params->perspective.vertical / 100.0 * 45.0; double vpalpha = (90 - vpdeg) / 180.0 * rtengine::RT_PI; - double vpteta = fabs(vpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((vpdeg > 0 ? 1.0 : -1.0) * sqrt((-oW * oW * tan(vpalpha) * tan(vpalpha) + (vpdeg > 0 ? 1.0 : -1.0) * oW * tan(vpalpha) * sqrt(16 * maxRadius * maxRadius + oW * oW * tan(vpalpha) * tan(vpalpha))) / (maxRadius * maxRadius * 8))); + double vpteta = fabs (vpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((vpdeg > 0 ? 1.0 : -1.0) * sqrt ((-oW * oW * tan (vpalpha) * tan (vpalpha) + (vpdeg > 0 ? 1.0 : -1.0) * oW * tan (vpalpha) * sqrt (16 * maxRadius * maxRadius + oW * oW * tan (vpalpha) * tan (vpalpha))) / (maxRadius * maxRadius * 8))); double vpcospt = (vpdeg >= 0 ? 1.0 : -1.0) * cos (vpteta), vptanpt = tan (vpteta); // auxiliary variables for horizontal perspective correction double hpdeg = params->perspective.horizontal / 100.0 * 45.0; double hpalpha = (90 - hpdeg) / 180.0 * rtengine::RT_PI; - double hpteta = fabs(hpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((hpdeg > 0 ? 1.0 : -1.0) * sqrt((-oH * oH * tan(hpalpha) * tan(hpalpha) + (hpdeg > 0 ? 1.0 : -1.0) * oH * tan(hpalpha) * sqrt(16 * maxRadius * maxRadius + oH * oH * tan(hpalpha) * tan(hpalpha))) / (maxRadius * maxRadius * 8))); + double hpteta = fabs (hpalpha - rtengine::RT_PI / 2) < 3e-4 ? 0.0 : acos ((hpdeg > 0 ? 1.0 : -1.0) * sqrt ((-oH * oH * tan (hpalpha) * tan (hpalpha) + (hpdeg > 0 ? 1.0 : -1.0) * oH * tan (hpalpha) * sqrt (16 * maxRadius * maxRadius + oH * oH * tan (hpalpha) * tan (hpalpha))) / (maxRadius * maxRadius * 8))); double hpcospt = (hpdeg >= 0 ? 1.0 : -1.0) * cos (hpteta), hptanpt = tan (hpteta); double ascale = params->commonTrans.autofill ? getTransformAutoFill (oW, oH, pLCPMap) : 1.0; @@ -976,13 +976,13 @@ void ImProcFunctions::transformPreview (Imagefloat* original, Imagefloat* transf double x_d = x, y_d = y; if (pLCPMap && params->lensProf.useDist) { - correct_distortion(pLCPMap, x_d, y_d, cx, cy); // must be first transform + correct_distortion (pLCPMap, x_d, y_d, cx, cy); // must be first transform } y_d = ascale * (y_d + cy - h2); // centering y coord & scale x_d = ascale * (x_d + cx - w2); // centering x coord & scale - double vig_x_d, vig_y_d; + double vig_x_d = 0., vig_y_d = 0.; if (needsVignetting()) { vig_x_d = ascale * (x + cx - vig_w2); // centering x coord & scale @@ -1007,18 +1007,18 @@ void ImProcFunctions::transformPreview (Imagefloat* original, Imagefloat* transf double s = 1; if (needsDist) { - double r = sqrt(Dx * Dx + Dy * Dy) / maxRadius; // sqrt is slow + double r = sqrt (Dx * Dx + Dy * Dy) / maxRadius; // sqrt is slow s = 1.0 - distAmount + distAmount * r ; Dx *= s; Dy *= s; } - double r2; + double r2 = 0.; if (needsVignetting()) { double vig_Dx = vig_x_d * cost - vig_y_d * sint; double vig_Dy = vig_x_d * sint + vig_y_d * cost; - r2 = sqrt(vig_Dx * vig_Dx + vig_Dy * vig_Dy); + r2 = sqrt (vig_Dx * vig_Dx + vig_Dy * vig_Dy); } // de-center @@ -1040,41 +1040,41 @@ void ImProcFunctions::transformPreview (Imagefloat* original, Imagefloat* transf double vignmul = 1.0; if (needsVignetting()) { - if(darkening) { - vignmul /= std::max(v + mul * tanh (b * (maxRadius - s * r2) / maxRadius), 0.001); + if (darkening) { + vignmul /= std::max (v + mul * tanh (b * (maxRadius - s * r2) / maxRadius), 0.001); } else { vignmul = v + mul * tanh (b * (maxRadius - s * r2) / maxRadius); } } if (needsGradient()) { - vignmul *= calcGradientFactor(gp, cx + x, cy + y); + vignmul *= calcGradientFactor (gp, cx + x, cy + y); } if (needsPCVignetting()) { - vignmul *= calcPCVignetteFactor(pcv, cx + x, cy + y); + vignmul *= calcPCVignetteFactor (pcv, cx + x, cy + y); } if (yc < original->getHeight() - 1 && xc < original->getWidth() - 1) { // all interpolation pixels inside image - transformed->r(y, x) = vignmul * (original->r(yc, xc) * (1.0 - Dx) * (1.0 - Dy) + original->r(yc, xc + 1) * Dx * (1.0 - Dy) + original->r(yc + 1, xc) * (1.0 - Dx) * Dy + original->r(yc + 1, xc + 1) * Dx * Dy); - transformed->g(y, x) = vignmul * (original->g(yc, xc) * (1.0 - Dx) * (1.0 - Dy) + original->g(yc, xc + 1) * Dx * (1.0 - Dy) + original->g(yc + 1, xc) * (1.0 - Dx) * Dy + original->g(yc + 1, xc + 1) * Dx * Dy); - transformed->b(y, x) = vignmul * (original->b(yc, xc) * (1.0 - Dx) * (1.0 - Dy) + original->b(yc, xc + 1) * Dx * (1.0 - Dy) + original->b(yc + 1, xc) * (1.0 - Dx) * Dy + original->b(yc + 1, xc + 1) * Dx * Dy); + transformed->r (y, x) = vignmul * (original->r (yc, xc) * (1.0 - Dx) * (1.0 - Dy) + original->r (yc, xc + 1) * Dx * (1.0 - Dy) + original->r (yc + 1, xc) * (1.0 - Dx) * Dy + original->r (yc + 1, xc + 1) * Dx * Dy); + transformed->g (y, x) = vignmul * (original->g (yc, xc) * (1.0 - Dx) * (1.0 - Dy) + original->g (yc, xc + 1) * Dx * (1.0 - Dy) + original->g (yc + 1, xc) * (1.0 - Dx) * Dy + original->g (yc + 1, xc + 1) * Dx * Dy); + transformed->b (y, x) = vignmul * (original->b (yc, xc) * (1.0 - Dx) * (1.0 - Dy) + original->b (yc, xc + 1) * Dx * (1.0 - Dy) + original->b (yc + 1, xc) * (1.0 - Dx) * Dy + original->b (yc + 1, xc + 1) * Dx * Dy); } else { // edge pixels - int y1 = LIM(yc, 0, original->getHeight() - 1); - int y2 = LIM(yc + 1, 0, original->getHeight() - 1); - int x1 = LIM(xc, 0, original->getWidth() - 1); - int x2 = LIM(xc + 1, 0, original->getWidth() - 1); - transformed->r(y, x) = vignmul * (original->r(y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->r(y1, x2) * Dx * (1.0 - Dy) + original->r(y2, x1) * (1.0 - Dx) * Dy + original->r(y2, x2) * Dx * Dy); - transformed->g(y, x) = vignmul * (original->g(y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->g(y1, x2) * Dx * (1.0 - Dy) + original->g(y2, x1) * (1.0 - Dx) * Dy + original->g(y2, x2) * Dx * Dy); - transformed->b(y, x) = vignmul * (original->b(y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->b(y1, x2) * Dx * (1.0 - Dy) + original->b(y2, x1) * (1.0 - Dx) * Dy + original->b(y2, x2) * Dx * Dy); + int y1 = LIM (yc, 0, original->getHeight() - 1); + int y2 = LIM (yc + 1, 0, original->getHeight() - 1); + int x1 = LIM (xc, 0, original->getWidth() - 1); + int x2 = LIM (xc + 1, 0, original->getWidth() - 1); + transformed->r (y, x) = vignmul * (original->r (y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->r (y1, x2) * Dx * (1.0 - Dy) + original->r (y2, x1) * (1.0 - Dx) * Dy + original->r (y2, x2) * Dx * Dy); + transformed->g (y, x) = vignmul * (original->g (y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->g (y1, x2) * Dx * (1.0 - Dy) + original->g (y2, x1) * (1.0 - Dx) * Dy + original->g (y2, x2) * Dx * Dy); + transformed->b (y, x) = vignmul * (original->b (y1, x1) * (1.0 - Dx) * (1.0 - Dy) + original->b (y1, x2) * Dx * (1.0 - Dy) + original->b (y2, x1) * (1.0 - Dx) * Dy + original->b (y2, x2) * Dx * Dy); } } else { // not valid (source pixel x,y not inside source image, etc.) - transformed->r(y, x) = 0; - transformed->g(y, x) = 0; - transformed->b(y, x) = 0; + transformed->r (y, x) = 0; + transformed->g (y, x) = 0; + transformed->b (y, x) = 0; } } } @@ -1126,12 +1126,12 @@ bool ImProcFunctions::needsPerspective () bool ImProcFunctions::needsGradient () { - return params->gradient.enabled && fabs(params->gradient.strength) > 1e-15; + return params->gradient.enabled && fabs (params->gradient.strength) > 1e-15; } bool ImProcFunctions::needsPCVignetting () { - return params->pcvignette.enabled && fabs(params->pcvignette.strength) > 1e-15; + return params->pcvignette.enabled && fabs (params->pcvignette.strength) > 1e-15; } bool ImProcFunctions::needsVignetting () diff --git a/rtengine/ipvibrance.cc b/rtengine/ipvibrance.cc index 8eb565434..49f956602 100644 --- a/rtengine/ipvibrance.cc +++ b/rtengine/ipvibrance.cc @@ -33,6 +33,7 @@ #include #endif + using namespace std; namespace rtengine @@ -44,7 +45,7 @@ using namespace procparams; extern const Settings* settings; -void fillCurveArrayVib(DiagonalCurve* diagCurve, LUTf &outCurve) +void fillCurveArrayVib (DiagonalCurve* diagCurve, LUTf &outCurve) { if (diagCurve) { @@ -56,7 +57,7 @@ void fillCurveArrayVib(DiagonalCurve* diagCurve, LUTf &outCurve) // change to [0,1] range // apply custom/parametric/NURBS curve, if any // and store result in a temporary array - outCurve[i] = 65535.f * diagCurve->getVal( double(i) / 65535.0 ); + outCurve[i] = 65535.f * diagCurve->getVal ( double (i) / 65535.0 ); } } else { outCurve.makeIdentity(); @@ -111,8 +112,8 @@ void ImProcFunctions::vibrance (LabImage* lab) // I use diagonal because I think it's better LUTf skin_curve (65536, 0); - if(skinCurveIsSet) { - fillCurveArrayVib(dcurve, skin_curve); + if (skinCurveIsSet) { + fillCurveArrayVib (dcurve, skin_curve); } if (dcurve) { @@ -123,10 +124,10 @@ void ImProcFunctions::vibrance (LabImage* lab) // skin_curve.dump("skin_curve"); - const float chromaPastel = float(params->vibrance.pastels) / 100.0f; - const float chromaSatur = float(params->vibrance.saturated) / 100.0f; + 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(params->vibrance.psthreshold.value[ThresholdSelector::TS_TOPLEFT]) / 100.0f) * (1.0f - p00) + p00; + const float limitpastelsatur = (static_cast (params->vibrance.psthreshold.value[ThresholdSelector::TS_TOPLEFT]) / 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,10 +136,10 @@ 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(params->vibrance.psthreshold.value[ThresholdSelector::TS_BOTTOMLEFT]) / 100.0f; + const float transitionweighting = static_cast (params->vibrance.psthreshold.value[ThresholdSelector::TS_BOTTOMLEFT]) / 100.0f; float chromamean = 0.0f; - if(chromaPastel != chromaSatur) { + if (chromaPastel != chromaSatur) { //if sliders pastels and saturated are different: transition with a double linear interpolation: between p2 and limitpastelsatur, and between limitpastelsatur and s0 //modify the "mean" point in function of double threshold => differential transition chromamean = maxdp * (chromaSatur - chromaPastel) / (s0 - p2) + chromaPastel; @@ -208,8 +209,8 @@ void ImProcFunctions::vibrance (LabImage* lab) if (settings->verbose) { #endif - printf("vibrance: p0=%1.2f p1=%1.2f p2=%1.2f s0=%1.2f s1=%1.2f s2=%1.2f\n", p0, p1, p2, s0, s1, s2); - printf(" pastel=%f satur=%f limit= %1.2f chromamean=%0.5f\n", 1.0f + chromaPastel, 1.0f + chromaSatur, limitpastelsatur, chromamean); + printf ("vibrance: p0=%1.2f p1=%1.2f p2=%1.2f s0=%1.2f s1=%1.2f s2=%1.2f\n", p0, p1, p2, s0, s1, s2); + printf (" pastel=%f satur=%f limit= %1.2f chromamean=%0.5f\n", 1.0f + chromaPastel, 1.0f + chromaSatur, limitpastelsatur, chromamean); } #pragma omp for schedule(dynamic, 16) @@ -217,12 +218,12 @@ void ImProcFunctions::vibrance (LabImage* lab) for (int i = 0; i < height; i++) for (int j = 0; j < width; j++) { float LL = lab->L[i][j] / 327.68f; - float CC = sqrt(SQR(lab->a[i][j]) + SQR(lab->b[i][j])) / 327.68f; - float HH = xatan2f(lab->b[i][j], lab->a[i][j]); + float CC = sqrt (SQR (lab->a[i][j]) + SQR (lab->b[i][j])) / 327.68f; + float HH = xatan2f (lab->b[i][j], lab->a[i][j]); float satredu = 1.0f; //reduct sat in function of skin - if(protectskins) { + if (protectskins) { Color::SkinSat (LL, HH, CC, satredu);// for skin colors } @@ -234,7 +235,7 @@ void ImProcFunctions::vibrance (LabImage* lab) float R, G, B; float2 sincosval; - if(CC == 0.0f) { + if (CC == 0.0f) { sincosval.y = 1.f; sincosval.x = 0.0f; } else { @@ -246,26 +247,26 @@ void ImProcFunctions::vibrance (LabImage* lab) bool neg = false; bool more_rgb = false; //gamut control : Lab values are in gamut - Color::gamutLchonly(HH, sincosval, Lprov, Chprov, R, G, B, wip, highlight, 0.15f, 0.98f, neg, more_rgb); + Color::gamutLchonly (HH, sincosval, Lprov, Chprov, R, G, B, wip, highlight, 0.15f, 0.98f, neg, more_rgb); - if(neg) { + if (neg) { negat++; } - if(more_rgb) { + if (more_rgb) { moreRGB++; } #else //gamut control : Lab values are in gamut - Color::gamutLchonly(HH, sincosval, Lprov, Chprov, R, G, B, wip, highlight, 0.15f, 0.98f); + Color::gamutLchonly (HH, sincosval, Lprov, Chprov, R, G, B, wip, highlight, 0.15f, 0.98f); #endif - if(Chprov > 6.0f) { - const float saturation = SAT(R, G, B); + if (Chprov > 6.0f) { + const float saturation = SAT (R, G, B); - if(saturation > 0.0f) { - if(satredu != 1.0f) { + if (saturation > 0.0f) { + if (satredu != 1.0f) { // for skin, no differentiation sathue [0] = sathue [1] = sathue [2] = sathue [3] = sathue[4] = 1.0f; sathue2[0] = sathue2[1] = sathue2[2] = sathue2[3] = 1.0f; @@ -274,7 +275,7 @@ void ImProcFunctions::vibrance (LabImage* lab) //I try to take into account: Munsell response (human vision) and Gamut..(less response for red): preferably using Prophoto or WideGamut //blue: -1.80 -3.14 green = 2.1 3.14 green-yellow=1.4 2.1 red:0 1.4 blue-purple:-0.7 -1.4 purple: 0 -0.7 //these values allow a better and differential response - if(LL < 20.0f) {//more for blue-purple, blue and red modulate + if (LL < 20.0f) { //more for blue-purple, blue and red modulate if (/*HH> -3.1415f &&*/ HH < -1.5f ) { sathue[0] = 1.3f; //blue sathue[1] = 1.2f; @@ -285,7 +286,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 1.1f ; sathue2[2] = 1.05f; sathue2[3] = 1.0f; - } else if(/*HH>=-1.5f &&*/ HH < -0.7f ) { + } else if (/*HH>=-1.5f &&*/ HH < -0.7f ) { sathue[0] = 1.6f; //blue purple 1.2 1.1 sathue[1] = 1.4f; sathue[2] = 1.3f; @@ -295,7 +296,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 1.15f; sathue2[2] = 1.1f ; sathue2[3] = 1.0f; - } else if(/*HH>=-0.7f &&*/ HH < 0.0f ) { + } else if (/*HH>=-0.7f &&*/ HH < 0.0f ) { sathue[0] = 1.2f; //purple sathue[1] = 1.0f; sathue[2] = 1.0f; @@ -307,7 +308,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[3] = 1.0f; } // else if( HH>= 0.0f && HH<= 1.4f ) {sathue[0]=1.1f;sathue[1]=1.1f;sathue[2]=1.1f;sathue[3]=1.0f ;sathue[4]=0.4f;sathue2[0]=1.0f ;sathue2[1]=1.0f ;sathue2[2]=1.0f ;sathue2[3]=1.0f;}//red 0.8 0.7 - else if(/*HH>= 0.0f &&*/ HH <= 1.4f ) { + else if (/*HH>= 0.0f &&*/ HH <= 1.4f ) { sathue[0] = 1.3f; //red 0.8 0.7 sathue[1] = 1.2f; sathue[2] = 1.1f; @@ -317,7 +318,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 1.0f ; sathue2[2] = 1.0f ; sathue2[3] = 1.0f; - } else if(/*HH> 1.4f &&*/ HH <= 2.1f ) { + } else if (/*HH> 1.4f &&*/ HH <= 2.1f ) { sathue[0] = 1.0f; //green yellow 1.2 1.1 sathue[1] = 1.0f; sathue[2] = 1.0f; @@ -349,7 +350,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 1.1f ; sathue2[2] = 1.05f; sathue2[3] = 1.0f; - } else if(/*HH>=-1.5f &&*/ HH < -0.7f ) { + } else if (/*HH>=-1.5f &&*/ HH < -0.7f ) { sathue[0] = 1.3f; //blue purple 1.2 1.1 sathue[1] = 1.2f; sathue[2] = 1.1f; @@ -359,7 +360,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 1.05f; sathue2[2] = 1.0f ; sathue2[3] = 1.0f; - } else if(/*HH>=-0.7f &&*/ HH < 0.0f ) { + } else if (/*HH>=-0.7f &&*/ HH < 0.0f ) { sathue[0] = 1.2f; //purple sathue[1] = 1.0f; sathue[2] = 1.0f; @@ -371,7 +372,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[3] = 1.0f; } // else if( HH>= 0.0f && HH<= 1.4f ) {sathue[0]=0.8f;sathue[1]=0.8f;sathue[2]=0.8f;sathue[3]=0.8f ;sathue[4]=0.4f;sathue2[0]=0.8f ;sathue2[1]=0.8f ;sathue2[2]=0.8f ;sathue2[3]=0.8f;}//red 0.8 0.7 - else if(/*HH>= 0.0f &&*/ HH <= 1.4f ) { + else if (/*HH>= 0.0f &&*/ HH <= 1.4f ) { sathue[0] = 1.1f; //red 0.8 0.7 sathue[1] = 1.0f; sathue[2] = 0.9f; @@ -381,7 +382,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 0.8f ; sathue2[2] = 0.8f ; sathue2[3] = 0.8f; - } else if(/*HH> 1.4f &&*/ HH <= 2.1f ) { + } else if (/*HH> 1.4f &&*/ HH <= 2.1f ) { sathue[0] = 1.1f; //green yellow 1.2 1.1 sathue[1] = 1.1f; sathue[2] = 1.1f; @@ -414,7 +415,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 1.1f ; sathue2[2] = 1.05f; sathue2[3] = 1.0f; - } else if(/*HH>=-1.5f &&*/ HH < -0.7f ) { + } else if (/*HH>=-1.5f &&*/ HH < -0.7f ) { sathue[0] = 1.3f; //blue purple 1.2 1.1 sathue[1] = 1.2f; sathue[2] = 1.15f; @@ -424,7 +425,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 1.05f; sathue2[2] = 1.0f ; sathue2[3] = 1.0f; - } else if(/*HH>=-0.7f &&*/ HH < 0.0f ) { + } else if (/*HH>=-0.7f &&*/ HH < 0.0f ) { sathue[0] = 1.2f; //purple sathue[1] = 1.0f; sathue[2] = 1.0f ; @@ -436,7 +437,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[3] = 1.0f; } // else if( HH>= 0.0f && HH<= 1.4f ) {sathue[0]=0.8f;sathue[1]=0.8f;sathue[2]=0.8f ;sathue[3]=0.8f ;sathue[4]=0.3f;sathue2[0]=0.8f ;sathue2[1]=0.8f ;sathue2[2]=0.8f ;sathue2[3]=0.8f;}//red 0.8 0.7 - else if(/*HH>= 0.0f &&*/ HH <= 1.4f ) { + else if (/*HH>= 0.0f &&*/ HH <= 1.4f ) { sathue[0] = 1.1f; //red 0.8 0.7 sathue[1] = 1.0f; sathue[2] = 0.9f ; @@ -446,7 +447,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 0.8f ; sathue2[2] = 0.8f ; sathue2[3] = 0.8f; - } else if(/*HH> 1.4f &&*/ HH <= 2.1f ) { + } else if (/*HH> 1.4f &&*/ HH <= 2.1f ) { sathue[0] = 1.3f; //green yellow 1.2 1.1 sathue[1] = 1.2f; sathue[2] = 1.1f ; @@ -478,7 +479,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 0.8f ; sathue2[2] = 0.8f ; sathue2[3] = 0.8f; - } else if(/*HH>=-1.5f &&*/ HH < -0.7f ) { + } else if (/*HH>=-1.5f &&*/ HH < -0.7f ) { sathue[0] = 1.0f; //blue purple 1.2 1.1 sathue[1] = 1.0f; sathue[2] = 0.9f; @@ -488,7 +489,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 0.8f ; sathue2[2] = 0.8f ; sathue2[3] = 0.8f; - } else if(/*HH>=-0.7f &&*/ HH < 0.0f ) { + } else if (/*HH>=-0.7f &&*/ HH < 0.0f ) { sathue[0] = 1.2f; //purple sathue[1] = 1.0f; sathue[2] = 1.0f; @@ -500,7 +501,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[3] = 0.8f; } // else if( HH>= 0.0f && HH<= 1.4f ) {sathue[0]=0.8f;sathue[1]=0.8f;sathue[2]=0.8f;sathue[3]=0.8f;sathue[4]=0.2f;sathue2[0]=0.8f;sathue2[1]=0.8f ;sathue2[2]=0.8f ;sathue2[3]=0.8f;}//red 0.8 0.7 - else if(/*HH>= 0.0f &&*/ HH <= 1.4f ) { + else if (/*HH>= 0.0f &&*/ HH <= 1.4f ) { sathue[0] = 1.1f; //red 0.8 0.7 sathue[1] = 1.0f; sathue[2] = 0.9f; @@ -510,7 +511,7 @@ void ImProcFunctions::vibrance (LabImage* lab) sathue2[1] = 0.8f ; sathue2[2] = 0.8f ; sathue2[3] = 0.8f; - } else if(/*HH> 1.4f &&*/ HH <= 2.1f ) { + } else if (/*HH> 1.4f &&*/ HH <= 2.1f ) { sathue[0] = 1.6f; //green yellow 1.2 1.1 sathue[1] = 1.5f; sathue[2] = 1.4f; @@ -534,7 +535,7 @@ void ImProcFunctions::vibrance (LabImage* lab) } } - float chmodpastel, chmodsat; + float chmodpastel = 0.f, chmodsat = 0.f; // variables to improve transitions float pa, pb;// transition = pa*saturation + pb float chl00 = chromaPastel * satredu * sathue[4]; @@ -585,16 +586,16 @@ void ImProcFunctions::vibrance (LabImage* lab) chmodsat = pa * saturation + pb; } - if(chromaPastel != chromaSatur) { + if (chromaPastel != chromaSatur) { // Pastels - if(saturation > p2 && saturation < limitpastelsatur) { + if (saturation > p2 && saturation < limitpastelsatur) { float newchromaPastel = chromaPastel_a * saturation + chromaPastel_b; chmodpastel = newchromaPastel * satredu * sathue[3]; } // Saturated - if(saturation < s0 && saturation >= limitpastelsatur) { + if (saturation < s0 && saturation >= limitpastelsatur) { float newchromaSatur = chromaSatur_a * saturation + chromaSatur_b; chmodsat = newchromaSatur * satredu * sathue2[0]; } @@ -603,25 +604,25 @@ void ImProcFunctions::vibrance (LabImage* lab) if (saturation <= limitpastelsatur) { if (chmodpastel > 2.0f ) { chmodpastel = 2.0f; //avoid too big values - } else if(chmodpastel < -0.93f) { + } else if (chmodpastel < -0.93f) { chmodpastel = -0.93f; //avoid negative values } Chprov *= (1.0f + chmodpastel); - if(Chprov < 6.0f) { + if (Chprov < 6.0f) { Chprov = 6.0f; } } else { //if (saturation > limitpastelsatur) if (chmodsat > 1.8f ) { chmodsat = 1.8f; //saturated - } else if(chmodsat < -0.93f) { + } else if (chmodsat < -0.93f) { chmodsat = -0.93f; } Chprov *= 1.0f + chmodsat; - if(Chprov < 6.0f) { + if (Chprov < 6.0f) { Chprov = 6.0f; } } @@ -631,15 +632,15 @@ void ImProcFunctions::vibrance (LabImage* lab) bool hhModified = false; // Vibrance's Skin curve - if(skinCurveIsSet) { + if (skinCurveIsSet) { if (HH > skbeg && HH < skend) { - if(Chprov < 60.0f) {//skin hue : todo ==> transition + if (Chprov < 60.0f) { //skin hue : todo ==> transition float HHsk = ask * HH + bsk; float Hn = (skin_curve[HHsk] - bsk) / ask; float Hc = (Hn * xx + HH * (1.0f - xx)); HH = Hc; hhModified = true; - } else if(Chprov < (60.0f + dchr)) { //transition chroma + } else if (Chprov < (60.0f + dchr)) { //transition chroma float HHsk = ask * HH + bsk; float Hn = (skin_curve[HHsk] - bsk) / ask; float Hc = (Hn * xx + HH * (1.0f - xx)); @@ -650,7 +651,7 @@ void ImProcFunctions::vibrance (LabImage* lab) } } //transition hue - else if(HH > (skbeg - dhue) && HH <= skbeg && Chprov < (60.0f + dchr * 0.5f)) { + else if (HH > (skbeg - dhue) && HH <= skbeg && Chprov < (60.0f + dchr * 0.5f)) { float HHsk = ask * skbeg + bsk; float Hn = (skin_curve[HHsk] - bsk) / ask; float Hcc = (Hn * xx + skbeg * (1.0f - xx)); @@ -658,7 +659,7 @@ void ImProcFunctions::vibrance (LabImage* lab) float bdh = Hcc - adh * skbeg; HH = adh * HH + bdh; hhModified = true; - } else if(HH >= skend && HH < (skend + dhue) && Chprov < (60.0f + dchr * 0.5f)) { + } else if (HH >= skend && HH < (skend + dhue) && Chprov < (60.0f + dchr * 0.5f)) { float HHsk = ask * skend + bsk; float Hn = (skin_curve[HHsk] - bsk) / ask; float Hcc = (Hn * xx + skend * (1.0f - xx)); @@ -671,8 +672,8 @@ void ImProcFunctions::vibrance (LabImage* lab) //Munsell correction // float2 sincosval; - if(!avoidcolorshift && hhModified) { - sincosval = xsincosf(HH); + if (!avoidcolorshift && hhModified) { + sincosval = xsincosf (HH); } float aprovn, bprovn; @@ -681,18 +682,18 @@ void ImProcFunctions::vibrance (LabImage* lab) do { inGamut = true; - if(avoidcolorshift) { + if (avoidcolorshift) { float correctionHue = 0.0f; float correctlum = 0.0f; #ifdef _DEBUG - Color::AllMunsellLch(/*lumaMuns*/false, Lprov, Lprov, HH, Chprov, CC, correctionHue, correctlum, MunsDebugInfo); + Color::AllMunsellLch (/*lumaMuns*/false, Lprov, Lprov, HH, Chprov, CC, correctionHue, correctlum, MunsDebugInfo); #else - Color::AllMunsellLch(/*lumaMuns*/false, Lprov, Lprov, HH, Chprov, CC, correctionHue, correctlum); + Color::AllMunsellLch (/*lumaMuns*/false, Lprov, Lprov, HH, Chprov, CC, correctionHue, correctlum); #endif - if(correctionHue != 0.f || hhModified) { - sincosval = xsincosf(HH + correctionHue); + if (correctionHue != 0.f || hhModified) { + sincosval = xsincosf (HH + correctionHue); hhModified = false; } } @@ -703,14 +704,14 @@ void ImProcFunctions::vibrance (LabImage* lab) float fyy = (0.00862069f * Lprov ) + 0.137932f; float fxx = (0.002f * aprovn) + fyy; float fzz = fyy - (0.005f * bprovn); - float xx_ = 65535.f * Color::f2xyz(fxx) * Color::D50x; + float xx_ = 65535.f * Color::f2xyz (fxx) * Color::D50x; // float yy_ = 65535.0f * Color::f2xyz(fyy); - float zz_ = 65535.f * Color::f2xyz(fzz) * Color::D50z; + float zz_ = 65535.f * Color::f2xyz (fzz) * Color::D50z; float yy_ = 65535.f * ((Lprov > Color::epskap) ? fyy * fyy*fyy : Lprov / Color::kappa); - Color::xyz2rgb(xx_, yy_, zz_, R, G, B, wip); + Color::xyz2rgb (xx_, yy_, zz_, R, G, B, wip); - if(R < 0.0f || G < 0.0f || B < 0.0f) { + if (R < 0.0f || G < 0.0f || B < 0.0f) { #ifdef _DEBUG negsat++; #endif @@ -719,7 +720,7 @@ void ImProcFunctions::vibrance (LabImage* lab) } // if "highlight reconstruction" enabled don't control Gamut for highlights - if((!highlight) && (R > 65535.0f || G > 65535.0f || B > 65535.0f)) { + if ((!highlight) && (R > 65535.0f || G > 65535.0f || B > 65535.0f)) { #ifdef _DEBUG moresat++; #endif @@ -740,11 +741,11 @@ void ImProcFunctions::vibrance (LabImage* lab) t2e.set(); if (settings->verbose) { - printf("Vibrance (performed in %d usec):\n", t2e.etime(t1e)); - printf(" Gamut: G1negat=%iiter G165535=%iiter G2negsat=%iiter G265535=%iiter\n", negat, moreRGB, negsat, moresat); + printf ("Vibrance (performed in %d usec):\n", t2e.etime (t1e)); + printf (" Gamut: G1negat=%iiter G165535=%iiter G2negsat=%iiter G265535=%iiter\n", negat, moreRGB, negsat, moresat); if (MunsDebugInfo) { - printf(" Munsell chrominance: MaxBP=%1.2frad MaxRY=%1.2frad MaxGY=%1.2frad MaxRP=%1.2frad depass=%u\n", MunsDebugInfo->maxdhue[0], MunsDebugInfo->maxdhue[1], MunsDebugInfo->maxdhue[2], MunsDebugInfo->maxdhue[3], MunsDebugInfo->depass); + printf (" Munsell chrominance: MaxBP=%1.2frad MaxRY=%1.2frad MaxGY=%1.2frad MaxRP=%1.2frad depass=%u\n", MunsDebugInfo->maxdhue[0], MunsDebugInfo->maxdhue[1], MunsDebugInfo->maxdhue[2], MunsDebugInfo->maxdhue[3], MunsDebugInfo->depass); } } From 01943c1ec70152538b13a7cdc525075b0b1cc5ff Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 13:35:53 +0200 Subject: [PATCH 37/90] Fix all warnings in pixelshift.cc --- rtengine/array2D.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/array2D.h b/rtengine/array2D.h index 8a77bfc3c..c05c739dc 100644 --- a/rtengine/array2D.h +++ b/rtengine/array2D.h @@ -113,7 +113,7 @@ public: // use as empty declaration, resize before use! // very useful as a member object array2D() : - x(0), y(0), owner(0), ptr(nullptr), data(nullptr), lock(0), flags(0) + x(0), y(0), owner(0), flags(0), ptr(nullptr), data(nullptr), lock(0) { //printf("got empty array2D init\n"); } From 21b1a34c24a3729bdfaba40da678bf502bbadceb Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 13:36:17 +0200 Subject: [PATCH 38/90] Fix all warnings in imageio.cc --- rtengine/imageio.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/imageio.cc b/rtengine/imageio.cc index f24842b65..fea072594 100644 --- a/rtengine/imageio.cc +++ b/rtengine/imageio.cc @@ -1245,7 +1245,7 @@ int ImageIO::saveTIFF (Glib::ustring fname, int bps, bool uncompressed) // The maximum lenght is strangely not the same than for the JPEG file... // Which maximum length is the good one ? - if (size > 0 && size <= bufferSize) { + if (size > 0 && size <= static_cast(bufferSize)) { fwrite (buffer, size, 1, file); } From 096bbeaf787d03d464d1b65e52484857c09a23ca Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 14:28:12 +0200 Subject: [PATCH 39/90] Fix all warnings in improcfun.cc --- rtengine/LUT.h | 4 +- rtengine/improcfun.cc | 85 +++++++++++--------------------------- rtengine/impulse_denoise.h | 1 - 3 files changed, 25 insertions(+), 65 deletions(-) diff --git a/rtengine/LUT.h b/rtengine/LUT.h index eb22ff7f9..df95dde7f 100644 --- a/rtengine/LUT.h +++ b/rtengine/LUT.h @@ -599,7 +599,7 @@ public: vint sumv = (vint)ZEROV; vfloat avgv = ZEROV; - for(; i < size - 3; i += 4) { + for(; i < static_cast(size) - 3; i += 4) { vint datav = _mm_loadu_si128((__m128i*)&data[i]); sumv += datav; avgv += iv * _mm_cvtepi32_ps(datav); @@ -611,7 +611,7 @@ public: avg = vhadd(avgv); #endif - for (; i < size; i++) { + for (; i < static_cast(size); i++) { T val = data[i]; sum += val; avg += i * val; diff --git a/rtengine/improcfun.cc b/rtengine/improcfun.cc index 2d9deb10e..6e8f479be 100644 --- a/rtengine/improcfun.cc +++ b/rtengine/improcfun.cc @@ -246,9 +246,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int begh, int endh //end preparate histogram int width = lab->W, height = lab->H; float minQ = 10000.f; - float minM = 10000.f; float maxQ = -1000.f; - float maxM = -1000.f; float w_h; float a_w; float c_; @@ -256,9 +254,9 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int begh, int endh double Yw; Yw = 1.0; double Xw, Zw; - double f, c, nc, yb, la, xw, yw, zw, f2, c2, nc2, yb2, la2; + double f, c, nc, yb = 0., la, xw, yw, zw, f2 = 0., c2 = 0., nc2 = 0., yb2 = 0., la2; double fl, n, nbb, ncb, aw; - double xwd, ywd, zwd; + double xwd = 0., ywd, zwd = 0.; int alg = 0; bool algepd = false; float sum = 0.f; @@ -1199,9 +1197,7 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int begh, int endh float t_l = static_cast(params->dirpyrequalizer.hueskin.value[1]) / 100.0f; float b_r = static_cast(params->dirpyrequalizer.hueskin.value[2]) / 100.0f; float t_r = static_cast(params->dirpyrequalizer.hueskin.value[3]) / 100.0f; - int choice = 0; - bool alread = false; float artifact = (float) settings->artifact_cbdl; if(artifact > 6.f) { @@ -1216,7 +1212,6 @@ void ImProcFunctions::ciecam_02 (CieImage* ncie, double adap, int begh, int endh float chrom = 50.f; { ImProcFunctions::badpixcam (ncie, artifact, 5, 2 , b_l, t_l, t_r, b_r, params->dirpyrequalizer.skinprotect , chrom, hotbad); //enabled remove artifacts for cbDL - alread = true; } } } @@ -1479,7 +1474,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int begh, int float Yw; Yw = 1.0; double Xw, Zw; - float f, nc, yb, la, c, xw, yw, zw, f2, c2, nc2, yb2; + float f, nc, yb = 0.f, la, c, xw, yw, zw, f2, c2 = 1.f, nc2, yb2; float fl, n, nbb, ncb, aw; //d float xwd, ywd, zwd; int alg = 0; @@ -1658,24 +1653,10 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int begh, int // extracting datas from 'params' to avoid cache flush (to be confirmed) const ColorAppearanceParams::eTCModeId curveMode = params->colorappearance.curveMode; const bool hasColCurve1 = bool(customColCurve1); - bool t1L = false; - bool t1B = false; - - if (hasColCurve1 && curveMode == ColorAppearanceParams::TC_MODE_LIGHT) { - t1L = true; - } - - if(hasColCurve1 && curveMode == ColorAppearanceParams::TC_MODE_BRIGHT) { - t1B = true; - } + const bool t1L = hasColCurve1 && curveMode == ColorAppearanceParams::TC_MODE_LIGHT; const ColorAppearanceParams::eTCModeId curveMode2 = params->colorappearance.curveMode2; const bool hasColCurve2 = bool(customColCurve2); - bool t2B = false; - - if(hasColCurve2 && curveMode2 == ColorAppearanceParams::TC_MODE_BRIGHT) { - t2B = true; - } const ColorAppearanceParams::eCTCModeId curveMode3 = params->colorappearance.curveMode3; const bool hasColCurve3 = bool(customColCurve3); @@ -2472,10 +2453,9 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int begh, int // gamut control in Lab mode; I must study how to do with cIECAM only if(gamu == 1) { - float HH, Lprov1, Chprov1; + float Lprov1, Chprov1; Lprov1 = Ll / 327.68f; Chprov1 = sqrtf(SQR(aa) + SQR(bb)) / 327.68f; - HH = xatan2f(bb, aa); float2 sincosval; if(Chprov1 == 0.0f) { @@ -2953,9 +2933,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer BENCHFUN Imagefloat *tmpImage = nullptr; - // NOTE: We're getting all 3 pointers here, but this function may not need them all, so one could optimize this Imagefloat* editImgFloat = nullptr; - LabImage* editLab = nullptr; PlanarWhateverData* editWhatever = nullptr; EditUniqueID editID = pipetteBuffer ? pipetteBuffer->getEditID() : EUID_None; @@ -2966,7 +2944,6 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer break; case (BT_LABIMAGE): - editLab = pipetteBuffer->getLabBuffer(); break; case (BT_SINGLEPLANE_FLOAT): @@ -3274,9 +3251,6 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer tmpImage = new Imagefloat(working->getWidth(), working->getHeight()); } - int W = working->getWidth(); - int H = working->getHeight(); - // For tonecurve histogram int toneCurveHistSize = histToneCurve ? histToneCurve.getSize() : 0; int histToneCurveCompression; @@ -3310,7 +3284,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer int tH; // Allocating buffer for the PipetteBuffer - float *editIFloatTmpR, *editIFloatTmpG, *editIFloatTmpB, *editWhateverTmp; + float *editIFloatTmpR = nullptr, *editIFloatTmpG = nullptr, *editIFloatTmpB = nullptr, *editWhateverTmp = nullptr; if (editImgFloat) { editIFloatBuffer = (char *) malloc(3 * sizeof(float) * TS * TS + 20 * 64 + 63); @@ -3952,7 +3926,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer else if (params->colorToning.method == "Lab" && opautili) { int algm = 0; bool twocol = true;//true=500 color false=2 color - int metchrom; + int metchrom = 0; if (params->colorToning.twocolor == "Std" ) { metchrom = 0; @@ -3968,7 +3942,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer twocol = false; } - float iplow, iphigh; + float iplow = 0.f, iphigh = 0.f; if(!twocol) { iplow = (float)ctColorCurve.low; @@ -5205,8 +5179,6 @@ void ImProcFunctions::toning2col (float r, float g, float b, float &ro, float &g Color::rgb2hsv(r, g, b, h, s, v); float ksat = 1.f; float ksatlow = 1.f; - float s_0 = 0.55f; - float s_1 = 0.85f; /* if(mode==0) {//color if(s < s_0) ksat=SQR((1.f/s_0)*s); @@ -5223,7 +5195,7 @@ void ImProcFunctions::toning2col (float r, float g, float b, float &ro, float &g float aa, bb, cc; //fixed value of reducac =0.4; secondeg_end (reducac, iplow, aa, bb, cc); - float aab, bbb, ccb; + float aab, bbb; secondeg_begin (0.7f, iplow, aab, bbb); @@ -5458,9 +5430,6 @@ SSEFUNCTION void ImProcFunctions::chromiLuminanceCurve (PipetteBuffer *pipetteBu // lhskcurve.dump("lh_curve"); //init Flatcurve for C=f(H) - // NOTE: We're getting all 3 pointers here, but this function may not need them all, so one could optimize this - Imagefloat* editImgFloat = nullptr; - LabImage* editLab = nullptr; PlanarWhateverData* editWhatever = nullptr; EditUniqueID editID = EUID_None; bool editPipette = false; @@ -5473,11 +5442,9 @@ SSEFUNCTION void ImProcFunctions::chromiLuminanceCurve (PipetteBuffer *pipetteBu switch (pipetteBuffer->getDataProvider()->getCurrSubscriber()->getPipetteBufferType()) { case (BT_IMAGEFLOAT): - editImgFloat = pipetteBuffer->getImgFloatBuffer(); break; case (BT_LABIMAGE): - editLab = pipetteBuffer->getLabBuffer(); break; case (BT_SINGLEPLANE_FLOAT): @@ -6404,7 +6371,6 @@ void ImProcFunctions::EPDToneMapCIE(CieImage *ncie, float a_w, float c_, float w float sca = params->epd.scale; float gamm = params->epd.gamma; float rew = params->epd.reweightingIterates; - unsigned int i, N = Wid * Hei; float Qpro = ( 4.0 / c_) * ( a_w + 4.0 ) ; //estimate Q max if J=100.0 float *Qpr = ncie->Q_p[0]; @@ -6519,7 +6485,7 @@ void ImProcFunctions::EPDToneMap(LabImage *lab, unsigned int Iterates, int skip) float *L = lab->L[0]; float *a = lab->a[0]; float *b = lab->b[0]; - unsigned int i, N = lab->W * lab->H; + size_t N = lab->W * lab->H; EdgePreservingDecomposition epd(lab->W, lab->H); //Due to the taking of logarithms, L must be nonnegative. Further, scale to 0 to 1 using nominal range of L, 0 to 15 bit. @@ -6531,7 +6497,7 @@ void ImProcFunctions::EPDToneMap(LabImage *lab, unsigned int Iterates, int skip) float lmaxL = 0.f; #pragma omp for - for(i = 0; i < N; i++) { + for(size_t i = 0; i < N; i++) { if(L[i] < lminL) { lminL = L[i]; } @@ -6542,15 +6508,15 @@ void ImProcFunctions::EPDToneMap(LabImage *lab, unsigned int Iterates, int skip) } #pragma omp critical + { + if(lminL < minL) { + minL = lminL; + } - if(lminL < minL) { - minL = lminL; + if(lmaxL > maxL) { + maxL = lmaxL; + } } - - if(lmaxL > maxL) { - maxL = lmaxL; - } - } if(minL > 0.0f) { @@ -6559,7 +6525,7 @@ void ImProcFunctions::EPDToneMap(LabImage *lab, unsigned int Iterates, int skip) #pragma omp parallel for - for(i = 0; i < N; i++) + for(size_t i = 0; i < N; ++i) //{L[i] = (L[i] - minL)/32767.0f; { L[i] = (L[i] - minL) / maxL; @@ -6594,7 +6560,7 @@ void ImProcFunctions::EPDToneMap(LabImage *lab, unsigned int Iterates, int skip) #pragma omp parallel for // removed schedule(dynamic,10) #endif - for(int ii = 0; ii < N; ii++) { + for(size_t ii = 0; ii < N; ++ii) { a[ii] *= s; b[ii] *= s; L[ii] = L[ii] * maxL * (1.f / gamm) + minL; @@ -6730,7 +6696,7 @@ void ImProcFunctions::getAutoExp (const LUTu &histogram, int histcompr, double // compute clipping points based on the original histograms (linear, without exp comp.) - int clipped = 0; + unsigned int clipped = 0; int rawmax = (imax) - 1; while (histogram[rawmax] + clipped <= 0 && rawmax > 1) { @@ -6739,17 +6705,15 @@ void ImProcFunctions::getAutoExp (const LUTu &histogram, int histcompr, double } //compute clipped white point - int clippable = (int)(sum * clip / 100.f ); - int somm = sum; + unsigned int clippable = (int)(sum * clip / 100.f ); clipped = 0; int whiteclip = (imax) - 1; - while (whiteclip > 1 && histogram[whiteclip] + clipped <= clippable) { + while (whiteclip > 1 && (histogram[whiteclip] + clipped) <= clippable) { clipped += histogram[whiteclip]; whiteclip--; } - int clipwh = clipped; //compute clipped black point clipped = 0; int shc = 0; @@ -6759,8 +6723,6 @@ void ImProcFunctions::getAutoExp (const LUTu &histogram, int histcompr, double shc++; } - int clipbl = clipped; - //rescale to 65535 max rawmax <<= histcompr; whiteclip <<= histcompr; @@ -6776,7 +6738,6 @@ void ImProcFunctions::getAutoExp (const LUTu &histogram, int histcompr, double //compute exposure compensation as geometric mean of the amount that //sets the mean or median at middle gray, and the amount that sets the estimated top //of the histogram at or near clipping. - float expo = log(midgray * scale / (ave - shc + midgray * shc)); //float expcomp1 = (log(/*(median/ave)*//*(hidev/lodev)*/midgray*scale/(ave-shc+midgray*shc))+log((hidev/lodev)))/log(2.f); float expcomp1 = (log(/*(median/ave)*//*(hidev/lodev)*/midgray * scale / (ave - shc + midgray * shc))) / log(2.f); float expcomp2; diff --git a/rtengine/impulse_denoise.h b/rtengine/impulse_denoise.h index 9d3b73b79..a40577f39 100644 --- a/rtengine/impulse_denoise.h +++ b/rtengine/impulse_denoise.h @@ -82,7 +82,6 @@ SSEFUNCTION void ImProcFunctions::impulse_nr (LabImage* lab, double thresh) #ifdef __SSE2__ vfloat hfnbravev, hpfabsv; vfloat impthrDiv24v = F2V( impthrDiv24 ); - vfloat onev = F2V( 1.0f ); #endif #ifdef _OPENMP #pragma omp for From 20472d3e69555901ed7da9e024b07cfda18ad151 Mon Sep 17 00:00:00 2001 From: Desmis Date: Fri, 31 Mar 2017 14:56:36 +0200 Subject: [PATCH 40/90] edgepresdecomposition Ftblockdn previewimage and all files checked without change --- rtengine/EdgePreservingDecomposition.cc | 8 ++++---- rtengine/FTblockDN.cc | 12 ++++++------ rtengine/previewimage.cc | 2 +- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/rtengine/EdgePreservingDecomposition.cc b/rtengine/EdgePreservingDecomposition.cc index 7bc292c3f..43a68f024 100644 --- a/rtengine/EdgePreservingDecomposition.cc +++ b/rtengine/EdgePreservingDecomposition.cc @@ -21,7 +21,7 @@ Takes less memory with OkToModify_b = true, and Preconditioner = nullptr. */ float *SparseConjugateGradient(void Ax(float *Product, float *x, void *Pass), float *b, int n, bool OkToModify_b, float *x, float RMSResidual, void *Pass, int MaximumIterates, void Preconditioner(float *Product, float *x, void *Pass)) { - int iterate, i; + int iterate; float* buffer = (float*)malloc(2 * n * sizeof(float) + 128); float *r = (buffer + 16); @@ -411,7 +411,7 @@ bool MultiDiagonalSymmetricMatrix::CreateIncompleteCholeskyFactorization(int Max //How many diagonals in the decomposition? MaxFillAbove++; //Conceptually, now "fill" includes an existing diagonal. Simpler in the math that follows. - int i, j, mic, fp; + int j, mic, fp; mic = 1; fp = 1; @@ -441,8 +441,8 @@ bool MultiDiagonalSymmetricMatrix::CreateIncompleteCholeskyFactorization(int Max } //It's all initialized? Uhkay. Do the actual math then. - int sss, ss; - int MaxStartRow = StartRows[m - 1]; //Handy number. + int sss; + // int MaxStartRow = StartRows[m - 1]; //Handy number. float **l = ic->Diagonals; float *d = ic->Diagonals[0]; //Describes D in LDLt. int icm = ic->m; diff --git a/rtengine/FTblockDN.cc b/rtengine/FTblockDN.cc index d075ec5bc..abcb896ad 100644 --- a/rtengine/FTblockDN.cc +++ b/rtengine/FTblockDN.cc @@ -125,7 +125,7 @@ void ImProcFunctions::Median_Denoise(float **src, float **dst, const int width, medBuffer[1] = dst; } - float ** medianIn, ** medianOut; + float ** medianIn, ** medianOut = nullptr; int BufferIndex = 0; for (int iteration = 1; iteration <= iterations; ++iteration) { @@ -454,10 +454,10 @@ SSEFUNCTION void ImProcFunctions::RGB_denoise(int kall, Imagefloat * src, Imagef const bool useNoiseLCurve = (noiseLCurve && noiseLCurve.getSum() >= 7.f); const bool autoch = (settings->leveldnautsimpl == 1 && (dnparams.Cmethod == "AUT" || dnparams.Cmethod == "PRE")) || (settings->leveldnautsimpl == 0 && (dnparams.C2method == "AUTO" || dnparams.C2method == "PREV")); - float** lumcalc; - float* lumcalcBuffer; - float** ccalc; - float* ccalcBuffer; + float** lumcalc = nullptr; + float* lumcalcBuffer = nullptr; + float** ccalc = nullptr; + float* ccalcBuffer = nullptr; bool ponder = false; float ponderCC = 1.f; @@ -518,7 +518,7 @@ SSEFUNCTION void ImProcFunctions::RGB_denoise(int kall, Imagefloat * src, Imagef ccalc[i] = ccalcBuffer + (i * wid); } - float cn100Precalc; + float cn100Precalc = 0.f; if (useNoiseCCurve) { cn100Precalc = SQR(1.f + ponderCC * (4.f * noiseCCurve[100.f / 60.f])); diff --git a/rtengine/previewimage.cc b/rtengine/previewimage.cc index 891186d8a..4d0fd59b6 100644 --- a/rtengine/previewimage.cc +++ b/rtengine/previewimage.cc @@ -141,7 +141,7 @@ PreviewImage::PreviewImage (const Glib::ustring &fname, const Glib::ustring &ext if (data) { int w, h; - double scale = 1.; + // double scale = 1.; w = output->getWidth(); h = output->getHeight(); previewImage = Cairo::ImageSurface::create(Cairo::FORMAT_RGB24, w, h); From fd32727a77630cb5874e7b783ca18373a921e52d Mon Sep 17 00:00:00 2001 From: Desmis Date: Fri, 31 Mar 2017 15:23:06 +0200 Subject: [PATCH 41/90] fixed warning in ipwavelet.cc --- rtengine/ipwavelet.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rtengine/ipwavelet.cc b/rtengine/ipwavelet.cc index 882dd8cdc..8ab7e0b4d 100644 --- a/rtengine/ipwavelet.cc +++ b/rtengine/ipwavelet.cc @@ -250,7 +250,7 @@ SSEFUNCTION void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int cp.edgampl = (float) params->wavelet.edgeampli; } - int N = imheight * imwidth; + //int N = imheight * imwidth; int maxmul = params->wavelet.thres; cp.maxilev = maxmul; static const float scales[10] = {1.f, 2.f, 4.f, 8.f, 16.f, 32.f, 64.f, 128.f, 256.f, 512.f}; @@ -2597,7 +2597,7 @@ void ImProcFunctions::ContAllL (float *koeLi[12], float *maxkoeLi, bool lipschit float bedstr = 1.f - 10.f * aedstr; if(cp.val > 0 && cp.edgeena) { - float * koe; + float * koe = nullptr; float maxkoe = 0.f; if(!lipschitz) { @@ -2766,7 +2766,7 @@ void ImProcFunctions::ContAllL (float *koeLi[12], float *maxkoeLi, bool lipschit float asig = 0.166f / sigma[level]; float bsig = 0.5f - asig * mean[level]; float amean = 0.5f / mean[level]; - float absciss; + float absciss = 0.f; float kinterm; float kmul; int borderL = 1; From 7fca8c16eebb03bfec38f622372954400a352aa5 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 15:33:17 +0200 Subject: [PATCH 42/90] Fix all warnings in rawimagesource.cc --- rtengine/rawimagesource.cc | 60 ++++++++++++++++++++------------------ 1 file changed, 32 insertions(+), 28 deletions(-) diff --git a/rtengine/rawimagesource.cc b/rtengine/rawimagesource.cc index 4aaacd4b0..9170628e0 100644 --- a/rtengine/rawimagesource.cc +++ b/rtengine/rawimagesource.cc @@ -425,25 +425,6 @@ RawImageSource::RawImageSource () : ImageSource() , W(0), H(0) , plistener(nullptr) - , border(4) - , ri(nullptr) - , cache(nullptr) - , rawData(0, 0) - , green(0, 0) - , red(0, 0) - , blue(0, 0) - , lc00(0.0) - , lc01(0.0) - , lc02(0.0) - , lc10(0.0) - , lc11(0.0) - , lc12(0.0) - , lc20(0.0) - , lc21(0.0) - , lc22(0.0) - , hlmax{} - , clmax{} - , chmax{} , scale_mul{} , c_black{} , c_white{} @@ -458,10 +439,29 @@ RawImageSource::RawImageSource () , cam_xyz{} , fuji(false) , d1x(false) + , border(4) + , chmax{} + , hlmax{} + , clmax{} , initialGain(0.0) , camInitialGain(0.0) , defGain(0.0) + , ri(nullptr) + , lc00(0.0) + , lc01(0.0) + , lc02(0.0) + , lc10(0.0) + , lc11(0.0) + , lc12(0.0) + , lc20(0.0) + , lc21(0.0) + , lc22(0.0) + , cache(nullptr) , threshold(0) + , rawData(0, 0) + , green(0, 0) + , red(0, 0) + , blue(0, 0) { camProfile = nullptr; embProfile = nullptr; @@ -748,7 +748,7 @@ void RawImageSource::getImage (const ColorTemp &ctemp, int tran, Imagefloat* ima if (ri->getSensorType() == ST_BAYER || ri->getSensorType() == ST_FUJI_XTRANS || ri->get_colors() == 1) { for (int j = 0, jx = sx1; j < imwidth; j++, jx += skip) { - jx = jx >= (maxx - skip) ? jx = maxx - skip - 1 : jx; // avoid trouble + jx = std::min(jx, maxx - skip - 1); // avoid trouble float rtot = 0.f, gtot = 0.f, btot = 0.f; @@ -896,6 +896,11 @@ void RawImageSource::getImage (const ColorTemp &ctemp, int tran, Imagefloat* ima case ST_FUJI_XTRANS: processFalseColorCorrection (image, raw.xtranssensor.ccSteps); + break; + + case ST_FOVEON: + case ST_NONE: + break; } } } @@ -1169,8 +1174,7 @@ int RawImageSource::interpolateBadPixelsXtrans( PixelsMap &bitmapBads ) } float wtdsum = 0.f, norm = 0.f; - int pixelColor = ri->XTRANSFC(row, col); - float oldval = rawData[row][col]; + unsigned int pixelColor = ri->XTRANSFC(row, col); if(pixelColor == 1) { // green channel. A green pixel can either be a solitary green pixel or a member of a 2x2 square of green pixels @@ -1782,7 +1786,7 @@ void RawImageSource::preprocess (const RAWParams &raw, const LensProfParams &le if(numFrames == 4) { int bufferNumber = 0; - for(int i=0; i<4; ++i) { + for(unsigned int i=0; i<4; ++i) { if(i==currFrame) { copyOriginalPixels(raw, ri, rid, rif, rawData); rawDataFrames[i] = &rawData; @@ -2840,7 +2844,7 @@ void RawImageSource::processFlatField(const RAWParams &raw, RawImage *riFlatFile float limitFactor = 1.f; if(raw.ff_AutoClipControl) { - int clipControlGui = 0; +// int clipControlGui = 0; for (int m = 0; m < 2; m++) for (int n = 0; n < 2; n++) { @@ -2885,7 +2889,7 @@ void RawImageSource::processFlatField(const RAWParams &raw, RawImage *riFlatFile } } - clipControlGui = (1.f - limitFactor) * 100.f; // this value can be used to set the clip control slider in gui +// clipControlGui = (1.f - limitFactor) * 100.f; // this value can be used to set the clip control slider in gui } else { limitFactor = max((float)(100 - raw.ff_clipControl) / 100.f, 0.01f); } @@ -5019,7 +5023,7 @@ ColorTemp RawImageSource::getSpotWB (std::vector &red, std::vectorgetSensorType() != ST_BAYER) { if(ri->getSensorType() == ST_FUJI_XTRANS) { @@ -5210,7 +5214,7 @@ ColorTemp RawImageSource::getSpotWB (std::vector &red, std::vector cInversePoints; cInversePoints.push_back(double(DCT_Spline)); // The first value is the curve type - for (int i = 0; i < sizeof(phase_one_forward) / sizeof(phase_one_forward[0]); i += 2) { + for (unsigned int i = 0; i < sizeof(phase_one_forward) / sizeof(phase_one_forward[0]); i += 2) { cForwardPoints.push_back(phase_one_forward[i + 0]); cForwardPoints.push_back(phase_one_forward[i + 1]); cInversePoints.push_back(phase_one_forward[i + 1]); From 071d960035696b643c44a645e416d7f25b90ce8f Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 19:07:58 +0200 Subject: [PATCH 43/90] Fix all warnings in demosaic_algos.cc --- rtengine/dcraw.cc | 4 +-- rtengine/dcraw.h | 3 +- rtengine/demosaic_algos.cc | 64 ++++++++++++++++++-------------------- rtengine/rawimage.cc | 2 +- rtengine/rawimage.h | 2 +- 5 files changed, 37 insertions(+), 38 deletions(-) diff --git a/rtengine/dcraw.cc b/rtengine/dcraw.cc index ec54b9fcf..4beec664d 100644 --- a/rtengine/dcraw.cc +++ b/rtengine/dcraw.cc @@ -5897,7 +5897,7 @@ int CLASS parse_tiff_ifd (int base) break; case 33422: /* CFAPattern */ if (filters == 9) { - FORC(36) ((char *)xtrans)[c] = fgetc(ifp) & 3; + FORC(36) ((int *)xtrans)[c] = fgetc(ifp) & 3; break; } case 64777: /* Kodak P-series */ @@ -9020,7 +9020,7 @@ canon_a5: } if (fuji_layout) raw_width *= is_raw; if (filters == 9) - FORC(36) ((char *)xtrans)[c] = + FORC(36) ((int *)xtrans)[c] = xtrans_abs[(c/6+top_margin) % 6][(c+left_margin) % 6]; } else if (!strcmp(model,"KD-400Z")) { height = 1712; diff --git a/rtengine/dcraw.h b/rtengine/dcraw.h index 3c5719db8..c0502ae5d 100644 --- a/rtengine/dcraw.h +++ b/rtengine/dcraw.h @@ -76,7 +76,8 @@ protected: FILE *ofp; short order; const char *ifname; - char *meta_data, xtrans[6][6],xtrans_abs[6][6]; + char *meta_data; + int xtrans[6][6],xtrans_abs[6][6]; char cdesc[5], desc[512], make[64], model[64], model2[64], model3[64], artist[64]; float flash_used, canon_ev, iso_speed, shutter, aperture, focal_len; time_t timestamp; diff --git a/rtengine/demosaic_algos.cc b/rtengine/demosaic_algos.cc index 877df35a4..7896219e5 100644 --- a/rtengine/demosaic_algos.cc +++ b/rtengine/demosaic_algos.cc @@ -1,4 +1,3 @@ -/* /* * This file is part of RawTherapee. * @@ -602,7 +601,7 @@ void RawImageSource::vng4_demosaic () const unsigned prefilters = ri->prefilters; const int width = W, height = H; - const int colors = 4; + constexpr unsigned int colors = 4; float (*image)[4]; image = (float (*)[4]) calloc (height * width, sizeof * image); @@ -648,7 +647,7 @@ void RawImageSource::vng4_demosaic () int colcount = 0; - for (int c = 0; c < colors; c++) + for (unsigned int c = 0; c < colors; c++) if (c != fc(row, col)) { *ip++ = c; csum[row][col][colcount] = sum[c]; @@ -671,7 +670,7 @@ void RawImageSource::vng4_demosaic () sum[ip[1]] += pix[ip[0]] * mul[row & 15][col & 15][i]; } - for (int i = 0; i < colors - 1; i++, ip++) { + for (unsigned int i = 0; i < colors - 1; i++, ip++) { pix[ip[0]] = sum[ip[0]] / csum[row & 15][col & 15][i]; } } @@ -694,7 +693,7 @@ void RawImageSource::vng4_demosaic () int x2 = *cp++; int weight = *cp++; int grads = *cp++; - int color = fc(row + y1, col + x1); + unsigned int color = fc(row + y1, col + x1); if (fc(row + y2, col + x2) != color) { continue; @@ -724,7 +723,7 @@ void RawImageSource::vng4_demosaic () int y = *cp++; int x = *cp++; *ip++ = (y * width + x) * 4; - int color = fc(row, col); + unsigned int color = fc(row, col); if (fc(row + y, col + x) != color && fc(row + y * 2, col + x * 2) == color) { *ip++ = (y * width + x) * 8 + color; @@ -878,7 +877,7 @@ void RawImageSource::vng4_demosaic () #define fc(row,col) \ (ri->get_filters() >> ((((row) << 1 & 14) + ((col) & 1)) << 1) & 3) -#define FORCC for (int c=0; c < colors; c++) +#define FORCC for (unsigned int c=0; c < colors; c++) /* Patterned Pixel Grouping Interpolation by Alain Desbiolles @@ -887,7 +886,7 @@ void RawImageSource::ppg_demosaic() { int width = W, height = H; int dir[5] = { 1, width, -1, -width, 1 }; - int row, col, diff[2], guess[2], c, d, i; + int row, col, diff[2] = {}, guess[2], c, d, i; float (*pix)[4]; float (*image)[4]; @@ -998,7 +997,7 @@ void RawImageSource::ppg_demosaic() void RawImageSource::border_interpolate(unsigned int border, float (*image)[4], unsigned int start, unsigned int end) { - unsigned row, col, y, x, f, c, sum[8]; + unsigned row, col, y, x, f, sum[8]; unsigned int width = W, height = H; unsigned int colors = 3; @@ -1338,7 +1337,7 @@ SSEFUNCTION void RawImageSource::lmmse_interpolate_omp(int winw, int winh, array h2 /= hs; h3 /= hs; h4 /= hs; - int passref; + int passref = 0; int iter; if(iterations <= 4) { @@ -2631,7 +2630,7 @@ void RawImageSource::ahd_demosaic(int winx, int winy, int winw, int winh) int width = W, height = H; float (*image)[4]; - int colors = 3; + unsigned int colors = 3; const double xyz_rgb[3][3] = { /* XYZ from RGB */ { 0.412453, 0.357580, 0.180423 }, @@ -2661,7 +2660,7 @@ void RawImageSource::ahd_demosaic(int winx, int winy, int winw, int winh) } for (i = 0; i < 3; i++) - for (j = 0; j < colors; j++) + for (unsigned int j = 0; j < colors; j++) for (xyz_cam[i][j] = k = 0; k < 3; k++) { xyz_cam[i][j] += xyz_rgb[i][k] * imatrices.rgb_cam[k][j] / d65_white[i]; } @@ -3293,12 +3292,12 @@ void RawImageSource::fill_raw( float (*cache )[3], int x0, int y0, float** rawDa void RawImageSource::fill_border( float (*cache )[3], int border, int x0, int y0) { - unsigned row, col, y, x, f, c; + unsigned f; float sum[8]; - const unsigned int colors = 3; // used in FORCC + constexpr unsigned int colors = 3; // used in FORCC - for (row = y0; row < y0 + TILESIZE + TILEBORDER && row < H; row++) { - for (col = x0; col < x0 + TILESIZE + TILEBORDER && col < W; col++) { + for (int row = y0; row < y0 + TILESIZE + TILEBORDER && row < H; row++) { + for (int col = x0; col < x0 + TILESIZE + TILEBORDER && col < W; col++) { if (col >= border && col < W - border && row >= border && row < H - border) { col = W - border; @@ -3309,8 +3308,8 @@ void RawImageSource::fill_border( float (*cache )[3], int border, int x0, int y0 memset(sum, 0, sizeof sum); - for (y = row - 1; y != row + 2; y++) - for (x = col - 1; x != col + 2; x++) + for (int y = row - 1; y != row + 2; y++) + for (int x = col - 1; x != col + 2; x++) if (y < H && y < y0 + TILESIZE + TILEBORDER && x < W && x < x0 + TILESIZE + TILEBORDER) { f = fc(y, x); sum[f] += cache[(y - y0 + TILEBORDER) * CACHESIZE + TILEBORDER + x - x0][f]; @@ -3361,13 +3360,13 @@ void RawImageSource::restore_from_buffer(float (*image)[3], float (*buffer)[2]) void RawImageSource::dcb_hid(float (*image)[3], int x0, int y0) { const int u = CACHESIZE; - int rowMin, colMin, rowMax, colMax, c; + int rowMin, colMin, rowMax, colMax; dcb_initTileLimits(colMin, rowMin, colMax, rowMax, x0, y0, 2); // simple green bilinear in R and B pixels for (int row = rowMin; row < rowMax; row++) - for (int col = colMin + (FC(y0 - TILEBORDER + row, x0 - TILEBORDER + colMin) & 1), indx = row * CACHESIZE + col, c = FC(y0 - TILEBORDER + row, x0 - TILEBORDER + col); col < colMax; col += 2, indx += 2) { - assert(indx - u - 1 >= 0 && indx + u + 1 < u * u && c >= 0 && c < 3); + for (int col = colMin + (FC(y0 - TILEBORDER + row, x0 - TILEBORDER + colMin) & 1), indx = row * CACHESIZE + col; col < colMax; col += 2, indx += 2) { + assert(indx - u - 1 >= 0 && indx + u + 1 < u * u); image[indx][1] = 0.25*(image[indx-1][1]+image[indx+1][1]+image[indx-u][1]+image[indx+u][1]); } @@ -3418,13 +3417,13 @@ void RawImageSource::dcb_color(float (*image)[3], int x0, int y0) // green correction void RawImageSource::dcb_hid2(float (*image)[3], int x0, int y0) { - const int u = CACHESIZE, v = 2 * CACHESIZE; + const int v = 2 * CACHESIZE; int rowMin, colMin, rowMax, colMax; dcb_initTileLimits(colMin, rowMin, colMax, rowMax, x0, y0, 2); for (int row = rowMin; row < rowMax; row++) { for (int col = colMin + (FC(y0 - TILEBORDER + row, x0 - TILEBORDER + colMin) & 1), indx = row * CACHESIZE + col, c = FC(y0 - TILEBORDER + row, x0 - TILEBORDER + col); col < colMax; col += 2, indx += 2) { - assert(indx - v >= 0 && indx + v < u * u); + assert(indx - v >= 0 && indx + v < CACHESIZE * CACHESIZE); //Jacek comment: one multiplication less image[indx][1] = image[indx][c] + @@ -3592,11 +3591,11 @@ void RawImageSource::dcb_correction2(float (*image)[3], uint8_t *map, int x0, in // image refinement void RawImageSource::dcb_refinement(float (*image)[3], uint8_t *map, int x0, int y0) { - const int u = CACHESIZE, v = 2 * CACHESIZE, w = 3 * CACHESIZE; + const int u = CACHESIZE, v = 2 * CACHESIZE; int rowMin, colMin, rowMax, colMax; dcb_initTileLimits(colMin, rowMin, colMax, rowMax, x0, y0, 4); - float f0, f1, f2, g1, h0, h1, h2, g2, current; + float f0, f1, f2, g1, h0, h1, h2, g2; for (int row = rowMin; row < rowMax; row++) for (int col = colMin + (FC(y0 - TILEBORDER + row, x0 - TILEBORDER + colMin) & 1), indx = row * CACHESIZE + col, c = FC(y0 - TILEBORDER + row, x0 - TILEBORDER + col); col < colMax; col += 2, indx += 2) { @@ -3937,7 +3936,7 @@ void RawImageSource::xtransborder_interpolate (int border) { const int height = H, width = W; - char xtrans[6][6]; + int xtrans[6][6]; ri->getXtransMatrix(xtrans); for (int row = 0; row < height; row++) @@ -4001,7 +4000,7 @@ void RawImageSource::xtrans_interpolate (const int passes, const bool useCieLab) plistener->setProgress (progress); } - char xtrans[6][6]; + int xtrans[6][6]; ri->getXtransMatrix(xtrans); constexpr short orth[12] = { 1, 0, 0, 1, -1, 0, 0, -1, 1, 0, 0, 1 }, @@ -4721,17 +4720,16 @@ void RawImageSource::xtrans_interpolate (const int passes, const bool useCieLab) /* Average the most homogeneous pixels for the final result: */ - uint8_t hm[8]; + uint8_t hm[8] = {}; for (int row = MIN(top, 8); row < mrow - 8; row++) for (int col = MIN(left, 8); col < mcol - 8; col++) { - int d = 0; - for (; d < 4; d++) { + for (int d = 0; d < 4; d++) { hm[d] = homosum[d][row][col]; } - for (; d < ndir; d++) { + for (int d = 4; d < ndir; d++) { hm[d] = homosum[d][row][col]; if (hm[d - 4] < hm[d]) { @@ -4745,7 +4743,7 @@ void RawImageSource::xtrans_interpolate (const int passes, const bool useCieLab) uint8_t maxval = homosummax[row][col]; - for (d = 0; d < ndir; d++) + for (int d = 0; d < ndir; d++) if (hm[d] >= maxval) { FORC3 avg[c] += rgb[d][row][col][c]; avg[3]++; @@ -4792,7 +4790,7 @@ void RawImageSource::fast_xtrans_interpolate () const int height = H, width = W; xtransborder_interpolate (1); - char xtrans[6][6]; + int xtrans[6][6]; ri->getXtransMatrix(xtrans); #pragma omp parallel for diff --git a/rtengine/rawimage.cc b/rtengine/rawimage.cc index f3252b06b..8ec59b957 100644 --- a/rtengine/rawimage.cc +++ b/rtengine/rawimage.cc @@ -779,7 +779,7 @@ RawImage::is_ppmThumb() const !thumb_load_raw ); } -void RawImage::getXtransMatrix( char XtransMatrix[6][6]) +void RawImage::getXtransMatrix( int XtransMatrix[6][6]) { for(int row = 0; row < 6; row++) for(int col = 0; col < 6; col++) { diff --git a/rtengine/rawimage.h b/rtengine/rawimage.h index 3f4307054..d9d5a71b8 100644 --- a/rtengine/rawimage.h +++ b/rtengine/rawimage.h @@ -180,7 +180,7 @@ public: eSensorType getSensorType(); void getRgbCam (float rgbcam[3][4]); - void getXtransMatrix ( char xtransMatrix[6][6]); + void getXtransMatrix ( int xtransMatrix[6][6]); void clearXtransCblack( ) { for(int c = 0; c < 4; c++) { From 1fb2aa0cde8f535cb8ff66038f175dfa7a51a851 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 19:12:13 +0200 Subject: [PATCH 44/90] Fix all warnings in fast_demo.cc --- rtengine/fast_demo.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/rtengine/fast_demo.cc b/rtengine/fast_demo.cc index d5bca20b9..12286d9f1 100644 --- a/rtengine/fast_demo.cc +++ b/rtengine/fast_demo.cc @@ -277,7 +277,6 @@ SSEFUNCTION void RawImageSource::fast_demosaic(int winx, int winy, int winw, int int j, cc; __m128 wtuv, wtdv, wtlv, wtrv; __m128 greenv, tempv, absv, abs2v; - __m128 onev = _mm_set1_ps( 1.0f ); __m128 c16v = _mm_set1_ps( 16.0f ); __m128 fourv = _mm_set1_ps( 4.0f ); vmask selmask; From a04fc0dc2f85089bfc9567d1328d02490e67616d Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 19:17:38 +0200 Subject: [PATCH 45/90] Fix all warnings in CA_correct_RT.cc --- rtengine/CA_correct_RT.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/rtengine/CA_correct_RT.cc b/rtengine/CA_correct_RT.cc index fc9967619..8471a1393 100644 --- a/rtengine/CA_correct_RT.cc +++ b/rtengine/CA_correct_RT.cc @@ -241,7 +241,6 @@ void RawImageSource::CA_correct_RT(const bool autoCA, const double cared, const for (int row = rr + top, cc = ccmin; cc < ccmax; cc++) { int col = cc + left; int c = FC(rr, cc); - int indx = row * width + col; int indx1 = rr * ts + cc; rgb[c][indx1] = (rawData[row][col]) / 65535.0f; } @@ -966,10 +965,9 @@ void RawImageSource::CA_correct_RT(const bool autoCA, const double cared, const // copy CA corrected results to temporary image matrix for (int rr = border; rr < rr1 - border; rr++) { - int c = FC(rr + top, left + border + FC(rr + top, 2) & 1); + int c = FC(rr + top, left + border + (FC(rr + top, 2) & 1)); for (int row = rr + top, cc = border + (FC(rr, 2) & 1), indx = (row * width + cc + left) >> 1; cc < cc1 - border; cc += 2, indx++) { - int col = cc + left; RawDataTmp[indx] = 65535.0f * rgb[c][(rr) * ts + cc] + 0.5f; } } From 975330fb97d27c96956b172fc5acd1b3e59e20d1 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 19:31:19 +0200 Subject: [PATCH 46/90] Fix all warnings in myfile.cc --- rtengine/myfile.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/myfile.cc b/rtengine/myfile.cc index 11a5b495b..09d9cd48f 100644 --- a/rtengine/myfile.cc +++ b/rtengine/myfile.cc @@ -364,7 +364,7 @@ int fscanf (IMFILE* f, const char* s ...) char buf[50], *endptr = nullptr; int copy_sz = f->size - f->pos; - if (copy_sz > sizeof(buf)) { + if (copy_sz > static_cast(sizeof(buf))) { copy_sz = sizeof(buf) - 1; } From 86ccc4b96866941aa0718fa96f87926fde83bca4 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 19:50:27 +0200 Subject: [PATCH 47/90] rtengine/dcrop.cc --- rtengine/dcrop.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/rtengine/dcrop.cc b/rtengine/dcrop.cc index 7b4862ea0..0bc6ce82a 100644 --- a/rtengine/dcrop.cc +++ b/rtengine/dcrop.cc @@ -806,7 +806,6 @@ void Crop::update (int todo) bool wavcontlutili = parent->wavcontlutili; LUTu dummy; - int moderetinex; // parent->ipf.MSR(labnCrop, labnCrop->W, labnCrop->H, 1); parent->ipf.chromiLuminanceCurve (this, 1, labnCrop, labnCrop, parent->chroma_acurve, parent->chroma_bcurve, parent->satcurve, parent->lhskcurve, parent->clcurve, parent->lumacurve, utili, autili, butili, ccutili, cclutili, clcutili, dummy, dummy); parent->ipf.vibrance (labnCrop); From a6ba054a712435c37d726993d3ea0fa7828c2e3e Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 20:09:11 +0200 Subject: [PATCH 48/90] Fix all warnings in improccoordinator.cc --- rtengine/improccoordinator.cc | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/rtengine/improccoordinator.cc b/rtengine/improccoordinator.cc index 179947948..5aa70e75d 100644 --- a/rtengine/improccoordinator.cc +++ b/rtengine/improccoordinator.cc @@ -38,7 +38,6 @@ ImProcCoordinator::ImProcCoordinator () softProof(false), gamutCheck(false), scale(10), highDetailPreprocessComputed(false), highDetailRawComputed(false), allocated(false), bwAutoR(-9000.f), bwAutoG(-9000.f), bwAutoB(-9000.f), CAMMean(NAN), - ctColorCurve(), hltonecurve(65536), shtonecurve(65536), tonecurve(65536, 0), //,1); @@ -48,6 +47,7 @@ ImProcCoordinator::ImProcCoordinator () satcurve(65536, 0), lhskcurve(65536, 0), clcurve(65536, 0), + conversionBuffer(1, 1), wavclCurve(65536, 0), clToningcurve(65536, 0), cl2Toningcurve(65536, 0), @@ -81,15 +81,16 @@ ImProcCoordinator::ImProcCoordinator () rCurve(), gCurve(), bCurve(), + ctColorCurve(), rcurvehist(256), rcurvehistCropped(256), rbeforehist(256), gcurvehist(256), gcurvehistCropped(256), gbeforehist(256), bcurvehist(256), bcurvehistCropped(256), bbeforehist(256), fw(0), fh(0), tr(0), fullw(1), fullh(1), pW(-1), pH(-1), - plistener(nullptr), imageListener(nullptr), aeListener(nullptr), acListener(nullptr), abwListener(nullptr), awbListener(nullptr), actListener(nullptr), adnListener(nullptr), awavListener(nullptr), dehaListener(nullptr), frameCountListener(nullptr), imageTypeListener(nullptr), hListener(nullptr), - resultValid(false), lastOutputProfile("BADFOOD"), lastOutputIntent(RI__COUNT), lastOutputBPC(false), thread(nullptr), changeSinceLast(0), updaterRunning(false), destroying(false), utili(false), autili(false), wavcontlutili(false), - butili(false), ccutili(false), cclutili(false), clcutili(false), opautili(false), conversionBuffer(1, 1), colourToningSatLimit(0.f), colourToningSatLimitOpacity(0.f) + plistener(nullptr), imageListener(nullptr), aeListener(nullptr), acListener(nullptr), abwListener(nullptr), awbListener(nullptr), frameCountListener(nullptr), imageTypeListener(nullptr), actListener(nullptr), adnListener(nullptr), awavListener(nullptr), dehaListener(nullptr), hListener(nullptr), + resultValid(false), lastOutputProfile("BADFOOD"), lastOutputIntent(RI__COUNT), lastOutputBPC(false), thread(nullptr), changeSinceLast(0), updaterRunning(false), destroying(false), utili(false), autili(false), + butili(false), ccutili(false), cclutili(false), clcutili(false), opautili(false), wavcontlutili(false), colourToningSatLimit(0.f), colourToningSatLimitOpacity(0.f) {} void ImProcCoordinator::assign (ImageSource* imgsrc) From 9abb397572e6bd78eaacf8f5b84c410bb245d124 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 20:22:13 +0200 Subject: [PATCH 49/90] Fix all warnings in hilite_recon.cc --- rtengine/hilite_recon.cc | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/rtengine/hilite_recon.cc b/rtengine/hilite_recon.cc index 9f618ace5..b0b211e3d 100644 --- a/rtengine/hilite_recon.cc +++ b/rtengine/hilite_recon.cc @@ -398,23 +398,20 @@ void RawImageSource :: HLRecovery_inpaint (float** red, float** green, float** b int height = H; int width = W; - static const int range = 2; - static const int pitch = 4; + constexpr int range = 2; + constexpr int pitch = 4; - static const int numdirs = 4; - - static const float threshpct = 0.25f; - static const float fixthreshpct = 0.7f; - static const float maxpct = 0.95f; - static const float epsilon = 0.00001f; + constexpr float threshpct = 0.25f; + constexpr float maxpct = 0.95f; + constexpr float epsilon = 0.00001f; //%%%%%%%%%%%%%%%%%%%% //for blend algorithm: - static const float blendthresh = 1.0; - static const int ColorCount = 3; + constexpr float blendthresh = 1.0; + constexpr int ColorCount = 3; // Transform matrixes rgb>lab and back - static const float trans[ColorCount][ColorCount] = + constexpr float trans[ColorCount][ColorCount] = { { 1.f, 1.f, 1.f }, { 1.7320508f, -1.7320508f, 0.f }, { -1.f, -1.f, 2.f } }; - static const float itrans[ColorCount][ColorCount] = + constexpr float itrans[ColorCount][ColorCount] = { { 1.f, 0.8660254f, -0.5f }, { 1.f, -0.8660254f, -0.5f }, { 1.f, 0.f, 1.f } }; if(settings->verbose) From 8cb367970a8331926a927454f5c384f494412711 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 20:28:04 +0200 Subject: [PATCH 50/90] Fix all warnings in shmap.cc --- rtengine/shmap.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rtengine/shmap.cc b/rtengine/shmap.cc index a92264117..26674c906 100644 --- a/rtengine/shmap.cc +++ b/rtengine/shmap.cc @@ -376,7 +376,7 @@ SSEFUNCTION void SHMap::dirpyr_shmap(float ** data_fine, float ** data_coarse, i #endif { #if defined( __SSE2__ ) && defined( __x86_64__ ) - __m128 dirwtv, valv, normv, dftemp1v, dftemp2v, fg; + vfloat dirwtv, valv, normv, dftemp1v, dftemp2v; #endif // __SSE2__ int j; #ifdef _OPENMP @@ -483,7 +483,7 @@ SSEFUNCTION void SHMap::dirpyr_shmap(float ** data_fine, float ** data_coarse, i #endif { #if defined( __SSE2__ ) && defined( __x86_64__ ) - __m128 dirwtv, valv, normv, dftemp1v, dftemp2v, fgg; + vfloat dirwtv, valv, normv, dftemp1v, dftemp2v; float domkerv[5][5][4] ALIGNED16 = {{{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}}, {{1, 1, 1, 1}, {2, 2, 2, 2}, {2, 2, 2, 2}, {2, 2, 2, 2}, {1, 1, 1, 1}}, {{1, 1, 1, 1}, {2, 2, 2, 2}, {2, 2, 2, 2}, {2, 2, 2, 2}, {1, 1, 1, 1}}, {{1, 1, 1, 1}, {2, 2, 2, 2}, {2, 2, 2, 2}, {2, 2, 2, 2}, {1, 1, 1, 1}}, {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}}}; #endif // __SSE2__ From 5c1701022d0974e28c7beaad4fae581d101ff9f5 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 20:39:17 +0200 Subject: [PATCH 51/90] Fix all warnings in dcp.cc --- rtengine/dcp.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/rtengine/dcp.cc b/rtengine/dcp.cc index 57e25691f..ad0621ce0 100644 --- a/rtengine/dcp.cc +++ b/rtengine/dcp.cc @@ -309,8 +309,6 @@ double xyCoordToTemperature(const std::array& white_xy) { 600, 0.33724, 0.36051, -116.45 } }; - constexpr double tint_scale = -3000.0; - double res = 0; // Convert to uv space. @@ -847,7 +845,7 @@ DCPProfile::DCPProfile(const Glib::ustring& filename) : // Saturation maps. Need to be unwinded. tag = tagDir->getTag(toUnderlying(TagKey::PROFILE_HUE_SAT_MAP_DATA_2)); - for (int i = 0; i < delta_info.array_count; ++i) { + for (unsigned int i = 0; i < delta_info.array_count; ++i) { deltas_2[i].hue_shift = tag->toDouble((i * 3) * tiff_float_size); deltas_2[i].sat_scale = tag->toDouble((i * 3 + 1) * tiff_float_size); deltas_2[i].val_scale = tag->toDouble((i * 3 + 2) * tiff_float_size); From 2c686acc4846d9ac220dd47a66d6df7b1eee9c2e Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 20:45:15 +0200 Subject: [PATCH 52/90] Fix all warnings in lcp.cc --- rtengine/lcp.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/rtengine/lcp.cc b/rtengine/lcp.cc index 310361a72..2ba401811 100644 --- a/rtengine/lcp.cc +++ b/rtengine/lcp.cc @@ -866,7 +866,6 @@ Glib::ustring LCPStore::getDefaultCommonDirectory() const #ifdef WIN32 WCHAR pathW[MAX_PATH] = {0}; - char pathA[MAX_PATH]; if (SHGetSpecialFolderPathW(NULL, pathW, CSIDL_COMMON_APPDATA, false)) { char pathA[MAX_PATH]; From 7b489a1d999fa98e385dc2989465c2a239d239a1 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 20:51:06 +0200 Subject: [PATCH 53/90] Fix all warnings in clutstore.cc --- rtengine/clutstore.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/clutstore.cc b/rtengine/clutstore.cc index 7a5f6fd19..ba117a2fd 100644 --- a/rtengine/clutstore.cc +++ b/rtengine/clutstore.cc @@ -32,7 +32,7 @@ bool loadFile( bool res = false; if (fw == fh) { - unsigned int level = 1; + int level = 1; while (level * level * level < fw) { ++level; From 5fdcfc1b6c9715cdf32f3743c1a084fc952562ee Mon Sep 17 00:00:00 2001 From: heckflosse Date: Fri, 31 Mar 2017 21:06:12 +0200 Subject: [PATCH 54/90] Fix all warnings in klt/trackFeatures.cc --- rtengine/klt/trackFeatures.cc | 54 +++++++++++++++++------------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/rtengine/klt/trackFeatures.cc b/rtengine/klt/trackFeatures.cc index 5930e2fcb..474d0f5f5 100644 --- a/rtengine/klt/trackFeatures.cc +++ b/rtengine/klt/trackFeatures.cc @@ -640,31 +640,31 @@ static void _am_getGradientWinAffine( } -/********************************************************************* - * _computeAffineMappedImage - * used only for DEBUG output - * -*/ - -static void _am_computeAffineMappedImage( - _KLT_FloatImage img, /* images */ - float x, float y, /* center of window */ - float Axx, float Ayx , float Axy, float Ayy, /* affine mapping */ - int width, int height, /* size of window */ - _FloatWindow imgdiff) /* output */ -{ - int hw = width/2, hh = height/2; - int i, j; - float mi, mj; - - /* Compute values */ - for (j = -hh ; j <= hh ; j++) - for (i = -hw ; i <= hw ; i++) { - mi = Axx * i + Axy * j; - mj = Ayx * i + Ayy * j; - *imgdiff++ = _interpolate(x+mi, y+mj, img); - } -} +///********************************************************************* +// * _computeAffineMappedImage +// * used only for DEBUG output +// * +//*/ +// +//static void _am_computeAffineMappedImage( +// _KLT_FloatImage img, /* images */ +// float x, float y, /* center of window */ +// float Axx, float Ayx , float Axy, float Ayy, /* affine mapping */ +// int width, int height, /* size of window */ +// _FloatWindow imgdiff) /* output */ +//{ +// int hw = width/2, hh = height/2; +// int i, j; +// float mi, mj; +// +// /* Compute values */ +// for (j = -hh ; j <= hh ; j++) +// for (i = -hw ; i <= hw ; i++) { +// mi = Axx * i + Axy * j; +// mj = Ayx * i + Ayy * j; +// *imgdiff++ = _interpolate(x+mi, y+mj, img); +// } +//} /********************************************************************* @@ -986,7 +986,7 @@ static int _am_trackFeatureAffine( _FloatWindow imgdiff, gradx, grady; - float gxx, gxy, gyy, ex, ey, dx, dy; + float gxx, gxy, gyy, ex, ey, dx = 0.f, dy = 0.f; int iteration = 0; int status = 0; int hw = width/2; @@ -1253,7 +1253,7 @@ void KLTTrackFeatures( pyramid2, pyramid2_gradx, pyramid2_grady; float subsampling = (float) tc->subsampling; float xloc, yloc, xlocout, ylocout; - int val; + int val = 0; int indx, r; KLT_BOOL floatimg1_created = FALSE; int i; From 9bbd7a95895188ceacf8ddcbd0962179b1a3cfc0 Mon Sep 17 00:00:00 2001 From: Desmis Date: Sat, 1 Apr 2017 08:59:48 +0200 Subject: [PATCH 55/90] Fix all warnings in rtgui whitebalance.cc --- rtgui/whitebalance.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/rtgui/whitebalance.cc b/rtgui/whitebalance.cc index 362d03a8d..135d30655 100644 --- a/rtgui/whitebalance.cc +++ b/rtgui/whitebalance.cc @@ -355,7 +355,6 @@ void WhiteBalance::adjusterChanged (Adjuster* a, double newval) int tVal = (int)temp->getValue(); double gVal = green->getValue(); double eVal = equal->getValue(); - double tempBiasVal = tempBias->getValue(); Gtk::TreeModel::Row row = getActiveMethod(); if (row == refTreeModel->children().end()) { From 24fd816c36918d83999051948bd5e2626a725450 Mon Sep 17 00:00:00 2001 From: Desmis Date: Sat, 1 Apr 2017 10:06:37 +0200 Subject: [PATCH 56/90] Fix all warnings for rtgui colortoning.cc --- rtgui/colortoning.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtgui/colortoning.cc b/rtgui/colortoning.cc index d471ef787..786030a73 100644 --- a/rtgui/colortoning.cc +++ b/rtgui/colortoning.cc @@ -952,7 +952,7 @@ void ColorToning::autoOpenCurve () void ColorToning::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller) { - float R, G, B; + float R = 0.f, G = 0.f, B = 0.f; if (callerId == 1) { // ch - main curve Color::hsv2rgb01(float(valY), 1.0f, 0.5f, R, G, B); From 73afa054c4fa8e95991367784ba57a86750b7fef Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 1 Apr 2017 13:34:16 +0200 Subject: [PATCH 57/90] fixed Clang warnings in rtengine and rtexif --- rtengine/color.cc | 2 +- rtengine/improcfun.cc | 2 +- rtengine/previewimage.cc | 4 +--- rtexif/kodakattribs.cc | 1 - 4 files changed, 3 insertions(+), 6 deletions(-) diff --git a/rtengine/color.cc b/rtengine/color.cc index b67343b82..acb50eae5 100644 --- a/rtengine/color.cc +++ b/rtengine/color.cc @@ -1530,7 +1530,7 @@ void Color::interpolateRGBColor (float realL, float iplow, float iphigh, int alg int toDo, const double xyz_rgb[3][3], const double rgb_xyz[3][3], float &ro, float &go, float &bo) { float X1, Y1, Z1, X2, Y2, Z2, X, Y, Z, XL, YL, ZL; - float L1, L2, LL, a_1 = 0.f, b_1 = 0.f, a_2, b_2, a_L, b_L; + float L1 = 0.f, L2, LL, a_1 = 0.f, b_1 = 0.f, a_2, b_2, a_L, b_L; // converting color 1 to Lab (image) Color::rgbxyz(r1, g1, b1, X1, Y1, Z1, xyz_rgb); diff --git a/rtengine/improcfun.cc b/rtengine/improcfun.cc index 6e8f479be..93a23d692 100644 --- a/rtengine/improcfun.cc +++ b/rtengine/improcfun.cc @@ -4634,7 +4634,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer else if (params->colorToning.method == "Lab" && opautili) { int algm = 0; bool twocol = true; - int metchrom; + int metchrom = 0; if (params->colorToning.twocolor == "Std" ) { metchrom = 0; diff --git a/rtengine/previewimage.cc b/rtengine/previewimage.cc index 4d0fd59b6..1bf11dc17 100644 --- a/rtengine/previewimage.cc +++ b/rtengine/previewimage.cc @@ -71,9 +71,7 @@ PreviewImage::PreviewImage (const Glib::ustring &fname, const Glib::ustring &ext int w, h; double scale = 1.; - if (tpp) { - tpp->getDimensions(w, h, scale); - } + tpp->getDimensions(w, h, scale); previewImage = Cairo::ImageSurface::create(Cairo::FORMAT_RGB24, w, h); previewImage->flush(); diff --git a/rtexif/kodakattribs.cc b/rtexif/kodakattribs.cc index c92be3a84..f2d6e84dd 100644 --- a/rtexif/kodakattribs.cc +++ b/rtexif/kodakattribs.cc @@ -20,7 +20,6 @@ void parseKodakIfdTextualInfo(Tag *textualInfo, Tag* exif_) TagDirectory *exif = exif_->getDirectory(); char *value = (char *)textualInfo->getValue(); - int valuesize = textualInfo->getValueSize(); char *p = value; char *pc, *plf; From 4ef3fc16de49dec451a72951885e1811fa1c4531 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 1 Apr 2017 13:38:38 +0200 Subject: [PATCH 58/90] fixed warnings in rtgui/thumbbrowserbase.cc --- rtgui/thumbbrowserbase.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtgui/thumbbrowserbase.cc b/rtgui/thumbbrowserbase.cc index b06abe467..deb423569 100644 --- a/rtgui/thumbbrowserbase.cc +++ b/rtgui/thumbbrowserbase.cc @@ -25,7 +25,7 @@ using namespace std; ThumbBrowserBase::ThumbBrowserBase () - : lastClicked(nullptr), previewHeight(options.thumbSize), numOfCols(1), inspector(nullptr), isInspectorActive(false), location(THLOC_FILEBROWSER) + : location(THLOC_FILEBROWSER), inspector(nullptr), isInspectorActive(false), lastClicked(nullptr), previewHeight(options.thumbSize), numOfCols(1) { inW = -1; inH = -1; From de1f607b45b51983f826b759ae5f7f6df2c2321c Mon Sep 17 00:00:00 2001 From: heckflosse Date: Sat, 1 Apr 2017 14:06:52 +0200 Subject: [PATCH 59/90] Fix all warnings in diagonalcurveeditorsubgroup.cc --- rtgui/diagonalcurveeditorsubgroup.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/rtgui/diagonalcurveeditorsubgroup.cc b/rtgui/diagonalcurveeditorsubgroup.cc index 8f81333d7..d12cdf023 100644 --- a/rtgui/diagonalcurveeditorsubgroup.cc +++ b/rtgui/diagonalcurveeditorsubgroup.cc @@ -40,7 +40,6 @@ DiagonalCurveEditorSubGroup::DiagonalCurveEditorSubGroup (CurveEditorGroup* prt, Gtk::PositionType sideStart = options.curvebboxpos == 0 || options.curvebboxpos == 2 ? Gtk::POS_LEFT : Gtk::POS_TOP; Gtk::PositionType sideEnd = options.curvebboxpos == 0 || options.curvebboxpos == 2 ? Gtk::POS_RIGHT : Gtk::POS_BOTTOM; - bool vExpand = options.curvebboxpos == 0 || options.curvebboxpos == 2; valLinear = (int)DCT_Linear; valUnchanged = (int)DCT_Unchanged; From 7f05567edff720c6a333929f0339c0e0d1fba35c Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 1 Apr 2017 15:31:19 +0200 Subject: [PATCH 60/90] fixed warnings in rtgui/editorpanel --- rtgui/editorpanel.cc | 2 +- rtgui/editorpanel.h | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/rtgui/editorpanel.cc b/rtgui/editorpanel.cc index 7bc1631d3..5160f695f 100644 --- a/rtgui/editorpanel.cc +++ b/rtgui/editorpanel.cc @@ -374,7 +374,7 @@ public: }; EditorPanel::EditorPanel (FilePanel* filePanel) - : realized(false), iHistoryShow(nullptr), iHistoryHide(nullptr), iTopPanel_1_Show(nullptr), iTopPanel_1_Hide(nullptr), iRightPanel_1_Show(nullptr), iRightPanel_1_Hide(nullptr), iBeforeLockON(nullptr), iBeforeLockOFF(nullptr), beforePreviewHandler(nullptr), beforeIarea(nullptr), beforeBox(nullptr), afterBox(nullptr), afterHeaderBox(nullptr), parent(nullptr), openThm(nullptr), ipc(nullptr), beforeIpc(nullptr), isProcessing(false), catalogPane(nullptr) + : catalogPane(nullptr), realized(false), iHistoryShow(nullptr), iHistoryHide(nullptr), iTopPanel_1_Show(nullptr), iTopPanel_1_Hide(nullptr), iRightPanel_1_Show(nullptr), iRightPanel_1_Hide(nullptr), iBeforeLockON(nullptr), iBeforeLockOFF(nullptr), beforePreviewHandler(nullptr), beforeIarea(nullptr), beforeBox(nullptr), afterBox(nullptr), afterHeaderBox(nullptr), parent(nullptr), openThm(nullptr), ipc(nullptr), beforeIpc(nullptr), isProcessing(false) { epih = new EditorPanelIdleHelper; diff --git a/rtgui/editorpanel.h b/rtgui/editorpanel.h index 609df5236..4434a660e 100644 --- a/rtgui/editorpanel.h +++ b/rtgui/editorpanel.h @@ -193,7 +193,6 @@ private: ToolPanelCoordinator* tpc; RTWindow* parent; //SaveAsDialog* saveAsDialog; - BatchToolPanelCoordinator* btpCoordinator; FilePanel* fPanel; bool firstProcessingDone; From 94685212b0a6bacd5345f6591a52a394df523d7d Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 1 Apr 2017 15:37:07 +0200 Subject: [PATCH 61/90] fixed warnings in rtgui/checkbox --- rtgui/checkbox.cc | 1 - rtgui/checkbox.h | 1 - 2 files changed, 2 deletions(-) diff --git a/rtgui/checkbox.cc b/rtgui/checkbox.cc index 716802f0f..88a85df83 100644 --- a/rtgui/checkbox.cc +++ b/rtgui/checkbox.cc @@ -27,7 +27,6 @@ CheckBox::CheckBox (Glib::ustring label, bool const& multiImageVal) : Gtk::CheckButton (label) , listener (nullptr) , lastActive (false) - , inBatchMode (false) , multiImage (multiImageVal) { conn = signal_toggled().connect( sigc::mem_fun(*this, &CheckBox::buttonToggled) ); diff --git a/rtgui/checkbox.h b/rtgui/checkbox.h index 8745de6d3..5b3088704 100644 --- a/rtgui/checkbox.h +++ b/rtgui/checkbox.h @@ -48,7 +48,6 @@ class CheckBox : public Gtk::CheckButton // Should ideally be private, but in t CheckBoxListener *listener; bool lastActive; - bool inBatchMode; bool const& multiImage; sigc::connection conn; void buttonToggled (); From 6fe04e3990c88302475bc3afabbec4f4e000954d Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 1 Apr 2017 15:55:39 +0200 Subject: [PATCH 62/90] fixed warnings in rtgui --- rtgui/batchqueueentry.cc | 2 +- rtgui/browserfilter.cc | 5 +++-- rtgui/clipboard.cc | 2 +- rtgui/colorappearance.cc | 2 +- rtgui/colortoning.h | 6 +----- rtgui/crophandler.cc | 2 +- rtgui/crophandler.h | 1 - rtgui/cropwindow.cc | 2 +- rtgui/cropwindow.h | 2 +- rtgui/defringe.cc | 2 +- rtgui/diagonalcurveeditorsubgroup.cc | 1 - rtgui/dirpyrdenoise.cc | 2 +- rtgui/dynamicprofilepanel.cc | 1 - rtgui/exifpanel.h | 2 -- rtgui/filebrowserentry.cc | 1 + rtgui/guiutils.cc | 4 ++-- rtgui/icmpanel.h | 3 --- rtgui/labcurve.cc | 2 +- rtgui/lwbuttonset.cc | 2 +- rtgui/popupcommon.cc | 4 ++-- rtgui/retinex.cc | 2 +- rtgui/shcselector.cc | 2 +- rtgui/thumbnail.cc | 2 +- rtgui/thumbnail.h | 1 - rtgui/wavelet.cc | 2 +- 25 files changed, 23 insertions(+), 34 deletions(-) diff --git a/rtgui/batchqueueentry.cc b/rtgui/batchqueueentry.cc index 09397f2a3..8386a8ee6 100644 --- a/rtgui/batchqueueentry.cc +++ b/rtgui/batchqueueentry.cc @@ -32,7 +32,7 @@ Glib::RefPtr BatchQueueEntry::savedAsIcon; BatchQueueEntry::BatchQueueEntry (rtengine::ProcessingJob* pjob, const rtengine::procparams::ProcParams& pparams, Glib::ustring fname, int prevw, int prevh, Thumbnail* thm) : ThumbBrowserEntryBase(fname), opreview(nullptr), origpw(prevw), origph(prevh), opreviewDone(false), - job(pjob), progress(0), outFileName(""), sequence(0), forceFormatOpts(false), params(pparams) + job(pjob), params(pparams), progress(0), outFileName(""), sequence(0), forceFormatOpts(false) { thumbnail = thm; diff --git a/rtgui/browserfilter.cc b/rtgui/browserfilter.cc index 3d43400ba..ab4c843a4 100644 --- a/rtgui/browserfilter.cc +++ b/rtgui/browserfilter.cc @@ -18,11 +18,12 @@ */ #include "browserfilter.h" -BrowserFilter::BrowserFilter () : exifFilterEnabled (false), +BrowserFilter::BrowserFilter () : showTrash (true), showNotTrash (true), showOriginal (false), - multiselect (false) + multiselect (false), + exifFilterEnabled (false) { for (int i = 0; i < 6; i++) { showRanked[i] = true; diff --git a/rtgui/clipboard.cc b/rtgui/clipboard.cc index a1b94a615..dfd78cdd1 100644 --- a/rtgui/clipboard.cc +++ b/rtgui/clipboard.cc @@ -20,7 +20,7 @@ Clipboard clipboard; -Clipboard::Clipboard () : partProfile (false), _hasIPTC(false), hasDiagonalCurveDataType(DCT_Empty), hasFlatCurveDataType(FCT_Empty) {} +Clipboard::Clipboard () : _hasIPTC(false), partProfile (false), hasDiagonalCurveDataType(DCT_Empty), hasFlatCurveDataType(FCT_Empty) {} Clipboard::~Clipboard () { diff --git a/rtgui/colorappearance.cc b/rtgui/colorappearance.cc index a198dd1f5..cdcfb10f2 100644 --- a/rtgui/colorappearance.cc +++ b/rtgui/colorappearance.cc @@ -1055,7 +1055,7 @@ bool ColorAppearance::adapCamComputed_ () void ColorAppearance::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller) { - float R, G, B; + float R = 0.f, G = 0.f, B = 0.f; if (elemType == ColorCaller::CCET_VERTICAL_BAR) { valY = 0.5; diff --git a/rtgui/colortoning.h b/rtgui/colortoning.h index 7f1290bf6..347cfd126 100644 --- a/rtgui/colortoning.h +++ b/rtgui/colortoning.h @@ -50,7 +50,7 @@ public: void colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller* caller); private: - Gtk::HSeparator* satLimiterSep; + //Gtk::HSeparator* satLimiterSep; Gtk::HSeparator* colorSep; CurveEditorGroup* colorCurveEditorG; CurveEditorGroup* opacityCurveEditorG; @@ -83,20 +83,16 @@ private: Adjuster* satProtectionThreshold; Adjuster* saturatedOpacity; Adjuster* strength; - Gtk::Image* itot; Gtk::Image* iby; Gtk::Image* irg; Gtk::Button* neutral; Gtk::HBox* neutrHBox; - Gtk::HBox* chromaHbox; - Gtk::Label* chroLabel; int nextbw; int nextsatth; int nextsatpr; Glib::ustring nextbalcolor; Glib::ustring balcolor; - bool lasttwocolor; sigc::connection neutralconn, twocconn; //, neutralcurvesconn; bool lastautosat; sigc::connection autosatConn; diff --git a/rtgui/crophandler.cc b/rtgui/crophandler.cc index 8ff95b01b..6d6e9c42f 100644 --- a/rtgui/crophandler.cc +++ b/rtgui/crophandler.cc @@ -30,7 +30,7 @@ using namespace rtengine; CropHandler::CropHandler () - : zoom(100), ww(0), wh(0), imx(-1), imy(-1), imw(0), imh(0), cax(-1), cay(-1), + : zoom(100), ww(0), wh(0), cax(-1), cay(-1), cx(0), cy(0), cw(0), ch(0), cropX(0), cropY(0), cropW(0), cropH(0), enabled(false), cropimg(nullptr), cropimgtrue(nullptr), cropimg_width(0), cropimg_height(0), cix(0), ciy(0), ciw(0), cih(0), cis(1), diff --git a/rtgui/crophandler.h b/rtgui/crophandler.h index 0492aea2a..1e7a9202b 100644 --- a/rtgui/crophandler.h +++ b/rtgui/crophandler.h @@ -108,7 +108,6 @@ private: int zoom; // scale factor (e.g. 5 if 1:5 scale) ; if 1:1 scale and bigger, factor is multiplied by 1000 (i.e. 1000 for 1:1 scale, 2000 for 2:1, etc...) int ww, wh; // size of the crop's canvas on the screen ; might be bigger than the displayed image, but not smaller - int imx, imy, imw, imh; // this is a copy of the cropwindow's parameters int cax, cay; // clamped crop anchor's coordinate, i.e. point of the image that coincide to the center of the display area, expressed in image coordinates; cannot be outside the image's bounds; but if cax==cay==-1, designate the center of the image int cx, cy, cw, ch; // position and size of the requested crop ; position expressed in image coordinates, so cx and cy might be negative and cw and ch higher than the image's 1:1 size int cropX, cropY, cropW, cropH; // cropPixbuf's displayed area (position and size), i.e. coordinates in 1:1 scale, i.e. cx, cy, cw & ch trimmed to the image's bounds diff --git a/rtgui/cropwindow.cc b/rtgui/cropwindow.cc index 6d0391232..bd66dac17 100644 --- a/rtgui/cropwindow.cc +++ b/rtgui/cropwindow.cc @@ -36,7 +36,7 @@ using namespace rtengine; CropWindow::CropWindow (ImageArea* parent, bool isLowUpdatePriority_, bool isDetailWindow) : ObjectMOBuffer(parent), state(SNormal), press_x(0), press_y(0), action_x(0), action_y(0), pickedObject(-1), pickModifierKey(0), rot_deg(0), onResizeArea(false), deleted(false), - fitZoomEnabled(true), fitZoom(false), isLowUpdatePriority(isLowUpdatePriority_), hoveredPicker(nullptr), cropLabel(Glib::ustring("100%")), + fitZoomEnabled(true), fitZoom(false), /*isLowUpdatePriority(isLowUpdatePriority_),*/ hoveredPicker(nullptr), cropLabel(Glib::ustring("100%")), backColor(options.bgcolor), decorated(true), isFlawnOver(false), titleHeight(30), sideBorderWidth(3), lowerBorderWidth(3), upperBorderWidth(1), sepWidth(2), xpos(30), ypos(30), width(0), height(0), imgAreaX(0), imgAreaY(0), imgAreaW(0), imgAreaH(0), imgX(-1), imgY(-1), imgW(1), imgH(1), iarea(parent), cropZoom(0), zoomVersion(0), exposeVersion(0), cropgl(nullptr), diff --git a/rtgui/cropwindow.h b/rtgui/cropwindow.h index 66b6405c5..3f80a75c4 100644 --- a/rtgui/cropwindow.h +++ b/rtgui/cropwindow.h @@ -58,7 +58,7 @@ class CropWindow : public LWButtonListener, public CropDisplayHandler, public Ed bool deleted; bool fitZoomEnabled; bool fitZoom; - bool isLowUpdatePriority; + //bool isLowUpdatePriority; CursorShape cursor_type; // color pickers diff --git a/rtgui/defringe.cc b/rtgui/defringe.cc index 0ba3dec9f..5f70925e7 100644 --- a/rtgui/defringe.cc +++ b/rtgui/defringe.cc @@ -68,7 +68,7 @@ Defringe::~Defringe () void Defringe::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller) { - float R, G, B; + float R = 0.f, G = 0.f, B = 0.f; if (elemType == ColorCaller::CCET_VERTICAL_BAR) { valY = 0.5; diff --git a/rtgui/diagonalcurveeditorsubgroup.cc b/rtgui/diagonalcurveeditorsubgroup.cc index 8f81333d7..d12cdf023 100644 --- a/rtgui/diagonalcurveeditorsubgroup.cc +++ b/rtgui/diagonalcurveeditorsubgroup.cc @@ -40,7 +40,6 @@ DiagonalCurveEditorSubGroup::DiagonalCurveEditorSubGroup (CurveEditorGroup* prt, Gtk::PositionType sideStart = options.curvebboxpos == 0 || options.curvebboxpos == 2 ? Gtk::POS_LEFT : Gtk::POS_TOP; Gtk::PositionType sideEnd = options.curvebboxpos == 0 || options.curvebboxpos == 2 ? Gtk::POS_RIGHT : Gtk::POS_BOTTOM; - bool vExpand = options.curvebboxpos == 0 || options.curvebboxpos == 2; valLinear = (int)DCT_Linear; valUnchanged = (int)DCT_Unchanged; diff --git a/rtgui/dirpyrdenoise.cc b/rtgui/dirpyrdenoise.cc index 1fe86c2ca..61b9bf55a 100644 --- a/rtgui/dirpyrdenoise.cc +++ b/rtgui/dirpyrdenoise.cc @@ -1247,7 +1247,7 @@ void DirPyrDenoise::setAdjusterBehavior (bool lumaadd, bool lumdetadd, bool chro void DirPyrDenoise::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller) { - float R, G, B; + float R = 0.f, G = 0.f, B = 0.f; if (elemType == ColorCaller::CCET_VERTICAL_BAR) { valY = 0.5; diff --git a/rtgui/dynamicprofilepanel.cc b/rtgui/dynamicprofilepanel.cc index e5f9ae1cc..172c06f47 100644 --- a/rtgui/dynamicprofilepanel.cc +++ b/rtgui/dynamicprofilepanel.cc @@ -505,7 +505,6 @@ void DynamicProfilePanel::on_button_edit() } EditDialog d(M("DYNPROFILEEDITOR_EDIT_RULE"), static_cast(*get_toplevel())); - auto it = s->get_selected(); Gtk::TreeModel::Row row = *(s->get_selected()); d.set_rule(to_rule(row)); int status = d.run(); diff --git a/rtgui/exifpanel.h b/rtgui/exifpanel.h index fd797ff56..6244c1a4f 100644 --- a/rtgui/exifpanel.h +++ b/rtgui/exifpanel.h @@ -27,8 +27,6 @@ class ExifPanel : public Gtk::VBox, public ToolPanel private: const rtengine::ImageMetaData* idata; - int fullw, fullh, cx, cy, cw, ch; - bool crenabled; rtengine::procparams::ExifPairs changeList; rtengine::procparams::ExifPairs defChangeList; bool recursiveOp; diff --git a/rtgui/filebrowserentry.cc b/rtgui/filebrowserentry.cc index d452b88cd..96861544b 100644 --- a/rtgui/filebrowserentry.cc +++ b/rtgui/filebrowserentry.cc @@ -635,6 +635,7 @@ bool FileBrowserEntry::onArea (CursorArea a, int x, int y) y1 < cropParams.y + cropParams.h - 1 && x1 > cropParams.x && x1 < cropParams.x + cropParams.w - 1; + default: /* do nothing */ ; } return false; diff --git a/rtgui/guiutils.cc b/rtgui/guiutils.cc index 451af4e38..3295ab169 100644 --- a/rtgui/guiutils.cc +++ b/rtgui/guiutils.cc @@ -1620,8 +1620,8 @@ void BackBuffer::copySurface(Cairo::RefPtr crDest, Gdk::Rectangl int offsetY = rtengine::LIM(offset.y, 0, surface->get_height()); // now copy the off-screen Surface to the destination Surface - int srcSurfW = surface->get_width(); - int srcSurfH = surface->get_height(); + // int srcSurfW = surface->get_width(); + // int srcSurfH = surface->get_height(); //printf("srcSurf: w: %d, h: %d\n", srcSurfW, srcSurfH); crDest->set_line_width(0.); diff --git a/rtgui/icmpanel.h b/rtgui/icmpanel.h index 84171ae87..846129105 100644 --- a/rtgui/icmpanel.h +++ b/rtgui/icmpanel.h @@ -88,8 +88,6 @@ private: sigc::connection onamesconn; PopUpButton* ointent; sigc::connection ointentconn; - Gtk::RadioButton* ofromdir; - Gtk::RadioButton* ofromfile; Gtk::RadioButton* iunchanged; MyFileChooserButton* ipDialog; Gtk::RadioButton::Group opts; @@ -99,7 +97,6 @@ private: ICMPanelListener* icmplistener; double dcpTemperatures[2]; - bool enableLastICCWorkDirChange; Glib::ustring lastRefFilename; Glib::ustring camName; void updateDCP(int dcpIlluminant, Glib::ustring dcp_name); diff --git a/rtgui/labcurve.cc b/rtgui/labcurve.cc index a173b47ec..dc9e404fb 100644 --- a/rtgui/labcurve.cc +++ b/rtgui/labcurve.cc @@ -559,7 +559,7 @@ void LCurve::adjusterChanged (Adjuster* a, double newval) void LCurve::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller) { - float R, G, B; + float R = 0.f, G = 0.f, B = 0.f; if (elemType == ColorCaller::CCET_VERTICAL_BAR) { valY = 0.5; diff --git a/rtgui/lwbuttonset.cc b/rtgui/lwbuttonset.cc index 9fc1bc443..6265c1039 100644 --- a/rtgui/lwbuttonset.cc +++ b/rtgui/lwbuttonset.cc @@ -72,7 +72,7 @@ void LWButtonSet::arrangeButtons (int x, int y, int w, int h) for (size_t i = 0; i < buttons.size(); i++) { LWButton::Alignment halign, valign; - int bx, by, bw, bh; + int bx = 0, by = 0, bw = 0, bh = 0; buttons[i]->getSize (bw, bh); buttons[i]->getAlignment (halign, valign); diff --git a/rtgui/popupcommon.cc b/rtgui/popupcommon.cc index 09feb1c3a..7dfdc0019 100644 --- a/rtgui/popupcommon.cc +++ b/rtgui/popupcommon.cc @@ -26,9 +26,9 @@ #include "guiutils.h" PopUpCommon::PopUpCommon (Gtk::Button* thisButton, const Glib::ustring& label) - : selected (-1) // -1 means that the button is invalid + : buttonImage (nullptr) , menu (nullptr) - , buttonImage (nullptr) + , selected (-1) // -1 means that the button is invalid { button = thisButton; hasMenu = false; diff --git a/rtgui/retinex.cc b/rtgui/retinex.cc index 4686e325e..26e4ac565 100644 --- a/rtgui/retinex.cc +++ b/rtgui/retinex.cc @@ -1513,7 +1513,7 @@ void Retinex::updateCurveBackgroundHistogram (LUTu & histToneCurve, LUTu & histL void Retinex::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller) { - float R, G, B; + float R = 0.f, G = 0.f, B = 0.f; if (elemType == ColorCaller::CCET_VERTICAL_BAR) { valY = 0.5; diff --git a/rtgui/shcselector.cc b/rtgui/shcselector.cc index cc22814e6..e8e7f46fa 100644 --- a/rtgui/shcselector.cc +++ b/rtgui/shcselector.cc @@ -204,7 +204,7 @@ void SHCSelector::updateBackBuffer() cr->set_source_rgb (c.get_red(), c.get_green(), c.get_blue()); cr->stroke (); } - /* + / * else if (i==litCursor) { // prelight Gdk::RGBA c = style->get_background_color(Gtk::STATE_FLAG_PRELIGHT); diff --git a/rtgui/thumbnail.cc b/rtgui/thumbnail.cc index 0bbefa298..2e8a904c1 100644 --- a/rtgui/thumbnail.cc +++ b/rtgui/thumbnail.cc @@ -64,7 +64,7 @@ Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, CacheImageDa Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, const std::string& md5) : fname(fname), cachemgr(cm), ref(1), enqueueNumber(0), tpp(nullptr), pparamsValid(false), - pparamsSet(false), needsReProcessing(true), imageLoading(false), lastImg(nullptr), + needsReProcessing(true), imageLoading(false), lastImg(nullptr), lastW(0), lastH(0), lastScale(0.0), initial_(true) { diff --git a/rtgui/thumbnail.h b/rtgui/thumbnail.h index e5b6a72b2..eb9e38f7f 100644 --- a/rtgui/thumbnail.h +++ b/rtgui/thumbnail.h @@ -49,7 +49,6 @@ class Thumbnail rtengine::procparams::ProcParams pparams; bool pparamsValid; - bool pparamsSet; bool needsReProcessing; bool imageLoading; diff --git a/rtgui/wavelet.cc b/rtgui/wavelet.cc index e1d0fc425..ef8c2c5e3 100644 --- a/rtgui/wavelet.cc +++ b/rtgui/wavelet.cc @@ -2863,7 +2863,7 @@ void Wavelet::tmrToggled () void Wavelet::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller) { - float R, G, B; + float R = 0.f, G = 0.f, B = 0.f; if (elemType == ColorCaller::CCET_VERTICAL_BAR) { valY = 0.5; From a3561049edcdd37584d41553bc9041cba487d822 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 1 Apr 2017 16:43:11 +0200 Subject: [PATCH 63/90] fixed warning in rtengine/ipretinex.cc --- rtengine/ipretinex.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/ipretinex.cc b/rtengine/ipretinex.cc index 2dbdbafb1..829810042 100644 --- a/rtengine/ipretinex.cc +++ b/rtengine/ipretinex.cc @@ -273,7 +273,7 @@ void RawImageSource::MSR(float** luminance, float** originalLuminance, float **e } } - float varx; + float varx = 0.f; float limdx, ilimdx; if(gradvart != 0) { From 27e822fdaedde066e48df8bdc53489f6a3e2f964 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 1 Apr 2017 16:43:32 +0200 Subject: [PATCH 64/90] fixed more warnings in rtgui (reported by gcc but not clang) --- rtgui/batchqueue.cc | 4 ++-- rtgui/checkbox.cc | 2 +- rtgui/cropwindow.cc | 2 +- rtgui/dirbrowser.cc | 2 +- rtgui/exiffiltersettings.h | 4 ++-- rtgui/filebrowser.cc | 10 +++++----- rtgui/filecatalog.cc | 8 ++++---- rtgui/guiutils.cc | 4 ++-- rtgui/guiutils.h | 2 +- rtgui/histogrampanel.cc | 4 ++-- rtgui/mycurve.cc | 2 +- rtgui/mydiagonalcurve.cc | 14 +++++++------- rtgui/myflatcurve.cc | 6 +++--- rtgui/popupcommon.cc | 4 ++-- 14 files changed, 34 insertions(+), 34 deletions(-) diff --git a/rtgui/batchqueue.cc b/rtgui/batchqueue.cc index a02046e01..fae7bdf6b 100644 --- a/rtgui/batchqueue.cc +++ b/rtgui/batchqueue.cc @@ -781,7 +781,7 @@ Glib::ustring BatchQueue::calcAutoFileNameBase (const Glib::ustring& origFileNam if (options.savePathTemplate[ix] == 'p') { ix++; - int i = options.savePathTemplate[ix] - '0'; + unsigned int i = options.savePathTemplate[ix] - '0'; if (i < pa.size()) { path = path + pa[pa.size() - i - 1] + '/'; @@ -790,7 +790,7 @@ Glib::ustring BatchQueue::calcAutoFileNameBase (const Glib::ustring& origFileNam ix++; } else if (options.savePathTemplate[ix] == 'd') { ix++; - int i = options.savePathTemplate[ix] - '0'; + unsigned i = options.savePathTemplate[ix] - '0'; if (i < da.size()) { path = path + da[da.size() - i - 1]; diff --git a/rtgui/checkbox.cc b/rtgui/checkbox.cc index 88a85df83..1e3c2b61e 100644 --- a/rtgui/checkbox.cc +++ b/rtgui/checkbox.cc @@ -35,7 +35,7 @@ CheckBox::CheckBox (Glib::ustring label, bool const& multiImageVal) void CheckBox::buttonToggled () { - CheckValue newValue; + CheckValue newValue = CheckValue::unchanged; if (multiImage) { if (get_inconsistent()) { diff --git a/rtgui/cropwindow.cc b/rtgui/cropwindow.cc index bd66dac17..4af132cea 100644 --- a/rtgui/cropwindow.cc +++ b/rtgui/cropwindow.cc @@ -1627,7 +1627,7 @@ void CropWindow::expose (Cairo::RefPtr cr) int delta = 0; // for efficiency, pre-calculate currWS_L as it may be needed in both // if (showch) and if (showcs) branches - int currWS_L; + int currWS_L = 0; if (showL && (showch || showcs)) { currWS_L = (int)(0.299f * currWS[0] + 0.587f * currWS[1] + 0.114f * currWS[2]); diff --git a/rtgui/dirbrowser.cc b/rtgui/dirbrowser.cc index 7b5adade2..a8825d310 100644 --- a/rtgui/dirbrowser.cc +++ b/rtgui/dirbrowser.cc @@ -348,7 +348,7 @@ void DirBrowser::updateDir (const Gtk::TreeModel::iterator& iter) auto dir = Gio::File::create_for_path (iter->get_value (dtColumns.dirname)); auto subDirs = listSubDirs (dir, options.fbShowHidden); - for (int i = 0; i < subDirs.size(); i++) { + for (size_t i = 0; i < subDirs.size(); i++) { bool found = false; for (Gtk::TreeModel::iterator it = iter->children().begin(); it != iter->children().end() && !found ; ++it) { diff --git a/rtgui/exiffiltersettings.h b/rtgui/exiffiltersettings.h index f462ddc30..d692eb510 100644 --- a/rtgui/exiffiltersettings.h +++ b/rtgui/exiffiltersettings.h @@ -36,8 +36,8 @@ public: double shutterTo; double focalFrom; double focalTo; - int isoFrom; - int isoTo; + unsigned isoFrom; + unsigned isoTo; bool filterFNumber; bool filterShutter; diff --git a/rtgui/filebrowser.cc b/rtgui/filebrowser.cc index 3d03c678a..2979b556f 100644 --- a/rtgui/filebrowser.cc +++ b/rtgui/filebrowser.cc @@ -405,7 +405,7 @@ FileBrowser::FileBrowser () colorlabel[i]->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), colorlabel[i])); } - for (int i = 0; i < mMenuExtProgs.size(); i++) { + for (size_t i = 0; i < mMenuExtProgs.size(); i++) { amiExtProg[i]->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), amiExtProg[i])); } @@ -730,14 +730,14 @@ void FileBrowser::menuItemActivated (Gtk::MenuItem* m) return; } - for (int j = 0; j < mMenuExtProgs.size(); j++) { + for (size_t j = 0; j < mMenuExtProgs.size(); j++) { if (m == amiExtProg[j]) { const auto pAct = mMenuExtProgs[m->get_label()]; // Build vector of all file names std::vector selFileNames; - for (int i = 0; i < mselected.size(); i++) { + for (size_t i = 0; i < mselected.size(); i++) { Glib::ustring fn = mselected[i]->thumbnail->getFileName(); // Maybe batch processed version @@ -1505,11 +1505,11 @@ bool FileBrowser::checkFilter (ThumbBrowserEntryBase* entryb) // true -> entry int iFilenameMatch = 0; std::vector vFilterStrings = Glib::Regex::split_simple(",", decodedQueryFileName.uppercase()); - for(int i = 0; i < vFilterStrings.size(); i++) { + for(size_t i = 0; i < vFilterStrings.size(); i++) { // ignore empty vFilterStrings. Otherwise filter will always return true if // e.g. filter.queryFileName ends on "," and will stop being a filter if (!vFilterStrings.at(i).empty()) { - if (FileName.find(vFilterStrings.at(i)) != -1) { + if (FileName.find(vFilterStrings.at(i)) != Glib::ustring::npos) { iFilenameMatch++; } } diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index 96a04ba0b..3dfb37971 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -748,12 +748,12 @@ void FileCatalog::previewReady (int dir_id, FileBrowserEntry* fdn) dirEFS.shutterTo = cfs->shutter; } - if (cfs->iso > 0 && (int)cfs->iso < dirEFS.isoFrom) { - dirEFS.isoFrom = (int)cfs->iso; + if (cfs->iso > 0 && cfs->iso < dirEFS.isoFrom) { + dirEFS.isoFrom = cfs->iso; } - if (cfs->iso > 0 && (int)cfs->iso > dirEFS.isoTo) { - dirEFS.isoTo = (int)cfs->iso; + if (cfs->iso > 0 && cfs->iso > dirEFS.isoTo) { + dirEFS.isoTo = cfs->iso; } if (cfs->focalLen < dirEFS.focalFrom) { diff --git a/rtgui/guiutils.cc b/rtgui/guiutils.cc index 3295ab169..9da116e11 100644 --- a/rtgui/guiutils.cc +++ b/rtgui/guiutils.cc @@ -1478,7 +1478,7 @@ void BackBuffer::copyRGBCharData(const unsigned char *srcData, int srcX, int src return; } - for (unsigned int i = 0; i < (unsigned int)(srcH); ++i) { + for (int i = 0; i < srcH; ++i) { if (dstY + i >= surfH) { break; } @@ -1486,7 +1486,7 @@ void BackBuffer::copyRGBCharData(const unsigned char *srcData, int srcX, int src src = srcData + i * srcRowStride; dst = dstData + ((dstY + i) * surfW + dstX) * 4; - for (unsigned int j = 0; j < (unsigned int)(srcW); ++j) { + for (int j = 0; j < srcW; ++j) { if (dstX + j >= surfW) { break; } diff --git a/rtgui/guiutils.h b/rtgui/guiutils.h index 3f88adf0c..ed342f5af 100644 --- a/rtgui/guiutils.h +++ b/rtgui/guiutils.h @@ -114,7 +114,7 @@ public: class ConnectionBlocker { public: - explicit ConnectionBlocker (Gtk::Widget *associatedWidget, sigc::connection& connection) : connection (associatedWidget ? &connection : nullptr) + explicit ConnectionBlocker (Gtk::Widget *associatedWidget, sigc::connection& connection) : connection (associatedWidget ? &connection : nullptr), wasBlocked(false) { if (this->connection) { wasBlocked = connection.block(); diff --git a/rtgui/histogrampanel.cc b/rtgui/histogrampanel.cc index 94fa2f24d..30519eb16 100644 --- a/rtgui/histogrampanel.cc +++ b/rtgui/histogrampanel.cc @@ -1007,7 +1007,7 @@ SSEFUNCTION void HistogramArea::updateBackBuffer () // does not take into account 0 and 255 values // them are handled separately - int fullhistheight = 0; + unsigned int fullhistheight = 0; for (int i = 1; i < 255; i++) { if (needLuma && lhisttemp[i] > fullhistheight) { @@ -1042,7 +1042,7 @@ SSEFUNCTION void HistogramArea::updateBackBuffer () vint iv = (vint)ZEROV; #endif - for (int i = 0; i < fullhistheight; i++) { + for (unsigned i = 0; i < fullhistheight; i++) { #ifdef __SSE2__ vint areatempv = (vint)ZEROV; diff --git a/rtgui/mycurve.cc b/rtgui/mycurve.cc index c36ec1cc7..c1bec868a 100644 --- a/rtgui/mycurve.cc +++ b/rtgui/mycurve.cc @@ -175,7 +175,7 @@ bool MyCurve::snapCoordinateY(double testedVal, double realVal) float MyCurve::getVal(LUTf &curve, int x) { - if ((graphW - 2) == curve.getSize()) { + if (size_t(graphW - 2) == curve.getSize()) { return curve[x]; } else { return curve.getVal01(float(x) / (graphW - 3)); diff --git a/rtgui/mydiagonalcurve.cc b/rtgui/mydiagonalcurve.cc index 8bdb7fa0d..7d7d66a15 100644 --- a/rtgui/mydiagonalcurve.cc +++ b/rtgui/mydiagonalcurve.cc @@ -398,7 +398,7 @@ void MyDiagonalCurve::draw (int handle) double y2 = double(graphY) - 1.5 - double(graphH - 3) * points[pos + 1]; // project (curve.y.at(i), 0, 1, graphH); // set the color of the line when the point is snapped to the cage - if (curve.x.size() == nbPoints && snapToElmt >= 1000 && ((i == (snapToElmt - 1000)) || (i == (snapToElmt - 999)))) { + if (curve.x.size() == nbPoints && snapToElmt >= 1000 && ((int(i) == (snapToElmt - 1000)) || (int(i) == (snapToElmt - 999)))) { cr->set_source_rgb (1.0, 0.0, 0.0); } else { cr->set_source_rgb (c.get_red(), c.get_green(), c.get_blue()); @@ -606,7 +606,7 @@ bool MyDiagonalCurve::handleEvents (GdkEvent* event) edited_point = lit_point; std::vector newBoundaries(2); - unsigned int size = curve.x.size(); + int size = curve.x.size(); if (edited_point == 0) { newBoundaries.at(0).minVal = 0.; @@ -655,7 +655,7 @@ bool MyDiagonalCurve::handleEvents (GdkEvent* event) draw (lit_point); std::vector newBoundaries; newBoundaries.resize(2); - unsigned int size = curve.x.size(); + int size = curve.x.size(); if (edited_point == 0) { newBoundaries.at(0).minVal = 0.; @@ -888,7 +888,7 @@ bool MyDiagonalCurve::handleEvents (GdkEvent* event) } else { // snapping point to specific values if (snapTo && curve.x.at(grab_point) != -1.) { - if (grab_point > 0 && grab_point < (curve.y.size() - 1)) { + if (grab_point > 0 && unsigned(grab_point) < (curve.y.size() - 1)) { double prevX = curve.x.at(grab_point - 1); double prevY = curve.y.at(grab_point - 1); double nextX = curve.x.at(grab_point + 1); @@ -910,7 +910,7 @@ bool MyDiagonalCurve::handleEvents (GdkEvent* event) } } - if (grab_point < (curve.y.size() - 1)) { + if (grab_point < int(curve.y.size() - 1)) { int nextP = grab_point + 1; if (snapCoordinateY(curve.y.at(nextP), ugpY)) { @@ -1208,7 +1208,7 @@ void MyDiagonalCurve::pipetteDrag(EditDataProvider *provider, int modifierKey) // snapping point to specific values if (snapTo && curve.x.at(grab_point) != -1.) { - if (grab_point > 0 && grab_point < (curve.y.size() - 1)) { + if (grab_point > 0 && unsigned(grab_point) < (curve.y.size() - 1)) { double prevX = curve.x.at(grab_point - 1); double prevY = curve.y.at(grab_point - 1); double nextX = curve.x.at(grab_point + 1); @@ -1230,7 +1230,7 @@ void MyDiagonalCurve::pipetteDrag(EditDataProvider *provider, int modifierKey) } } - if (grab_point < (curve.y.size() - 1)) { + if (grab_point < int(curve.y.size() - 1)) { int nextP = grab_point + 1; if (snapCoordinateY(curve.y.at(nextP), ugpY)) { diff --git a/rtgui/myflatcurve.cc b/rtgui/myflatcurve.cc index 532557a3b..c98268683 100644 --- a/rtgui/myflatcurve.cc +++ b/rtgui/myflatcurve.cc @@ -711,7 +711,7 @@ bool MyFlatCurve::handleEvents (GdkEvent* event) setDirty(true); draw (); std::vector newBoundaries(4); - unsigned int size = curve.x.size(); + int size = curve.x.size(); if (edited_point == 0) { newBoundaries.at(0).minVal = 0.; @@ -761,7 +761,7 @@ bool MyFlatCurve::handleEvents (GdkEvent* event) setDirty(true); draw (); std::vector newBoundaries(4); - unsigned int size = curve.x.size(); + int size = curve.x.size(); if (edited_point == 0) { newBoundaries.at(0).minVal = 0.; @@ -1544,7 +1544,7 @@ void MyFlatCurve::movePoint(bool moveX, bool moveY, bool pipetteDrag) } if (curve.y.size() > 2) { - if (lit_point == (curve.y.size() - 1)) { + if (lit_point == int(curve.y.size()) - 1) { if (snapCoordinateY(curve.y.at(0), ugpY)) { snapToElmt = 0; } diff --git a/rtgui/popupcommon.cc b/rtgui/popupcommon.cc index 7dfdc0019..47d9efe66 100644 --- a/rtgui/popupcommon.cc +++ b/rtgui/popupcommon.cc @@ -107,8 +107,8 @@ void PopUpCommon::entrySelected (int i) void PopUpCommon::setItemSensitivity (int index, bool isSensitive) { const auto items = menu->get_children (); - if (index < items.size ()) { - items[index]->set_sensitive (isSensitive); + if (size_t(index) < items.size ()) { + items[size_t(index)]->set_sensitive (isSensitive); } } From 6171db443f0f130e23fed51f45d842840cf22e45 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Sat, 1 Apr 2017 20:16:01 +0200 Subject: [PATCH 65/90] Fix warning in extprog.cc --- rtgui/extprog.cc | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/rtgui/extprog.cc b/rtgui/extprog.cc index 30e33b6b9..bdbbb85b4 100644 --- a/rtgui/extprog.cc +++ b/rtgui/extprog.cc @@ -325,9 +325,7 @@ bool ExtProgStore::openInCustomEditor (const Glib::ustring& fileName) const auto cmdLine = Glib::ustring("\"") + options.customEditorProg + Glib::ustring("\""); auto success = ShellExecute( NULL, "open", cmdLine.c_str(), fileName.c_str(), NULL, SW_SHOWNORMAL ); - if ((uintptr_t)success > 32) { - return true; - } + return (uintptr_t)success > 32; #elif defined __APPLE__ From f9aa67b05e0553f1b7cd48c906f48e02f05ac06e Mon Sep 17 00:00:00 2001 From: heckflosse Date: Sat, 1 Apr 2017 20:59:10 +0200 Subject: [PATCH 66/90] Fix warning in rtengine/rawimage.cc and rtgui/dirbrowser.cc --- rtengine/rawimage.cc | 2 +- rtgui/dirbrowser.cc | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/rtengine/rawimage.cc b/rtengine/rawimage.cc index 8ec59b957..9bf0588a4 100644 --- a/rtengine/rawimage.cc +++ b/rtengine/rawimage.cc @@ -442,7 +442,7 @@ int RawImage::loadRaw (bool loadData, unsigned int imageNum, bool closeFile, Pro return 2; } - if(!strcmp(make,"Fujifilm") && raw_height * raw_width * 2 != raw_size) { + if(!strcmp(make,"Fujifilm") && raw_height * raw_width * 2u != raw_size) { parse_fuji_compressed_header(); } diff --git a/rtgui/dirbrowser.cc b/rtgui/dirbrowser.cc index a8825d310..572e779a6 100644 --- a/rtgui/dirbrowser.cc +++ b/rtgui/dirbrowser.cc @@ -21,7 +21,8 @@ #include #include -#ifdef WIN32 +#ifdef _WIN32_WINNT +#undef _WIN32_WINNT #define _WIN32_WINNT 0x0600 #include #endif From 3a90374d599c56a19155488d0ff312b776f77e7e Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sun, 2 Apr 2017 10:35:19 +0200 Subject: [PATCH 67/90] Fixed handling of shadows/highlights in simpleprocess.cc (broken by the fast export refactoring) See issue #3793 --- rtengine/simpleprocess.cc | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/rtengine/simpleprocess.cc b/rtengine/simpleprocess.cc index c49535a3c..2124ffb4d 100644 --- a/rtengine/simpleprocess.cc +++ b/rtengine/simpleprocess.cc @@ -55,6 +55,7 @@ public: tunnelMetaData(tunnelMetaData), flush(flush), // internal state + ipf_p(nullptr), ii(nullptr), imgsrc(nullptr), fw(-1), @@ -160,10 +161,11 @@ private: // MyTime t1,t2; // t1.set(); - ImProcFunctions ipf (¶ms, true); + ipf_p.reset(new ImProcFunctions(¶ms, true)); + ImProcFunctions &ipf = *(ipf_p.get()); pp = PreviewProps(0, 0, fw, fh, 1); - imgsrc->setCurrentFrame(params.raw.bayersensor.imageNum); + imgsrc->setCurrentFrame(params.raw.bayersensor.imageNum); imgsrc->preprocess( params.raw, params.lensProf, params.coarse, params.dirpyrDenoise.enabled); if (params.toneCurve.autoexp) {// this enabled HLRecovery @@ -733,7 +735,8 @@ private: void stage_denoise() { procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); + //ImProcFunctions ipf (¶ms, true); + ImProcFunctions &ipf = *(ipf_p.get()); // perform luma/chroma denoise // CieImage *cieView; @@ -797,7 +800,8 @@ private: void stage_transform() { procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); + //ImProcFunctions ipf (¶ms, true); + ImProcFunctions &ipf = *(ipf_p.get()); imgsrc->convertColorSpace(baseImg, params.icm, currWB); @@ -819,7 +823,8 @@ private: Image16 *stage_finish() { procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); + //ImProcFunctions ipf (¶ms, true); + ImProcFunctions &ipf = *(ipf_p.get()); if (params.dirpyrequalizer.cbdlMethod == "bef" && params.dirpyrequalizer.enabled && !params.colorappearance.enabled) { const int W = baseImg->getWidth(); @@ -1344,7 +1349,8 @@ private: void stage_early_resize() { procparams::ProcParams& params = job->pparams; - ImProcFunctions ipf (¶ms, true); + //ImProcFunctions ipf (¶ms, true); + ImProcFunctions &ipf = *(ipf_p.get()); int imw, imh; double scale_factor = ipf.resizeScale(¶ms, fw, fh, imw, imh); @@ -1445,6 +1451,7 @@ private: bool flush; // internal state + std::unique_ptr ipf_p; InitialImage *ii; ImageSource *imgsrc; int fw; From dbfb1c480bbac370b0fdfde714dc540b4aaba6a8 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Sun, 2 Apr 2017 19:13:46 +0200 Subject: [PATCH 68/90] Fix warning in myfile.h --- rtengine/myfile.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/rtengine/myfile.h b/rtengine/myfile.h index 771dd7b84..e4609c697 100644 --- a/rtengine/myfile.h +++ b/rtengine/myfile.h @@ -68,7 +68,10 @@ inline void fseek (IMFILE* f, int p, int how) } else if (how == SEEK_CUR) { f->pos += p; } else if (how == SEEK_END) { - f->pos = f->size + p; + if(p <= 0 && -p <= f->size) { + f->pos = f->size + p; + } + return; } if (f->pos < 0 || f->pos > f->size) { From 817f4cee834c58597629354000461a89efe6fe62 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Sun, 2 Apr 2017 19:35:08 +0200 Subject: [PATCH 69/90] Fix all warnings in fujicompressed.cc --- rtengine/fujicompressed.cc | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/rtengine/fujicompressed.cc b/rtengine/fujicompressed.cc index 2e0b83485..75ca46c04 100644 --- a/rtengine/fujicompressed.cc +++ b/rtengine/fujicompressed.cc @@ -20,7 +20,7 @@ it under the terms of the one of three licenses as you choose: void CLASS init_fuji_compr (struct fuji_compressed_params* info) { - int cur_val, i; + int cur_val; char *qt; if ((fuji_block_width % 3 && fuji_raw_type == 16) || (fuji_block_width & 1 && fuji_raw_type == 0)) { @@ -171,7 +171,7 @@ void CLASS copy_line_to_xtrans (struct fuji_compressed_block* info, int cur_line while (row_count < 6) { pixel_count = 0; - while (pixel_count < cur_block_width) { + while (static_cast(pixel_count) < cur_block_width) { switch (xtrans_abs[row_count][ (pixel_count % 6)]) { case 0: // red line_buf = lineBufR[row_count >> 1]; @@ -182,11 +182,12 @@ void CLASS copy_line_to_xtrans (struct fuji_compressed_block* info, int cur_line break; case 2: // blue + default: line_buf = lineBufB[row_count >> 1]; break; } - index = (((pixel_count * 2 / 3) & 0x7FFFFFFE) | (pixel_count % 3) & 1) + ((pixel_count % 3) >> 1); + index = (((pixel_count * 2 / 3) & 0x7FFFFFFE) | ((pixel_count % 3) & 1)) + ((pixel_count % 3) >> 1); raw_block_data[pixel_count] = line_buf[index]; ++pixel_count; @@ -228,7 +229,7 @@ void CLASS copy_line_to_bayer (struct fuji_compressed_block *info, int cur_line, while (row_count < 6) { pixel_count = 0; - while (pixel_count < cur_block_width) { + while (static_cast(pixel_count) < cur_block_width) { switch (fuji_bayer[row_count & 1][pixel_count & 1]) { case 0: // red line_buf = lineBufR[row_count >> 1]; @@ -897,12 +898,11 @@ void CLASS fuji_compressed_load_raw() { struct fuji_compressed_params common_info; int cur_block; - unsigned line_size, *block_sizes; + unsigned *block_sizes; INT64 raw_offset, *raw_block_offsets; //struct fuji_compressed_block info; init_fuji_compr (&common_info); - line_size = sizeof (ushort) * (common_info.line_width + 2); // read block sizes block_sizes = (unsigned*) malloc (sizeof (unsigned) * fuji_total_blocks); From de64d21b37d885353ca85d36c59ad2bbdcd5d9af Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 3 Apr 2017 13:58:15 +0200 Subject: [PATCH 70/90] =?UTF-8?q?Crash=20when=20switching=20between=20raw?= =?UTF-8?q?=20and=20tif,=20fixes=20#3797.=20Thanks=20to=20Fl=C3=B6ssie=20f?= =?UTF-8?q?or=20the=20patch!?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- rtgui/toolpanelcoord.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/rtgui/toolpanelcoord.cc b/rtgui/toolpanelcoord.cc index cacbee99d..7920b7a9b 100644 --- a/rtgui/toolpanelcoord.cc +++ b/rtgui/toolpanelcoord.cc @@ -311,6 +311,7 @@ ToolPanelCoordinator::~ToolPanelCoordinator () void ToolPanelCoordinator::imageTypeChanged(bool isRaw, bool isBayer, bool isXtrans) { + GThreadLock lock; if(isRaw) { rawPanelSW->set_sensitive(true); From 4c7b7683c1e494c75c4417b539214bc8a744256c Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 3 Apr 2017 17:14:42 +0200 Subject: [PATCH 71/90] Fixes some warnings and disabled the remaining ones in dcraw.cc --- rtengine/dcraw.cc | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/rtengine/dcraw.cc b/rtengine/dcraw.cc index 4beec664d..f598b35a3 100644 --- a/rtengine/dcraw.cc +++ b/rtengine/dcraw.cc @@ -1,3 +1,10 @@ +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Warray-bounds" +#pragma GCC diagnostic ignored "-Wsign-compare" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif + /*RT*/#include /*RT*/#include /*RT*/#undef MAX @@ -251,7 +258,11 @@ void CLASS derror() if (feof(ifp)) fprintf (stderr,_("Unexpected end of file\n")); else +#ifdef WIN32 + fprintf (stderr,_("Corrupt data near 0x%I64x\n"), (INT64) ftello(ifp)); +#else fprintf (stderr,_("Corrupt data near 0x%llx\n"), (INT64) ftello(ifp)); +#endif } data_error++; /*RT Issue 2467 longjmp (failure, 1);*/ @@ -1840,8 +1851,8 @@ void CLASS parse_hasselblad_gain() not be seen as clipped). */ - ushort raw_h, count, ch_count, u16; - int i, offset; + ushort raw_h; + int offset; off_t base; base = ftell(ifp); @@ -9881,3 +9892,6 @@ struct tiff_hdr { /*RT*/#undef LIM /*RT*/#undef ULIM /*RT*/#undef CLIP +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif \ No newline at end of file From c600ad056d52f6809cba4669cbbaa814e5cedf1c Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 3 Apr 2017 17:15:43 +0200 Subject: [PATCH 72/90] =?UTF-8?q?Fixed=20warnings=20in=20rtthumbnail.cc=20?= =?UTF-8?q?(by=20Fl=C3=B6ssie)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- rtengine/rtthumbnail.cc | 44 +++++++++++++++++++++++++++-------------- 1 file changed, 29 insertions(+), 15 deletions(-) diff --git a/rtengine/rtthumbnail.cc b/rtengine/rtthumbnail.cc index 500c5cd85..5e459318c 100644 --- a/rtengine/rtthumbnail.cc +++ b/rtengine/rtthumbnail.cc @@ -50,7 +50,7 @@ namespace return false; } - const std::size_t length = + const ssize_t length = fdata(raw_image.get_thumbOffset(), raw_image.get_file())[1] != 0xD8 && raw_image.is_ppmThumb() ? raw_image.get_thumbWidth() * raw_image.get_thumbHeight() * (raw_image.get_thumbBPS() / 8) * 3 : raw_image.get_thumbLength(); @@ -254,7 +254,7 @@ Thumbnail* Thumbnail::loadQuickFromRaw (const Glib::ustring& fname, RawMetaDataL std::string fname = ri->get_filename(); std::string suffix = fname.length() > 4 ? fname.substr(fname.length() - 3) : ""; - for (int i = 0; i < suffix.length(); i++) { + for (unsigned int i = 0; i < suffix.length(); i++) { suffix[i] = std::tolower(suffix[i]); } @@ -500,8 +500,8 @@ Thumbnail* Thumbnail::loadFromRaw (const Glib::ustring& fname, RawMetaDataLocati for (int row = 0; row < high; row++) for (int col = 0; col < wide; col++) { - unsigned ur = r = fw + (row - col) * step; - unsigned uc = c = (row + col) * step; + int ur = r = fw + (row - col) * step; + int uc = c = (row + col) * step; if (ur > tmph - 2 || uc > tmpw - 2) { continue; @@ -779,17 +779,33 @@ void Thumbnail::init () } Thumbnail::Thumbnail () : - iColorMatrix{}, cam2xyz{}, scale(1.0), colorMatrix{}, isRaw(true), - camProfile(nullptr), thumbImg(nullptr), - camwbRed(1.0), camwbGreen(1.0), camwbBlue(1.0), - redAWBMul(-1.0), greenAWBMul(-1.0), blueAWBMul(-1.0), - autoWBTemp(2700), autoWBGreen(1.0), wbEqual(-1.0), wbTempBias(0.0), - embProfileLength(0), embProfileData(nullptr), embProfile(nullptr), - redMultiplier(1.0), greenMultiplier(1.0), blueMultiplier(1.0), + camProfile(nullptr), + iColorMatrix{}, + cam2xyz{}, + thumbImg(nullptr), + camwbRed(1.0), + camwbGreen(1.0), + camwbBlue(1.0), + redAWBMul(-1.0), + greenAWBMul(-1.0), + blueAWBMul(-1.0), + autoWBTemp(2700), + autoWBGreen(1.0), + wbEqual(-1.0), + wbTempBias(0.0), + aeHistCompression(3), + embProfileLength(0), + embProfileData(nullptr), + embProfile(nullptr), + redMultiplier(1.0), + greenMultiplier(1.0), + blueMultiplier(1.0), + scale(1.0), defGain(1.0), scaleForSave(8192), gammaCorrected(false), - aeHistCompression(3) + colorMatrix{}, + isRaw(true) { } @@ -959,7 +975,6 @@ IImage8* Thumbnail::processImage (const procparams::ProcParams& params, int rhei LUTu hist16 (65536); - double gamma = isRaw ? Color::sRGBGamma : 0; // usually in ImageSource, but we don't have that here ipf.firstAnalysis (baseImg, params, hist16); // perform transform @@ -967,7 +982,7 @@ IImage8* Thumbnail::processImage (const procparams::ProcParams& params, int rhei Imagefloat* trImg = new Imagefloat (fw, fh); int origFW; int origFH; - double tscale; + double tscale = 0.0; getDimensions(origFW, origFH, tscale); ipf.transform (baseImg, trImg, 0, 0, 0, 0, fw, fh, origFW * tscale + 0.5, origFH * tscale + 0.5, focalLen, focalLen35mm, focusDist, 0, true); // Raw rotate degree not detectable here delete baseImg; @@ -1193,7 +1208,6 @@ IImage8* Thumbnail::processImage (const procparams::ProcParams& params, int rhei LUTf CAMBrightCurveQ; float CAMMean; int sk; - int scale; sk = 16; int rtt = 0; CieImage* cieView = new CieImage (fw, fh); From 55b768edfcfd636f04dbd6e015bc725e8283d4a2 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 3 Apr 2017 17:16:30 +0200 Subject: [PATCH 73/90] Disabled -Wdeprecated-declarations in main.cc --- rtgui/main.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/rtgui/main.cc b/rtgui/main.cc index 155d9f3ba..0af9082cf 100644 --- a/rtgui/main.cc +++ b/rtgui/main.cc @@ -21,6 +21,8 @@ #if defined(__FAST_MATH__) #error Using the -ffast-math CFLAG is known to lead to problems. Disable it to compile RawTherapee. #endif +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" #endif #include "config.h" @@ -465,3 +467,6 @@ int processLineParams( int argc, char **argv ) return errors > 0 ? -2 : 0; } +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ \ No newline at end of file From 602162a343186a0f1d81b685b4b1f08894b13bc8 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 3 Apr 2017 17:17:05 +0200 Subject: [PATCH 74/90] Enable -Wall --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 31a04b569..f8dc38d01 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -296,7 +296,7 @@ endif (WITH_PROF) if (OPTION_OMP) find_package(OpenMP) if (OPENMP_FOUND) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -Werror=unknown-pragmas") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -Werror=unknown-pragmas -Wall") endif (OPENMP_FOUND) endif (OPTION_OMP) From 9b5f4296026673d65dfd5f60b9086af743c0f237 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Mon, 3 Apr 2017 21:01:28 +0200 Subject: [PATCH 75/90] Fixed another bunch of warnings --- CMakeLists.txt | 2 +- rtengine/dcraw.cc | 4 ++++ rtengine/demosaic_algos.cc | 4 ++-- rtengine/dirpyr_equalizer.cc | 2 +- rtengine/gauss.cc | 4 ++-- rtengine/imageio.cc | 6 ++---- rtengine/improcfun.cc | 18 +++++++++--------- rtengine/ipretinex.cc | 2 +- rtengine/ipsharpen.cc | 2 +- rtengine/rawimagesource.cc | 4 ++-- rtgui/main.cc | 5 ----- 11 files changed, 25 insertions(+), 28 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f8dc38d01..a7e29e03a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -296,7 +296,7 @@ endif (WITH_PROF) if (OPTION_OMP) find_package(OpenMP) if (OPENMP_FOUND) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -Werror=unknown-pragmas -Wall") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -Werror=unknown-pragmas -Wall -Wno-unused-result -Wno-deprecated-declarations") endif (OPENMP_FOUND) endif (OPTION_OMP) diff --git a/rtengine/dcraw.cc b/rtengine/dcraw.cc index f598b35a3..e55c0256b 100644 --- a/rtengine/dcraw.cc +++ b/rtengine/dcraw.cc @@ -3,6 +3,10 @@ #pragma GCC diagnostic ignored "-Warray-bounds" #pragma GCC diagnostic ignored "-Wsign-compare" #pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#pragma GCC diagnostic ignored "-Wparentheses" +#if (__GNUC__ == 6) +#pragma GCC diagnostic ignored "-Wmisleading-indentation" +#endif #endif /*RT*/#include diff --git a/rtengine/demosaic_algos.cc b/rtengine/demosaic_algos.cc index 7896219e5..847af784f 100644 --- a/rtengine/demosaic_algos.cc +++ b/rtengine/demosaic_algos.cc @@ -1338,7 +1338,7 @@ SSEFUNCTION void RawImageSource::lmmse_interpolate_omp(int winw, int winh, array h3 /= hs; h4 /= hs; int passref = 0; - int iter; + int iter = 0; if(iterations <= 4) { iter = iterations - 1; @@ -4011,7 +4011,7 @@ void RawImageSource::xtrans_interpolate (const int passes, const bool useCieLab) // sgrow/sgcol is the offset in the sensor matrix of the solitary // green pixels - ushort sgrow, sgcol; + ushort sgrow = 0, sgcol = 0; const int height = H, width = W; diff --git a/rtengine/dirpyr_equalizer.cc b/rtengine/dirpyr_equalizer.cc index a3a6d81b0..e0527140b 100644 --- a/rtengine/dirpyr_equalizer.cc +++ b/rtengine/dirpyr_equalizer.cc @@ -149,7 +149,7 @@ SSEFUNCTION void ImProcFunctions :: dirpyr_equalizer(float ** src, float ** dst, level ++; } - float **tmpHue, **tmpChr; + float **tmpHue = nullptr, **tmpChr = nullptr; if(skinprot != 0.f) { // precalculate hue and chroma, use SSE, if available diff --git a/rtengine/gauss.cc b/rtengine/gauss.cc index 4b84a125a..c7be015dc 100644 --- a/rtengine/gauss.cc +++ b/rtengine/gauss.cc @@ -231,8 +231,8 @@ template void gaussHorizontal3 (T** src, T** dst, int W, int H, const f #ifdef __SSE2__ template SSEFUNCTION void gaussVertical3 (T** src, T** dst, int W, int H, const float c0, const float c1) { - vfloat Tv, Tm1v, Tp1v; - vfloat Tv1, Tm1v1, Tp1v1; + vfloat Tv = F2V(0.f), Tm1v, Tp1v; + vfloat Tv1 = F2V(0.f), Tm1v1, Tp1v1; vfloat c0v, c1v; c0v = F2V(c0); c1v = F2V(c1); diff --git a/rtengine/imageio.cc b/rtengine/imageio.cc index fea072594..197055858 100644 --- a/rtengine/imageio.cc +++ b/rtengine/imageio.cc @@ -216,9 +216,8 @@ int ImageIO::getPNGSampleFormat (Glib::ustring fname, IIOSampleFormat &sFormat, //reading PNG header unsigned char header[8]; - fread (header, 1, 8, file); - if (png_sig_cmp (header, 0, 8)) { + if (fread (header, 1, 8, file) != 8 || png_sig_cmp (header, 0, 8)) { fclose(file); return IMIO_HEADERERROR; } @@ -295,9 +294,8 @@ int ImageIO::loadPNG (Glib::ustring fname) //reading PNG header unsigned char header[8]; - fread (header, 1, 8, file); - if (png_sig_cmp (header, 0, 8)) { + if (fread (header, 1, 8, file) != 8 || png_sig_cmp (header, 0, 8)) { fclose(file); return IMIO_HEADERERROR; } diff --git a/rtengine/improcfun.cc b/rtengine/improcfun.cc index 93a23d692..362fdc09a 100644 --- a/rtengine/improcfun.cc +++ b/rtengine/improcfun.cc @@ -1474,7 +1474,7 @@ void ImProcFunctions::ciecam_02float (CieImage* ncie, float adap, int begh, int float Yw; Yw = 1.0; double Xw, Zw; - float f, nc, yb = 0.f, la, c, xw, yw, zw, f2, c2 = 1.f, nc2, yb2; + float f, nc, yb = 0.f, la, c, xw, yw, zw, f2 = 1.f, c2 = 1.f, nc2 = 1.f, yb2; float fl, n, nbb, ncb, aw; //d float xwd, ywd, zwd; int alg = 0; @@ -2952,7 +2952,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer } } - int h_th, s_th; + int h_th = 0, s_th = 0; if (shmap) { h_th = shmap->max_f - params->sh.htonalwidth * (shmap->max_f - shmap->avg) / 100; @@ -3007,10 +3007,10 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer params->chmixer.green[0] != 0 || params->chmixer.green[1] != 100 || params->chmixer.green[2] != 0 || params->chmixer.blue[0] != 0 || params->chmixer.blue[1] != 0 || params->chmixer.blue[2] != 100); - FlatCurve* hCurve; - FlatCurve* sCurve; - FlatCurve* vCurve; - FlatCurve* bwlCurve; + FlatCurve* hCurve = nullptr; + FlatCurve* sCurve = nullptr; + FlatCurve* vCurve = nullptr; + FlatCurve* bwlCurve = nullptr; FlatCurveType hCurveType = (FlatCurveType)params->hsvequalizer.hcurve.at(0); FlatCurveType sCurveType = (FlatCurveType)params->hsvequalizer.scurve.at(0); @@ -3064,7 +3064,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer std::shared_ptr hald_clut; bool clutAndWorkingProfilesAreSame = false; - TMatrix xyz2clut, clut2xyz; + TMatrix xyz2clut = {}, clut2xyz = {}; #ifdef __SSE2__ vfloat v_work2xyz[3][3] ALIGNED16; vfloat v_xyz2clut[3][3] ALIGNED16; @@ -3253,7 +3253,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer // For tonecurve histogram int toneCurveHistSize = histToneCurve ? histToneCurve.getSize() : 0; - int histToneCurveCompression; + int histToneCurveCompression = 0; if(toneCurveHistSize > 0) { histToneCurve.clear(); @@ -4650,7 +4650,7 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer twocol = false; } - float iplow, iphigh; + float iplow = 0.f, iphigh = 0.f; if(!twocol) { iplow = (float)ctColorCurve.low; diff --git a/rtengine/ipretinex.cc b/rtengine/ipretinex.cc index 829810042..321298349 100644 --- a/rtengine/ipretinex.cc +++ b/rtengine/ipretinex.cc @@ -345,7 +345,7 @@ void RawImageSource::MSR(float** luminance, float** originalLuminance, float **e src[i] = &srcBuffer[i * W_L]; } - int h_th, s_th; + int h_th = 0, s_th = 0; int shHighlights = deh.highlights; int shShadows = deh.shadows; diff --git a/rtengine/ipsharpen.cc b/rtengine/ipsharpen.cc index c1a2f479e..5b96fc971 100644 --- a/rtengine/ipsharpen.cc +++ b/rtengine/ipsharpen.cc @@ -934,7 +934,7 @@ void ImProcFunctions::sharpeningcam (CieImage* ncie, float** b2) // Rest is UNSHARP MASK int W = ncie->W, H = ncie->H; - float** b3; + float** b3 = nullptr; if (params->sharpening.edgesonly) { b3 = new float*[H]; diff --git a/rtengine/rawimagesource.cc b/rtengine/rawimagesource.cc index 9170628e0..731166117 100644 --- a/rtengine/rawimagesource.cc +++ b/rtengine/rawimagesource.cc @@ -672,7 +672,7 @@ void RawImageSource::getImage (const ColorTemp &ctemp, int tran, Imagefloat* ima defGain = 0.0; // compute image area to render in order to provide the requested part of the image - int sx1, sy1, imwidth, imheight, fw, d1xHeightOdd; + int sx1, sy1, imwidth, imheight, fw, d1xHeightOdd = 0; transformRect (pp, tran, sx1, sy1, imwidth, imheight, fw); // check possible overflows @@ -2384,7 +2384,7 @@ void RawImageSource::retinex(ColorManagementParams cmp, RetinexParams deh, ToneC LUTf lutToneireti; lutToneireti(65536); - LUTf *retinexigamtab;//gamma before and after Retinex to restore tones + LUTf *retinexigamtab = nullptr;//gamma before and after Retinex to restore tones if(deh.gammaretinex == "low") { retinexigamtab = &(Color::igammatab_115_2); diff --git a/rtgui/main.cc b/rtgui/main.cc index 0af9082cf..155d9f3ba 100644 --- a/rtgui/main.cc +++ b/rtgui/main.cc @@ -21,8 +21,6 @@ #if defined(__FAST_MATH__) #error Using the -ffast-math CFLAG is known to lead to problems. Disable it to compile RawTherapee. #endif -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" #endif #include "config.h" @@ -467,6 +465,3 @@ int processLineParams( int argc, char **argv ) return errors > 0 ? -2 : 0; } -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif // __GNUC__ \ No newline at end of file From 084f264aa9f38e52533d26c97912215c79c8912a Mon Sep 17 00:00:00 2001 From: heckflosse Date: Tue, 4 Apr 2017 14:39:50 +0200 Subject: [PATCH 76/90] Fixed another two warnings --- rtengine/ipwavelet.cc | 2 +- rtengine/rawimagesource.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/rtengine/ipwavelet.cc b/rtengine/ipwavelet.cc index 8ab7e0b4d..5e0188856 100644 --- a/rtengine/ipwavelet.cc +++ b/rtengine/ipwavelet.cc @@ -699,7 +699,7 @@ SSEFUNCTION void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int int width = tileright - tileleft; int height = tilebottom - tiletop; LabImage * labco; - float **Lold; + float **Lold = nullptr; float *LoldBuffer = nullptr; if(numtiles == 1) { // untiled processing => we can use output buffer for labco diff --git a/rtengine/rawimagesource.cc b/rtengine/rawimagesource.cc index 731166117..7c99801c6 100644 --- a/rtengine/rawimagesource.cc +++ b/rtengine/rawimagesource.cc @@ -2111,7 +2111,7 @@ void RawImageSource::retinexPrepareBuffers(ColorManagementParams cmp, RetinexPar conversionBuffer[2] (W - 2 * border, H - 2 * border); conversionBuffer[3] (W - 2 * border, H - 2 * border); - LUTf *retinexgamtab;//gamma before and after Retinex to restore tones + LUTf *retinexgamtab = nullptr;//gamma before and after Retinex to restore tones LUTf lutTonereti; if(retinexParams.gammaretinex == "low") { From 9723dca95a0c6e7d39ef0f593037ed8dcc1704c9 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Tue, 4 Apr 2017 21:23:20 +0200 Subject: [PATCH 77/90] Fix another warning in gauss.cc, by Alberto Griggio --- rtengine/gauss.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/gauss.cc b/rtengine/gauss.cc index c7be015dc..09c91db1e 100644 --- a/rtengine/gauss.cc +++ b/rtengine/gauss.cc @@ -921,7 +921,7 @@ template void gaussVertical (T** src, T** dst, const int W, const int H #pragma omp for nowait #endif - for (int i = 0; i < W - numcols + 1; i += numcols) { + for (unsigned int i = 0; i < static_cast(std::max(0, W - numcols + 1)); i += numcols) { for (int k = 0; k < numcols; k++) { temp2[0][k] = B * src[0][i + k] + b1 * src[0][i + k] + b2 * src[0][i + k] + b3 * src[0][i + k]; temp2[1][k] = B * src[1][i + k] + b1 * temp2[0][k] + b2 * src[0][i + k] + b3 * src[0][i + k]; From 0a89447d85d82c534fefa8110ddd85fd523b33f1 Mon Sep 17 00:00:00 2001 From: Morgan Hardwood Date: Wed, 5 Apr 2017 13:58:36 +0200 Subject: [PATCH 78/90] add Lens ID2 for new Sony FE 85/1.8, fixes #3800 --- rtexif/sonyminoltaattribs.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/rtexif/sonyminoltaattribs.cc b/rtexif/sonyminoltaattribs.cc index a559969bf..d838934fc 100644 --- a/rtexif/sonyminoltaattribs.cc +++ b/rtexif/sonyminoltaattribs.cc @@ -1023,6 +1023,7 @@ public: {65535, "Sony FE PZ 28-135mm f/4 G OSS"}, {65535, "Sony FE 24-70mm f/2.8 GM"}, {65535, "Sony FE 85mm f/1.4 GM"}, + {65535, "Sony FE 85mm f/1.8"}, {65535, "Sony FE 50mm f/1.8"}, {65535, "Sony FE 21mm f/2.8 (SEL28F20 + SEL075UWC)"}, {65535, "Sony FE 16mm f/3.5 Fisheye (SEL28F20 + SEL057FEC)"}, @@ -1112,6 +1113,7 @@ public: choices.insert(p_t(32793, "Sony E PZ 16-50mm f/3.5-5.6 OSS")); choices.insert(p_t(32794, "Sony FE 35mm f/2.8 ZA")); choices.insert(p_t(32795, "Sony FE 24-70mm f/4 ZA OSS")); + choices.insert(p_t(32796, "Sony FE 85mm f/1.8")); choices.insert(p_t(32797, "Sony E 18-200mm f/3.5-6.3 OSS LE")); choices.insert(p_t(32798, "Sony E 20mm f/2.8")); choices.insert(p_t(32799, "Sony E 35mm f/1.8 OSS")); From 30a31cfc73ec67409bb9d9b46e40f11bb080b395 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Thu, 6 Apr 2017 09:00:02 +0200 Subject: [PATCH 79/90] Make rtengine::Thumbnail use the same logic as RawImageSource for computing black and white levels See issue #3804 --- rtengine/rtthumbnail.cc | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/rtengine/rtthumbnail.cc b/rtengine/rtthumbnail.cc index 5e459318c..5e2b65e65 100644 --- a/rtengine/rtthumbnail.cc +++ b/rtengine/rtthumbnail.cc @@ -58,6 +58,20 @@ namespace return raw_image.get_thumbOffset() + length <= raw_image.get_file()->size; } + +void scale_colors(rtengine::RawImage *ri, float scale_mul[4], float cblack[4]) +{ + DCraw::dcrawImage_t image = ri->get_image(); + int size = ri->get_iheight() * ri->get_iwidth(); + + for (int i = 0; i < size * 4; ++i) { + float val = reinterpret_cast(image)[i]; + val -= cblack[i & 3]; + val *= scale_mul[i & 3]; + reinterpret_cast(image)[i] = rtengine::CLIP(val); + } +} + } extern Options options; @@ -333,17 +347,23 @@ Thumbnail* Thumbnail::loadFromRaw (const Glib::ustring& fname, RawMetaDataLocati tpp->greenMultiplier = ri->get_pre_mul(1); tpp->blueMultiplier = ri->get_pre_mul(2); - ri->scale_colors(); + //ri->scale_colors(); + float pre_mul[4], scale_mul[4], cblack[4]; + ri->get_colorsCoeff(pre_mul, scale_mul, cblack, false); + scale_colors(ri, scale_mul, cblack); + ri->pre_interpolate(); rml.exifBase = ri->get_exifBase(); rml.ciffBase = ri->get_ciffBase(); rml.ciffLength = ri->get_ciffLen(); - tpp->camwbRed = tpp->redMultiplier / ri->get_pre_mul(0); - tpp->camwbGreen = tpp->greenMultiplier / ri->get_pre_mul(1); - tpp->camwbBlue = tpp->blueMultiplier / ri->get_pre_mul(2); - tpp->defGain = 1.0 / min(ri->get_pre_mul(0), ri->get_pre_mul(1), ri->get_pre_mul(2)); + tpp->camwbRed = tpp->redMultiplier / pre_mul[0]; //ri->get_pre_mul(0); + tpp->camwbGreen = tpp->greenMultiplier / pre_mul[1]; //ri->get_pre_mul(1); + tpp->camwbBlue = tpp->blueMultiplier / pre_mul[2]; //ri->get_pre_mul(2); + //tpp->defGain = 1.0 / min(ri->get_pre_mul(0), ri->get_pre_mul(1), ri->get_pre_mul(2)); + tpp->defGain = max(scale_mul[0], scale_mul[1], scale_mul[2], scale_mul[3]) / min(scale_mul[0], scale_mul[1], scale_mul[2], scale_mul[3]); + tpp->gammaCorrected = true; unsigned filter = ri->get_filters(); From 6dfe6f95b88f896b2ade67033ae84282f245b2a6 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Thu, 6 Apr 2017 09:00:53 +0200 Subject: [PATCH 80/90] Fix wrong computation of black levels (in some cases) in RawImage::get_colorsCoeff Was happening e.g. with compressed DNG files --- rtengine/rawimage.cc | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/rtengine/rawimage.cc b/rtengine/rawimage.cc index 9bf0588a4..19fcb6c16 100644 --- a/rtengine/rawimage.cc +++ b/rtengine/rawimage.cc @@ -98,7 +98,10 @@ void RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, float *cblac } } else if ((this->get_cblack(4) + 1) / 2 == 1 && (this->get_cblack(5) + 1) / 2 == 1) { for (int c = 0; c < 4; c++) { - cblack_[FC(c / 2, c % 2)] = this->get_cblack(6 + c / 2 % this->get_cblack(4) * this->get_cblack(5) + c % 2 % this->get_cblack(5)); + cblack_[c] = this->get_cblack(c); + } + for (int c = 0; c < 4; c++) { + cblack_[FC(c / 2, c % 2)] += this->get_cblack(6 + c / 2 % this->get_cblack(4) * this->get_cblack(5) + c % 2 % this->get_cblack(5)); pre_mul_[c] = this->get_pre_mul(c); } } else { From 9c7ed822e15a01f2e9fcd4ba39bec4aa8a4cd43f Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Thu, 6 Apr 2017 09:47:29 +0200 Subject: [PATCH 81/90] implementation of scale_colors without reinterpret_cast (thanks @Floessie) --- rtengine/rtthumbnail.cc | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/rtengine/rtthumbnail.cc b/rtengine/rtthumbnail.cc index 5e2b65e65..1d2706b7a 100644 --- a/rtengine/rtthumbnail.cc +++ b/rtengine/rtthumbnail.cc @@ -62,13 +62,14 @@ namespace void scale_colors(rtengine::RawImage *ri, float scale_mul[4], float cblack[4]) { DCraw::dcrawImage_t image = ri->get_image(); - int size = ri->get_iheight() * ri->get_iwidth(); - - for (int i = 0; i < size * 4; ++i) { - float val = reinterpret_cast(image)[i]; - val -= cblack[i & 3]; - val *= scale_mul[i & 3]; - reinterpret_cast(image)[i] = rtengine::CLIP(val); + const int size = ri->get_iheight() * ri->get_iwidth(); + for (int i = 0; i < size; ++i) { + for (int j = 0; j < 4; ++j) { + float val = image[i][j]; + val -= cblack[j]; + val *= scale_mul[j]; + image[i][j] = rtengine::CLIP(val); + } } } From 795a473602b04c2a162df5ca2cbb594e12674bca Mon Sep 17 00:00:00 2001 From: Morgan Hardwood Date: Thu, 6 Apr 2017 12:27:44 +0200 Subject: [PATCH 82/90] generateTranslationDiffs --- rtdata/languages/Catala | 41 ++++++++++------- rtdata/languages/Chinese (Simplified) | 41 ++++++++++------- rtdata/languages/Chinese (Traditional) | 44 +++++++++++-------- rtdata/languages/Czech | 39 ++++++++++------ rtdata/languages/Dansk | 44 +++++++++++-------- rtdata/languages/Deutsch | 15 +++++++ rtdata/languages/English (UK) | 44 +++++++++++-------- rtdata/languages/English (US) | 44 +++++++++++-------- rtdata/languages/Espanol | 39 ++++++++++------ rtdata/languages/Euskara | 44 +++++++++++-------- rtdata/languages/Francais | 36 +++++++++------ rtdata/languages/Greek | 44 +++++++++++-------- rtdata/languages/Hebrew | 44 +++++++++++-------- rtdata/languages/Italiano | 39 ++++++++++------ rtdata/languages/Japanese | 39 ++++++++++------ rtdata/languages/Latvian | 44 +++++++++++-------- rtdata/languages/Magyar | 41 ++++++++++------- rtdata/languages/Nederlands | 39 ++++++++++------ rtdata/languages/Norsk BM | 44 +++++++++++-------- rtdata/languages/Polish | 39 ++++++++++------ rtdata/languages/Polish (Latin Characters) | 39 ++++++++++------ rtdata/languages/Portugues (Brasil) | 44 +++++++++++-------- rtdata/languages/Russian | 39 ++++++++++------ rtdata/languages/Serbian (Cyrilic Characters) | 39 ++++++++++------ rtdata/languages/Serbian (Latin Characters) | 39 ++++++++++------ rtdata/languages/Slovak | 44 +++++++++++-------- rtdata/languages/Suomi | 44 +++++++++++-------- rtdata/languages/Swedish | 39 ++++++++++------ rtdata/languages/Turkish | 44 +++++++++++-------- rtdata/languages/default | 16 +++---- 30 files changed, 736 insertions(+), 455 deletions(-) diff --git a/rtdata/languages/Catala b/rtdata/languages/Catala index e311b3a40..d2c610e9e 100644 --- a/rtdata/languages/Catala +++ b/rtdata/languages/Catala @@ -983,8 +983,13 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: - !DYNPROFILEEDITOR_PROFILE;Processing Profile !EDIT_OBJECT_TOOLTIP;Displays a widget on the preview window which lets you adjust this tool. !EDIT_PIPETTE_TOOLTIP;To add an adjustment point to the curve, hold the Ctrl key while left-clicking the desired spot in the image preview.\nTo adjust the point, hold the Ctrl key while left-clicking the corresponding area in the preview, then let go of Ctrl (unless you desire fine control) and while still holding the left mouse button move the mouse up or down to move that point up or down in the curve. +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels !EXPORT_BYPASS_RAW_LMMSE_ITERATIONS;Bypass [raw] LMMSE Enhancement Steps +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !FILEBROWSER_COLORLABEL_TOOLTIP;Color label.\n\nUse dropdown menu or shortcuts:\nShift-Ctrl-0 No Color\nShift-Ctrl-1 Red\nShift-Ctrl-2 Yellow\nShift-Ctrl-3 Green\nShift-Ctrl-4 Blue\nShift-Ctrl-5 Purple !FILEBROWSER_POPUPCOLORLABEL0;Label: None !FILEBROWSER_POPUPCOLORLABEL1;Label: Red @@ -1003,6 +1008,7 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: - !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILEBROWSER_UNRANK_TOOLTIP;Unrank.\nShortcut: Shift-0 @@ -1379,8 +1385,11 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: - !PARTIALPASTE_PREPROCESS_DEADPIXFILT;Dead pixel filter !PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1417,6 +1426,8 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLUOF2;Fluorescent F2 !PREFERENCES_FLUOF7;Fluorescent F7 @@ -1817,28 +1828,28 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: - !TP_RAWEXPOS_BLACK_GREEN;Green !TP_RAWEXPOS_BLACK_RED;Red !TP_RAWEXPOS_RGB;Red, Green, Blue -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1887,7 +1898,7 @@ ZOOMPANEL_ZOOMOUT;Allunya\nDrecera: - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Chinese (Simplified) b/rtdata/languages/Chinese (Simplified) index b5a74f58d..0955d7ea8 100644 --- a/rtdata/languages/Chinese (Simplified) +++ b/rtdata/languages/Chinese (Simplified) @@ -815,6 +815,7 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !EDIT_PIPETTE_TOOLTIP;To add an adjustment point to the curve, hold the Ctrl key while left-clicking the desired spot in the image preview.\nTo adjust the point, hold the Ctrl key while left-clicking the corresponding area in the preview, then let go of Ctrl (unless you desire fine control) and while still holding the left mouse button move the mouse up or down to move that point up or down in the curve. !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction !EXPORT_BYPASS_DIRPYREQUALIZER;Bypass Contrast by Detail Levels @@ -831,7 +832,11 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !EXPORT_BYPASS_SHARPENMICRO;Bypass Microcontrast !EXPORT_BYPASS_SH_HQ;Bypass Sharp Mask Shadows/Highlights !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. +!EXPORT_PIPELINE;Processing pipeline !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... !FILEBROWSER_APPLYPROFILE_PARTIAL;Apply - partial @@ -854,6 +859,7 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !FILEBROWSER_POPUPRANK;Rank !FILEBROWSER_POPUPRANK0;Unrank !FILEBROWSER_QUERYHINT;Type filenames to search for. Supports partial filenames. Separate the search terms using commas, e.g.\n1001,1004,1199\n\nExclude search terms by prefixing them with !=\ne.g.\n!=1001,1004,1199\n\nShortcuts:\nCtrl-f - focus the Find box,\nEnter - search,\nEsc - clear the Find box,\nShift-Esc - defocus the Find box. +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 !FILEBROWSER_SHOWCOLORLABEL2HINT;Show images labeled Yellow.\nShortcut: Alt-2 !FILEBROWSER_SHOWCOLORLABEL3HINT;Show images labeled Green.\nShortcut: Alt-3 @@ -1302,6 +1308,8 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !PARTIALPASTE_PREPROCESS_DEADPIXFILT;Dead pixel filter !PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1311,6 +1319,7 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1351,6 +1360,8 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELDSDIR;Flat-fields directory @@ -1781,33 +1792,33 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD;Method !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD !TP_RAW_FALSECOLOR;False color suppression steps -!TP_RAW_FAST;fast +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1856,7 +1867,7 @@ ZOOMPANEL_ZOOMOUT;缩放拉远\n快捷键: - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* diff --git a/rtdata/languages/Chinese (Traditional) b/rtdata/languages/Chinese (Traditional) index 0c94d8f3b..4501bcd86 100644 --- a/rtdata/languages/Chinese (Traditional) +++ b/rtdata/languages/Chinese (Traditional) @@ -473,6 +473,7 @@ TP_WBALANCE_TEMPERATURE;色溫 !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -495,8 +496,12 @@ TP_WBALANCE_TEMPERATURE;色溫 !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -512,7 +517,6 @@ TP_WBALANCE_TEMPERATURE;色溫 !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -547,6 +551,7 @@ TP_WBALANCE_TEMPERATURE;色溫 !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1091,8 +1096,8 @@ TP_WBALANCE_TEMPERATURE;色溫 !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1103,6 +1108,7 @@ TP_WBALANCE_TEMPERATURE;色溫 !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1157,6 +1163,8 @@ TP_WBALANCE_TEMPERATURE;色溫 !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1739,33 +1747,33 @@ TP_WBALANCE_TEMPERATURE;色溫 !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD;Method !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD !TP_RAW_FALSECOLOR;False color suppression steps -!TP_RAW_FAST;fast +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1814,7 +1822,7 @@ TP_WBALANCE_TEMPERATURE;色溫 !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Czech b/rtdata/languages/Czech index 7e2d5889c..0ba7bbcc8 100644 --- a/rtdata/languages/Czech +++ b/rtdata/languages/Czech @@ -2083,6 +2083,12 @@ ZOOMPANEL_ZOOMOUT;Oddálit\nZkratka: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !HISTORY_MSG_444;WB - Temp bias !HISTORY_MSG_445;Raw Sub-Image !HISTORY_MSG_446;EvPixelShiftMotion @@ -2114,24 +2120,29 @@ ZOOMPANEL_ZOOMOUT;Oddálit\nZkratka: - !HISTORY_MSG_472;PS Smooth transitions !HISTORY_MSG_473;PS Use lmmse !HISTORY_MSG_474;PS Equalize +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_TAB_DYNAMICPROFILE;Dynamic Profile Rules !PROFILEPANEL_PDYNAMIC;Dynamic -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -2177,6 +2188,6 @@ ZOOMPANEL_ZOOMOUT;Oddálit\nZkratka: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_WBALANCE_TEMPBIAS;AWB temperature bias !TP_WBALANCE_TEMPBIAS_TOOLTIP;Allows to alter the computation of the "auto white balance"\nby biasing it towards warmer or cooler temperatures. The bias\nis expressed as a percentage of the computed temperature,\nso that the result is given by "computedTemp + computedTemp * bias". diff --git a/rtdata/languages/Dansk b/rtdata/languages/Dansk index 9c72632d2..61002e376 100644 --- a/rtdata/languages/Dansk +++ b/rtdata/languages/Dansk @@ -465,6 +465,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -487,8 +488,12 @@ TP_WBALANCE_TEMPERATURE;Temperatur !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -504,7 +509,6 @@ TP_WBALANCE_TEMPERATURE;Temperatur !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -539,6 +543,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1089,8 +1094,8 @@ TP_WBALANCE_TEMPERATURE;Temperatur !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1101,6 +1106,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1155,6 +1161,8 @@ TP_WBALANCE_TEMPERATURE;Temperatur !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1737,31 +1745,31 @@ TP_WBALANCE_TEMPERATURE;Temperatur !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1810,7 +1818,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Deutsch b/rtdata/languages/Deutsch index c9b8e3d04..faf11aa28 100644 --- a/rtdata/languages/Deutsch +++ b/rtdata/languages/Deutsch @@ -2177,3 +2177,18 @@ ZOOMPANEL_ZOOMFITCROPSCREEN;Ausschnitt an Bildschirm anpassen\nTaste: Alt ZOOMPANEL_ZOOMFITSCREEN;An Bildschirm anpassen\nTaste: f ZOOMPANEL_ZOOMIN;Hineinzoomen\nTaste: + ZOOMPANEL_ZOOMOUT;Herauszoomen\nTaste: - + +!!!!!!!!!!!!!!!!!!!!!!!!! +! Untranslated keys follow; remove the ! prefix after an entry is translated. +!!!!!!!!!!!!!!!!!!!!!!!!! + +!EXPORT_BYPASS;Processing steps to bypass +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. diff --git a/rtdata/languages/English (UK) b/rtdata/languages/English (UK) index a74829fa5..ff0781eb1 100644 --- a/rtdata/languages/English (UK) +++ b/rtdata/languages/English (UK) @@ -177,6 +177,7 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !EXIFPANEL_RESETALLHINT;Reset all tags to their original values. !EXIFPANEL_RESETHINT;Reset the selected tags to their original values. !EXIFPANEL_SUBDIRECTORY;Subdirectory +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -198,8 +199,12 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -221,7 +226,6 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? !FILEBROWSER_EMPTYTRASH;Empty trash !FILEBROWSER_EMPTYTRASHHINT;Permanently delete the files from trash. -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -270,6 +274,7 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 !FILEBROWSER_RENAMEDLGLABEL;Rename file +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -971,8 +976,8 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -982,6 +987,7 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !PARTIALPASTE_RAW_DMETHOD;Demosaic method !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RESIZE;Resize !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves @@ -1057,6 +1063,8 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !PREFERENCES_EDITORCMDLINE;Other command line !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_EXTERNALEDITOR;External Editor !PREFERENCES_FBROWSEROPTS;File Browser / Thumbnail Options !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) @@ -1698,32 +1706,32 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD;Method !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1772,7 +1780,7 @@ TP_WBALANCE_EQBLUERED_TOOLTIP;Allows to deviate from the normal behaviour of "wh !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/English (US) b/rtdata/languages/English (US) index 56a13fe7c..1284d8395 100644 --- a/rtdata/languages/English (US) +++ b/rtdata/languages/English (US) @@ -72,6 +72,7 @@ !EXIFPANEL_RESETALLHINT;Reset all tags to their original values. !EXIFPANEL_RESETHINT;Reset the selected tags to their original values. !EXIFPANEL_SUBDIRECTORY;Subdirectory +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -94,8 +95,12 @@ !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -118,7 +123,6 @@ !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? !FILEBROWSER_EMPTYTRASH;Empty trash !FILEBROWSER_EMPTYTRASHHINT;Permanently delete the files from trash. -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -168,6 +172,7 @@ !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 !FILEBROWSER_RENAMEDLGLABEL;Rename file +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -896,8 +901,8 @@ !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -908,6 +913,7 @@ !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RESIZE;Resize !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves @@ -986,6 +992,8 @@ !PREFERENCES_EDITORCMDLINE;Other command line !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_EXTERNALEDITOR;External Editor !PREFERENCES_FBROWSEROPTS;File Browser / Thumbnail Options !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) @@ -1687,33 +1695,33 @@ !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD;Method !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD !TP_RAW_FALSECOLOR;False color suppression steps -!TP_RAW_FAST;fast +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1762,7 +1770,7 @@ !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Espanol b/rtdata/languages/Espanol index 077d6a64e..38691cf95 100644 --- a/rtdata/languages/Espanol +++ b/rtdata/languages/Espanol @@ -1523,8 +1523,14 @@ ZOOMPANEL_ZOOMOUT;Reducir Zoom\nAtajo: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !FILEBROWSER_POPUPCOLORLABEL0;Label: None +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILECHOOSER_FILTER_ANY;All files @@ -1755,7 +1761,10 @@ ZOOMPANEL_ZOOMOUT;Reducir Zoom\nAtajo: - !PARTIALPASTE_EQUALIZER;Wavelet levels !PARTIALPASTE_GRADIENT;Graduated filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1776,6 +1785,8 @@ ZOOMPANEL_ZOOMOUT;Reducir Zoom\nAtajo: - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT;Same thumbnail height between the Filmstrip and the File Browser !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT_HINT;Having separate thumbnail size will require more processing time each time you'll switch between the single Editor tab and the File Browser. !PREFERENCES_GREYSC;Scene Yb luminance (%) @@ -1898,23 +1909,23 @@ ZOOMPANEL_ZOOMOUT;Reducir Zoom\nAtajo: - !TP_PRSHARPENING_LABEL;Post-Resize Sharpening !TP_PRSHARPENING_TOOLTIP;Sharpens the image after resizing. Only works when the "Lanczos" resizing method is used. It is impossible to preview the effects of this tool. See RawPedia for usage instructions. !TP_RAWCACORR_CASTR;Strength -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1960,7 +1971,7 @@ ZOOMPANEL_ZOOMOUT;Reducir Zoom\nAtajo: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Euskara b/rtdata/languages/Euskara index e8f9deeae..7022450b9 100644 --- a/rtdata/languages/Euskara +++ b/rtdata/languages/Euskara @@ -465,6 +465,7 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -487,8 +488,12 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -504,7 +509,6 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -539,6 +543,7 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1089,8 +1094,8 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1101,6 +1106,7 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1155,6 +1161,8 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1737,31 +1745,31 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1810,7 +1818,7 @@ TP_WBALANCE_TEMPERATURE;Tenperatura !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Francais b/rtdata/languages/Francais index b0fdf3c0d..22deca58a 100644 --- a/rtdata/languages/Francais +++ b/rtdata/languages/Francais @@ -2049,6 +2049,12 @@ ZOOMPANEL_ZOOMOUT;Zoom Arrière\nRaccourci: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !HISTORY_MSG_444;WB - Temp bias !HISTORY_MSG_445;Raw Sub-Image !HISTORY_MSG_446;EvPixelShiftMotion @@ -2081,23 +2087,25 @@ ZOOMPANEL_ZOOMOUT;Zoom Arrière\nRaccourci: - !HISTORY_MSG_473;PS Use lmmse !HISTORY_MSG_474;PS Equalize !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_TAB_DYNAMICPROFILE;Dynamic Profile Rules !PROFILEPANEL_PDYNAMIC;Dynamic -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -2143,6 +2151,6 @@ ZOOMPANEL_ZOOMOUT;Zoom Arrière\nRaccourci: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_WBALANCE_TEMPBIAS;AWB temperature bias !TP_WBALANCE_TEMPBIAS_TOOLTIP;Allows to alter the computation of the "auto white balance"\nby biasing it towards warmer or cooler temperatures. The bias\nis expressed as a percentage of the computed temperature,\nso that the result is given by "computedTemp + computedTemp * bias". diff --git a/rtdata/languages/Greek b/rtdata/languages/Greek index 0771b0252..67ef64f46 100644 --- a/rtdata/languages/Greek +++ b/rtdata/languages/Greek @@ -464,6 +464,7 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -486,8 +487,12 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -503,7 +508,6 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -538,6 +542,7 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1088,8 +1093,8 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1100,6 +1105,7 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1154,6 +1160,8 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1736,31 +1744,31 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1809,7 +1817,7 @@ TP_WBALANCE_TEMPERATURE;Θερμοκρασία !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Hebrew b/rtdata/languages/Hebrew index 71fe69f20..5d51653e3 100644 --- a/rtdata/languages/Hebrew +++ b/rtdata/languages/Hebrew @@ -465,6 +465,7 @@ TP_WBALANCE_TEMPERATURE;מידת חום !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -487,8 +488,12 @@ TP_WBALANCE_TEMPERATURE;מידת חום !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -504,7 +509,6 @@ TP_WBALANCE_TEMPERATURE;מידת חום !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -539,6 +543,7 @@ TP_WBALANCE_TEMPERATURE;מידת חום !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1089,8 +1094,8 @@ TP_WBALANCE_TEMPERATURE;מידת חום !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1101,6 +1106,7 @@ TP_WBALANCE_TEMPERATURE;מידת חום !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1155,6 +1161,8 @@ TP_WBALANCE_TEMPERATURE;מידת חום !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1737,31 +1745,31 @@ TP_WBALANCE_TEMPERATURE;מידת חום !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1810,7 +1818,7 @@ TP_WBALANCE_TEMPERATURE;מידת חום !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Italiano b/rtdata/languages/Italiano index 207deb019..d4482acfc 100644 --- a/rtdata/languages/Italiano +++ b/rtdata/languages/Italiano @@ -1354,7 +1354,13 @@ ZOOMPANEL_ZOOMOUT;Rimpicciolisci.\nScorciatoia: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILECHOOSER_FILTER_ANY;All files @@ -1624,7 +1630,10 @@ ZOOMPANEL_ZOOMOUT;Rimpicciolisci.\nScorciatoia: - !PARTIALPASTE_PREPROCESS_DEADPIXFILT;Dead pixel filter !PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1646,6 +1655,8 @@ ZOOMPANEL_ZOOMOUT;Rimpicciolisci.\nScorciatoia: - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT;Same thumbnail height between the Filmstrip and the File Browser !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT_HINT;Having separate thumbnail size will require more processing time each time you'll switch between the single Editor tab and the File Browser. @@ -1836,23 +1847,23 @@ ZOOMPANEL_ZOOMOUT;Rimpicciolisci.\nScorciatoia: - !TP_RAWEXPOS_BLACK_GREEN;Green !TP_RAWEXPOS_BLACK_RED;Red !TP_RAWEXPOS_RGB;Red, Green, Blue -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1901,7 +1912,7 @@ ZOOMPANEL_ZOOMOUT;Rimpicciolisci.\nScorciatoia: - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Japanese b/rtdata/languages/Japanese index a49b54cd3..c882fcca6 100644 --- a/rtdata/languages/Japanese +++ b/rtdata/languages/Japanese @@ -1893,6 +1893,12 @@ ZOOMPANEL_ZOOMOUT;ズームアウト\nショートカット: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !GENERAL_APPLY;Apply !GENERAL_OPEN;Open @@ -1993,9 +1999,14 @@ ZOOMPANEL_ZOOMOUT;ズームアウト\nショートカット: - !MAIN_BUTTON_SENDTOEDITOR;Edit image in external editor !MONITOR_PROFILE_SYSTEM;System default !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PREFERENCES_CMMBPC;Black point compensation +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_MONINTENT;Default rendering intent !PREFERENCES_MONITOR;Monitor !PREFERENCES_MONPROFILE;Default color profile @@ -2034,21 +2045,21 @@ ZOOMPANEL_ZOOMOUT;ズームアウト\nショートカット: - !TP_ICM_SAVEREFERENCE;Save Reference Image !TP_NEUTRAL;Reset !TP_RAWCACORR_CASTR;Strength -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -2094,7 +2105,7 @@ ZOOMPANEL_ZOOMOUT;ズームアウト\nショートカット: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Latvian b/rtdata/languages/Latvian index d4661ecaf..1eee14523 100644 --- a/rtdata/languages/Latvian +++ b/rtdata/languages/Latvian @@ -465,6 +465,7 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -487,8 +488,12 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -504,7 +509,6 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -539,6 +543,7 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1089,8 +1094,8 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1101,6 +1106,7 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1155,6 +1161,8 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1737,31 +1745,31 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1810,7 +1818,7 @@ TP_WBALANCE_TEMPERATURE;Temperatūra !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Magyar b/rtdata/languages/Magyar index 174ccc202..39475006e 100644 --- a/rtdata/languages/Magyar +++ b/rtdata/languages/Magyar @@ -898,8 +898,13 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés - !DYNPROFILEEDITOR_PROFILE;Processing Profile !EDIT_OBJECT_TOOLTIP;Displays a widget on the preview window which lets you adjust this tool. !EDIT_PIPETTE_TOOLTIP;To add an adjustment point to the curve, hold the Ctrl key while left-clicking the desired spot in the image preview.\nTo adjust the point, hold the Ctrl key while left-clicking the corresponding area in the preview, then let go of Ctrl (unless you desire fine control) and while still holding the left mouse button move the mouse up or down to move that point up or down in the curve. +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels !EXPORT_BYPASS_RAW_LMMSE_ITERATIONS;Bypass [raw] LMMSE Enhancement Steps +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_COLORLABEL_TOOLTIP;Color label.\n\nUse dropdown menu or shortcuts:\nShift-Ctrl-0 No Color\nShift-Ctrl-1 Red\nShift-Ctrl-2 Yellow\nShift-Ctrl-3 Green\nShift-Ctrl-4 Blue\nShift-Ctrl-5 Purple @@ -923,6 +928,7 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés - !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILEBROWSER_UNRANK_TOOLTIP;Unrank.\nShortcut: Shift-0 @@ -1315,8 +1321,11 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés - !PARTIALPASTE_PREPROCESS_DEADPIXFILT;Dead pixel filter !PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1353,6 +1362,8 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLUOF2;Fluorescent F2 !PREFERENCES_FLUOF7;Fluorescent F7 @@ -1810,28 +1821,28 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés - !TP_RAWEXPOS_BLACK_GREEN;Green !TP_RAWEXPOS_BLACK_RED;Red !TP_RAWEXPOS_RGB;Red, Green, Blue -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1880,7 +1891,7 @@ ZOOMPANEL_ZOOMOUT;Kicsinyítés - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Nederlands b/rtdata/languages/Nederlands index 2d5e6a717..4d96c2290 100644 --- a/rtdata/languages/Nederlands +++ b/rtdata/languages/Nederlands @@ -2007,6 +2007,12 @@ ZOOMPANEL_ZOOMOUT;Zoom uit\nSneltoets: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !GENERAL_APPLY;Apply !GENERAL_OPEN;Open !HISTORY_MSG_439;Retinex - Process @@ -2069,8 +2075,13 @@ ZOOMPANEL_ZOOMOUT;Zoom uit\nSneltoets: - !IPTCPANEL_TITLEHINT;Enter a short verbal and human readable name for the image, this may be the file name. !IPTCPANEL_TRANSREFERENCE;Job ID !IPTCPANEL_TRANSREFERENCEHINT;Enter a number or identifier needed for workflow control or tracking. +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PREFERENCES_CMMBPC;Black point compensation +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_MONITOR;Monitor !PREFERENCES_MONPROFILE;Default color profile !PREFERENCES_MONPROFILE_WARNOSX;Due to MacOS limitations, only sRGB is supported. @@ -2096,21 +2107,21 @@ ZOOMPANEL_ZOOMOUT;Zoom uit\nSneltoets: - !TP_ICM_BPC;Black Point Compensation !TP_ICM_BPC_TOOLTIP;Enable this to fit the Luminosity channel to the output color space with a fix White Point !TP_ICM_SAVEREFERENCE;Save Reference Image -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -2156,7 +2167,7 @@ ZOOMPANEL_ZOOMOUT;Zoom uit\nSneltoets: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_GAINOFFS;Gain and Offset (brightness) !TP_RETINEX_GAINTRANSMISSION;Gain transmission !TP_RETINEX_GAINTRANSMISSION_TOOLTIP;Amplify or reduce transmission map to achieve luminance.\nAbscissa: transmission -min from 0, mean, and values (max).\nOrdinate: gain. diff --git a/rtdata/languages/Norsk BM b/rtdata/languages/Norsk BM index ed85637b3..19c0c2b92 100644 --- a/rtdata/languages/Norsk BM +++ b/rtdata/languages/Norsk BM @@ -464,6 +464,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -486,8 +487,12 @@ TP_WBALANCE_TEMPERATURE;Temperatur !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -503,7 +508,6 @@ TP_WBALANCE_TEMPERATURE;Temperatur !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -538,6 +542,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1088,8 +1093,8 @@ TP_WBALANCE_TEMPERATURE;Temperatur !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1100,6 +1105,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1154,6 +1160,8 @@ TP_WBALANCE_TEMPERATURE;Temperatur !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1736,31 +1744,31 @@ TP_WBALANCE_TEMPERATURE;Temperatur !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1809,7 +1817,7 @@ TP_WBALANCE_TEMPERATURE;Temperatur !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Polish b/rtdata/languages/Polish index 42692fccd..a83c2ce48 100644 --- a/rtdata/languages/Polish +++ b/rtdata/languages/Polish @@ -1481,7 +1481,13 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrót: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILECHOOSER_FILTER_ANY;All files @@ -1703,7 +1709,10 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrót: - !MONITOR_PROFILE_SYSTEM;System default !PARTIALPASTE_EQUALIZER;Wavelet levels !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1724,6 +1733,8 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrót: - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT;Same thumbnail height between the Filmstrip and the File Browser !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT_HINT;Having separate thumbnail size will require more processing time each time you'll switch between the single Editor tab and the File Browser. !PREFERENCES_GREYSC;Scene Yb luminance (%) @@ -1845,23 +1856,23 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrót: - !TP_PRSHARPENING_LABEL;Post-Resize Sharpening !TP_PRSHARPENING_TOOLTIP;Sharpens the image after resizing. Only works when the "Lanczos" resizing method is used. It is impossible to preview the effects of this tool. See RawPedia for usage instructions. !TP_RAWCACORR_CASTR;Strength -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1907,7 +1918,7 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrót: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Polish (Latin Characters) b/rtdata/languages/Polish (Latin Characters) index b961fa959..12ba19e83 100644 --- a/rtdata/languages/Polish (Latin Characters) +++ b/rtdata/languages/Polish (Latin Characters) @@ -1481,7 +1481,13 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrot: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILECHOOSER_FILTER_ANY;All files @@ -1703,7 +1709,10 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrot: - !MONITOR_PROFILE_SYSTEM;System default !PARTIALPASTE_EQUALIZER;Wavelet levels !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1724,6 +1733,8 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrot: - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT;Same thumbnail height between the Filmstrip and the File Browser !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT_HINT;Having separate thumbnail size will require more processing time each time you'll switch between the single Editor tab and the File Browser. !PREFERENCES_GREYSC;Scene Yb luminance (%) @@ -1845,23 +1856,23 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrot: - !TP_PRSHARPENING_LABEL;Post-Resize Sharpening !TP_PRSHARPENING_TOOLTIP;Sharpens the image after resizing. Only works when the "Lanczos" resizing method is used. It is impossible to preview the effects of this tool. See RawPedia for usage instructions. !TP_RAWCACORR_CASTR;Strength -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1907,7 +1918,7 @@ ZOOMPANEL_ZOOMOUT;Oddal\nSkrot: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Portugues (Brasil) b/rtdata/languages/Portugues (Brasil) index cf85697a8..b325ef4bd 100644 --- a/rtdata/languages/Portugues (Brasil) +++ b/rtdata/languages/Portugues (Brasil) @@ -465,6 +465,7 @@ TP_WBALANCE_TEMPERATURE;Temperatura !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -487,8 +488,12 @@ TP_WBALANCE_TEMPERATURE;Temperatura !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -504,7 +509,6 @@ TP_WBALANCE_TEMPERATURE;Temperatura !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -539,6 +543,7 @@ TP_WBALANCE_TEMPERATURE;Temperatura !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1089,8 +1094,8 @@ TP_WBALANCE_TEMPERATURE;Temperatura !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1101,6 +1106,7 @@ TP_WBALANCE_TEMPERATURE;Temperatura !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1155,6 +1161,8 @@ TP_WBALANCE_TEMPERATURE;Temperatura !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1737,31 +1745,31 @@ TP_WBALANCE_TEMPERATURE;Temperatura !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1810,7 +1818,7 @@ TP_WBALANCE_TEMPERATURE;Temperatura !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Russian b/rtdata/languages/Russian index 343526a17..b3ce61cfa 100644 --- a/rtdata/languages/Russian +++ b/rtdata/languages/Russian @@ -1292,8 +1292,14 @@ ZOOMPANEL_ZOOMOUT;Удалить - !DYNPROFILEEDITOR_PROFILE;Processing Profile !EDIT_OBJECT_TOOLTIP;Displays a widget on the preview window which lets you adjust this tool. !EDIT_PIPETTE_TOOLTIP;To add an adjustment point to the curve, hold the Ctrl key while left-clicking the desired spot in the image preview.\nTo adjust the point, hold the Ctrl key while left-clicking the corresponding area in the preview, then let go of Ctrl (unless you desire fine control) and while still holding the left mouse button move the mouse up or down to move that point up or down in the curve. +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !FILEBROWSER_POPUPRANK0;Unrank +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILECHOOSER_FILTER_ANY;All files @@ -1578,7 +1584,10 @@ ZOOMPANEL_ZOOMOUT;Удалить - !PARTIALPASTE_PREPROCESS_DEADPIXFILT;Dead pixel filter !PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1600,6 +1609,8 @@ ZOOMPANEL_ZOOMOUT;Удалить - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT;Same thumbnail height between the Filmstrip and the File Browser !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT_HINT;Having separate thumbnail size will require more processing time each time you'll switch between the single Editor tab and the File Browser. @@ -1838,23 +1849,23 @@ ZOOMPANEL_ZOOMOUT;Удалить - !TP_RAWEXPOS_BLACK_GREEN;Green !TP_RAWEXPOS_BLACK_RED;Red !TP_RAWEXPOS_RGB;Red, Green, Blue -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1903,7 +1914,7 @@ ZOOMPANEL_ZOOMOUT;Удалить - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Serbian (Cyrilic Characters) b/rtdata/languages/Serbian (Cyrilic Characters) index a8742d98b..3a29d9cdb 100644 --- a/rtdata/languages/Serbian (Cyrilic Characters) +++ b/rtdata/languages/Serbian (Cyrilic Characters) @@ -1448,7 +1448,12 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике - !DYNPROFILEEDITOR_PROFILE;Processing Profile !EDIT_OBJECT_TOOLTIP;Displays a widget on the preview window which lets you adjust this tool. !EDIT_PIPETTE_TOOLTIP;To add an adjustment point to the curve, hold the Ctrl key while left-clicking the desired spot in the image preview.\nTo adjust the point, hold the Ctrl key while left-clicking the corresponding area in the preview, then let go of Ctrl (unless you desire fine control) and while still holding the left mouse button move the mouse up or down to move that point up or down in the curve. +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !FILEBROWSER_POPUPCOLORLABEL0;Label: None !FILEBROWSER_POPUPCOLORLABEL1;Label: Red !FILEBROWSER_POPUPCOLORLABEL2;Label: Yellow @@ -1462,6 +1467,7 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике - !FILEBROWSER_POPUPRANK3;Rank 3 *** !FILEBROWSER_POPUPRANK4;Rank 4 **** !FILEBROWSER_POPUPRANK5;Rank 5 ***** +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILECHOOSER_FILTER_ANY;All files @@ -1744,7 +1750,10 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике - !PARTIALPASTE_PREPROCESS_DEADPIXFILT;Dead pixel filter !PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1766,6 +1775,8 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT;Same thumbnail height between the Filmstrip and the File Browser !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT_HINT;Having separate thumbnail size will require more processing time each time you'll switch between the single Editor tab and the File Browser. @@ -1971,23 +1982,23 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике - !TP_RAWEXPOS_BLACK_GREEN;Green !TP_RAWEXPOS_BLACK_RED;Red !TP_RAWEXPOS_RGB;Red, Green, Blue -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -2036,7 +2047,7 @@ ZOOMPANEL_ZOOMOUT;Умањује приказ слике - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Serbian (Latin Characters) b/rtdata/languages/Serbian (Latin Characters) index 2a57b01eb..269c941d4 100644 --- a/rtdata/languages/Serbian (Latin Characters) +++ b/rtdata/languages/Serbian (Latin Characters) @@ -1448,7 +1448,12 @@ ZOOMPANEL_ZOOMOUT;Umanjuje prikaz slike - !DYNPROFILEEDITOR_PROFILE;Processing Profile !EDIT_OBJECT_TOOLTIP;Displays a widget on the preview window which lets you adjust this tool. !EDIT_PIPETTE_TOOLTIP;To add an adjustment point to the curve, hold the Ctrl key while left-clicking the desired spot in the image preview.\nTo adjust the point, hold the Ctrl key while left-clicking the corresponding area in the preview, then let go of Ctrl (unless you desire fine control) and while still holding the left mouse button move the mouse up or down to move that point up or down in the curve. +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_EQUALIZER;Bypass Wavelet Levels +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !FILEBROWSER_POPUPCOLORLABEL0;Label: None !FILEBROWSER_POPUPCOLORLABEL1;Label: Red !FILEBROWSER_POPUPCOLORLABEL2;Label: Yellow @@ -1462,6 +1467,7 @@ ZOOMPANEL_ZOOMOUT;Umanjuje prikaz slike - !FILEBROWSER_POPUPRANK3;Rank 3 *** !FILEBROWSER_POPUPRANK4;Rank 4 **** !FILEBROWSER_POPUPRANK5;Rank 5 ***** +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SHOWNOTTRASHHINT;Show only non-deleted images. !FILEBROWSER_SHOWORIGINALHINT;Show only original images.\n\nWhen several images exist with the same filename but different extensions, the one considered original is the one whose extension is nearest the top of the parsed extensions list in Preferences > File Browser > Parsed Extensions. !FILECHOOSER_FILTER_ANY;All files @@ -1744,7 +1750,10 @@ ZOOMPANEL_ZOOMOUT;Umanjuje prikaz slike - !PARTIALPASTE_PREPROCESS_DEADPIXFILT;Dead pixel filter !PARTIALPASTE_PREPROCESS_HOTPIXFILT;Hot pixel filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_WAVELETGROUP;Wavelet Levels !PREFERENCES_AUTLISLOW;Low @@ -1766,6 +1775,8 @@ ZOOMPANEL_ZOOMOUT;Umanjuje prikaz slike - !PREFERENCES_DAUB_LABEL;Use Daubechies D6 wavelets instead of D4 !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT;Same thumbnail height between the Filmstrip and the File Browser !PREFERENCES_FSTRIP_SAME_THUMB_HEIGHT_HINT;Having separate thumbnail size will require more processing time each time you'll switch between the single Editor tab and the File Browser. @@ -1971,23 +1982,23 @@ ZOOMPANEL_ZOOMOUT;Umanjuje prikaz slike - !TP_RAWEXPOS_BLACK_GREEN;Green !TP_RAWEXPOS_BLACK_RED;Red !TP_RAWEXPOS_RGB;Red, Green, Blue -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -2036,7 +2047,7 @@ ZOOMPANEL_ZOOMOUT;Umanjuje prikaz slike - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_HSL;Histogram equalizer HSL !TP_RETINEX_CONTEDIT_LAB;Histogram equalizer L*a*b* !TP_RETINEX_CONTEDIT_LH;Hue equalizer diff --git a/rtdata/languages/Slovak b/rtdata/languages/Slovak index 68b277f00..2ebc31ab7 100644 --- a/rtdata/languages/Slovak +++ b/rtdata/languages/Slovak @@ -546,6 +546,7 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !EDIT_PIPETTE_TOOLTIP;To add an adjustment point to the curve, hold the Ctrl key while left-clicking the desired spot in the image preview.\nTo adjust the point, hold the Ctrl key while left-clicking the corresponding area in the preview, then let go of Ctrl (unless you desire fine control) and while still holding the left mouse button move the mouse up or down to move that point up or down in the curve. !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -568,8 +569,12 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_APPLYPROFILE_PARTIAL;Apply - partial @@ -583,7 +588,6 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !FILEBROWSER_COLORLABEL_TOOLTIP;Color label.\n\nUse dropdown menu or shortcuts:\nShift-Ctrl-0 No Color\nShift-Ctrl-1 Red\nShift-Ctrl-2 Yellow\nShift-Ctrl-3 Green\nShift-Ctrl-4 Blue\nShift-Ctrl-5 Purple !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -617,6 +621,7 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1143,8 +1148,8 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1155,6 +1160,7 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1205,6 +1211,8 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !PREFERENCES_DAUB_TOOLTIP;The Noise Reduction and Wavelet Levels tools use a Debauchies mother wavelet. If you choose D6 instead of D4 you increase the number of orthogonal Daubechies coefficients and probably increase quality of small-scale levels. There is no memory or processing time difference between the two. !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1750,29 +1758,29 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1821,7 +1829,7 @@ ZOOMPANEL_ZOOMOUT;Oddialiť - !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Suomi b/rtdata/languages/Suomi index 925727ba7..b6556bbb0 100644 --- a/rtdata/languages/Suomi +++ b/rtdata/languages/Suomi @@ -466,6 +466,7 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -488,8 +489,12 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -505,7 +510,6 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -540,6 +544,7 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1090,8 +1095,8 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1102,6 +1107,7 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1156,6 +1162,8 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1737,31 +1745,31 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1810,7 +1818,7 @@ TP_WBALANCE_TEMPERATURE;Lämpötila [K] !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/Swedish b/rtdata/languages/Swedish index 722ec8f53..1fffdb51f 100644 --- a/rtdata/languages/Swedish +++ b/rtdata/languages/Swedish @@ -1904,6 +1904,12 @@ ZOOMPANEL_ZOOMOUT;Förminska.\nKortkommando: - !DYNPROFILEEDITOR_NEW;New !DYNPROFILEEDITOR_NEW_RULE;New Dynamic Profile Rule !DYNPROFILEEDITOR_PROFILE;Processing Profile +!EXPORT_BYPASS;Processing steps to bypass +!EXPORT_PIPELINE;Processing pipeline +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !HISTORY_MSG_257;Color Toning !HISTORY_MSG_288;Flat Field - Clip control !HISTORY_MSG_289;Flat Field - Clip control - Auto @@ -1985,8 +1991,13 @@ ZOOMPANEL_ZOOMOUT;Förminska.\nKortkommando: - !IPTCPANEL_TRANSREFERENCEHINT;Enter a number or identifier needed for workflow control or tracking. !PARTIALPASTE_COLORTONING;Color toning !PARTIALPASTE_FLATFIELDCLIPCONTROL;Flat-field clip control +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAW_IMAGENUM;Sub-image +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PREFERENCES_CMMBPC;Black point compensation +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_INSPECT_MAXBUFFERS_TOOLTIP;Set the maximum number of images stored in cache when hovering over them in the File Browser; systems with little RAM (2GB) should keep this value set to 1 or 2. !PREFERENCES_LISS;Auto multi-zone smoothing !PREFERENCES_MONINTENT;Default rendering intent @@ -2025,21 +2036,21 @@ ZOOMPANEL_ZOOMOUT;Förminska.\nKortkommando: - !TP_ICM_BPC_TOOLTIP;Enable this to fit the Luminosity channel to the output color space with a fix White Point !TP_ICM_PROFILEINTENT;Rendering Intent !TP_ICM_SAVEREFERENCE;Save Reference Image -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_DCB;DCB +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. -!TP_RAW_LMMSE;lmmse -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. +!TP_RAW_LMMSE;LMMSE +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -2085,7 +2096,7 @@ ZOOMPANEL_ZOOMOUT;Förminska.\nKortkommando: - !TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE;StdDev factor Blue !TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN;StdDev factor Green !TP_RAW_PIXELSHIFTSTDDEVFACTORRED;StdDev factor Red -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RETINEX_CONTEDIT_MAP;Mask equalizer !TP_RETINEX_CURVEEDITOR_CD_TOOLTIP;Luminance according to luminance L=f(L)\nCorrect raw data to reduce halos and artifacts. !TP_RETINEX_CURVEEDITOR_MAP_TOOLTIP;This curve can be applied alone or with a Gaussian mask or wavelet mask.\nBeware of artifacts! diff --git a/rtdata/languages/Turkish b/rtdata/languages/Turkish index e22ccd1b9..b84ef05a8 100644 --- a/rtdata/languages/Turkish +++ b/rtdata/languages/Turkish @@ -465,6 +465,7 @@ TP_WBALANCE_TEMPERATURE;Isı !EXIFFILTER_EXPOSURECOMPENSATION;Exposure compensation (EV) !EXIFFILTER_FILETYPE;File type !EXIFFILTER_METADATAFILTER;Enable metadata filters +!EXPORT_BYPASS;Processing steps to bypass !EXPORT_BYPASS_ALL;Select / Unselect All !EXPORT_BYPASS_DEFRINGE;Bypass Defringe !EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -487,8 +488,12 @@ TP_WBALANCE_TEMPERATURE;Isı !EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. !EXPORT_MAXHEIGHT;Maximum height: !EXPORT_MAXWIDTH;Maximum width: +!EXPORT_PIPELINE;Processing pipeline !EXPORT_PUTTOQUEUEFAST; Put to queue for fast export !EXPORT_RAW_DMETHOD;Demosaic method +!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) !EXTPROGTARGET_1;raw !EXTPROGTARGET_2;queue-processed !FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -504,7 +509,6 @@ TP_WBALANCE_TEMPERATURE;Isı !FILEBROWSER_CURRENT_NAME;Current name: !FILEBROWSER_DARKFRAME;Dark-frame !FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? -!FILEBROWSER_EXEC_CPB;Custom Profile Builder !FILEBROWSER_EXTPROGMENU;Open with !FILEBROWSER_FLATFIELD;Flat-Field !FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -539,6 +543,7 @@ TP_WBALANCE_TEMPERATURE;Isı !FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 !FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 !FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 +!FILEBROWSER_RESETDEFAULTPROFILE;Reset to default !FILEBROWSER_SELECTDARKFRAME;Select dark-frame... !FILEBROWSER_SELECTFLATFIELD;Select flat-field... !FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -1089,8 +1094,8 @@ TP_WBALANCE_TEMPERATURE;Isı !PARTIALPASTE_PREPROCESS_LINEDENOISE;Line noise filter !PARTIALPASTE_PRSHARPENING;Post-resize sharpening !PARTIALPASTE_RAWCACORR_AUTO;CA auto-correction -!PARTIALPASTE_RAWCACORR_CABLUE;CA blue -!PARTIALPASTE_RAWCACORR_CARED;CA red +!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength +!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue !PARTIALPASTE_RAWEXPOS_BLACK;Black levels !PARTIALPASTE_RAWEXPOS_LINEAR;White point correction !PARTIALPASTE_RAWEXPOS_PRESER;Highlight preservation @@ -1101,6 +1106,7 @@ TP_WBALANCE_TEMPERATURE;Isı !PARTIALPASTE_RAW_FALSECOLOR;False color suppression !PARTIALPASTE_RAW_IMAGENUM;Sub-image !PARTIALPASTE_RAW_LMMSEITERATIONS;LMMSE enhancement steps +!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift !PARTIALPASTE_RETINEX;Retinex !PARTIALPASTE_RGBCURVES;RGB curves !PARTIALPASTE_SHARPENEDGE;Edges @@ -1155,6 +1161,8 @@ TP_WBALANCE_TEMPERATURE;Isı !PREFERENCES_DIRDARKFRAMES;Dark-frames directory !PREFERENCES_EDITORLAYOUT;Editor Layout !PREFERENCES_EXPAUT;Expert +!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. !PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) !PREFERENCES_FILMSIMULATION;Film Simulation !PREFERENCES_FLATFIELD;Flat-Field @@ -1736,31 +1744,31 @@ TP_WBALANCE_TEMPERATURE;Isı !TP_RAWEXPOS_PRESER;Highlight preservation !TP_RAWEXPOS_RGB;Red, Green, Blue !TP_RAWEXPOS_TWOGREEN;Link greens -!TP_RAW_1-PASS (MEDIUM);1-pass (medium) -!TP_RAW_3-PASS (BEST);3-pass (best) -!TP_RAW_AHD;ahd +!TP_RAW_1PASSMEDIUM;1-Pass (Medium) +!TP_RAW_3PASSBEST;3-Pass (Best) +!TP_RAW_AHD;AHD !TP_RAW_AMAZE;AMaZE -!TP_RAW_DCB;dcb +!TP_RAW_DCB;DCB !TP_RAW_DCBENHANCE;DCB enhancement !TP_RAW_DCBITERATIONS;Number of DCB iterations !TP_RAW_DMETHOD_PROGRESSBAR;%1 demosaicing... !TP_RAW_DMETHOD_PROGRESSBAR_REFINE;Demosaicing refinement... -!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixelshift is for Pentax pixelshift files. It falls back to Amaze for non pixelshift files. -!TP_RAW_EAHD;eahd -!TP_RAW_FAST;fast +!TP_RAW_DMETHOD_TOOLTIP;Note: IGV and LMMSE are dedicated to high ISO images to aid in noise reduction without leading to maze patterns, posterization or a washed-out look.\nPixel Shift is for Pentax Pixel Shift files. It falls back to AMaZE for non-Pixel Shift files. +!TP_RAW_EAHD;EAHD +!TP_RAW_FAST;Fast !TP_RAW_HD;Threshold !TP_RAW_HD_TOOLTIP;Lower values make hot/dead pixel detection more aggressive, but false positives may lead to artifacts. If you notice any artifacts appearing when enabling the Hot/Dead Pixel Filters, gradually increase the threshold value until they disappear. -!TP_RAW_HPHD;hphd -!TP_RAW_IGV;igv +!TP_RAW_HPHD;HPHD +!TP_RAW_IGV;IGV !TP_RAW_IMAGENUM;Sub-image -!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel-Shift, Dual Sensitivity). Use this button to select the sub-image.\n\nThe last sub-image will be used if you select a value beyond the real sub-image count. +!TP_RAW_IMAGENUM_TOOLTIP;Some raw files might embed several sub-images (HDR, Pixel Shift, Dual Pixel, Dual Sensitivity). Use this button to select the sub-image. !TP_RAW_LABEL;Demosaicing -!TP_RAW_LMMSE;lmmse +!TP_RAW_LMMSE;LMMSE !TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps !TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio. -!TP_RAW_MONO;mono -!TP_RAW_NONE;none (show sensor pattern) -!TP_RAW_PIXELSHIFT;Pixel Shift (Pentax) +!TP_RAW_MONO;Mono +!TP_RAW_NONE;None (Shows sensor pattern) +!TP_RAW_PIXELSHIFT;Pixel Shift !TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection !TP_RAW_PIXELSHIFTBLUR;Blur motion mask !TP_RAW_PIXELSHIFTBLUR_TOOLTIP;Blur motion mask @@ -1809,7 +1817,7 @@ TP_WBALANCE_TEMPERATURE;Isı !TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix !TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster. !TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix -!TP_RAW_VNG4;vng4 +!TP_RAW_VNG4;VNG4 !TP_RESIZE_APPLIESTO;Applies to: !TP_RESIZE_CROPPEDAREA;Cropped Area !TP_RESIZE_FITBOX;Bounding Box diff --git a/rtdata/languages/default b/rtdata/languages/default index 44a751725..39e594b83 100644 --- a/rtdata/languages/default +++ b/rtdata/languages/default @@ -71,6 +71,7 @@ EXIFPANEL_RESETALL;Reset All EXIFPANEL_RESETALLHINT;Reset all tags to their original values. EXIFPANEL_RESETHINT;Reset the selected tags to their original values. EXIFPANEL_SUBDIRECTORY;Subdirectory +EXPORT_BYPASS;Processing steps to bypass EXPORT_BYPASS_ALL;Select / Unselect All EXPORT_BYPASS_DEFRINGE;Bypass Defringe EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction @@ -89,17 +90,16 @@ EXPORT_BYPASS_SHARPENEDGE;Bypass Edge Sharpening EXPORT_BYPASS_SHARPENING;Bypass Sharpening EXPORT_BYPASS_SHARPENMICRO;Bypass Microcontrast EXPORT_BYPASS_SH_HQ;Bypass Sharp Mask Shadows/Highlights -EXPORT_PIPELINE;Processing pipeline -EXPORT_BYPASS;Processing steps to bypass -EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) -EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) -EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. EXPORT_FASTEXPORTOPTIONS;Fast Export Options EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. EXPORT_MAXHEIGHT;Maximum height: EXPORT_MAXWIDTH;Maximum width: +EXPORT_PIPELINE;Processing pipeline EXPORT_PUTTOQUEUEFAST; Put to queue for fast export EXPORT_RAW_DMETHOD;Demosaic method +EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) +EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. +EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) EXTPROGTARGET_1;raw EXTPROGTARGET_2;queue-processed FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... @@ -122,7 +122,6 @@ FILEBROWSER_DELETEDLGMSG;Are you sure you want to delete the selected %1 FILEBROWSER_DELETEDLGMSGINCLPROC;Are you sure you want to delete the selected %1 files including a queue-processed version? FILEBROWSER_EMPTYTRASH;Empty trash FILEBROWSER_EMPTYTRASHHINT;Permanently delete the files from trash. -FILEBROWSER_RESETDEFAULTPROFILE;Reset to default FILEBROWSER_EXTPROGMENU;Open with FILEBROWSER_FLATFIELD;Flat-Field FILEBROWSER_MOVETODARKFDIR;Move to dark-frames directory @@ -172,6 +171,7 @@ FILEBROWSER_RANK3_TOOLTIP;Rank 3 *\nShortcut: Shift-3 FILEBROWSER_RANK4_TOOLTIP;Rank 4 *\nShortcut: Shift-4 FILEBROWSER_RANK5_TOOLTIP;Rank 5 *\nShortcut: Shift-5 FILEBROWSER_RENAMEDLGLABEL;Rename file +FILEBROWSER_RESETDEFAULTPROFILE;Reset to default FILEBROWSER_SELECTDARKFRAME;Select dark-frame... FILEBROWSER_SELECTFLATFIELD;Select flat-field... FILEBROWSER_SHOWCOLORLABEL1HINT;Show images labeled Red.\nShortcut: Alt-1 @@ -991,6 +991,8 @@ PREFERENCES_DIRSOFTWARE;Installation directory PREFERENCES_EDITORCMDLINE;Other command line PREFERENCES_EDITORLAYOUT;Editor Layout PREFERENCES_EXPAUT;Expert +PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. PREFERENCES_EXTERNALEDITOR;External Editor PREFERENCES_FBROWSEROPTS;File Browser / Thumbnail Options PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Single row file browser toolbar\n(de-select for low resolution display) @@ -1092,8 +1094,6 @@ PREFERENCES_PRTPROFILE;Color profile PREFERENCES_PSPATH;Adobe Photoshop installation directory PREFERENCES_REMEMBERZOOMPAN;Remember zoom % and pan offset PREFERENCES_REMEMBERZOOMPAN_TOOLTIP;Remember the zoom % and pan offset of the current image when opening a new image.\n\nThis option only works in "Single Editor Tab Mode" and when "Demosaicing method used for the preview at <100% zoom" is set to "As in PP3". -PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming -PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. PREFERENCES_RGBDTL_LABEL;Max number of threads for Noise Reduction and Wavelet Levels PREFERENCES_RGBDTL_TOOLTIP;Leave the setting at "0" to automatically use as many threads as possible. The more threads run in parallel, the faster the computation. Refer to RawPedia for memory requirements. PREFERENCES_SELECTFONT;Select main font From 850577b8c77591fa0966eaa5ae38080158faa681 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 6 Apr 2017 13:16:39 +0200 Subject: [PATCH 83/90] About 3x speed for scale_colors in rtthumbnail.cc --- rtengine/rawimage.h | 9 ++++---- rtengine/rtthumbnail.cc | 46 +++++++++++++++++++++++++++++++++-------- 2 files changed, 42 insertions(+), 13 deletions(-) diff --git a/rtengine/rawimage.h b/rtengine/rawimage.h index d9d5a71b8..3c4075207 100644 --- a/rtengine/rawimage.h +++ b/rtengine/rawimage.h @@ -129,10 +129,6 @@ protected: char* profile_data; // Embedded ICC color profile float* allocation; // pointer to allocated memory int maximum_c4[4]; - bool isBayer() const - { - return (filters != 0 && filters != 9); - } bool isXtrans() const { return filters == 9; @@ -308,6 +304,11 @@ public: return zero_is_bad == 1; } + bool isBayer() const + { + return (filters != 0 && filters != 9); + } + public: // dcraw functions void scale_colors() diff --git a/rtengine/rtthumbnail.cc b/rtengine/rtthumbnail.cc index 1d2706b7a..20d3efd06 100644 --- a/rtengine/rtthumbnail.cc +++ b/rtengine/rtthumbnail.cc @@ -37,7 +37,7 @@ #include "../rtgui/ppversion.h" #include "improccoordinator.h" #include -//#define BENCHMARK +#define BENCHMARK #include "StopWatch.h" @@ -61,14 +61,42 @@ namespace void scale_colors(rtengine::RawImage *ri, float scale_mul[4], float cblack[4]) { - DCraw::dcrawImage_t image = ri->get_image(); - const int size = ri->get_iheight() * ri->get_iwidth(); - for (int i = 0; i < size; ++i) { - for (int j = 0; j < 4; ++j) { - float val = image[i][j]; - val -= cblack[j]; - val *= scale_mul[j]; - image[i][j] = rtengine::CLIP(val); + BENCHFUNMICRO + if(ri->isBayer()) { + DCraw::dcrawImage_t image = ri->get_image(); + const int height = ri->get_iheight(); + const int width = ri->get_iwidth(); + for(int row = 0; row < height; ++row) { + unsigned c0 = ri->FC(row,0); + unsigned c1 = ri->FC(row,1); + int col = 0; + for(; col < width - 1; col += 2) { + float val0 = image[row * width + col][c0]; + float val1 = image[row * width + col + 1][c1]; + val0 -= cblack[c0]; + val1 -= cblack[c1]; + val0 *= scale_mul[c0]; + val1 *= scale_mul[c1]; + image[row * width + col][c0] = rtengine::CLIP(val0); + image[row * width + col + 1][c1] = rtengine::CLIP(val1); + } + if(col < width) { // in case width is odd + float val0 = image[row * width + col][c0]; + val0 -= cblack[c0]; + val0 *= scale_mul[c0]; + image[row * width + col][c0] = rtengine::CLIP(val0); + } + } + } else { + DCraw::dcrawImage_t image = ri->get_image(); + const int size = ri->get_iheight() * ri->get_iwidth(); + for (int i = 0; i < size; ++i) { + for (int j = 0; j < 4; ++j) { + float val = image[i][j]; + val -= cblack[j]; + val *= scale_mul[j]; + image[i][j] = rtengine::CLIP(val); + } } } } From 85bf313b778bc0865c15cbdfda799c4eccb7de82 Mon Sep 17 00:00:00 2001 From: Morgan Hardwood Date: Thu, 6 Apr 2017 15:24:20 +0200 Subject: [PATCH 84/90] Updated Deutsch by TooWaBoo, closes #3808 --- rtdata/languages/Deutsch | 33 +++++++++++++++------------------ 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/rtdata/languages/Deutsch b/rtdata/languages/Deutsch index faf11aa28..5d2a9ad88 100644 --- a/rtdata/languages/Deutsch +++ b/rtdata/languages/Deutsch @@ -35,8 +35,9 @@ #34 2017-01-07 IPTC (TooWaBoo) RT4.2.1492 #35 2017-02-18 AWB bias (TooWaBoo) RT 5.0 r1 #36 2017-02-23 Korrekturen (TooWaBoo) RT 5.0 r1 -#37 2017-03-06 Dynamisches Profil (TooWaBoo) -#38 2017-03-26 Pixel Shift (TooWaBoo) +#37 2017-03-06 Dynamisches Profil (TooWaBoo) RT 5.0 r1 +#38 2017-03-26 Pixel Shift (TooWaBoo) RT 5.0 r1 +#39 06.04.2017 Fast Export (TooWaBoo) RT 5.0 r1 ABOUT_TAB_BUILD;Version ABOUT_TAB_CREDITS;Danksagungen @@ -107,6 +108,7 @@ EXIFPANEL_RESETALL;Alle zurücksetzen EXIFPANEL_RESETALLHINT;Alle Attribute auf die ursprünglichen Werte zurücksetzen EXIFPANEL_RESETHINT;Gewählte Attribute auf die ursprünglichen Werte zurücksetzen EXIFPANEL_SUBDIRECTORY;Unterverzeichnis +EXPORT_BYPASS;Verarbeitungsschritte überspringen EXPORT_BYPASS_ALL;Alle/Keine auswählen EXPORT_BYPASS_DEFRINGE;Farbsaum entfernen überspringen EXPORT_BYPASS_DIRPYRDENOISE;Rauschreduzierung überspringen @@ -129,8 +131,12 @@ EXPORT_FASTEXPORTOPTIONS;Schnell-Export - Einstellungen EXPORT_INSTRUCTIONS;Die Einstellungen zum schnellen Export\nerlauben es, zeit- und ressourcenintensive\nEntwicklungsschritte zu überspringen und dafür\ndie Warteschlangenverarbeitung mit\nschnellen Export-Einstellungen auszuführen.\nDieses Vorgehen wird zur schnelleren\nGenerierung von gering aufgelösten Bildern\nempfohlen, falls es auf die Geschwindigkeit\nankommt oder für ein oder mehrere Bilder\nandere Ausgabegrößen gewünscht werden,\nohne Änderungen an deren gespeicherten\nParameter vornehmen zu müssen. EXPORT_MAXHEIGHT;Maximale Höhe: EXPORT_MAXWIDTH;Maximale Breite: +EXPORT_PIPELINE;Verarbeitungspipeline EXPORT_PUTTOQUEUEFAST; Zur Warteschlange “Schneller Export“ hinzufügen EXPORT_RAW_DMETHOD;Demosaikmethode +EXPORT_USE_FAST_PIPELINE;Priorität Geschwindigkeit +EXPORT_USE_FAST_PIPELINE_TIP;Wendet alle Bearbeitungsschritte, im Gegensatz\nzu „Standard“ , auf das bereits skalierte Bild an.\nDadurch steigt die Verarbeitungsgeschwindigkeit\nauf Kosten der Qualität. +EXPORT_USE_NORMAL_PIPELINE;Standard EXTPROGTARGET_1;RAW EXTPROGTARGET_2;Stapelverarbeitung beendet FILEBROWSER_ADDDELTEMPLATE;Vorlagen hinzufügen/entfernen... @@ -932,8 +938,10 @@ PARTIALPASTE_PREPROCESS_HOTPIXFILT;Vorverarbeitung: Hot-Pixel-Filter PARTIALPASTE_PREPROCESS_LINEDENOISE;Vorverarbeitung: Zeilenrauschfilter PARTIALPASTE_PRSHARPENING;Schärfung nach Größenänderung PARTIALPASTE_RAWCACORR_AUTO;Chromatische Aberration: Automatische Korrektur +PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength PARTIALPASTE_RAWCACORR_CABLUE;Chromatische Aberration: Blau PARTIALPASTE_RAWCACORR_CARED;Chromatische Aberration: Rot +PARTIALPASTE_RAWCACORR_CAREDBLUE;Chromatische Aberration: Rot & Blau PARTIALPASTE_RAWEXPOS_BLACK;Weißpunkt: Schwarzpegel PARTIALPASTE_RAWEXPOS_LINEAR;Weißpunkt: Korrekturfaktor PARTIALPASTE_RAWEXPOS_PRESER;Weißpunkt: Lichter schützen (EV) @@ -944,6 +952,7 @@ PARTIALPASTE_RAW_DMETHOD;Farbinterpolation: Methode PARTIALPASTE_RAW_FALSECOLOR;Farbinterpolation: Falschfarbenreduzierung PARTIALPASTE_RAW_IMAGENUM;Farbinterpolation: Unterbild PARTIALPASTE_RAW_LMMSEITERATIONS;Farbinterpolation: LMMSE-Verbesserungsstufen +PARTIALPASTE_RAW_PIXELSHIFT;Farbinterpolation: Pixel Shift PARTIALPASTE_RESIZE;Skalieren PARTIALPASTE_RETINEX;Retinex (Bildschleier entfernen) PARTIALPASTE_RGBCURVES;RGB-Kurven @@ -1022,6 +1031,8 @@ PREFERENCES_DIRSOFTWARE;Installationsverzeichnis PREFERENCES_EDITORCMDLINE;Befehlszeile PREFERENCES_EDITORLAYOUT;Editor-Layout PREFERENCES_EXPAUT;Experte +PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming +PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. PREFERENCES_EXTERNALEDITOR;Externer Editor PREFERENCES_FBROWSEROPTS;Bildinformationen und Miniaturbilder PREFERENCES_FILEBROWSERTOOLBARSINGLEROW;Einzeilige Toolbar\n(Bei geringer Bildschirmauflösung deaktivieren) @@ -1761,8 +1772,8 @@ TP_RAW_PIXELSHIFTEXP0;Experimentell TP_RAW_PIXELSHIFTGREEN;Bewegung im Grün-Kanal erkennen TP_RAW_PIXELSHIFTHOLEFILL;Lücken in der Bewegungsmaske erkennen TP_RAW_PIXELSHIFTHOLEFILL_TOOLTIP;Lücken in der Bewegungsmaske erkennen -TP_RAW_PIXELSHIFTLMMSE;LMMSE für Bewegungsteile verwenden -TP_RAW_PIXELSHIFTLMMSE_TOOLTIP;LMMSE anstatt AMaZE für bewegte Bildanteile verwenden.\nSinnvoll bei High-ISO-Aufnahmen. +TP_RAW_PIXELSHIFTLMMSE;LMMSE für Bewegungsbereiche verwenden +TP_RAW_PIXELSHIFTLMMSE_TOOLTIP;LMMSE anstatt AMaZE für bewegte Bildbereiche verwenden.\nSinnvoll bei High-ISO-Aufnahmen. TP_RAW_PIXELSHIFTMASKTHRESHOLD;3x3 new threshold TP_RAW_PIXELSHIFTMEDIAN;Median TP_RAW_PIXELSHIFTMEDIAN3;Aktuellen Frame vom Median ausschließen. @@ -2178,17 +2189,3 @@ ZOOMPANEL_ZOOMFITSCREEN;An Bildschirm anpassen\nTaste: f ZOOMPANEL_ZOOMIN;Hineinzoomen\nTaste: + ZOOMPANEL_ZOOMOUT;Herauszoomen\nTaste: - -!!!!!!!!!!!!!!!!!!!!!!!!! -! Untranslated keys follow; remove the ! prefix after an entry is translated. -!!!!!!!!!!!!!!!!!!!!!!!!! - -!EXPORT_BYPASS;Processing steps to bypass -!EXPORT_PIPELINE;Processing pipeline -!EXPORT_USE_FAST_PIPELINE;Dedicated (full processing on resized image) -!EXPORT_USE_FAST_PIPELINE_TIP;Use a dedicated processing pipeline for images in Fast Export mode, that trades speed for quality. Resizing of the image is done as early as possible, instead of doing it at the end like in the normal pipeline. The speedup can be significant, but be prepared to see artifacts and a general degradation of output quality. -!EXPORT_USE_NORMAL_PIPELINE;Standard (bypass some steps, resize at the end) -!PARTIALPASTE_RAWCACORR_CAAUTOSTRENGTH;CA auto-correction strength -!PARTIALPASTE_RAWCACORR_CAREDBLUE;CA red & blue -!PARTIALPASTE_RAW_PIXELSHIFT;PixelShift -!PREFERENCES_EXTENDEDZOOMLEVELS;Use finer-grained zoom levels for "fit to screen" zooming -!PREFERENCES_EXTENDEDZOOMLEVELS_TOOLTIP;This allows to better fill the editor window when using one of the "fit to screen" zoom modes. However, the preview quality might be slightly degraded, depending on the actual zoom factor computed. From 6917f6bba320a1c4b21a1adf240a78e3b8ec23e1 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 6 Apr 2017 16:16:08 +0200 Subject: [PATCH 85/90] About 3x speed for scale_colors in rtthumbnail.cc also for xtrans files --- rtengine/rawimage.h | 9 +++++---- rtengine/rtthumbnail.cc | 32 +++++++++++++++++++++++++++++--- 2 files changed, 34 insertions(+), 7 deletions(-) diff --git a/rtengine/rawimage.h b/rtengine/rawimage.h index 3c4075207..cc6dccb67 100644 --- a/rtengine/rawimage.h +++ b/rtengine/rawimage.h @@ -129,10 +129,6 @@ protected: char* profile_data; // Embedded ICC color profile float* allocation; // pointer to allocated memory int maximum_c4[4]; - bool isXtrans() const - { - return filters == 9; - } bool isFoveon() const { return is_foveon; @@ -309,6 +305,11 @@ public: return (filters != 0 && filters != 9); } + bool isXtrans() const + { + return filters == 9; + } + public: // dcraw functions void scale_colors() diff --git a/rtengine/rtthumbnail.cc b/rtengine/rtthumbnail.cc index 20d3efd06..1033cc035 100644 --- a/rtengine/rtthumbnail.cc +++ b/rtengine/rtthumbnail.cc @@ -62,8 +62,8 @@ namespace void scale_colors(rtengine::RawImage *ri, float scale_mul[4], float cblack[4]) { BENCHFUNMICRO + DCraw::dcrawImage_t image = ri->get_image(); if(ri->isBayer()) { - DCraw::dcrawImage_t image = ri->get_image(); const int height = ri->get_iheight(); const int width = ri->get_iwidth(); for(int row = 0; row < height; ++row) { @@ -87,8 +87,34 @@ void scale_colors(rtengine::RawImage *ri, float scale_mul[4], float cblack[4]) image[row * width + col][c0] = rtengine::CLIP(val0); } } + } else if(ri->isXtrans()) { + const int height = ri->get_iheight(); + const int width = ri->get_iwidth(); + unsigned c[6]; + for(int row = 0; row < height; ++row) { + for(int i = 0; i < 6; ++i) { + c[i] = ri->XTRANSFC(row,i); + } + + int col = 0; + for(; col < width - 5; col += 6) { + for(int i = 0; i < 6; ++i) { + const unsigned ccol = c[i]; + float val = image[row * width + col + i][ccol]; + val -= cblack[ccol]; + val *= scale_mul[ccol]; + image[row * width + col + i][ccol] = rtengine::CLIP(val); + } + } + for(; col < width; ++col) { // remaining columns + const unsigned ccol = ri->XTRANSFC(row,col); + float val = image[row * width + col][ccol]; + val -= cblack[ccol]; + val *= scale_mul[ccol]; + image[row * width + col][ccol] = rtengine::CLIP(val); + } + } } else { - DCraw::dcrawImage_t image = ri->get_image(); const int size = ri->get_iheight() * ri->get_iwidth(); for (int i = 0; i < size; ++i) { for (int j = 0; j < 4; ++j) { @@ -908,7 +934,7 @@ IImage8* Thumbnail::quickProcessImage (const procparams::ProcParams& params, int IImage8* Thumbnail::processImage (const procparams::ProcParams& params, int rheight, TypeInterpolation interp, std::string camName, double focalLen, double focalLen35mm, float focusDist, float shutter, float fnumber, float iso, std::string expcomp_, double& myscale) { - BENCHFUN +// BENCHFUN // check if the WB's equalizer value has changed if (wbEqual < (params.wb.equal - 5e-4) || wbEqual > (params.wb.equal + 5e-4) || wbTempBias < (params.wb.tempBias - 5e-4) || wbTempBias > (params.wb.tempBias + 5e-4)) { From 1db6e78817446d8be70103c939ac260f82bb0de1 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 6 Apr 2017 16:59:38 +0200 Subject: [PATCH 86/90] minimize changes for 'Fix wrong computation of black levels (in some cases) in RawImage::get_colorsCoeff' --- rtengine/rawimage.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rtengine/rawimage.cc b/rtengine/rawimage.cc index 19fcb6c16..c0fd1f576 100644 --- a/rtengine/rawimage.cc +++ b/rtengine/rawimage.cc @@ -101,7 +101,7 @@ void RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, float *cblac cblack_[c] = this->get_cblack(c); } for (int c = 0; c < 4; c++) { - cblack_[FC(c / 2, c % 2)] += this->get_cblack(6 + c / 2 % this->get_cblack(4) * this->get_cblack(5) + c % 2 % this->get_cblack(5)); + cblack_[FC(c / 2, c % 2)] = this->get_cblack(6 + c / 2 % this->get_cblack(4) * this->get_cblack(5) + c % 2 % this->get_cblack(5)); pre_mul_[c] = this->get_pre_mul(c); } } else { From 633af0bb6c8376afb6e715e99c8075a372081019 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Thu, 6 Apr 2017 17:57:00 +0200 Subject: [PATCH 87/90] fix buffering issue in the LCP profile parser (issue #3788) --- rtengine/lcp.cc | 43 +++++++++++++++++++++++++++---------------- rtengine/lcp.h | 4 ++++ 2 files changed, 31 insertions(+), 16 deletions(-) diff --git a/rtengine/lcp.cc b/rtengine/lcp.cc index 2ba401811..fdf46270f 100644 --- a/rtengine/lcp.cc +++ b/rtengine/lcp.cc @@ -678,7 +678,9 @@ void XMLCALL LCPProfile::XmlStartHandler(void *pLCPProfile, const char *el, cons } strcpy(pProf->lastTag, nameStart); - XmlTextHandler(pLCPProfile, attr[i + 1], strlen(attr[i + 1])); + + pProf->handle_text(attr[i+1]); + //XmlTextHandler(pLCPProfile, attr[i + 1], strlen(attr[i + 1])); } } } @@ -690,24 +692,33 @@ void XMLCALL LCPProfile::XmlTextHandler(void *pLCPProfile, const XML_Char *s, in if (!pProf->inCamProfiles || pProf->inAlternateLensID || pProf->inAlternateLensNames || *pProf->inInvalidTag) { return; } + + for (int i = 0; i < len; ++i) { + pProf->textbuf << s[i]; + } +} + +void LCPProfile::handle_text(std::string text) +{ + const char *raw = text.c_str(); + // Check if it contains non-whitespaces (there are several calls to this for one tag unfortunately) bool onlyWhiteSpace = true; - int i = 0; - - while (i < len && onlyWhiteSpace) { - onlyWhiteSpace = isspace(s[i]); - i++; + for (size_t i = 0; i < text.size(); ++i) { + if (!isspace(text[i])) { + onlyWhiteSpace = false; + break; + } } if (onlyWhiteSpace) { return; } + LCPProfile *pProf = this; + // convert to null terminated - char raw[len + 1]; - memcpy(raw, s, len); - raw[len] = 0; char* tag = pProf->lastTag; // Common data section @@ -732,15 +743,12 @@ void XMLCALL LCPProfile::XmlTextHandler(void *pLCPProfile, const XML_Char *s, in // WARNING: called by different threads, that may run on different local settings, // so don't use system params if (atof("1,2345") == 1.2345) { - char* p = raw; - - while (*p) { - if (*p == '.') { - *p = ','; + for (size_t i = 0; i < text.size(); ++i) { + if (text[i] == '.') { + text[i] = ','; } - - p++; } + raw = text.c_str(); } if (!pProf->firstLIDone) { @@ -789,6 +797,9 @@ void XMLCALL LCPProfile::XmlEndHandler(void *pLCPProfile, const char *el) { LCPProfile *pProf = static_cast(pLCPProfile); + pProf->handle_text(pProf->textbuf.str()); + pProf->textbuf.str(""); + // We ignore everything in dirty tag till it's gone if (*pProf->inInvalidTag) { if (strstr(el, pProf->inInvalidTag)) { diff --git a/rtengine/lcp.h b/rtengine/lcp.h index fa8cf226d..e108e61b7 100644 --- a/rtengine/lcp.h +++ b/rtengine/lcp.h @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -94,6 +95,9 @@ class LCPProfile int filterBadFrames(double maxAvgDevFac, int minFramesLeft); + void handle_text(std::string text); + std::ostringstream textbuf; + public: // Common data Glib::ustring profileName, lensPrettyName, cameraPrettyName, lens, camera; // lens/camera(=model) can be auto-matched with DNG From be4cc858a23ddfe88c509b433e1002cce6ea7162 Mon Sep 17 00:00:00 2001 From: heckflosse Date: Thu, 6 Apr 2017 23:51:36 +0200 Subject: [PATCH 88/90] Remove obsolete dcraw::scale_colors() --- rtengine/dcraw.cc | 2 ++ rtengine/dcraw.h | 13 ------------- rtengine/rawimage.h | 14 -------------- 3 files changed, 2 insertions(+), 27 deletions(-) diff --git a/rtengine/dcraw.cc b/rtengine/dcraw.cc index e55c0256b..eca373337 100644 --- a/rtengine/dcraw.cc +++ b/rtengine/dcraw.cc @@ -4526,6 +4526,7 @@ void CLASS colorcheck() // free (fimg); //} +/* void CLASS scale_colors() { unsigned bottom, right, size, row, col, ur, uc, i, x, y, c, sum[8]; @@ -4641,6 +4642,7 @@ skip_block: ; } } +*/ void CLASS pre_interpolate() { ushort (*img)[4]; diff --git a/rtengine/dcraw.h b/rtengine/dcraw.h index c0502ae5d..6a1a83391 100644 --- a/rtengine/dcraw.h +++ b/rtengine/dcraw.h @@ -410,23 +410,10 @@ void foveon_make_curves(short **curvep, float dq[3], float div[3], float filt); int foveon_apply_curve (short *curve, int i); void foveon_interpolate(); -//void xtrans_interpolate (int passes); -//void cielab (ushort rgb[3], short lab[3]); - -//void remove_zeroes(); -//void bad_pixels (const char *cfname); -//void subtract (const char *fname); void gamma_curve (double pwr, double ts, int mode, int imax); void pseudoinverse (double (*in)[3], double (*out)[3], int size); void cam_xyz_coeff (float rgb_cam[3][4], double cam_xyz[4][3]); -//void hat_transform (float *temp, float *base, int st, int size, int sc); -//void wavelet_denoise(); -void scale_colors(); void pre_interpolate(); -//void border_interpolate (int border); -//void median_filter(); -//void blend_highlights(); -//void recover_highlights(); void crop_masked_pixels(); void tiff_get (unsigned base, unsigned *tag, unsigned *type, unsigned *len, unsigned *save); diff --git a/rtengine/rawimage.h b/rtengine/rawimage.h index cc6dccb67..62752b59c 100644 --- a/rtengine/rawimage.h +++ b/rtengine/rawimage.h @@ -173,12 +173,6 @@ public: void getRgbCam (float rgbcam[3][4]); void getXtransMatrix ( int xtransMatrix[6][6]); - void clearXtransCblack( ) - { - for(int c = 0; c < 4; c++) { - cblack[c] = 0; - } - } unsigned get_filters() const { return filters; @@ -312,14 +306,6 @@ public: public: // dcraw functions - void scale_colors() - { - if(isXtrans()) { - clearXtransCblack( ); - } - - DCraw::scale_colors(); - } void pre_interpolate() { DCraw::pre_interpolate(); From bdca39bbb0e583928ebe33f6c8deb4c3336b87b6 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Fri, 7 Apr 2017 08:54:11 +0200 Subject: [PATCH 89/90] removed benchmarking code from rtthumbnail.cc --- rtengine/rtthumbnail.cc | 5 ----- 1 file changed, 5 deletions(-) diff --git a/rtengine/rtthumbnail.cc b/rtengine/rtthumbnail.cc index 1033cc035..16fd4dc5d 100644 --- a/rtengine/rtthumbnail.cc +++ b/rtengine/rtthumbnail.cc @@ -37,8 +37,6 @@ #include "../rtgui/ppversion.h" #include "improccoordinator.h" #include -#define BENCHMARK -#include "StopWatch.h" namespace @@ -61,7 +59,6 @@ namespace void scale_colors(rtengine::RawImage *ri, float scale_mul[4], float cblack[4]) { - BENCHFUNMICRO DCraw::dcrawImage_t image = ri->get_image(); if(ri->isBayer()) { const int height = ri->get_iheight(); @@ -934,8 +931,6 @@ IImage8* Thumbnail::quickProcessImage (const procparams::ProcParams& params, int IImage8* Thumbnail::processImage (const procparams::ProcParams& params, int rheight, TypeInterpolation interp, std::string camName, double focalLen, double focalLen35mm, float focusDist, float shutter, float fnumber, float iso, std::string expcomp_, double& myscale) { -// BENCHFUN - // check if the WB's equalizer value has changed if (wbEqual < (params.wb.equal - 5e-4) || wbEqual > (params.wb.equal + 5e-4) || wbTempBias < (params.wb.tempBias - 5e-4) || wbTempBias > (params.wb.tempBias + 5e-4)) { wbEqual = params.wb.equal; From 73e14702dd808da0d5b28596944dd306ff0af186 Mon Sep 17 00:00:00 2001 From: Alberto Griggio Date: Sat, 8 Apr 2017 10:13:53 +0200 Subject: [PATCH 90/90] fix out-of-bounds access to crop when lcp distortion correction is enabled --- rtengine/dcrop.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rtengine/dcrop.cc b/rtengine/dcrop.cc index 0bc6ce82a..18cb927aa 100644 --- a/rtengine/dcrop.cc +++ b/rtengine/dcrop.cc @@ -1150,10 +1150,10 @@ bool Crop::setCropSizes (int rcx, int rcy, int rcw, int rch, int skip, bool inte // distortion relative to the image // size. BUT IS 15% REALLY ENOUGH? // In fact, is there a better way?? - orw = min(int(orw + dW), parent->fw); - orh = min(int(orh + dH), parent->fh); orx = max(int(orx - dW/2.0), 0); ory = max(int(ory - dH/2.0), 0); + orw = min(int(orw + dW), parent->fw - orx); + orh = min(int(orh + dH), parent->fh - ory); }