/*
 *  This file is part of RawTherapee.
 *
 *  Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
 *
 *
 *  RawTherapee is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  RawTherapee is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
 *  2016 Jacques Desmis <jdesmis@gmail.com>
 *  2016 Ingo Weyrich <heckflosse@i-weyrich.de>

 */
#include <cmath>
#include <fftw3.h>

#include "improcfun.h"
#include "curves.h"
#include "gauss.h"
#include "iccmatrices.h"
#include "color.h"
#include "rt_math.h"
#include "jaggedarray.h"
#include "rt_algo.h"

#ifdef _OPENMP
#include <omp.h>
#endif
#include "../rtgui/thresholdselector.h"

#include "cplx_wavelet_dec.h"
#include "ciecam02.h"

#define BENCHMARK
#include "StopWatch.h"
#include "guidedfilter.h"

#define TS 64       // Tile size
#define offset 25   // shift between tiles
#define fTS ((TS/2+1))  // second dimension of Fourier tiles
#define blkrad 1    // radius of block averaging
#define offset2 25   // shift between tiles

#define epsilon 0.001f/(TS*TS) //tolerance
#define MAXSCOPE 1.25f
#define MINSCOPE 0.025f
#define mSP 5  //minimum size Spot
#define mDEN 64  //minimum size Spot Denoise

#define CLIPC(a) LIM(a, -42000.f, 42000.f)  // limit a and b  to 130 probably enough ?
#define CLIPL(x) LIM(x,0.f,40000.f) // limit L to about L=120 probably enough ?
#define CLIPLOC(x) LIM(x,0.f,32767.f)
#define CLIPLIG(x) LIM(x,-99.5f, 99.5f)
#define CLIPCHRO(x) LIM(x,0.f, 140.f)
#define CLIPRET(x) LIM(x,-99.5f, 99.5f)
#define CLIP1(x) LIM(x, 0.f, 1.f)
//define to prevent crash with old pp3 with integer range 100 instead of double range 1.
#define CLIP24(x) LIM(x, -2., 4.)
#define CLIP04(x) LIM(x, 0.f, 4.f)
#define CLIP42_35(x) LIM(x, 0.42, 3.5)
#define CLIP2_30(x) LIM(x, 0.2, 3.)
#define CLIPMAX(x) LIM(x,0.f,500000.f)
#define CLIPdE(x) LIM(x,0.3f,1.f)

#pragma GCC diagnostic warning "-Wall"
#pragma GCC diagnostic warning "-Wextra"


namespace
{

void calcGammaLut(double gamma, double ts, LUTf &gammaLut)
{
    double pwr = 1.0 / gamma;
    double gamm = gamma;
    const double gamm2 = gamma;
    rtengine::GammaValues g_a;

    if (gamm2 < 1.0) {
        std::swap(pwr, gamm);
    }

    rtengine::Color::calcGamma(pwr, ts, 0, g_a); // call to calcGamma with selected gamma and slope

    const double start = gamm2 < 1. ? g_a[2] : g_a[3];
    const double add = g_a[4];
    const double mul = 1.0 + g_a[4];

    if (gamm2 < 1.) {
        #pragma omp parallel for schedule(dynamic, 1024)

        for (int i = 0; i < 65536; i++) {
            const double x = rtengine::Color::igammareti(i / 65535.0, gamm, start, ts, mul, add);
            gammaLut[i] = 0.5 * rtengine::CLIP(x * 65535.0);  // CLIP avoid in some case extra values
        }
    } else {
        #pragma omp parallel for schedule(dynamic, 1024)

        for (int i = 0; i < 65536; i++) {
            const double x = rtengine::Color::gammareti(i / 65535.0, gamm, start, ts, mul, add);
            gammaLut[i] = 0.5 * rtengine::CLIP(x * 65535.0);  // CLIP avoid in some case extra values
        }
    }
}

float calcLocalFactor(const float lox, const float loy, const float lcx, const float dx, const float lcy, const float dy, const float ach, const float gradient)
{
//elipse x2/a2 + y2/b2=1
//transition elipsoidal
//x==>lox y==>loy
// a==> dx  b==>dy
//printf("grad=%f", gradient);
    float eps = 0.0001f;
    float kelip = dx / dy;
    float belip = sqrt((rtengine::SQR((lox - lcx) / kelip) + rtengine::SQR(loy - lcy)));    //determine position ellipse ==> a and b

    if (belip == 0.f) {
        belip = eps;
    }

    //gradient allows differenciation between transition x and y
    float rapy = fabs((loy - lcy) / belip);
    float aelip = belip * kelip;
    float degrad = aelip / dx;
    float gradreal = gradient * rapy + 1.f;
    float ap = rtengine::RT_PI_F / (1.f - ach);
    float bp = rtengine::RT_PI_F - ap;
    float retreal = pow(0.5f * (1.f + xcosf(degrad * ap + bp)), rtengine::SQR(gradreal));
    return retreal;  //trigo cos transition
}

float calcLocalFactorrect(const float lox, const float loy, const float lcx, const float dx, const float lcy, const float dy, const float ach, const float gradient)
{
    float eps = 0.0001f;
    float krap = fabs(dx / dy);
    float kx = (lox - lcx);
    float ky = (loy - lcy);
    float ref = 0.f;
    //gradient allows differenciation between transition x and y

    if (fabs(kx / (ky + eps)) < krap) {
        ref = sqrt(rtengine::SQR(dy) * (1.f + rtengine::SQR(kx / (ky + eps))));
    } else {
        ref = sqrt(rtengine::SQR(dx) * (1.f + rtengine::SQR(ky / (kx + eps))));
    }

    float rad = sqrt(rtengine::SQR(kx) + rtengine::SQR(ky));

    if (rad == 0.f) {
        rad = eps;
    }

    float rapy = fabs((loy - lcy) / rad);
    float gradreal = gradient * rapy + 1.f;

    float coef = rad / ref;
    float ac = 1.f / (ach - 1.f);
    float fact = ac * (coef - 1.f);
    return pow(fact, rtengine::SQR(gradreal));

}


}

namespace rtengine

{
extern MyMutex *fftwMutex;

using namespace procparams;

extern const Settings* settings;


struct local_params {
    float yc, xc;
    float ycbuf, xcbuf;
    float lx, ly;
    float lxL, lyT;
    float dxx, dyy;
    float iterat;
    float balance;
    int cir;
    float thr;
    float stru;
    int chro, cont, sens, sensh, senscb, sensbn, senstm, sensex, sensexclu, sensden, senslc, senssf, senshs;
    float clarityml;
    float contresid;
    float blurcbdl;
    float struco;
    float strengrid;
    float struexc;
    float blendmacol;
    float radmacol;
    float chromacol;
    float gammacol;
    float slomacol;
    float radmaexp;
    float chromaexp;
    float gammaexp;
    float slomaexp;
    float softradiusexp;
    float softradiuscol;
    float softradiuscb;
    float softradiusret;
    float softradiustm;
    float blendmaexp;
    float radmaSH;
    float blendmaSH;
    float chromaSH;
    float gammaSH;
    float slomaSH;
    float radmacb;
    float blendmacb;
    float chromacbm;
    float gammacb;
    float slomacb;
    float radmatm;
    float blendmatm;
    float chromatm;
    float gammatm;
    float slomatm;

    float radmabl;
    float blendmabl;
    float chromabl;
    float gammabl;
    float slomabl;

    float struexp;
    float blurexp;
    float blurcol;
    float blurSH;
    float ligh;
    float lowA, lowB, highA, highB;
    int shamo, shdamp, shiter, senssha, sensv;
    float neig;
    float strng;
    float lap;
    float lcamount;
    double shrad;
    double shblurr;
    double rad;
    double stren;
    int it;
    int guidb;
    float epsb;
    float trans;
    float transweak;
    float transgrad;
    int dehaze;
    int depth;
    bool inv;
    bool invex;
    bool invsh;
    bool curvact;
    bool invrad;
    bool invret;
    bool equret;
    bool equtm;
    bool invshar;
    bool actsp;
    bool ftwlc;
    bool ftwreti;
    float str;
    int qualmet;
    int qualcurvemet;
    int gridmet;
    int showmaskcolmet;
    int showmaskcolmetinv;
    int showmaskexpmet;
    int showmaskexpmetinv;
    int showmaskSHmet;
    int showmaskSHmetinv;
    int showmaskcbmet;
    int showmaskretimet;
    int showmasksoftmet;
    int showmasktmmet;
    int showmaskblmet;
    float laplacexp;
    float balanexp;
    float linear;
    int expmet;
    int softmet;
    int blurmet;
    int blmet;
    int medmet;
    int locmet;
    float noiself;
    float noiself0;
    float noiself2;
    float noiseldetail;
    int detailthr;
    int noiselequal;
    float noisechrodetail;
    float bilat;
    float noiselc;
    float noisecf;
    float noisecc;
    float mulloc[6];
    float threshol;
    float chromacb;
    float strengt;
    float gamm;
    float esto;
    float scalt;
    float rewe;
    float amo;
    bool colorena;
    bool blurena;
    bool tonemapena;
    bool retiena;
    bool sharpena;
    bool lcena;
    bool sfena;
    bool cbdlena;
    bool denoiena;
    bool expvib;
    bool exposena;
    bool hsena;
    bool cut_past;
    float past;
    float satur;
    int blac;
    int shcomp;
    int shadex;
    int hlcomp;
    int hlcompthr;
    double expcomp;
    float expchroma;
    int excmet;
    int war;
    float adjch;
    int shapmet;
    bool enaColorMask;
    bool enaColorMaskinv;
    bool enaExpMask;
    bool enaExpMaskinv;
    bool enaSHMask;
    bool enaSHMaskinv;
    bool enacbMask;
    bool enaretiMask;
    bool enaretiMasktmap;
    bool enatmMask;
    bool enablMask;
    int highlihs;
    int shadowhs;
    int radiushs;
    int hltonalhs;
    int shtonalhs;
    float radmareti;
    float blendmareti;
    float chromareti;
    float gammareti;
    float slomareti;
    int scalereti;
};

static void SobelCannyLuma(float **sobelL, float **luma, int bfw, int bfh, float radius, bool multiThread = false)
{
    // base of the process to detect shape in complement of deltaE
    // use for calculate Spot reference
    // and for structure of the shape
    // actually , as the program don't use these function, I just create a simple "Canny" near of Sobel. This can be completed after with teta, etc.
    array2D<float> tmL(bfw, bfh);

    //inspired from Chen Guanghua Zhang Xiaolong
    //Sobel Horizontal
    constexpr float GX[3][3] = {
        {1.f, 0.f, -1.f},
        {2.f, 0.f, -2.f},
        {1.f, 0.f, -1.f}
    };

    //Sobel Vertical
    constexpr float GY[3][3] = {
        {1.f, 2.f, 1.f},
        {0.f, 0.f, 0.f},
        {-1.f, -2.f, -1.f}
    };

    if (radius > 0.f) {
        radius = rtengine::max(radius / 2.f, 0.5f);

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
            gaussianBlur(luma, tmL, bfw, bfh, radius);
        }
    } else {
        for (int y = 0; y < bfh ; y++) {
            for (int x = 0; x < bfw ; x++) {
                sobelL[y][x] = 0.f;
                tmL[y][x] = luma[y][x];
            }
        }
    }

#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic, 16) if (multiThread)
#endif

    for (int y = 0; y < bfh ; y++) {
        for (int x = 0; x < bfw ; x++) {
            float sumXL = 0.f;
            float sumYL = 0.f;
            float SUML;

            if (y == 0 || y == bfh - 1) {
                SUML = 0.f;
            } else if (x == 0 || x == bfw - 1) {
                SUML = 0.f;
            } else {
                for (int i = -1; i < 2; i += 2) {
                    for (int j = -1; j < 2; j += 1) {
                        sumXL += GX[j + 1][i + 1] * tmL[y + i][x + j];
                    }
                }

                for (int i = -1; i < 2; i += 1) {
                    for (int j = -1; j < 2; j += 2) {
                        sumYL += GY[j + 1][i + 1] * tmL[y + i][x + j];
                    }
                }

                //Edge strength
                SUML = sqrt(SQR(sumXL) + SQR(sumYL));
                //we can add if need teta = atan2 (sumYr, sumXr)
            }

            sobelL[y][x] = CLIPLOC(SUML);
        }
    }
}



static void calcLocalParams(int sp, int oW, int oH, const LocallabParams& locallab, struct local_params& lp, int llColorMask, int llColorMaskinv, int llExpMask, int llExpMaskinv, int llSHMask, int llSHMaskinv, int llcbMask, int llretiMask, int llsoftMask, int lltmMask, int llblMask)
{
    int w = oW;
    int h = oH;
    int circr = locallab.spots.at(sp).circrad;
    float streng = ((float)locallab.spots.at(sp).stren);
    float gam = ((float)locallab.spots.at(sp).gamma);
    float est = ((float)locallab.spots.at(sp).estop);
    float scal_tm = ((float)locallab.spots.at(sp).scaltm);
    float rewe = ((float)locallab.spots.at(sp).rewei);
    float amo = ((float)locallab.spots.at(sp).amount);
    float strlight = ((float)locallab.spots.at(sp).streng);
    float strucc = locallab.spots.at(sp).struc;
    float laplac = ((float)locallab.spots.at(sp).laplace);

    float thre = locallab.spots.at(sp).thresh;

    if (thre > 8.f || thre < 0.f) {//to avoid artifacts if user does not clear cache with new settings. Can be suppressed after
        thre = 2.f;
    }

    double local_x = locallab.spots.at(sp).locX / 2000.0;
    double local_y = locallab.spots.at(sp).locY / 2000.0;
    double local_xL = locallab.spots.at(sp).locXL / 2000.0;
    double local_yT = locallab.spots.at(sp).locYT / 2000.0;
    double local_center_x = locallab.spots.at(sp).centerX / 2000.0 + 0.5;
    double local_center_y = locallab.spots.at(sp).centerY / 2000.0 + 0.5;
    double local_center_xbuf = 0.0; // Provision
    double local_center_ybuf = 0.0; // Provision
    double local_dxy = locallab.spots.at(sp).iter / 8000.0; //for proxi = 2==> # 1 pixel
    float iterati = (float) locallab.spots.at(sp).iter;
    float balanc = (float) locallab.spots.at(sp).balan;

    if (iterati > 4.f || iterati < 0.2f) {//to avoid artifacts if user does not clear cache with new settings Can be suppressed after
        iterati = 2.f;
    }

    float neigh = float (locallab.spots.at(sp).neigh);
    float chromaPastel = float (locallab.spots.at(sp).pastels)   / 100.0f;
    float chromaSatur  = float (locallab.spots.at(sp).saturated) / 100.0f;
    int local_sensiv = locallab.spots.at(sp).sensiv;
    int local_sensiex = locallab.spots.at(sp).sensiex;

    if (locallab.spots.at(sp).qualityMethod == "enh") {
        lp.qualmet = 1;
    } else if (locallab.spots.at(sp).qualityMethod == "enhden") {
        lp.qualmet = 2;
    }

    if (locallab.spots.at(sp).qualitycurveMethod == "none") {
        lp.qualcurvemet = 0;
    } else if (locallab.spots.at(sp).qualitycurveMethod == "std") {
        lp.qualcurvemet = 1;
    }

    if (locallab.spots.at(sp).gridMethod == "one") {
        lp.gridmet = 0;
    } else if (locallab.spots.at(sp).gridMethod == "two") {
        lp.gridmet = 1;
    }

    if (locallab.spots.at(sp).expMethod == "std") {
        lp.expmet = 0;
    } else if (locallab.spots.at(sp).expMethod == "pde") {
        lp.expmet = 1;
    }

    if (locallab.spots.at(sp).localcontMethod == "loc") {
        lp.locmet = 0;
    } else if (locallab.spots.at(sp).localcontMethod == "wav") {
        lp.locmet = 1;
    }

    lp.laplacexp = locallab.spots.at(sp).laplacexp;
    lp.balanexp = locallab.spots.at(sp).balanexp;
    lp.linear = locallab.spots.at(sp).linear;

    lp.showmaskcolmet = llColorMask;
    lp.showmaskcolmetinv = llColorMaskinv;
    lp.showmaskexpmet = llExpMask;
    lp.showmaskexpmetinv = llExpMaskinv;
    lp.showmaskSHmet = llSHMask;
    lp.showmaskSHmetinv = llSHMaskinv;
    lp.showmaskcbmet = llcbMask;
    lp.showmaskretimet = llretiMask;
    lp.showmasksoftmet = llsoftMask;
    lp.showmasktmmet = lltmMask;
    lp.showmaskblmet = llblMask;
    lp.enaColorMask = locallab.spots.at(sp).enaColorMask && llColorMask == 0 && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0 && llblMask == 0;// Exposure mask is deactivated if Color & Light mask is visible
    lp.enaColorMaskinv = locallab.spots.at(sp).enaColorMask && llColorMaskinv == 0 && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0 && llblMask == 0;// Exposure mask is deactivated if Color & Light mask is visible
    lp.enaExpMask = locallab.spots.at(sp).enaExpMask && llExpMask == 0 && llColorMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0 && llblMask == 0;// Exposure mask is deactivated if Color & Light mask is visible
    lp.enaExpMaskinv = locallab.spots.at(sp).enaExpMask && llExpMaskinv == 0 && llColorMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0 && llblMask == 0;// Exposure mask is deactivated if Color & Light mask is visible
    lp.enaSHMask = locallab.spots.at(sp).enaSHMask && llSHMask == 0 && llColorMask == 0 && llExpMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0 && llblMask == 0 ;
    lp.enaSHMaskinv = locallab.spots.at(sp).enaSHMask && llSHMaskinv == 0 && llColorMask == 0 && llExpMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0 && llblMask == 0 ;
    lp.enacbMask = locallab.spots.at(sp).enacbMask && llcbMask == 0 && llColorMask == 0 && llExpMask == 0 && llSHMask == 0 && llretiMask == 0 && lltmMask == 0  && llblMask == 0;
    lp.enaretiMask = locallab.spots.at(sp).enaretiMask && llretiMask == 0 && llColorMask == 0 && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && lltmMask == 0  && llblMask == 0;
    lp.enatmMask = locallab.spots.at(sp).enatmMask && lltmMask == 0 && llColorMask == 0 && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0  && llblMask == 0;
    lp.enablMask = locallab.spots.at(sp).enablMask && llblMask == 0 && llColorMask == 0 && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0;

//printf("lp.showmaskSHmetinv=%i\n", lp.showmaskSHmetinv);
    if (locallab.spots.at(sp).softMethod == "soft") {
        lp.softmet = 0;
    } else if (locallab.spots.at(sp).softMethod == "reti") {
        lp.softmet = 1;
    }

    if (locallab.spots.at(sp).blMethod == "blur") {
        lp.blmet = 0;
    } else if (locallab.spots.at(sp).blMethod == "med") {
        lp.blmet = 1;
    } else if (locallab.spots.at(sp).blMethod == "guid") {
        lp.blmet = 2;
    }

    if (locallab.spots.at(sp).medMethod == "33") {
        lp.medmet = 0;
    } else if (locallab.spots.at(sp).medMethod == "55") {
        lp.medmet = 1;
    } else if (locallab.spots.at(sp).medMethod == "77") {
        lp.medmet = 2;
    } else if (locallab.spots.at(sp).medMethod == "99") {
        lp.medmet = 3;
    }

    if (locallab.spots.at(sp).blurMethod == "norm") {
        lp.blurmet = 0;
    } else if (locallab.spots.at(sp).blurMethod == "inv") {
        lp.blurmet = 1;
    }

    if (locallab.spots.at(sp).spotMethod == "norm") {
        lp.excmet = 0;
    } else if (locallab.spots.at(sp).spotMethod == "exc") {
        lp.excmet = 1;
    }

    if (locallab.spots.at(sp).shape == "ELI") {
        lp.shapmet = 0;
    } else if (locallab.spots.at(sp).shape == "RECT") {
        lp.shapmet = 1;
    }

    float local_noiself = (float)locallab.spots.at(sp).noiselumf;
    float local_noiself0 = (float)locallab.spots.at(sp).noiselumf0;
    float local_noiself2 = (float)locallab.spots.at(sp).noiselumf2;
    float local_noiselc = (float)locallab.spots.at(sp).noiselumc;
    float local_noiseldetail = (float)locallab.spots.at(sp).noiselumdetail;
    int local_noiselequal = locallab.spots.at(sp).noiselequal;
    float local_noisechrodetail = (float)locallab.spots.at(sp).noisechrodetail;
    int local_sensiden = locallab.spots.at(sp).sensiden;
    float local_detailthr = (float)locallab.spots.at(sp).detailthr;

    float local_noisecf = ((float)locallab.spots.at(sp).noisechrof) / 10.f;
    float local_noisecc = ((float)locallab.spots.at(sp).noisechroc) / 10.f;
    float multi[6];

    for (int y = 0; y < 6; y++) {
        multi[y] = ((float) locallab.spots.at(sp).mult[y]);
    }

    float thresho = ((float)locallab.spots.at(sp).threshold);
    float chromcbdl = (float)locallab.spots.at(sp).chromacbdl;

    int local_chroma = locallab.spots.at(sp).chroma;
    int local_sensi = locallab.spots.at(sp).sensi;
    int local_sensibn = locallab.spots.at(sp).sensibn;
    int local_sensitm = locallab.spots.at(sp).sensitm;
    int local_sensiexclu = locallab.spots.at(sp).sensiexclu;
    float structexclude = (float) locallab.spots.at(sp).structexclu;
    int local_sensilc = locallab.spots.at(sp).sensilc;
//    int local_struc = locallab.spots.at(sp).struc;
    int local_warm = locallab.spots.at(sp).warm;
    int local_sensih = locallab.spots.at(sp).sensih;
    int local_dehaze = locallab.spots.at(sp).dehaz;
    int local_depth = locallab.spots.at(sp).depth;
    int local_sensicb = locallab.spots.at(sp).sensicb;
    float local_clarityml = (float) locallab.spots.at(sp).clarityml;
    float local_contresid = (float) locallab.spots.at(sp).contresid;
    int local_blurcbdl = (float) locallab.spots.at(sp).blurcbdl;
    int local_contrast = locallab.spots.at(sp).contrast;
    float local_lightness = (float) locallab.spots.at(sp).lightness;
    float labgridALowloc = locallab.spots.at(sp).labgridALow;
    float labgridBLowloc = locallab.spots.at(sp).labgridBLow;
    float labgridBHighloc = locallab.spots.at(sp).labgridBHigh;
    float labgridAHighloc = locallab.spots.at(sp).labgridAHigh;
    float strengthgrid = (float) locallab.spots.at(sp).strengthgrid;

    float structcolor = (float) locallab.spots.at(sp).structcol;
    float blendmaskcolor = ((float) locallab.spots.at(sp).blendmaskcol) / 100.f ;
    float radmaskcolor = ((float) locallab.spots.at(sp).radmaskcol);
    float chromaskcolor = ((float) locallab.spots.at(sp).chromaskcol);
    float gammaskcolor = ((float) locallab.spots.at(sp).gammaskcol);
    float slomaskcolor = ((float) locallab.spots.at(sp).slomaskcol);
    float blendmaskexpo = ((float) locallab.spots.at(sp).blendmaskexp) / 100.f ;
    float radmaskexpo = ((float) locallab.spots.at(sp).radmaskexp);
    float chromaskexpo = ((float) locallab.spots.at(sp).chromaskexp);
    float gammaskexpo = ((float) locallab.spots.at(sp).gammaskexp);
    float slomaskexpo = ((float) locallab.spots.at(sp).slomaskexp);
    float softradiusexpo = ((float) locallab.spots.at(sp).softradiusexp);
    float softradiuscolor = ((float) locallab.spots.at(sp).softradiuscol);
    float softradiusreti = ((float) locallab.spots.at(sp).softradiusret);
    float softradiustma = ((float) locallab.spots.at(sp).softradiustm);
    float softradiuscbdl = ((float) locallab.spots.at(sp).softradiuscb);
    float blendmaskSH = ((float) locallab.spots.at(sp).blendmaskSH) / 100.f ;
    float radmaskSH = ((float) locallab.spots.at(sp).radmaskSH);
    float chromaskSH = ((float) locallab.spots.at(sp).chromaskSH);
    float gammaskSH = ((float) locallab.spots.at(sp).gammaskSH);
    float slomaskSH = ((float) locallab.spots.at(sp).slomaskSH);
    float structexpo = (float) locallab.spots.at(sp).structexp;
    float blurexpo = (float) locallab.spots.at(sp).blurexpde;
    float blurcolor = (float) locallab.spots.at(sp).blurcolde;
    float blurSH = (float) locallab.spots.at(sp).blurSHde;
    float local_transit = locallab.spots.at(sp).transit;
    float local_transitweak = (float)locallab.spots.at(sp).transitweak;
    float local_transitgrad = (float)locallab.spots.at(sp).transitgrad;
    float radius = (float) locallab.spots.at(sp).radius;
    int itera = locallab.spots.at(sp).itera;
    int guidbl = locallab.spots.at(sp).guidbl;
    float epsbl = (float) locallab.spots.at(sp).epsbl;
    double sharradius = ((double) locallab.spots.at(sp).sharradius);
    sharradius = CLIP42_35(sharradius);
    float lcamount = ((float) locallab.spots.at(sp).lcamount);
    lcamount = CLIP1(lcamount); //to prevent crash with old pp3 integer
    double sharblurr = ((double) locallab.spots.at(sp).sharblur);
    sharblurr = CLIP2_30(sharblurr);//to prevent crash with old pp3 integer
    int local_sensisha = locallab.spots.at(sp).sensisha;
    int local_sharamount = locallab.spots.at(sp).sharamount;
    int local_shardamping = locallab.spots.at(sp).shardamping;
    int local_shariter = locallab.spots.at(sp).shariter;
    bool inverse = locallab.spots.at(sp).invers;
    bool curvacti = locallab.spots.at(sp).curvactiv;
    bool acti = locallab.spots.at(sp).activlum;
    bool cupas = false; // Provision
    int local_sensisf = locallab.spots.at(sp).sensisf;
    bool inverseex = locallab.spots.at(sp).inversex;
    bool inversesh = locallab.spots.at(sp).inverssh;
    bool equiltm = locallab.spots.at(sp).equiltm;
    bool fftwlc = locallab.spots.at(sp).fftwlc;
    bool fftwreti = locallab.spots.at(sp).fftwreti;

    bool equilret = locallab.spots.at(sp).equilret;
    bool inverserad = false; // Provision
    bool inverseret = locallab.spots.at(sp).inversret;
    bool inversesha = locallab.spots.at(sp).inverssha;
    double strength = (double) locallab.spots.at(sp).strength;
    float str = (float)locallab.spots.at(sp).str;
    int scaleret = (float)locallab.spots.at(sp).scalereti;

    int local_sensihs = locallab.spots.at(sp).sensihs;
    int highhs = locallab.spots.at(sp).highlights;
    int hltonahs = locallab.spots.at(sp).h_tonalwidth;
    int shadhs = locallab.spots.at(sp).shadows;
    int shtonals = locallab.spots.at(sp).s_tonalwidth;
    int radhs = locallab.spots.at(sp).sh_radius;
    float blendmaskcb = ((float) locallab.spots.at(sp).blendmaskcb) / 100.f ;
    float radmaskcb = ((float) locallab.spots.at(sp).radmaskcb);
    float chromaskcb = ((float) locallab.spots.at(sp).chromaskcb);
    float gammaskcb = ((float) locallab.spots.at(sp).gammaskcb);
    float slomaskcb = ((float) locallab.spots.at(sp).slomaskcb);
    bool enaretiMasktm = locallab.spots.at(sp).enaretiMasktmap;
    lp.enaretiMasktmap =  enaretiMasktm;
    float blendmasktm = ((float) locallab.spots.at(sp).blendmasktm) / 100.f ;
    float radmasktm = ((float) locallab.spots.at(sp).radmasktm);
    float chromasktm = ((float) locallab.spots.at(sp).chromasktm);
    float gammasktm = ((float) locallab.spots.at(sp).gammasktm);
    float slomasktm = ((float) locallab.spots.at(sp).slomasktm);

    float blendmaskbl = ((float) locallab.spots.at(sp).blendmaskbl) / 100.f ;
    float radmaskbl = ((float) locallab.spots.at(sp).radmaskbl);
    float chromaskbl = ((float) locallab.spots.at(sp).chromaskbl);
    float gammaskbl = ((float) locallab.spots.at(sp).gammaskbl);
    float slomaskbl = ((float) locallab.spots.at(sp).slomaskbl);

    lp.scalereti = scaleret;
    lp.cir = circr;
    lp.actsp = acti;
    lp.xc = w * local_center_x;
    lp.yc = h * local_center_y;
    lp.xcbuf = w * local_center_xbuf;
    lp.ycbuf = h * local_center_ybuf;
    lp.lx = w * local_x;
    lp.ly = h * local_y;
    lp.lxL = w * local_xL;
    lp.lyT = h * local_yT;
    lp.chro = local_chroma;
    lp.struco = structcolor;
    lp.strengrid = strengthgrid;
    lp.blendmacol = blendmaskcolor;
    lp.radmacol = radmaskcolor;
    lp.chromacol = chromaskcolor;
    lp.gammacol = gammaskcolor;
    lp.slomacol = slomaskcolor;
    lp.radmaexp = radmaskexpo;
    lp.chromaexp = chromaskexpo;
    lp.gammaexp = gammaskexpo;
    lp.slomaexp = slomaskexpo;
    lp.softradiusexp = softradiusexpo;
    lp.softradiuscol = softradiuscolor;
    lp.softradiusret = softradiusreti;
    lp.softradiuscb = softradiuscbdl;
    lp.softradiustm = softradiustma;
    lp.struexc = structexclude;
    lp.blendmaexp = blendmaskexpo;
    lp.blendmaSH = blendmaskSH;
    lp.radmaSH = radmaskSH;
    lp.chromaSH = chromaskSH;
    lp.gammaSH = gammaskSH;
    lp.slomaSH = slomaskSH;
    lp.blendmacb = blendmaskcb;
    lp.radmacb = radmaskcb;
    lp.chromacbm = chromaskcb;
    lp.gammacb = gammaskcb;
    lp.slomacb = slomaskcb;
    lp.blendmatm = blendmasktm;
    lp.radmatm = radmasktm;
    lp.chromatm = chromasktm;
    lp.gammatm = gammasktm;
    lp.slomatm = slomasktm;

    lp.blendmabl = blendmaskbl;
    lp.radmabl = radmaskbl;
    lp.chromabl = chromaskbl;
    lp.gammabl = gammaskbl;
    lp.slomabl = slomaskbl;
    lp.it = itera;
    lp.guidb = guidbl;
    lp.epsb = epsbl;
    lp.struexp = structexpo;
    lp.blurexp = blurexpo;
    lp.blurcol = blurcolor;
    lp.blurSH = blurSH;
    lp.sens = local_sensi;
    lp.sensh = local_sensih;
    lp.dehaze = local_dehaze;
    lp.depth = local_depth;
    lp.senscb = local_sensicb;
    lp.clarityml = local_clarityml;
    lp.contresid = local_contresid;
    lp.blurcbdl = local_blurcbdl;
    lp.cont = local_contrast;
    lp.ligh = local_lightness;
    lp.lowA = labgridALowloc;
    lp.lowB = labgridBLowloc;
    lp.highB = labgridBHighloc;
    lp.highA = labgridAHighloc;

    lp.senssf = local_sensisf;
    lp.strng = strlight;
    lp.neig = neigh;
    lp.lap = laplac;

    if (lp.ligh >= -2.f && lp.ligh <= 2.f) {
        lp.ligh /= 5.f;
    }

    lp.trans = local_transit;
    lp.transweak = local_transitweak;
    lp.transgrad = local_transitgrad;
    lp.rad = radius;
    lp.stren = strength;
    lp.sensbn = local_sensibn;
    lp.sensexclu = local_sensiexclu;
    lp.senslc = local_sensilc;
    lp.lcamount = lcamount;
    lp.inv = inverse;
    lp.invex = inverseex;
    lp.invsh = inversesh;
    lp.curvact = curvacti;
    lp.invrad = inverserad;
    lp.invret = inverseret;
    lp.equret = equilret;
    lp.equtm = equiltm;
    lp.invshar = inversesha;
    lp.str = str;
    lp.shrad = sharradius;
    lp.shblurr = sharblurr;
    lp.senssha = local_sensisha;
    lp.shamo = local_sharamount;
    lp.shdamp = local_shardamping;
    lp.shiter = local_shariter;
    lp.iterat = iterati;
    lp.balance = balanc;
    lp.dxx = w * local_dxy;
    lp.dyy = h * local_dxy;
    lp.thr = thre;
    lp.stru = strucc;
    lp.noiself = local_noiself;
    lp.noiself0 = local_noiself0;
    lp.noiself2 = local_noiself2;
    lp.noiseldetail = local_noiseldetail;
    lp.detailthr = local_detailthr;
    lp.noiselequal = local_noiselequal;
    lp.noisechrodetail = local_noisechrodetail;
    lp.noiselc = local_noiselc;
    lp.noisecf = local_noisecf;
    lp.noisecc = local_noisecc;
    lp.sensden = local_sensiden;
    lp.bilat = locallab.spots.at(sp).bilateral;
    lp.adjch = (float) locallab.spots.at(sp).adjblur;
    lp.strengt = streng;
    lp.gamm = gam;
    lp.esto = est;
    lp.scalt = scal_tm;
    lp.rewe = rewe;
    lp.senstm = local_sensitm;
    lp.amo = amo;

    for (int y = 0; y < 6; y++) {
        lp.mulloc[y] = CLIP04(multi[y]);//to prevent crash with old pp3 integer
    }

    lp.threshol = thresho;
    lp.chromacb = chromcbdl;
    lp.colorena = locallab.spots.at(sp).expcolor && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0; // Color & Light tool is deactivated if Exposure mask is visible or SHMask
    lp.blurena = locallab.spots.at(sp).expblur && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && llColorMask == 0 && lltmMask == 0;
    lp.tonemapena = locallab.spots.at(sp).exptonemap && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && llColorMask == 0;
    lp.retiena = locallab.spots.at(sp).expreti && llExpMask == 0 && llSHMask == 0 && llcbMask == 0 && llColorMask == 0 && lltmMask == 0;
    lp.sharpena = locallab.spots.at(sp).expsharp;
    lp.lcena = locallab.spots.at(sp).expcontrast;
    lp.sfena = locallab.spots.at(sp).expsoft;
    lp.cbdlena = locallab.spots.at(sp).expcbdl && llExpMask == 0 && llSHMask == 0 && llretiMask == 0 && llColorMask == 0 && lltmMask == 0;
    lp.denoiena = locallab.spots.at(sp).expdenoi;
    lp.expvib = locallab.spots.at(sp).expvibrance;
    lp.sensv = local_sensiv;
    lp.past =  chromaPastel;
    lp.satur = chromaSatur;

    lp.exposena = locallab.spots.at(sp).expexpose && llColorMask == 0 && llSHMask == 0 && llcbMask == 0 && llretiMask == 0 && lltmMask == 0; // Exposure tool is deactivated if Color & Light mask SHmask is visible
    lp.cut_past = cupas;
    lp.blac = locallab.spots.at(sp).black;
    lp.shcomp = locallab.spots.at(sp).shcompr;
    lp.shadex = locallab.spots.at(sp).shadex;
    lp.hlcomp = locallab.spots.at(sp).hlcompr;
    lp.hlcompthr = locallab.spots.at(sp).hlcomprthresh;
    lp.expcomp = locallab.spots.at(sp).expcomp;
    lp.expcomp = CLIP24(lp.expcomp); //to prevent crash with Old pp3 with integer
    lp.expchroma = locallab.spots.at(sp).expchroma / 100.;
    lp.sensex = local_sensiex;
    lp.war = local_warm;
    lp.hsena = locallab.spots.at(sp).expshadhigh && llColorMask == 0 && llExpMask == 0 && llcbMask == 0 && llretiMask == 0 && llcbMask == 0 && lltmMask == 0;// Shadow Highlight tool is deactivated if Color & Light mask or SHmask is visible
    lp.highlihs = highhs;
    lp.shadowhs = shadhs;
    lp.radiushs = radhs;
    lp.hltonalhs = hltonahs;
    lp.shtonalhs = shtonals;
    lp.senshs = local_sensihs;
    lp.ftwlc = fftwlc;
    lp.ftwreti = fftwreti;
}

static void calcTransitionrect(const float lox, const float loy, const float ach, const local_params& lp, int &zone, float &localFactor)
{
    zone = 0;

    if (lox >= lp.xc && lox < (lp.xc + lp.lx) && loy >= lp.yc && loy < lp.yc + lp.ly) {
        if (lox < (lp.xc + lp.lx * ach)  && loy < (lp.yc + lp.ly * ach)) {
            zone = 2;
        } else {
            zone = 1;
            localFactor = calcLocalFactorrect(lox, loy, lp.xc, lp.lx, lp.yc, lp.ly, ach, lp.transgrad);
            localFactor = pow(localFactor, lp.transweak);
        }

    } else if (lox >= lp.xc && lox < lp.xc + lp.lx && loy < lp.yc && loy > lp.yc - lp.lyT) {
        if (lox < (lp.xc + lp.lx * ach) && loy > (lp.yc - lp.lyT * ach)) {
            zone = 2;
        } else {
            zone = 1;
            localFactor = calcLocalFactorrect(lox, loy, lp.xc, lp.lx, lp.yc, lp.lyT, ach, lp.transgrad);
            localFactor = pow(localFactor, lp.transweak);
        }


    } else if (lox < lp.xc && lox > lp.xc - lp.lxL && loy <= lp.yc && loy > lp.yc - lp.lyT) {
        if (lox > (lp.xc - lp.lxL * ach) && loy > (lp.yc - lp.lyT * ach)) {
            zone = 2;
        } else {
            zone = 1;
            localFactor = calcLocalFactorrect(lox, loy, lp.xc, lp.lxL, lp.yc, lp.lyT, ach, lp.transgrad);
            localFactor = pow(localFactor, lp.transweak);
        }

    } else if (lox < lp.xc && lox > lp.xc - lp.lxL && loy > lp.yc && loy < lp.yc + lp.ly) {
        if (lox > (lp.xc - lp.lxL * ach) && loy < (lp.yc + lp.ly * ach)) {
            zone = 2;
        } else {
            zone = 1;
            localFactor = calcLocalFactorrect(lox, loy, lp.xc, lp.lxL, lp.yc, lp.ly, ach, lp.transgrad);
            localFactor = pow(localFactor, lp.transweak);
        }

    }

}


static void calcTransition(const float lox, const float loy, const float ach, const local_params& lp, int &zone, float &localFactor)
{
    // returns the zone (0 = outside selection, 1 = transition zone between outside and inside selection, 2 = inside selection)
    // and a factor to calculate the transition in case zone == 1

    zone = 0;

    if (lox >= lp.xc && lox < (lp.xc + lp.lx) && loy >= lp.yc && loy < lp.yc + lp.ly) {
        float zoneVal = SQR((lox - lp.xc) / (ach * lp.lx)) + SQR((loy - lp.yc) / (ach * lp.ly));
        zone = zoneVal < 1.f ? 2 : 0;

        if (!zone) {
            zone = (zoneVal > 1.f && ((SQR((lox - lp.xc) / (lp.lx)) + SQR((loy - lp.yc) / (lp.ly))) < 1.f)) ? 1 : 0;

            if (zone == 1) {
                localFactor = pow(calcLocalFactor(lox, loy, lp.xc, lp.lx, lp.yc, lp.ly, ach, lp.transgrad), lp.transweak);
            }
        }
    } else if (lox >= lp.xc && lox < lp.xc + lp.lx && loy < lp.yc && loy > lp.yc - lp.lyT) {
        float zoneVal = SQR((lox - lp.xc) / (ach * lp.lx)) + SQR((loy - lp.yc) / (ach * lp.lyT));
        zone = zoneVal < 1.f ? 2 : 0;

        if (!zone) {
            zone = (zoneVal > 1.f && ((SQR((lox - lp.xc) / (lp.lx)) + SQR((loy - lp.yc) / (lp.lyT))) < 1.f)) ? 1 : 0;

            if (zone == 1) {
                localFactor = pow(calcLocalFactor(lox, loy, lp.xc, lp.lx, lp.yc, lp.lyT, ach, lp.transgrad), lp.transweak);
            }
        }
    } else if (lox < lp.xc && lox > lp.xc - lp.lxL && loy <= lp.yc && loy > lp.yc - lp.lyT) {
        float zoneVal = SQR((lox - lp.xc) / (ach * lp.lxL)) + SQR((loy - lp.yc) / (ach * lp.lyT));
        zone = zoneVal < 1.f ? 2 : 0;

        if (!zone) {
            zone = (zoneVal > 1.f && ((SQR((lox - lp.xc) / (lp.lxL)) + SQR((loy - lp.yc) / (lp.lyT))) < 1.f)) ? 1 : 0;

            if (zone == 1) {
                localFactor = pow(calcLocalFactor(lox, loy, lp.xc, lp.lxL, lp.yc, lp.lyT, ach, lp.transgrad), lp.transweak);
            }
        }
    } else if (lox < lp.xc && lox > lp.xc - lp.lxL && loy > lp.yc && loy < lp.yc + lp.ly) {
        float zoneVal = SQR((lox - lp.xc) / (ach * lp.lxL)) + SQR((loy - lp.yc) / (ach * lp.ly));
        zone = zoneVal < 1.f ? 2 : 0;

        if (!zone) {
            zone = (zoneVal > 1.f && ((SQR((lox - lp.xc) / (lp.lxL)) + SQR((loy - lp.yc) / (lp.ly))) < 1.f)) ? 1 : 0;

            if (zone == 1) {
                localFactor = pow(calcLocalFactor(lox, loy, lp.xc, lp.lxL, lp.yc, lp.ly, ach, lp.transgrad), lp.transweak);
            }
        }
    }
}



void ImProcFunctions::ciecamloc_02float(int sp, LabImage* lab)
{
    //be carefull quasi duplicate with branch cat02wb
    BENCHFUN

    int width = lab->W, height = lab->H;
    float Yw;
    Yw = 1.0f;
    double Xw, Zw;
    float f = 0.f, nc = 0.f, la, c = 0.f, xw, yw, zw, f2 = 1.f, c2 = 1.f, nc2 = 1.f, yb2;
    float fl, n, nbb, ncb, aw; //d
    float xwd, ywd, zwd, xws, yws, zws;
    //  int alg = 0;
    double Xwout, Zwout;
    double Xwsc, Zwsc;

    int tempo;

    if (params->locallab.spots.at(sp).warm > 0) {
        tempo = 5000 - 30 * params->locallab.spots.at(sp).warm;
    } else {
        tempo = 5000 - 49 * params->locallab.spots.at(sp).warm;
    }

    ColorTemp::temp2mulxyz(params->wb.temperature, params->wb.method, Xw, Zw);  //compute white Xw Yw Zw  : white current WB
    ColorTemp::temp2mulxyz(tempo, "Custom", Xwout, Zwout);
    ColorTemp::temp2mulxyz(5000, "Custom", Xwsc, Zwsc);

    //viewing condition for surrsrc
    f  = 1.00f;
    c  = 0.69f;
    nc = 1.00f;
    //viewing condition for surround
    f2 = 1.0f, c2 = 0.69f, nc2 = 1.0f;
    //with which algorithm
    //  alg = 0;


    xwd = 100.f * Xwout;
    zwd = 100.f * Zwout;
    ywd = 100.f;

    xws = 100.f * Xwsc;
    zws = 100.f * Zwsc;
    yws = 100.f;


    yb2 = 18;
    //La and la2 = ambiant luminosity scene and viewing
    la = 400.f;
    const float la2 = 400.f;
    const float pilot = 2.f;
    const float pilotout = 2.f;

    //algoritm's params
    // const float rstprotection = 100. ;//- params->colorappearance.rstprotection;
    LUTu hist16J;
    LUTu hist16Q;
    float yb = 18.f;
    float d, dj;

    // const int gamu = 0; //(params->colorappearance.gamut) ? 1 : 0;
    xw = 100.0f * Xw;
    yw = 100.0f * Yw;
    zw = 100.0f * Zw;
    float xw1 = xws, yw1 = yws, zw1 = zws, xw2 = xwd, yw2 = ywd, zw2 = zwd;

    float cz, wh, pfl;
    Ciecam02::initcam1float(yb, pilot, f, la, xw, yw, zw, n, d, nbb, ncb, cz, aw, wh, pfl, fl, c);
//   const float chr = 0.f;
    const float pow1 = pow_F(1.64f - pow_F(0.29f, n), 0.73f);
    float nj, nbbj, ncbj, czj, awj, flj;
    Ciecam02::initcam2float(yb2, pilotout, f2,  la2,  xw2,  yw2,  zw2, nj, dj, nbbj, ncbj, czj, awj, flj);
#ifdef __SSE2__
    const float reccmcz = 1.f / (c2 * czj);
#endif
    const float pow1n = pow_F(1.64f - pow_F(0.29f, nj), 0.73f);
//    const float QproFactor = (0.4f / c) * (aw + 4.0f) ;
    const bool LabPassOne = true;

#ifdef __SSE2__
    int bufferLength = ((width + 3) / 4) * 4; // bufferLength has to be a multiple of 4
#endif
#ifndef _DEBUG
    #pragma omp parallel
#endif
    {
#ifdef __SSE2__
        // one line buffer per channel and thread
        float Jbuffer[bufferLength] ALIGNED16;
        float Cbuffer[bufferLength] ALIGNED16;
        float hbuffer[bufferLength] ALIGNED16;
        float Qbuffer[bufferLength] ALIGNED16;
        float Mbuffer[bufferLength] ALIGNED16;
        float sbuffer[bufferLength] ALIGNED16;
#endif
#ifndef _DEBUG
        #pragma omp for schedule(dynamic, 16)
#endif

        for (int i = 0; i < height; i++) {
#ifdef __SSE2__
            // vectorized conversion from Lab to jchqms
            int k;
            vfloat x, y, z;
            vfloat J, C, h, Q, M, s;

            vfloat c655d35 = F2V(655.35f);

            for (k = 0; k < width - 3; k += 4) {
                Color::Lab2XYZ(LVFU(lab->L[i][k]), LVFU(lab->a[i][k]), LVFU(lab->b[i][k]), x, y, z);
                x = x / c655d35;
                y = y / c655d35;
                z = z / c655d35;
                Ciecam02::xyz2jchqms_ciecam02float(J, C,  h,
                                                   Q,  M,  s, F2V(aw), F2V(fl), F2V(wh),
                                                   x,  y,  z,
                                                   F2V(xw1), F2V(yw1),  F2V(zw1),
                                                   F2V(c),  F2V(nc), F2V(pow1), F2V(nbb), F2V(ncb), F2V(pfl), F2V(cz), F2V(d));
                STVF(Jbuffer[k], J);
                STVF(Cbuffer[k], C);
                STVF(hbuffer[k], h);
                STVF(Qbuffer[k], Q);
                STVF(Mbuffer[k], M);
                STVF(sbuffer[k], s);
            }

            for (; k < width; k++) {
                float L = lab->L[i][k];
                float a = lab->a[i][k];
                float b = lab->b[i][k];
                float x, y, z;
                //convert Lab => XYZ
                Color::Lab2XYZ(L, a, b, x, y, z);
                x = x / 655.35f;
                y = y / 655.35f;
                z = z / 655.35f;
                float J, C, h, Q, M, s;
                Ciecam02::xyz2jchqms_ciecam02float(J, C,  h,
                                                   Q,  M,  s, aw, fl, wh,
                                                   x,  y,  z,
                                                   xw1, yw1,  zw1,
                                                   c,  nc, pow1, nbb, ncb, pfl, cz, d);
                Jbuffer[k] = J;
                Cbuffer[k] = C;
                hbuffer[k] = h;
                Qbuffer[k] = Q;
                Mbuffer[k] = M;
                sbuffer[k] = s;
            }

#endif // __SSE2__

            for (int j = 0; j < width; j++) {
                float J, C, h, Q, M, s;

#ifdef __SSE2__
                // use precomputed values from above
                J = Jbuffer[j];
                C = Cbuffer[j];
                h = hbuffer[j];
                Q = Qbuffer[j];
                M = Mbuffer[j];
                s = sbuffer[j];
#else
                float x, y, z;
                float L = lab->L[i][j];
                float a = lab->a[i][j];
                float b = lab->b[i][j];
                float x1, y1, z1;
                //convert Lab => XYZ
                Color::Lab2XYZ(L, a, b, x1, y1, z1);
                x = (float)x1 / 655.35f;
                y = (float)y1 / 655.35f;
                z = (float)z1 / 655.35f;
                //process source==> normal
                Ciecam02::xyz2jchqms_ciecam02float(J, C,  h,
                                                   Q,  M,  s, aw, fl, wh,
                                                   x,  y,  z,
                                                   xw1, yw1,  zw1,
                                                   c,  nc, pow1, nbb, ncb, pfl, cz, d);
#endif
                float Jpro, Cpro, hpro, Qpro, Mpro, spro;
                Jpro = J;
                Cpro = C;
                hpro = h;
                Qpro = Q;
                Mpro = M;
                spro = s;
                /*
                */


                //retrieve values C,J...s
                C = Cpro;
                J = Jpro;
                Q = Qpro;
                M = Mpro;
                h = hpro;
                s = spro;

                if (LabPassOne) {
#ifdef __SSE2__
                    // write to line buffers
                    Jbuffer[j] = J;
                    Cbuffer[j] = C;
                    hbuffer[j] = h;
#else
                    float xx, yy, zz;
                    //process normal==> viewing

                    Ciecam02::jch2xyz_ciecam02float(xx, yy, zz,
                                                    J,  C, h,
                                                    xw2, yw2,  zw2,
                                                    c2, nc2,  pow1n, nbbj, ncbj, flj, czj, dj, awj);
                    float x, y, z;
                    x = xx * 655.35f;
                    y = yy * 655.35f;
                    z = zz * 655.35f;
                    float Ll, aa, bb;
                    //convert xyz=>lab
                    Color::XYZ2Lab(x,  y,  z, Ll, aa, bb);
                    lab->L[i][j] = Ll;
                    lab->a[i][j] = aa;
                    lab->b[i][j] = bb;

#endif
                }

                //    }
            }

#ifdef __SSE2__
            // process line buffers
            float *xbuffer = Qbuffer;
            float *ybuffer = Mbuffer;
            float *zbuffer = sbuffer;

            for (k = 0; k < bufferLength; k += 4) {
                Ciecam02::jch2xyz_ciecam02float(x, y, z,
                                                LVF(Jbuffer[k]), LVF(Cbuffer[k]), LVF(hbuffer[k]),
                                                F2V(xw2), F2V(yw2), F2V(zw2),
                                                F2V(nc2), F2V(pow1n), F2V(nbbj), F2V(ncbj), F2V(flj), F2V(dj), F2V(awj), F2V(reccmcz));
                STVF(xbuffer[k], x * c655d35);
                STVF(ybuffer[k], y * c655d35);
                STVF(zbuffer[k], z * c655d35);
            }

            // XYZ2Lab uses a lookup table. The function behind that lut is a cube root.
            // SSE can't beat the speed of that lut, so it doesn't make sense to use SSE
            for (int j = 0; j < width; j++) {
                float Ll, aa, bb;
                //convert xyz=>lab
                Color::XYZ2Lab(xbuffer[j], ybuffer[j], zbuffer[j], Ll, aa, bb);

                lab->L[i][j] = Ll;
                lab->a[i][j] = aa;
                lab->b[i][j] = bb;
            }

#endif
        }

    }
}

void ImProcFunctions::softproc(const LabImage* bufcolorig, const LabImage* bufcolfin, float rad, int bfh, int bfw, double epsilmax, double epsilmin,  float thres, int sk, bool multiThread, int flag)
{
    if (flag == 0) {
        if (rad > 0.f) {
            array2D<float> ble(bfw, bfh);
            array2D<float> guid(bfw, bfh);
            Imagefloat *tmpImage = nullptr;
            tmpImage = new Imagefloat(bfw, bfh);

#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int ir = 0; ir < bfh; ir++)
                for (int jr = 0; jr < bfw; jr++) {
                    float X, Y, Z;
                    float L = bufcolorig->L[ir][jr];
                    float a = bufcolorig->a[ir][jr];
                    float b = bufcolorig->b[ir][jr];
                    Color::Lab2XYZ(L, a, b, X, Y, Z);

                    guid[ir][jr] = Y / 32768.f;
                    float La = bufcolfin->L[ir][jr];
                    float aa = bufcolfin->a[ir][jr];
                    float ba = bufcolfin->b[ir][jr];
                    Color::Lab2XYZ(La, aa, ba, X, Y, Z);
                    tmpImage->r(ir, jr) = X;
                    tmpImage->g(ir, jr) = Y;
                    tmpImage->b(ir, jr) = Z;
                    ble[ir][jr] = Y / 32768.f;
                }

            double aepsil = (epsilmax - epsilmin) / 90.f;
            double bepsil = epsilmax - 100.f * aepsil;
            double epsil = aepsil * rad + bepsil;

            float blur = 10.f / sk * (thres + 0.8f * rad);
            rtengine::guidedFilter(guid, ble, ble, blur, epsil,  multiThread, 4);



#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int ir = 0; ir < bfh; ir++)
                for (int jr = 0; jr < bfw; jr++) {
                    float X = tmpImage->r(ir, jr);
                    float Y = 32768.f * ble[ir][jr];
                    float Z = tmpImage->b(ir, jr);
                    float L, a, b;
                    Color::XYZ2Lab(X, Y, Z, L, a, b);
                    bufcolfin->L[ir][jr] =  L;
                }

            delete tmpImage;
        }
    } else if (flag == 1) {
        if (rad > 0.f) {
            array2D<float> ble(bfw, bfh);
            array2D<float> guid(bfw, bfh);
#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int ir = 0; ir < bfh; ir++)
                for (int jr = 0; jr < bfw; jr++) {
                    ble[ir][jr] = (bufcolfin->L[ir][jr]) / 32768.f;
                    guid[ir][jr] = bufcolorig->L[ir][jr] / 32768.f;
                }

            double aepsil = (epsilmax - epsilmin) / 90.f;
            double bepsil = epsilmax - 100.f * aepsil;
            double epsil = aepsil * rad + bepsil;

            float blur = 10.f / sk * (thres + 0.8f * rad);
            rtengine::guidedFilter(guid, ble, ble, blur, epsil,  multiThread, 4);



#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int ir = 0; ir < bfh; ir++)
                for (int jr = 0; jr < bfw; jr++) {
                    bufcolfin->L[ir][jr] =  32768.f * ble[ir][jr];
                }
        }

    }
}


void ImProcFunctions::softprocess(const LabImage* bufcolorig, array2D<float> &buflight, float rad, int bfh, int bfw, double epsilmax, double epsilmin,  float thres, int sk, bool multiThread)
{
    float minlig = buflight[0][0];

#ifdef _OPENMP
    #pragma omp parallel for reduction(min:minlig) schedule(dynamic,16)
#endif

    for (int ir = 0; ir < bfh; ir++) {
        for (int jr = 0; jr < bfw; jr++) {
            minlig = rtengine::min(buflight[ir][jr], minlig);
        }
    }

    array2D<float> guidsoft(bfw, bfh);

#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic,16)
#endif

    for (int ir = 0; ir < bfh; ir++) {
        for (int jr = 0; jr < bfw; jr++) {
            buflight[ir][jr] = LIM01((buflight[ir][jr] - minlig) / (100.f - minlig));
            guidsoft[ir][jr] = bufcolorig->L[ir][jr] / 32768.f;
        }
    }

    double aepsil = (epsilmax - epsilmin) / 90.f;
    double bepsil = epsilmax - 100.f * aepsil;
    double epsil = aepsil * rad + bepsil;
    float blur = 1.f / sk * (thres + 0.8f * rad);
    guidedFilter(guidsoft, buflight, buflight, blur, epsil,  multiThread, 4);


#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic,16)
#endif

    for (int ir = 0; ir < bfh; ir++) {
        for (int jr = 0; jr < bfw; jr++) {
            buflight[ir][jr] = (100.f - minlig) * buflight[ir][jr] + minlig;
        }
    }
}

void ImProcFunctions::exlabLocal(local_params& lp, int bfh, int bfw, LabImage* bufexporig, LabImage* lab,  LUTf & hltonecurve, LUTf & shtonecurve, LUTf & tonecurve, float mean)
{
    BENCHFUN
    //exposure local

    constexpr float maxran = 65536.f;
    float exp_scale = pow(2.0, lp.expcomp);
    float comp = (max(0.0, lp.expcomp) + 1.0) * lp.hlcomp / 100.0;
    float shoulder = ((maxran / max(1.0f, exp_scale)) * (lp.hlcompthr / 200.0)) + 0.1;
    float hlrange = maxran - shoulder;
    float linear = lp.linear;
    float kl = 1.5f;
    float addcomp = 0.f;

    if (lp.linear > 0.f) {
        if (lp.expcomp == 0.f) {
            lp.expcomp = 0.01f;
        }
    }

#ifdef _OPENMP
    #pragma omp parallel for
#endif

    for (int ir = 0; ir < bfh; ir++) {
        for (int jr = 0; jr < bfw; jr++) {
            float L = bufexporig->L[ir][jr];

            if (L < mean && lp.expmet == 1 && lp.linear > 0.f && lp.laplacexp > 0.1f && !lp.invex) {
                float Llin = LIM01(L / 32768.f);
                addcomp = linear * (-kl * Llin + kl);//maximum about 1.5 IL
                exp_scale = pow(2.0, (lp.expcomp + addcomp));
                shoulder = ((maxran / max(1.0f, exp_scale)) * (lp.hlcompthr / 200.0)) + 0.1;
                comp = (max(0.0, (lp.expcomp + addcomp)) + 1.0) * lp.hlcomp / 100.0;
                hlrange = maxran - shoulder;
            }

            //  CurveFactory::Curvelocalhl(comp, lp.hlcomp, lp.hlcompthr, hltonecurve);//to change with comp(ir,jr) if need

            //highlight
            const float hlfactor = (2 * L < MAXVALF ? hltonecurve[2 * L] : CurveFactory::hlcurve(exp_scale, comp, hlrange, 2 * L));
            L *= hlfactor * pow(2.0, addcomp);//approximation but pretty good with Laplacian and L < mean, hl aren't call
            //shadow tone curve
            const float shfactor = shtonecurve[2 * L];
            //tonecurve
            L *= shfactor;
            lab->L[ir][jr] = 0.5f * tonecurve[2 * L];
        }

    }
}


void ImProcFunctions::addGaNoise(LabImage *lab, LabImage *dst, const float mean, const float variance, const int sk)
{
//   BENCHFUN
//Box-Muller method.
// add luma noise to image

    srand(1);

    const float variaFactor = SQR(variance) / sk;
    constexpr float randFactor1 = 1.f / RAND_MAX;
    constexpr float randFactor2 = (2.f * rtengine::RT_PI_F) / RAND_MAX;
#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
        float z0, z1;
        bool generate = false;
#ifdef _OPENMP
        #pragma omp for schedule(static) // static scheduling is important to avoid artefacts
#endif

        for (int y = 0; y < lab->H; y++) {
            for (int x = 0; x < lab->W; x++) {
                generate = !generate;
                float kvar = 1.f;

                if (lab->L[y][x] < 12000.f) {
                    constexpr float ah = -0.5f / 12000.f;
                    constexpr float bh = 1.5f;
                    kvar = ah * lab->L[y][x] + bh;    //increase effect for low lights < 12000.f
                } else if (lab->L[y][x] > 20000.f) {
                    constexpr float ah = -0.5f / 12768.f;
                    constexpr float bh = 1.f - 20000.f * ah;
                    kvar = ah * lab->L[y][x] + bh;    //decrease effect for high lights > 20000.f
                    kvar = kvar < 0.5f ? 0.5f : kvar;
                }

                float varia = SQR(kvar) * variaFactor;

                if (!generate) {
                    dst->L[y][x] = LIM(lab->L[y][x] + mean + varia * z1, 0.f, 32768.f);
                    continue;
                }

                int u1 = 0;
                int u2;

                while (u1 == 0) {
                    u1 = rand();
                    u2 = rand();
                }

                float u1f = u1 * randFactor1;
                float u2f = u2 * randFactor2;

                float2 sincosval = xsincosf(2.f * rtengine::RT_PI_F * u2f);
                float factor = sqrtf(-2.f * xlogf(u1f));
                z0 = factor * sincosval.y;
                z1 = factor * sincosval.x;

                dst->L[y][x] = LIM(lab->L[y][x] + mean + varia * z0, 0.f, 32768.f);

            }
        }
    }
}

static void balancedeltaE(float kL, float &kab)
{
    float mincurs = 0.3f;//minimum slider balan_
    float maxcurs = 1.7f;//maximum slider balan_
    float maxkab = 1.35;//0.5 * (3 - 0.3)
    float minkab = 0.65;//0.5 * (3 - 1.7)
    float abal = (maxkab - minkab) / (mincurs - maxcurs);
    float bbal = maxkab - mincurs * abal;
    kab = abal * kL + bbal;
}

static void calcreducdE(float dE, float maxdE, float mindE, float maxdElim,  float mindElim, float iterat, float limscope, int scope, float &reducdE)
{
    if (dE > maxdE) {
        reducdE = 0.f;
    } else if (dE > mindE && dE <= maxdE) {
        const float ar = 1.f / (mindE - maxdE);
        const float br = - ar * maxdE;
        reducdE = pow(ar * dE + br, iterat);
    } else {
        reducdE = 1.f;
    }

    if (scope > limscope) {//80 arbitrary value, if we change we must change limscope
        if (dE > maxdElim) {
            reducdE = 0.f;
        } else if (dE > mindElim && dE <= maxdElim) {
            const float arlim = 1.f / (mindElim - maxdElim);
            const float brlim = - arlim * maxdElim;
            const float reducdElim = pow(arlim * dE + brlim, iterat);
            const float aalim = (1.f - reducdElim) / 20.f;
            const float bblim = 1.f - 100.f * aalim;
            reducdE = aalim * scope  +  bblim;
        } else {
            reducdE = 1.f;
        }
    }
}
void ImProcFunctions::DeNoise_Local(int call,  const struct local_params& lp, LabImage*originalmask, int levred, float hueref, float lumaref, float chromaref,  LabImage* original, LabImage* transformed, LabImage &tmp1, int cx, int cy, int sk)
{
    //warning, but I hope used it next
    // local denoise and impulse
    //simple algo , perhaps we can improve as the others, but noise is here and not good for hue detection
    // BENCHFUN
    const float ach = (float)lp.trans / 100.f;

    const float factnoise1 = 1.f + (lp.noisecf) / 500.f;
    const float factnoise2 = 1.f + (lp.noisecc) / 500.f;
    const float factnoise = factnoise1 * factnoise2;

    const int GW = transformed->W;
    const int GH = transformed->H;
    const float refa = chromaref * cos(hueref);
    const float refb = chromaref * sin(hueref);
    const bool usemaskbl = (lp.showmaskblmet == 2 || lp.enablMask || lp.showmaskblmet == 4);
    const bool usemaskall = (usemaskbl);
    const bool blshow = ((lp.showmaskblmet == 1 || lp.showmaskblmet == 2));
    const bool previewbl = ((lp.showmaskblmet == 4));

    std::unique_ptr<LabImage> origblur(new LabImage(GW, GH));
    std::unique_ptr<LabImage> origblurmask;

    const float radius = 3.f / sk;

    if (usemaskall) {
        origblurmask.reset(new LabImage(GW, GH));

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
            gaussianBlur(originalmask->L, origblurmask->L, GW, GH, radius);
            gaussianBlur(originalmask->a, origblurmask->a, GW, GH, radius);
            gaussianBlur(originalmask->b, origblurmask->b, GW, GH, radius);
        }
    }

#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
        gaussianBlur(original->L, origblur->L, GW, GH, radius);
        gaussianBlur(original->a, origblur->a, GW, GH, radius);
        gaussianBlur(original->b, origblur->b, GW, GH, radius);
    }

    const int begx = int (lp.xc - lp.lxL);
    const int begy = int (lp.yc - lp.lyT);

#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        const LabImage *maskptr = usemaskall ? origblurmask.get() : origblur.get();
        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * lp.sensden * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * lp.sensden * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            const int loy = cy + y;

            const bool isZone0 = loy > lp.yc + lp.ly || loy < lp.yc - lp.lyT; // whole line is zone 0 => we can skip a lot of processing

            if (isZone0) { // outside selection and outside transition zone => no effect, keep original values
                continue;
            }

            for (int x = 0, lox = cx + x; x < transformed->W; x++, lox++) {
                int zone = 0;

                float localFactor = 1.f;

                if (lp.shapmet == 0) {
                    calcTransition(lox, loy, ach, lp, zone, localFactor);
                } else if (lp.shapmet == 1) {
                    calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                }

                if (zone == 0) { // outside selection and outside transition zone => no effect, keep original values
                    continue;
                }

//                float rL = original->L[y][x] / 327.6f;
                float dEL = sqrt(0.9f * SQR(refa - maskptr->a[y][x] / 327.6f) + 0.9f * SQR(refb - maskptr->b[y][x] / 327.8f) + 1.2f * SQR(lumaref - maskptr->L[y][x] / 327.8f));
                float dEa = sqrt(1.2f * SQR(refa - maskptr->a[y][x] / 327.6f) + 1.f * SQR(refb - maskptr->b[y][x] / 327.8f) + 0.8f * SQR(lumaref - maskptr->L[y][x] / 327.8f));
                float dEb = sqrt(1.f * SQR(refa - maskptr->a[y][x] / 327.6f) + 1.2f * SQR(refb - maskptr->b[y][x] / 327.8f) + 0.8f * SQR(lumaref - maskptr->L[y][x] / 327.8f));

                float reducdEL = 1.f;
                float reducdEa = 1.f;
                float reducdEb = 1.f;

                if (levred == 7) {
                    calcreducdE(dEL, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, lp.sensden, reducdEL);
                    calcreducdE(dEa, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, lp.sensden, reducdEa);
                    calcreducdE(dEb, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, lp.sensden, reducdEb);
                    reducdEL = SQR(reducdEL);
                    reducdEa = SQR(reducdEa);
                    reducdEb = SQR(reducdEb);

                }

                switch (zone) {
                    case 1: { // inside transition zone
                        float difL, difa, difb;

                        if (call == 2  /*|| call == 1  || call == 3 */) { //simpleprocess
                            difL = tmp1.L[loy - begy][lox - begx] - original->L[y][x];
                            difa = tmp1.a[loy - begy][lox - begx] - original->a[y][x];
                            difb = tmp1.b[loy - begy][lox - begx] - original->b[y][x];
                        } else  { //dcrop
                            difL = tmp1.L[y][x] - original->L[y][x];
                            difa = tmp1.a[y][x] - original->a[y][x];
                            difb = tmp1.b[y][x] - original->b[y][x];

                        }

                        difL *= localFactor * reducdEL;
                        difa *= localFactor * reducdEa;
                        difb *= localFactor * reducdEb;
                        transformed->L[y][x] = CLIP(original->L[y][x] + difL);
                        transformed->a[y][x] = CLIPC((original->a[y][x] + difa) * factnoise);
                        transformed->b[y][x] = CLIPC((original->b[y][x] + difb) * factnoise) ;

                        if (blshow) {
                            transformed->L[y][x] = CLIP(12000.f + 10.f * difL);// * 10.f empirical to can visualize modifications
                            transformed->a[y][x] = CLIPC(10.f * difa);// * 10.f empirical to can visualize modifications
                            transformed->b[y][x] = CLIPC(10.f * difb);// * 10.f empirical to can visualize modifications
                        } else if (previewbl) {
                            transformed->a[y][x] = 0.f;
                            transformed->b[y][x] = (10.f * difb);// * 10.f empirical to can visualize modifications
                        }

                        break;
                    }

                    case 2: { // inside selection => full effect, no transition
                        float difL, difa, difb;

                        if (call == 2 /*|| call == 1 || call == 3 */) { //simpleprocess
                            difL = tmp1.L[loy - begy][lox - begx] - original->L[y][x];
                            difa = tmp1.a[loy - begy][lox - begx] - original->a[y][x];
                            difb = tmp1.b[loy - begy][lox - begx] - original->b[y][x];
                        } else  { //dcrop
                            difL = tmp1.L[y][x] - original->L[y][x];
                            difa = tmp1.a[y][x] - original->a[y][x];
                            difb = tmp1.b[y][x] - original->b[y][x];

                        }

                        difL *= reducdEL;
                        difa *= reducdEa;
                        difb *= reducdEb;

                        transformed->L[y][x] = CLIP(original->L[y][x] + difL);
                        transformed->a[y][x] = CLIPC((original->a[y][x] + difa) * factnoise);
                        transformed->b[y][x] = CLIPC((original->b[y][x] + difb) * factnoise);

                        if (blshow) {
                            transformed->L[y][x] = CLIP(12000.f + 10.f * difL);// * 10.f empirical to can visualize modifications
                            transformed->a[y][x] = CLIPC(10.f * difa);// * 10.f empirical to can visualize modifications
                            transformed->b[y][x] = CLIPC(10.f * difb);// * 10.f empirical to can visualize modifications
                        } else if (previewbl) {
                            transformed->a[y][x] = 0.f;
                            transformed->b[y][x] = (10.f * difb);// * 10.f empirical to can visualize modifications
                        }
                    }
                }

            }
        }
    }
}

void ImProcFunctions::BlurNoise_Local(LabImage *tmp1, LabImage * originalmask, float **bufchro, const float hueref, const float chromaref, const float lumaref, const local_params & lp, LabImage * original, LabImage * transformed, int cx, int cy, int sk)
{
//local BLUR
    BENCHFUN

    const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
    const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
    const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
    const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);

    const float ach = lp.trans / 100.f;
    const int GW = transformed->W;
    const int GH = transformed->H;
    const float refa = chromaref * cos(hueref) * 327.68f;
    const float refb = chromaref * sin(hueref) * 327.68f;
    const float refL = lumaref * 327.68f;
    const bool blshow = ((lp.showmaskblmet == 1 || lp.showmaskblmet == 2));
    const bool previewbl = ((lp.showmaskblmet == 4));

    //balance deltaE
    float kL = lp.balance;
    float kab = 1.f;
    balancedeltaE(kL, kab);
    kab /= SQR(327.68f);
    kL /= SQR(327.68f);
    const bool usemaskbl = (lp.showmaskblmet == 2 || lp.enablMask || lp.showmaskblmet == 4);
    const bool usemaskall = (usemaskbl);
    const float radius = 3.f / sk;
    std::unique_ptr<LabImage> origblurmask;

    std::unique_ptr<LabImage> origblur(new LabImage(GW, GH));

    if (usemaskall) {
        origblurmask.reset(new LabImage(GW, GH));

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
            gaussianBlur(originalmask->L, origblurmask->L, GW, GH, radius);
            gaussianBlur(originalmask->a, origblurmask->a, GW, GH, radius);
            gaussianBlur(originalmask->b, origblurmask->b, GW, GH, radius);
        }
    }

#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
        gaussianBlur(original->L, origblur->L, GW, GH, radius);
        gaussianBlur(original->a, origblur->a, GW, GH, radius);
        gaussianBlur(original->b, origblur->b, GW, GH, radius);
    }

#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        const LabImage *maskptr = usemaskall ? origblurmask.get() : origblur.get();
        const int limscope = 80;
        const float mindE = 4.f + MINSCOPE * lp.sensbn * lp.thr;//best usage ?? with blurnoise
        const float maxdE = 5.f + MAXSCOPE * lp.sensbn * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp for schedule(dynamic,16)
#endif

        for (int y = ystart; y < yend; y++) {
            const int loy = cy + y;

            for (int x = xstart, lox = cx + x; x < xend; x++, lox++) {
                int zone = 0;
                float localFactor = 1.f;

                if (lp.shapmet == 0) {
                    calcTransition(lox, loy, ach, lp, zone, localFactor);
                } else if (lp.shapmet == 1) {
                    calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                }

                if (zone == 0) { // outside selection and outside transition zone => no effect, keep original values
                    continue;
                }

                //  const float dE = sqrt(kab * (SQR(refa - origblur->a[y][x]) + SQR(refb - origblur->b[y][x])) + kL * SQR(refL - origblur->L[y][x]));
                const float dE = sqrt(kab * (SQR(refa - maskptr->a[y][x]) + SQR(refb - maskptr->b[y][x])) + kL * SQR(refL - maskptr->L[y][x]));

                float reducdE;
                calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, lp.sensbn, reducdE);
                const float clc = (previewbl) ? settings->previewselection * 100.f : bufchro[y - ystart][x - xstart];
                const float realstrchdE = reducdE * clc;
                float flia = 1.f;
                float flib = 1.f;
                const float chra = tmp1->a[y - ystart][x - xstart];
                const float chrb = tmp1->b[y - ystart][x - xstart];

                const float difL = (tmp1->L[y - ystart][x - xstart] - original->L[y][x]) * localFactor * reducdE;
                transformed->L[y][x] = CLIP(original->L[y][x] + difL);
                flia = flib = ((100.f + realstrchdE) / 100.f);
                float difa = chra * flia - original->a[y][x];
                float difb = chrb * flib - original->b[y][x];
                difa *= localFactor;
                difb *= localFactor;

                if (!lp.actsp) {
                    transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                    transformed->b[y][x] = CLIPC(original->b[y][x] + difb);
                }

                if (blshow) {
                    transformed->L[y][x] = CLIP(12000.f + difL);
                    transformed->a[y][x] = CLIPC(difa);
                    transformed->b[y][x] = CLIPC(difb);
                } else if (previewbl) {
                    transformed->a[y][x] = 0.f;
                    transformed->b[y][x] = (difb);
                }

            }
        }
    }
}

void ImProcFunctions::InverseReti_Local(const struct local_params & lp, const float hueref, const float chromaref,  const float lumaref, LabImage * original, LabImage * transformed, const LabImage * const tmp1, int cx, int cy, int chro, int sk)
{
    // BENCHFUN
//inverse local retinex
    float ach = (float)lp.trans / 100.f;
    int GW = transformed->W;
    int GH = transformed->H;
    float refa = chromaref * cos(hueref);
    float refb = chromaref * sin(hueref);

    //balance deltaE
    float kL = lp.balance;
    float kab = 1.f;
    balancedeltaE(kL, kab);

    LabImage *origblur = new LabImage(GW, GH);

    float radius = 3.f / sk;
#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
        gaussianBlur(original->L, origblur->L, GW, GH, radius);
        gaussianBlur(original->a, origblur->a, GW, GH, radius);
        gaussianBlur(original->b, origblur->b, GW, GH, radius);

    }
#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * lp.sensh * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * lp.sensh * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            int loy = cy + y;

            for (int x = 0; x < transformed->W; x++) {
                int lox = cx + x;

                int zone;
                float localFactor;

                if (lp.shapmet == 0) {
                    calcTransition(lox, loy, ach, lp, zone, localFactor);
                } else if (lp.shapmet == 1) {
                    calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                }

                float rL = origblur->L[y][x] / 327.68f;
                float reducdE = 0.f;
                float dE = sqrt(kab * SQR(refa - origblur->a[y][x] / 327.68f) + kab * SQR(refb - origblur->b[y][x] / 327.68f) + kL * SQR(lumaref - rL));
                calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, lp.sensh, reducdE);

                switch (zone) {
                    case 0: { // outside selection and outside transition zone => full effect, no transition
                        if (chro == 0) {
                            float difL = tmp1->L[y][x] - original->L[y][x];
                            transformed->L[y][x] = CLIP(original->L[y][x] + difL * reducdE);

                        }

                        if (chro == 1) {

                            float difa = tmp1->a[y][x] - original->a[y][x];
                            float difb = tmp1->b[y][x] - original->b[y][x];


                            transformed->a[y][x] = CLIPC(original->a[y][x] + difa * reducdE);
                            transformed->b[y][x] = CLIPC(original->b[y][x] + difb * reducdE);
                        }

                        break;
                    }

                    case 1: { // inside transition zone
                        float factorx = 1.f - localFactor;

                        if (chro == 0) {
                            float difL = tmp1->L[y][x] - original->L[y][x];
                            difL *= factorx;
                            transformed->L[y][x] = CLIP(original->L[y][x] + difL * reducdE);
                        }

                        if (chro == 1) {
                            float difa = tmp1->a[y][x] - original->a[y][x];
                            float difb = tmp1->b[y][x] - original->b[y][x];

                            difa *= factorx;
                            difb *= factorx;

                            transformed->a[y][x] = CLIPC(original->a[y][x] + difa * reducdE);
                            transformed->b[y][x] = CLIPC(original->b[y][x] + difb * reducdE);
                        }

                        break;
                    }

                    case 2: { // inside selection => no effect, keep original values
                        if (chro == 0) {
                            transformed->L[y][x] = original->L[y][x];
                        }

                        if (chro == 1) {
                            transformed->a[y][x] = original->a[y][x];
                            transformed->b[y][x] = original->b[y][x];
                        }
                    }
                }
            }
        }

    }
    delete origblur;
}




void ImProcFunctions::InverseBlurNoise_Local(LabImage * originalmask, float **bufchro, const struct local_params & lp,  const float hueref, const float chromaref, const float lumaref, LabImage * original, LabImage * transformed, const LabImage * const tmp1, int cx, int cy, int sk)
{
    // BENCHFUN
//inverse local blur and noise
    float ach = (float)lp.trans / 100.f;
    int GW = transformed->W;
    int GH = transformed->H;
    float refa = chromaref * cos(hueref);
    float refb = chromaref * sin(hueref);
    const bool blshow = (lp.showmaskblmet == 1 || lp.showmaskblmet == 2);
    const bool previewbl = (lp.showmaskblmet == 4);

    //balance deltaE
    float kL = lp.balance;
    float kab = 1.f;
    balancedeltaE(kL, kab);

    std::unique_ptr<LabImage> origblur(new LabImage(GW, GH));
    std::unique_ptr<LabImage> origblurmask;
    const bool usemaskbl = (lp.showmaskblmet == 2 || lp.enablMask || lp.showmaskblmet == 4);
    const bool usemaskall = usemaskbl;

    float radius = 3.f / sk;

    if (usemaskall) {
        origblurmask.reset(new LabImage(GW, GH));

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
            gaussianBlur(originalmask->L, origblurmask->L, GW, GH, radius);
            gaussianBlur(originalmask->a, origblurmask->a, GW, GH, radius);
            gaussianBlur(originalmask->b, origblurmask->b, GW, GH, radius);
        }
    }


#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
        gaussianBlur(original->L, origblur->L, GW, GH, radius);
        gaussianBlur(original->a, origblur->a, GW, GH, radius);
        gaussianBlur(original->b, origblur->b, GW, GH, radius);

    }
#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        const LabImage *maskptr = usemaskall ? origblurmask.get() : origblur.get();
        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * lp.sensbn * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * lp.sensbn * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            int loy = cy + y;

            for (int x = 0; x < transformed->W; x++) {
                int lox = cx + x;

                int zone;
                float localFactor;

                if (lp.shapmet == 0) {
                    calcTransition(lox, loy, ach, lp, zone, localFactor);
                } else if (lp.shapmet == 1) {
                    calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                }

                const float clc = (previewbl) ? settings->previewselection * 100.f : bufchro[y][x];

                float dE = sqrt(kab * SQR(refa - maskptr->a[y][x] / 327.68f) +  kab * SQR(refb - maskptr->b[y][x] / 327.68f) + kL * SQR(lumaref - maskptr->L[y][x] / 327.68f));
                float reducdE;
                calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, lp.sensbn, reducdE);
                const float realstrchdE = reducdE * clc;

                switch (zone) {

                    case 0: { // outside selection and outside transition zone => full effect, no transition
                        float difL = tmp1->L[y][x] - original->L[y][x];
                        transformed->L[y][x] = CLIP(original->L[y][x] + difL * reducdE);
                        float difa = tmp1->a[y][x] - original->a[y][x];
                        float difb = tmp1->b[y][x] - original->b[y][x];
                        float flia = 1.f, flib = 1.f;
                        flia = flib = ((100.f + realstrchdE) / 100.f);
                        const float chra = tmp1->a[y][x];
                        const float chrb = tmp1->b[y][x];

                        if (!lp.actsp) {
                            difa = chra * flia - original->a[y][x];
                            difb = chrb * flib - original->b[y][x];
                            transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                            transformed->b[y][x] = CLIPC(original->b[y][x] + difb);
                        }

                        if (blshow) {
                            transformed->L[y][x] = CLIP(12000.f + difL);
                            transformed->a[y][x] = CLIPC(difa);
                            transformed->b[y][x] = CLIPC(difb);
                        } else if (previewbl) {
                            transformed->a[y][x] = 0.f;
                            transformed->b[y][x] = (difb);
                        }

                        break;
                    }

                    case 1: { // inside transition zone
                        float difL = tmp1->L[y][x] - original->L[y][x];
                        float difa = tmp1->a[y][x] - original->a[y][x];
                        float difb = tmp1->b[y][x] - original->b[y][x];
                        float flia = 1.f, flib = 1.f;
                        flia = flib = ((100.f + realstrchdE) / 100.f);
                        const float chra = tmp1->a[y][x];
                        const float chrb = tmp1->b[y][x];

                        float factorx = 1.f - localFactor;
                        difL *= factorx;

                        transformed->L[y][x] = CLIP(original->L[y][x] + difL * reducdE);

                        if (!lp.actsp) {
                            difa = chra * flia - original->a[y][x];
                            difb = chrb * flib - original->b[y][x];
                            difa *= factorx;
                            difb *= factorx;
                            transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                            transformed->b[y][x] = CLIPC(original->b[y][x] + difb);

                        }

                        if (blshow) {
                            transformed->L[y][x] = CLIP(12000.f + difL);
                            transformed->a[y][x] = CLIPC(difa);
                            transformed->b[y][x] = CLIPC(difb);
                        } else if (previewbl) {
                            transformed->a[y][x] = 0.f;
                            transformed->b[y][x] = (difb);
                        }

                        break;
                    }

                    case 2: { // inside selection => no effect, keep original values
                        transformed->L[y][x] = original->L[y][x];

                        if (!lp.actsp) {

                            transformed->a[y][x] = original->a[y][x];
                            transformed->b[y][x] = original->b[y][x];
                        }
                    }
                }
            }
        }
    }
}

static void calclight(float lum, float koef, float &lumnew, const LUTf &lightCurveloc)
{
    lumnew = koef != -100.f ? CLIPLOC(lightCurveloc[lum]) : 0.f;
}


static void mean_fab(int xstart, int ystart, int bfw, int bfh, LabImage* bufexporig, const LabImage* original, float &fab, float &meanfab, float chrom)
{
    const int nbfab = bfw * bfh;

    meanfab = 0.f;
    fab = 50.f;

    if (nbfab > 0) {
        double sumab = 0.0;

#ifdef _OPENMP
        #pragma omp parallel for reduction(+:sumab)
#endif

        for (int y = 0; y < bfh; y++) {
            for (int x = 0; x < bfw; x++) {
                bufexporig->a[y][x] = original->a[y + ystart][x + xstart];
                bufexporig->b[y][x] = original->b[y + ystart][x + xstart];
                sumab += fabs(bufexporig->a[y][x]);
                sumab += fabs(bufexporig->b[y][x]);
            }
        }

        meanfab = sumab / (2.f * nbfab);

        double som = 0.0;

#ifdef _OPENMP
        #pragma omp parallel for reduction(+:som)
#endif

        for (int y = 0; y < bfh; y++) {
            for (int x = 0; x < bfw; x++) {
                som += SQR(fabs(bufexporig->a[y][x]) - meanfab) + SQR(fabs(bufexporig->b[y][x]) - meanfab);
            }
        }

        const float multsigma = (chrom >= 0.f ? 0.035f : 0.018f) * chrom + 1.f;

        const float stddv = sqrt(som / nbfab);
        fab = meanfab + multsigma * stddv;

        if (fab <= 0.f) {
            fab = 50.f;
        }
    }
}


void ImProcFunctions::blendstruc(int bfw, int bfh, LabImage* bufcolorig, float radius, float stru, array2D<float> & blend2, int sk, bool multiThread)
{
    SobelCannyLuma(blend2, bufcolorig->L, bfw, bfh, radius, multiThread);

    array2D<float> ble(bfw, bfh);
    array2D<float> guid(bfw, bfh);
#ifdef _OPENMP
    #pragma omp parallel for if (multiThread)
#endif

    for (int ir = 0; ir < bfh; ir++) {
        for (int jr = 0; jr < bfw; jr++) {
            float X, Y, Z;
            float L = bufcolorig->L[ir][jr];
            float a = bufcolorig->a[ir][jr];
            float b = bufcolorig->b[ir][jr];
            Color::Lab2XYZ(L, a, b, X, Y, Z);

            guid[ir][jr] = Y / 32768.f;

            blend2[ir][jr] /= 32768.f;
        }
    }

    const float blur = 25 / sk * (10.f + 1.2f * stru);

    rtengine::guidedFilter(guid, blend2, ble, blur, 0.001, multiThread);

#ifdef _OPENMP
    #pragma omp parallel for if (multiThread)
#endif

    for (int ir = 0; ir < bfh; ir++) {
        for (int jr = 0; jr < bfw; jr++) {
            ble[ir][jr] *= 32768.f;
        }
    }

    Median_Denoise(ble, blend2, bfw, bfh, Median::TYPE_3X3_STRONG, 1, multiThread);
}


static void blendmask(const local_params& lp, int xstart, int ystart, int cx, int cy, int bfw, int bfh, LabImage* bufexporig, LabImage* original, LabImage* bufmaskor, LabImage* originalmas, float bl, int inv)
{
#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic,16)
#endif

    for (int y = 0; y < bfh ; y++) {
        const int loy = y + ystart + cy;

        for (int x = 0; x < bfw; x++) {
            const int lox = x + xstart + cx;
            int zone = 0;

            float localFactor = 1.f;
            const float achm = (float)lp.trans / 100.f;

            if (lp.shapmet == 0) {
                calcTransition(lox, loy, achm, lp, zone, localFactor);
            } else if (lp.shapmet == 1) {
                calcTransitionrect(lox, loy, achm, lp, zone, localFactor);
            }

            if (inv == 0) {
                if (zone > 0) {
                    bufexporig->L[y][x] += (bl * bufmaskor->L[y][x]);
                    bufexporig->a[y][x] *= (1.f + bl * bufmaskor->a[y][x]);
                    bufexporig->b[y][x] *= (1.f + bl * bufmaskor->b[y][x]);

                    bufexporig->L[y][x] = CLIP(bufexporig->L[y][x]);
                    bufexporig->a[y][x] = CLIPC(bufexporig->a[y][x]);
                    bufexporig->b[y][x] = CLIPC(bufexporig->b[y][x]);

                    originalmas->L[y][x] = CLIP(bufexporig->L[y][x] - bufmaskor->L[y][x]);
                    originalmas->a[y][x] = CLIPC(bufexporig->a[y][x] * (1.f - bufmaskor->a[y][x]));
                    originalmas->b[y][x] = CLIPC(bufexporig->b[y][x] * (1.f - bufmaskor->b[y][x]));

                    switch (zone) {

                        case 1: {
                            original->L[y + ystart][x + xstart] += (bl * localFactor * bufmaskor->L[y][x]);
                            original->a[y + ystart][x + xstart] *= (1.f + bl * localFactor * bufmaskor->a[y][x]);
                            original->b[y + ystart][x + xstart] *= (1.f + bl * localFactor * bufmaskor->b[y][x]);
                            original->L[y + ystart][x + xstart] = CLIP(original->L[y + ystart][x + xstart]);
                            original->a[y + ystart][x + xstart] = CLIPC(original->a[y + ystart][x + xstart]);
                            original->b[y + ystart][x + xstart] = CLIPC(original->b[y + ystart][x + xstart]);
                            break;
                        }

                        case 2: {
                            original->L[y + ystart][x + xstart] += (bl * bufmaskor->L[y][x]);
                            original->a[y + ystart][x + xstart] *= (1.f + bl * bufmaskor->a[y][x]);
                            original->b[y + ystart][x + xstart] *= (1.f + bl * bufmaskor->b[y][x]);
                            original->L[y + ystart][x + xstart] = CLIP(original->L[y + ystart][x + xstart]);
                            original->a[y + ystart][x + xstart] = CLIPC(original->a[y + ystart][x + xstart]);
                            original->b[y + ystart][x + xstart] = CLIPC(original->b[y + ystart][x + xstart]);

                        }
                    }
                }
            } else if (inv == 1) {
                localFactor = 1.f - localFactor;

                if (zone < 2) {
                    bufexporig->L[y][x] += (bl * bufmaskor->L[y][x]);
                    bufexporig->a[y][x] *= (1.f + bl * bufmaskor->a[y][x]);
                    bufexporig->b[y][x] *= (1.f + bl * bufmaskor->b[y][x]);

                    bufexporig->L[y][x] = CLIP(bufexporig->L[y][x]);
                    bufexporig->a[y][x] = CLIPC(bufexporig->a[y][x]);
                    bufexporig->b[y][x] = CLIPC(bufexporig->b[y][x]);

                    originalmas->L[y][x] = CLIP(bufexporig->L[y][x] - bufmaskor->L[y][x]);
                    originalmas->a[y][x] = CLIPC(bufexporig->a[y][x] * (1.f - bufmaskor->a[y][x]));
                    originalmas->b[y][x] = CLIPC(bufexporig->b[y][x] * (1.f - bufmaskor->b[y][x]));

                    switch (zone) {
                        case 0: {
                            original->L[y + ystart][x + xstart] += (bl * bufmaskor->L[y][x]);
                            original->a[y + ystart][x + xstart] *= (1.f + bl * bufmaskor->a[y][x]);
                            original->b[y + ystart][x + xstart] *= (1.f + bl * bufmaskor->b[y][x]);
                            original->L[y + ystart][x + xstart] = CLIP(original->L[y + ystart][x + xstart]);
                            original->a[y + ystart][x + xstart] = CLIPC(original->a[y + ystart][x + xstart]);
                            original->b[y + ystart][x + xstart] = CLIPC(original->b[y + ystart][x + xstart]);
                            break;
                        }

                        case 1: {
                            original->L[y + ystart][x + xstart] += (bl * localFactor * bufmaskor->L[y][x]);
                            original->a[y + ystart][x + xstart] *= (1.f + bl * localFactor * bufmaskor->a[y][x]);
                            original->b[y + ystart][x + xstart] *= (1.f + bl * localFactor * bufmaskor->b[y][x]);
                            original->L[y + ystart][x + xstart] = CLIP(original->L[y + ystart][x + xstart]);
                            original->a[y + ystart][x + xstart] = CLIPC(original->a[y + ystart][x + xstart]);
                            original->b[y + ystart][x + xstart] = CLIPC(original->b[y + ystart][x + xstart]);
                        }

                    }
                }

            }
        }
    }
}


static void deltaEforLaplace(float *dE, const local_params& lp, int bfw, int bfh, LabImage* bufexporig, const float hueref, const float chromaref, const float lumaref)
{

    const float refa = chromaref * cos(hueref);
    const float refb = chromaref * sin(hueref);
    const float refL = lumaref;
    float maxdE = 5.f + MAXSCOPE * lp.lap;
    float *dEforLaplace = new float [bfw * bfh];
    float maxC = sqrt((SQR(refa - bufexporig->a[0][0] / 327.68f) + SQR(refb - bufexporig->b[0][0] / 327.68f)) +  SQR(refL - bufexporig->L[0][0] / 327.68f));
    //  float sumde = 0.f;
#ifdef _OPENMP
    #pragma omp parallel for reduction(max:maxC) // reduction(+:sumde)
#endif

    for (int y = 0; y < bfh; y++) {
        for (int x = 0; x < bfw; x++) {
            dEforLaplace[y * bfw + x] = sqrt((SQR(refa - bufexporig->a[y][x] / 327.68f) + SQR(refb - bufexporig->b[y][x] / 327.68f)) +  SQR(refL - bufexporig->L[y][x] / 327.68f));
            maxC = rtengine::max(maxC, dEforLaplace[y * bfw + x]);
            //    sumde += dEforLaplace[y * bfw + x];
        }
    }

//  float mxde = sumde /(bfh * bfw);
//   maxC = 0.5f * (mxde + maxC);
    if (maxdE > maxC) {
        maxdE = maxC - 1.f;
    }

    float ade = 1.f / (maxdE - maxC);
    float bde = -ade * maxC;

#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic,16)
#endif

    for (int y = 0; y < bfh; y++) {
        for (int x = 0; x < bfw; x++) {

            float reducdEforLap = 1.f;

            if (dEforLaplace[y * bfw + x] < maxdE) {
                reducdEforLap = 1.f;
            } else {
                reducdEforLap = ade * dEforLaplace[y * bfw + x] + bde;
            }

            dE[y * bfw + x] = reducdEforLap;
        }
    }

    delete [] dEforLaplace;
}


static void showmask(const local_params& lp, int xstart, int ystart, int cx, int cy, int bfw, int bfh, LabImage* bufexporig, LabImage* transformed, LabImage* bufmaskorigSH, int inv)
{
#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic,16)
#endif

    for (int y = 0; y < bfh; y++) {
        const int loy = y + ystart + cy;

        for (int x = 0; x < bfw; x++) {
            const int lox = x + xstart + cx;
            int zone = 0;
            float localFactor = 1.f;
            const float achm = (float)lp.trans / 100.f;

            if (lp.shapmet == 0) {
                calcTransition(lox, loy, achm, lp, zone, localFactor);
            } else if (lp.shapmet == 1) {
                calcTransitionrect(lox, loy, achm, lp, zone, localFactor);
            }

            if (inv == 0) {
                if (zone > 0) {//normal
                    transformed->L[y + ystart][x + xstart] = 6000.f + CLIPLOC(bufmaskorigSH->L[y][x]);
                    transformed->a[y + ystart][x + xstart] = bufexporig->a[y][x] * bufmaskorigSH->a[y][x];
                    transformed->b[y + ystart][x + xstart] = bufexporig->b[y][x] * bufmaskorigSH->b[y][x];
                }
            } else if (inv == 1) { //inverse
                if (zone == 0) {
                    transformed->L[y + ystart][x + xstart] = 6000.f + CLIPLOC(bufmaskorigSH->L[y][x]);
                    transformed->a[y + ystart][x + xstart] = bufexporig->a[y][x] * bufmaskorigSH->a[y][x];
                    transformed->b[y + ystart][x + xstart] = bufexporig->b[y][x] * bufmaskorigSH->b[y][x];
                }
            }
        }
    }
}

void ImProcFunctions::discrete_laplacian_threshold(float * data_out, const float * data_in, size_t nx, size_t ny, float t)
{
    BENCHFUN

    size_t i, j;
    float *ptr_out;
    float diff = 0.f;
    /* pointers to the current and neighbour values */
    const float *ptr_in, *ptr_in_xm1, *ptr_in_xp1, *ptr_in_ym1, *ptr_in_yp1;

    if (NULL == data_in || NULL == data_out) {
        fprintf(stderr, "a pointer is NULL and should not be so\n");
        abort();
    }

    /* pointers to the data and neighbour values */
    /*
     *                 y-1
     *             x-1 ptr x+1
     *                 y+1
     *    <---------------------nx------->
     */
    ptr_in = data_in;
    ptr_in_xm1 = data_in - 1;
    ptr_in_xp1 = data_in + 1;
    ptr_in_ym1 = data_in - nx;
    ptr_in_yp1 = data_in + nx;
    ptr_out = data_out;

    for (j = 0; j < ny; j++) {
        for (i = 0; i < nx; i++) {
            *ptr_out = 0.f;

            /* row differences */
            if (0 < i) {
                diff = *ptr_in - *ptr_in_xm1;

                if (fabs(diff) > t) {
                    *ptr_out += diff;
                }
            }

            if (nx - 1 > i) {
                diff = *ptr_in - *ptr_in_xp1;

                if (fabs(diff) > t) {
                    *ptr_out += diff;
                }
            }

            /* column differences */
            if (0 < j) {
                diff = *ptr_in - *ptr_in_ym1;

                if (fabs(diff) > t) {
                    *ptr_out += diff;
                }
            }

            if (ny - 1 > j) {
                diff = *ptr_in - *ptr_in_yp1;

                if (fabs(diff) > t) {
                    *ptr_out += diff;
                }
            }

            ptr_in++;
            ptr_in_xm1++;
            ptr_in_xp1++;
            ptr_in_ym1++;
            ptr_in_yp1++;
            ptr_out++;
        }
    }

}

double *ImProcFunctions::cos_table(size_t size)
{
    double *table = NULL;
    double pi_size;
    size_t i;

    /* allocate the cosinus table */
    if (NULL == (table = (double *) malloc(sizeof(double) * size))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    /*
     * fill the cosinus table,
     * table[i] = cos(i Pi / n) for i in [0..n[
     */
    pi_size = rtengine::RT_PI / size;

    for (i = 0; i < size; i++) {
        table[i] = cos(pi_size * i);
    }

    return table;
}


void ImProcFunctions::rex_poisson_dct(float * data, size_t nx, size_t ny, double m)
{
    /*
     * Copyright 2009-2011 IPOL Image Processing On Line http://www.ipol.im/
     *

     * @file retinex_pde_lib.c discrete Poisson equation
     * @brief laplacian, DFT and Poisson routines
     *
     * @author Nicolas Limare <nicolas.limare@cmla.ens-cachan.fr>
     * some adaptations for Rawtherapee
     */
    BENCHFUN

    double *cosx = NULL, *cosy = NULL;
    size_t i;
    double m2;

    /*
     * get the cosinus tables
     * cosx[i] = cos(i Pi / nx) for i in [0..nx[
     * cosy[i] = cos(i Pi / ny) for i in [0..ny[
     */

    cosx = cos_table(nx);
    cosy = cos_table(ny);

    /*
     * we will now multiply data[i, j] by
     * m / (4 - 2 * cosx[i] - 2 * cosy[j]))
     * and set data[0, 0] to 0
     */
    m2 = m / 2.;
    /*
     * handle the first value, data[0, 0] = 0
     * after that, by construction, we always have
     * cosx[] + cosy[] != 2.
     */
    data[0] = 0.;

    /*
     * continue with all the array:
     * i % nx is the position on the x axis (column number)
     * i / nx is the position on the y axis (row number)
     */
    for (i = 1; i < nx * ny; i++) {
        data[i] *= m2 / (2. - cosx[i % nx] - cosy[i / nx]);
    }

    free(cosx);
    free(cosy);

}

void ImProcFunctions::mean_dt(const float * data, size_t size, double * mean_p, double * dt_p)
{
    double mean, dt;
    const float *ptr_data;
    size_t i;

    mean = 0.;
    dt = 0.;
    ptr_data = data;

    for (i = 0; i < size; i++) {
        mean += *ptr_data;
        dt += (*ptr_data) * (*ptr_data);
        ptr_data++;
    }

    mean /= (double) size;
    dt /= (double) size;
    dt -= (mean * mean);
    dt = sqrt(dt);

    *mean_p = mean;
    *dt_p = dt;

}

void ImProcFunctions::normalize_mean_dt(float * data, const float * ref, size_t size, float mod)
{
    /*
     * Copyright 2009-2011 IPOL Image Processing On Line http://www.ipol.im/
     *

     * @file retinex_pde_lib.c discrete Poisson equation
     * @brief laplacian, DFT and Poisson routines
     *
     * @author Nicolas Limare <nicolas.limare@cmla.ens-cachan.fr>
     * adapted for Rawtherapee - jacques Desmis july 2019
     */

    double mean_ref, mean_data, dt_ref, dt_data;
    double a, b;
    size_t i;
    float *ptr_data;
    float *ptr_dataold;

    if (NULL == data || NULL == ref) {
        fprintf(stderr, "a pointer is NULL and should not be so\n");
        abort();
    }

    /* compute mean and variance of the two arrays */
    mean_dt(ref, size, &mean_ref, &dt_ref);
    mean_dt(data, size, &mean_data, &dt_data);

    /* compute the normalization coefficients */
    a = dt_ref / dt_data;
    b = mean_ref - a * mean_data;

    /* normalize the array */
    ptr_data = data;
    ptr_dataold = data;

    for (i = 0; i < size; i++) {
        *ptr_data = mod * (a * *ptr_data + b) + (1.f - mod) * *ptr_dataold;//normalize mean and stdv and balance PDE
        ptr_data++;
    }

}

void ImProcFunctions::retinex_pde(float * datain, float * dataout, int bfw, int bfh, float thresh, float multy, float * dE, int show, int dEenable, int normalize)
{
    /*
     * Copyright 2009-2011 IPOL Image Processing On Line http://www.ipol.im/
     *

     * @file retinex_pde_lib.c discrete Poisson equation
     * @brief laplacian, DFT and Poisson routines
     *
     * @author Nicolas Limare <nicolas.limare@cmla.ens-cachan.fr>
     * adapted for Rawtherapee by Jacques Desmis 6-2019 <jdesmis@gmail.com>
     */

    BENCHFUN
#ifdef _OPENMP

    if (multiThread) {
        fftwf_init_threads();
        fftwf_plan_with_nthreads(omp_get_max_threads());
    }

#endif
    fftwf_plan dct_fw, dct_fw04, dct_bw;
    float *data_fft, *data_fft04, *data_tmp, *data, *data_tmp04;
    float *datashow = nullptr;

    if (show != 0) {
        if (NULL == (datashow = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
            fprintf(stderr, "allocation error\n");
            abort();
        }
    }

    if (NULL == (data_tmp = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    if (NULL == (data_tmp04 = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    //first call to laplacian with plein strength
    ImProcFunctions::discrete_laplacian_threshold(data_tmp, datain, bfw, bfh, thresh);

    if (NULL == (data_fft = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    if (show == 1) {
        for (int y = 0; y < bfh ; y++) {
            for (int x = 0; x < bfw; x++) {
                datashow[y * bfw + x]   = data_tmp[y * bfw + x];
            }
        }
    }

    //second call to laplacian with 40% strength ==> reduce effect if we are far from ref (deltaE)
    ImProcFunctions::discrete_laplacian_threshold(data_tmp04, datain, bfw, bfh, 0.4f * thresh);

    if (NULL == (data_fft04 = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    if (NULL == (data = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    //execute first
    dct_fw = fftwf_plan_r2r_2d(bfh, bfw, data_tmp, data_fft, FFTW_REDFT10, FFTW_REDFT10, FFTW_ESTIMATE | FFTW_DESTROY_INPUT);
    fftwf_execute(dct_fw);

    //execute second
    if (dEenable == 1) {
        dct_fw04 = fftwf_plan_r2r_2d(bfh, bfw, data_tmp04, data_fft04, FFTW_REDFT10, FFTW_REDFT10, FFTW_ESTIMATE | FFTW_DESTROY_INPUT);
        fftwf_execute(dct_fw04);
    }

    if (dEenable == 1) {
#ifdef _OPENMP
        #pragma omp parallel for
#endif

        for (int y = 0; y < bfh ; y++) {//mix two fftw Laplacian : plein if dE near ref
            for (int x = 0; x < bfw; x++) {
                float prov = pow(dE[y * bfw + x], 4.5f);
                data_fft[y * bfw + x] = prov * data_fft[y * bfw + x] + (1.f - prov) * data_fft04[y * bfw + x];
            }
        }
    }

    if (show == 2) {
        for (int y = 0; y < bfh ; y++) {
            for (int x = 0; x < bfw; x++) {
                datashow[y * bfw + x]   = data_fft[y * bfw + x];
            }
        }
    }

    fftwf_free(data_fft04);
    fftwf_free(data_tmp);
    fftwf_free(data_tmp04);

    if (dEenable == 1) {
        fftwf_destroy_plan(dct_fw04);
    }

    /* solve the Poisson PDE in Fourier space */
    /* 1. / (float) (bfw * bfh)) is the DCT normalisation term, see libfftw */
    ImProcFunctions::rex_poisson_dct(data_fft, bfw, bfh, 1. / (double)(bfw * bfh));

    if (show == 3) {
        for (int y = 0; y < bfh ; y++) {
            for (int x = 0; x < bfw; x++) {
                datashow[y * bfw + x]   = data_fft[y * bfw + x];
            }
        }
    }

    dct_bw = fftwf_plan_r2r_2d(bfh, bfw, data_fft, data, FFTW_REDFT01, FFTW_REDFT01, FFTW_ESTIMATE | FFTW_DESTROY_INPUT);
    fftwf_execute(dct_bw);
    fftwf_destroy_plan(dct_fw);
    fftwf_destroy_plan(dct_bw);
    fftwf_free(data_fft);
    fftwf_cleanup();

    if (multiThread) {
        fftwf_cleanup_threads();
    }

    if (show != 4 && normalize == 1) {
        normalize_mean_dt(data, datain, bfw * bfh, 1.f);
    }

    if (show == 0  || show == 4) {

#ifdef _OPENMP
        #pragma omp parallel for
#endif

        for (int y = 0; y < bfh ; y++) {
            for (int x = 0; x < bfw; x++) {
                dataout[y * bfw + x]   = CLIPLOC(multy * data[y * bfw + x]);
            }
        }
    } else if (show == 1 || show == 2 || show == 3) {
        for (int y = 0; y < bfh ; y++) {
            for (int x = 0; x < bfw; x++) {
                dataout[y * bfw + x]   = CLIPLOC(multy * datashow[y * bfw + x]);
            }
        }

        fftwf_free(datashow);
    }
}

void ImProcFunctions::maskcalccol(bool invmask, bool pde, int bfw, int bfh, int xstart, int ystart, int sk, int cx, int cy, LabImage* bufcolorig, LabImage* bufmaskblurcol, LabImage* originalmaskcol, LabImage* original, int inv, const struct local_params & lp,
        const LocCCmaskCurve & locccmasCurve, bool & lcmasutili, 
        const LocLLmaskCurve & locllmasCurve, bool & llmasutili, 
        const LocHHmaskCurve & lochhmasCurve, bool &lhmasutili,
        bool multiThread, bool enaMask, bool showmaske, bool deltaE, bool modmask, bool zero, bool modif, float chrom, float rad, float lap, float gamma, float slope, float blendm,
        LUTf & lmasklocalcurve, bool & localmaskutili
)
{
    array2D<float> ble(bfw, bfh);
    array2D<float> guid(bfw, bfh);
    float meanfab, fab;
    mean_fab(xstart, ystart, bfw, bfh, bufcolorig, original, fab, meanfab, chrom);
    float kinv = 1.f;
    float kneg = 1.f;

    if (invmask) {
        kinv = 0.f;
        kneg = -1.f;
    }

    if (deltaE || modmask || enaMask || showmaske) {

#ifdef _OPENMP
        #pragma omp parallel for schedule(dynamic,16)
#endif

        for (int y = 0; y < bfh; y++) {
            for (int x = 0; x < bfw; x++) {
                bufmaskblurcol->L[y][x] = original->L[y + ystart][x + xstart];
                bufmaskblurcol->a[y][x] = original->a[y + ystart][x + xstart];
                bufmaskblurcol->b[y][x] = original->b[y + ystart][x + xstart];
            }
        }

#ifdef _OPENMP
        #pragma omp parallel
#endif
        {
#ifdef __SSE2__
            float atan2Buffer[bfw] ALIGNED64;
#endif
#ifdef _OPENMP
            #pragma omp for schedule(dynamic, 16)
#endif

            for (int ir = 0; ir < bfh; ir++) {
#ifdef __SSE2__

                if (lochhmasCurve && lhmasutili) {
                    int i = 0;

                    for (; i < bfw - 3; i += 4) {
                        STVF(atan2Buffer[i], xatan2f(LVFU(bufcolorig->b[ir][i]), LVFU(bufcolorig->a[ir][i])));
                    }

                    for (; i < bfw; i++) {
                        atan2Buffer[i] = xatan2f(bufcolorig->b[ir][i], bufcolorig->a[ir][i]);
                    }
                }

#endif

                for (int jr = 0; jr < bfw; jr++) {
                    float kmaskL = 0.f;
                    float kmaskC = 0.f;
                    float kmaskHL = 0.f;
                    float kmaskH = 0.f;

                    if (locllmasCurve && llmasutili) {
                        kmaskL = 32768.f * LIM01(kinv - kneg * locllmasCurve[(500.f / 32768.f) * bufcolorig->L[ir][jr]]);
                    }

                    if (!deltaE && locccmasCurve && lcmasutili) {
                        kmaskC = LIM01(kinv  - kneg * locccmasCurve[500.f * (0.0001f + sqrt(SQR(bufcolorig->a[ir][jr]) + SQR(bufcolorig->b[ir][jr])) / fab)]);
                    }

                    if (lochhmasCurve && lhmasutili) {
#ifdef __SSE2__
                        const float huema = atan2Buffer[jr];
#else
                        const float huema = xatan2f(bufcolorig->b[ir][jr], bufcolorig->a[ir][jr]);
#endif
                        float h = Color::huelab_to_huehsv2(huema);
                        h += 1.f / 6.f;

                        if (h > 1.f) {
                            h -= 1.f;
                        }

                        const float valHH = LIM01(kinv - kneg * lochhmasCurve[500.f *  h]);

                        if (!deltaE) {
                            kmaskH = valHH;
                        }

                        kmaskHL = 32768.f * valHH;
                    }

                    bufmaskblurcol->L[ir][jr] = CLIPLOC(kmaskL + kmaskHL);
                    bufmaskblurcol->a[ir][jr] = CLIPC(kmaskC + kmaskH);
                    bufmaskblurcol->b[ir][jr] = CLIPC(kmaskC + kmaskH);
                    ble[ir][jr] = bufmaskblurcol->L[ir][jr] / 32768.f;
                    float X, Y, Z;
                    float L = bufcolorig->L[ir][jr];
                    float a = bufcolorig->a[ir][jr];
                    float b = bufcolorig->b[ir][jr];
                    Color::Lab2XYZ(L, a, b, X, Y, Z);

                    guid[ir][jr] = Y / 32768.f;

                }
            }
        }

        if (rad > 0.f) {
            guidedFilter(guid, ble, ble, rad * 10.f / sk, 0.001, multiThread, 4);
        }

        LUTf lutTonemaskexp(65536);
        calcGammaLut(gamma, slope, lutTonemaskexp);


#ifdef _OPENMP
        #pragma omp parallel for schedule(dynamic,16)
#endif

        for (int ir = 0; ir < bfh; ir++) {
            for (int jr = 0; jr < bfw; jr++) {
                bufmaskblurcol->L[ir][jr] = lutTonemaskexp[LIM01(ble[ir][jr]) * 65536.f];
            }
        }

//curve actually only for color and light
        if (lmasklocalcurve && localmaskutili) {
#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int ir = 0; ir < bfh; ir++)
                for (int jr = 0; jr < bfw; jr++) {
                    bufmaskblurcol->L[ir][jr] = 0.5f * lmasklocalcurve[2.f * bufmaskblurcol->L[ir][jr]];
                }
        }


        if (lap > 0.f) {
            float *datain = new float[bfh * bfw];
            float *data_tmp = new float[bfh * bfw];

#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int y = 0; y < bfh; y++) {
                for (int x = 0; x < bfw; x++) {
                    datain[y * bfw + x] =  bufmaskblurcol->L[y][x];
                }
            }

            if (!pde) {
                ImProcFunctions::discrete_laplacian_threshold(data_tmp, datain, bfw, bfh, 200.f * lap);
            } else {
                ImProcFunctions::retinex_pde(datain, data_tmp, bfw, bfh, 12.f * lap, 1.f, nullptr, 0, 0, 1);
            }

#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int y = 0; y < bfh; y++) {
                for (int x = 0; x < bfw; x++) {
                    bufmaskblurcol->L[y][x] = data_tmp[y * bfw + x];
                }
            }

            delete [] datain;
            delete [] data_tmp;

        }
    }

    const float radiusb = 1.f / sk;

    if (deltaE || modmask || enaMask || showmaske) {
#ifdef _OPENMP
        #pragma omp parallel
#endif
        {
            gaussianBlur(bufmaskblurcol->L, bufmaskblurcol->L, bfw, bfh, radiusb);
            gaussianBlur(bufmaskblurcol->a, bufmaskblurcol->a, bfw, bfh, 1.f + (0.5f * rad) / sk);
            gaussianBlur(bufmaskblurcol->b, bufmaskblurcol->b, bfw, bfh, 1.f + (0.5f * rad) / sk);
        }

        if (zero || modif || modmask || deltaE || enaMask) {
            originalmaskcol->CopyFrom(bufcolorig);
            blendmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufcolorig, original, bufmaskblurcol, originalmaskcol, blendm, inv);
        }
    }
}

void ImProcFunctions::InverseSharp_Local(float **loctemp, const float hueref, const float lumaref, const float chromaref, const local_params & lp, LabImage * original, LabImage * transformed, int cx, int cy, int sk)
{
//local sharp
    //  BENCHFUN
    const float ach = (float)lp.trans / 100.f;
    int GW = transformed->W;
    int GH = transformed->H;
    float refa = chromaref * cos(hueref);
    float refb = chromaref * sin(hueref);
    //balance deltaE
    float kL = lp.balance;
    float kab = 1.f;
    balancedeltaE(kL, kab);

    LabImage *origblur = new LabImage(GW, GH);

    float radius = 3.f / sk;
#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
        gaussianBlur(original->L, origblur->L, GW, GH, radius);
        gaussianBlur(original->a, origblur->a, GW, GH, radius);
        gaussianBlur(original->b, origblur->b, GW, GH, radius);

    }

#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * lp.senssha * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * lp.senssha * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            int loy = cy + y;

            for (int x = 0; x < transformed->W; x++) {
                int lox = cx + x;
                int zone;
                float localFactor = 1.f;

                if (lp.shapmet == 0) {
                    calcTransition(lox, loy, ach, lp, zone, localFactor);
                } else if (lp.shapmet == 1) {
                    calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                }

                float rL = origblur->L[y][x] / 327.68f;
                float reducdE = 0.f;
                float dE = sqrt(kab * SQR(refa - origblur->a[y][x] / 327.68f) + kab * SQR(refb - origblur->b[y][x] / 327.68f) + kL * SQR(lumaref - rL));
                calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, lp.senssha, reducdE);

                switch (zone) {
                    case 0: { // outside selection and outside transition zone => full effect, no transition
                        float difL = loctemp[y][x] - original->L[y][x];
                        transformed->L[y][x] = CLIP(original->L[y][x] + difL * reducdE);

                        break;
                    }

                    case 1: { // inside transition zone
                        float difL = loctemp[y][x] - original->L[y][x];

                        float factorx = 1.f - localFactor;
                        difL *= factorx;

                        transformed->L[y][x] = CLIP(original->L[y][x] + difL * reducdE);
                        break;
                    }

                    case 2: { // inside selection => no effect, keep original values
                        transformed->L[y][x] = original->L[y][x];
                    }
                }
            }
        }
    }
    delete origblur;
}


void ImProcFunctions::Sharp_Local(int call, float **loctemp, int senstype, const float hueref, const float chromaref, const float lumaref, const local_params & lp, LabImage * original, LabImage * transformed, int cx, int cy, int sk)
{
    BENCHFUN
    const float ach = lp.trans / 100.f;
    const float varsens = senstype == 1 ? lp.senslc : lp.senssha;

    //balance deltaE
    float kL = lp.balance;
    float kab = 1.f;
    balancedeltaE(kL, kab);
    kab /= SQR(327.68f);
    kL /= SQR(327.68f);

    const int GW = transformed->W;
    const int GH = transformed->H;

    std::unique_ptr<LabImage> origblur(new LabImage(GW, GH));
    const float refa = chromaref * cos(hueref) * 327.68f;
    const float refb = chromaref * sin(hueref) * 327.68f;
    const float refL = lumaref * 327.68f;
    const float radius = 3.f / sk;

#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        gaussianBlur(original->L, origblur->L, GW, GH, radius);
        gaussianBlur(original->a, origblur->a, GW, GH, radius);
        gaussianBlur(original->b, origblur->b, GW, GH, radius);
    }

#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        const int begy = int (lp.yc - lp.lyT);
        const int begx = int (lp.xc - lp.lxL);
        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * varsens * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * varsens * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            const int loy = cy + y;
            const bool isZone0 = loy > lp.yc + lp.ly || loy < lp.yc - lp.lyT; // whole line is zone 0 => we can skip a lot of processing

            if (isZone0) { // outside selection and outside transition zone => no effect, keep original values
                continue;
            }

            for (int x = 0; x < transformed->W; x++) {
                const int lox = cx + x;
                int zone = 0;
                float localFactor = 1.f;

                if (lp.shapmet == 0) {
                    calcTransition(lox, loy, ach, lp, zone, localFactor);
                } else if (lp.shapmet == 1) {
                    calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                }

                if (zone == 0) { // outside selection and outside transition zone => no effect, keep original values
                    continue;
                }

                const float dE = sqrt(kab * (SQR(refa - origblur->a[y][x]) + SQR(refb - origblur->b[y][x])) + kL * SQR(refL - origblur->L[y][x]));

                float reducdE = 0.f;
                calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, varsens, reducdE);
                reducdE *= localFactor;

                float difL;

                if (call == 2) {
                    difL = loctemp[loy - begy][lox - begx] - original->L[y][x];
                } else {
                    difL = loctemp[y][x] - original->L[y][x];
                }

                transformed->L[y][x] = CLIP(original->L[y][x] + difL * reducdE);
            }
        }
    }
}

void ImProcFunctions::Exclude_Local(float **deltaso, float hueref, float chromaref, float lumaref, float sobelref, float meansobel, const struct local_params & lp, const LabImage * original, LabImage * transformed, const LabImage * rsv, const LabImage * reserv, int cx, int cy, int sk)
{

    BENCHFUN {
        const float ach = (float)lp.trans / 100.f;
        const float varsens =  lp.sensexclu;

        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * varsens * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * varsens * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

        const int GW = transformed->W;
        const int GH = transformed->H;

        const float refa = chromaref * cos(hueref) * 327.68f;
        const float refb = chromaref * sin(hueref) * 327.68f;
        lumaref *= 327.68f;
        //balance deltaE
        float kL = lp.balance;
        float kab = 1.f;
        balancedeltaE(kL, kab);
        kL /= SQR(327.68f);
        kab /= SQR(327.68f);
        //sobel
        sobelref = rtengine::min(sobelref / 100.f, 60.f);

        const bool recip = sobelref <  meansobel && sobelref < lp.stru;

        sobelref = log1p(sobelref);

        LabImage *origblur = new LabImage(GW, GH);

        const float radius = 3.f / sk;

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
            gaussianBlur(reserv->L, origblur->L, GW, GH, radius);
            gaussianBlur(reserv->a, origblur->a, GW, GH, radius);
            gaussianBlur(reserv->b, origblur->b, GW, GH, radius);


#ifdef _OPENMP
            #pragma omp barrier
            #pragma omp for schedule(dynamic,16)
#endif

            for (int y = 0; y < transformed->H; y++)
            {
                const int loy = cy + y;
                const bool isZone0 = loy > lp.yc + lp.ly || loy < lp.yc - lp.lyT; // whole line is zone 0 => we can skip a lot of processing

                if (isZone0) { // outside selection and outside transition zone => no effect, keep original values
                    for (int x = 0; x < transformed->W; x++) {
                        transformed->L[y][x] = original->L[y][x];
                    }

                    continue;
                }

                for (int x = 0; x < transformed->W; x++) {
                    const int lox = cx + x;
                    const int begx = int (lp.xc - lp.lxL);
                    const int begy = int (lp.yc - lp.lyT);

                    int zone = 0;
                    float localFactor = 1.f;

                    if (lp.shapmet == 0) {
                        calcTransition(lox, loy, ach, lp, zone, localFactor);
                    } else if (lp.shapmet == 1) {
                        calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                    }


                    if (zone == 0) { // outside selection and outside transition zone => no effect, keep original values
                        transformed->L[y][x] = original->L[y][x];
                        continue;
                    }

                    float rs = 0.f;

                    const float csob = xlogf(1.f + rtengine::min(deltaso[loy - begy][lox - begx] / 100.f, 60.f) + 0.001f);

                    if (!recip) {
                        rs = sobelref / csob;
                    } else {
                        rs = csob / sobelref;
                    }

                    float affsob = 1.f;

                    if (lp.struexc > 0.f && rs > 0.f) {
                        const float rsob =  0.002f *  lp.struexc * rs;
                        const float minrs = 1.3f + 0.05f * lp.stru;

                        if (rs < minrs) {
                            affsob = 1.f;
                        } else {
                            affsob = 1.f / pow_F((1.f + rsob), SQR(SQR(rs - minrs)));
                        }
                    }

                    const float rL = origblur->L[y][x];
                    const float dE = sqrt(kab * SQR(refa - origblur->a[y][x]) + kab * SQR(refb - origblur->b[y][x]) + kL * SQR(lumaref - rL));

                    float reducdE;
                    calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, varsens, reducdE);

                    const float affde = reducdE;

                    if (rL > 32.768f) { //to avoid crash with very low gamut in rare cases ex : L=0.01 a=0.5 b=-0.9
                        switch (zone) {

                            case 1: { // inside transition zone
                                const float difL = (rsv->L[loy - begy][lox - begx] - original->L[y][x]) * localFactor;
                                transformed->L[y][x] = CLIP(original->L[y][x] + difL * affsob * affde);

                                const float difa = (rsv->a[loy - begy][lox - begx] - original->a[y][x]) * localFactor;
                                transformed->a[y][x] = CLIPC(original->a[y][x] + difa * affsob * affde);

                                const float difb = (rsv->b[loy - begy][lox - begx] - original->b[y][x]) * localFactor;
                                transformed->b[y][x] = CLIPC(original->b[y][x] + difb * affsob * affde);

                                break;

                            }

                            case 2: { // inside selection => full effect, no transition
                                const float difL = rsv->L[loy - begy][lox - begx] - original->L[y][x];
                                transformed->L[y][x] = CLIP(original->L[y][x] + difL * affsob * affde);

                                const float difa = rsv->a[loy - begy][lox - begx] - original->a[y][x];;
                                transformed->a[y][x] = CLIPC(original->a[y][x] + difa * affsob * affde);

                                const float difb = rsv->b[loy - begy][lox - begx] - original->b[y][x];
                                transformed->b[y][x] = CLIPC(original->b[y][x] + difb * affsob * affde);
                            }
                        }
                    }
                }
            }
        }
        delete origblur;
    }
}

void ImProcFunctions::transit_shapedetect_retinex(int call, int senstype, LabImage * bufexporig, LabImage * bufmask, LabImage * buforigmas, float **buflight, float **bufchro, const float hueref, const float chromaref, const float lumaref, const struct local_params & lp, LabImage * original, LabImage * transformed, int cx, int cy, int sk)
{

    BENCHFUN {
        const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
        const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
        const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
        const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);


        const float ach = (float)lp.trans / 100.f;
        const float varsens = lp.sensh;

        int GW = transformed->W;
        int GH = transformed->H;

        const float refa = chromaref * cos(hueref);
        const float refb = chromaref * sin(hueref);
        const bool retishow = ((lp.showmaskretimet == 1 || lp.showmaskretimet == 2));
        const bool previewreti = ((lp.showmaskretimet == 4));
        //balance deltaE
        float kL = lp.balance;
        float kab = 1.f;
        balancedeltaE(kL, kab);
        bool showmas = false ;

        if (lp.showmaskretimet == 3)
        {
            showmas = true;
        }

        std::unique_ptr<LabImage> origblur(new LabImage(GW, GH));
        const float radius = 3.f / sk;
        const bool usemaskreti = lp.enaretiMask && senstype == 4  && !lp.enaretiMasktmap;
        float strcli = 0.03f * lp.str;

        if (lp.scalereti == 1)
        {
            strcli = 0.015 * lp.str;
        }

#ifdef _OPENMP
        #pragma omp parallel
#endif
        {
            gaussianBlur(original->L, origblur->L, GW, GH, radius);
            gaussianBlur(original->a, origblur->a, GW, GH, radius);
            gaussianBlur(original->b, origblur->b, GW, GH, radius);
        }


#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
            const int limscope = 80;
            const float mindE = 2.f + MINSCOPE * varsens * lp.thr;
            const float maxdE = 5.f + MAXSCOPE * varsens * (1 + 0.1f * lp.thr);
            const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
            const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
            #pragma omp for schedule(dynamic,16)
#endif

            for (int y = ystart; y < yend; y++)
            {
                const int loy = cy + y;

                for (int x = xstart; x < xend; x++) {
                    const int lox = cx + x;
                    int zone = 0;
                    float localFactor = 1.f;

                    if (lp.shapmet == 0) {
                        calcTransition(lox, loy, ach, lp, zone, localFactor);
                    } else if (lp.shapmet == 1) {
                        calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                    }


                    if (zone == 0) { // outside selection and outside transition zone => no effect, keep original values
                        continue;
                    }

                    float rL = origblur->L[y][x] / 327.68f;
                    float dE;

                    if (!usemaskreti) {
                        dE = sqrt(kab * SQR(refa - origblur->a[y][x] / 327.68f) + kab * SQR(refb - origblur->b[y][x] / 327.68f) + kL * SQR(lumaref - rL));
                    } else {
                        if (call == 2) {
                            dE = sqrt(kab * SQR(refa - buforigmas->a[y - ystart][x - xstart] / 327.68f) + kab * SQR(refb - buforigmas->b[y - ystart][x - xstart] / 327.68f) + kL * SQR(lumaref - buforigmas->L[y - ystart][x - xstart] / 327.68f));
                        } else {
                            dE = sqrt(kab * SQR(refa - buforigmas->a[y][x] / 327.68f) + kab * SQR(refb - buforigmas->b[y][x] / 327.68f) + kL * SQR(lumaref - buforigmas->L[y][x] / 327.68f));
                        }
                    }

                    float cli, clc;

                    if (call == 2) {
                        cli = buflight[y - ystart][x - xstart];
                        clc = previewreti ? settings->previewselection * 100.f : bufchro[y - ystart][x - xstart];
                    } else {
                        cli = buflight[y][x];
                        clc = previewreti ? settings->previewselection * 100.f : bufchro[y][x];

                    }

                    float reducdE;

                    calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, varsens, reducdE);

                    reducdE /= 100.f;
                    cli *= reducdE;
                    clc *= reducdE;
                    cli *= (1.f + strcli);

                    if (rL > 0.1f) { //to avoid crash with very low gamut in rare cases ex : L=0.01 a=0.5 b=-0.9
                        if (senstype == 4) {//all except color and light (TODO) and exposure
                            float lightc;

                            if (call == 2) {
                                lightc = bufexporig->L[y - ystart][x - xstart];
                            } else {
                                lightc = bufexporig->L[y][x];
                            }

                            float fli = 1.f + cli;
                            float diflc = lightc * fli - original->L[y][x];
                            diflc *= localFactor;

                            if (!showmas) {
                                transformed->L[y][x] = CLIP(original->L[y][x] + diflc);
                            } else {
                                if (call == 2) {

                                    transformed->L[y][x] =  bufmask->L[y - ystart][x - xstart];
                                } else {
                                    transformed->L[y][x] =  bufmask->L[y][x];
                                }
                            } ;

                            if (retishow) {
                                transformed->L[y][x] = CLIP(12000.f + diflc);
                            }
                        }

                        float fliab = 1.f;
                        float chra, chrb;

                        if (call == 2) {
                            chra = bufexporig->a[y - ystart][x - xstart];
                            chrb = bufexporig->b[y - ystart][x - xstart];
                        } else {
                            chra = bufexporig->a[y][x];
                            chrb = bufexporig->b[y][x];

                        }

                        if (senstype == 5) {
                            fliab = 1.f + clc;
                        }

                        const float difa = (chra * fliab - original->a[y][x]) * localFactor;
                        const float difb = (chrb * fliab - original->b[y][x]) * localFactor;

                        transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                        transformed->b[y][x] = CLIPC(original->b[y][x] + difb);

                        if (showmas) {
                            if (call == 2) {
                                transformed->a[y][x] = bufmask->a[y - ystart][x - xstart];
                                transformed->b[y][x] = bufmask->b[y - ystart][x - xstart];
                            } else {
                                transformed->a[y][x] = bufmask->a[y][x];
                                transformed->b[y][x] = bufmask->b[y][x];

                            }
                        }

                        if (retishow) {
                            transformed->a[y][x] = CLIPC(difa);
                            transformed->b[y][x] = CLIPC(difb);
                        }

                        if (previewreti) {
                            transformed->a[y][x] = 0.f;
                            transformed->b[y][x] = CLIPC(difb);
                        }
                    }
                }
            }
        }

        if (showmas  || retishow || previewreti)
        {
            return;
        }

    }
}


void ImProcFunctions::transit_shapedetect(int senstype, const LabImage * bufexporig, LabImage * originalmask, float **buflight, float **bufchro, float **buf_a_cat, float ** buf_b_cat, float ** bufhh, bool HHutili, const float hueref, const float chromaref, const float lumaref, float sobelref, float meansobel, float ** blend2, const struct local_params & lp, LabImage * original, LabImage * transformed, int cx, int cy, int sk)
{

    BENCHFUN {
        const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
        const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
        const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
        const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
        const int bfw = xend - xstart;
        const int bfh = yend - ystart;
        // printf("h=%f l=%f c=%f s=%f\n", hueref, lumaref, chromaref, sobelref);
        const float ach = lp.trans / 100.f;
        float varsens = lp.sensex;

        if (senstype == 0)   //Color and Light
        {
            varsens =  lp.sens;
        } else if (senstype == 1)   //exposure
        {
            varsens =  lp.sensex;
        } else if (senstype == 2)   //vibrance
        {
            varsens =  lp.sensv;
        } else if (senstype == 3)   //soft light
        {
            varsens =  lp.senssf;
        } else if (senstype == 30)   //dehaze
        {
            varsens =  lp.sensh;
        } else if (senstype == 6 || senstype == 7)   //cbdl
        {
            varsens =  lp.senscb;
        } else if (senstype == 8)   //TM
        {
            varsens =  lp.senstm;
        } else if (senstype == 9)   //Shadow highlight
        {
            varsens =  lp.senshs;
        } else if (senstype == 10) //local contrast
        {
            varsens =  lp.senslc;
        }

        //sobel
        sobelref /= 100.f;
        meansobel /= 100.f;

        sobelref = rtengine::min(sobelref, 60.f);

        const bool k = !(sobelref < meansobel && sobelref < lp.stru); //does not always work with noisy images

        sobelref = log1p(sobelref);

        const float refa = chromaref * cos(hueref) * 327.68f;
        const float refb = chromaref * sin(hueref) * 327.68f;
        const float refL = lumaref * 327.68f;

        const bool expshow = ((lp.showmaskexpmet == 1 || lp.showmaskexpmet == 2)  &&  senstype == 1);
        const bool colshow = ((lp.showmaskcolmet == 1 || lp.showmaskcolmet == 2)  &&  senstype == 0);
        const bool SHshow = ((lp.showmaskSHmet == 1 || lp.showmaskSHmet == 2)  &&  senstype == 9);
        const bool cbshow = ((lp.showmaskcbmet == 1 || lp.showmaskcbmet == 2)  &&  senstype == 6);
        const bool tmshow = ((lp.showmasktmmet == 1 || lp.showmasktmmet == 2)  &&  senstype == 8);
        const bool previewcol = ((lp.showmaskcolmet == 5)  &&  senstype == 0);
        const bool previewexp = ((lp.showmaskexpmet == 5)  &&  senstype == 1);
        const bool previewSH = ((lp.showmaskSHmet == 4)  &&  senstype == 9);
        const bool previewcb = ((lp.showmaskcbmet == 4)  &&  senstype == 6);
        const bool previewtm = ((lp.showmasktmmet == 4)  &&  senstype == 8);

        std::unique_ptr<LabImage> origblur(new LabImage(bfw, bfh));
        std::unique_ptr<LabImage> origblurmask;

        float radius = 3.f / sk;

        if (senstype == 1)
        {
            radius = (2.f + 0.2f * lp.blurexp) / sk;
        } else if (senstype == 0)
        {
            radius = (2.f + 0.2f * lp.blurcol) / sk;
        } else if (senstype == 9)
        {
            radius = (2.f + 0.2f * lp.blurSH) / sk;
        }

        //balance deltaE
        float kL = lp.balance;
        float kab = 1.f;
        balancedeltaE(kL, kab);
        kab /= SQR(327.68f);
        kL /= SQR(327.68f);
        const bool usemaskexp = (lp.showmaskexpmet == 2 || lp.enaExpMask || lp.showmaskexpmet == 5) && senstype == 1;
        const bool usemaskcol = (lp.showmaskcolmet == 2 || lp.enaColorMask || lp.showmaskcolmet == 5) && senstype == 0;
        const bool usemaskSH = (lp.showmaskSHmet == 2 || lp.enaSHMask || lp.showmaskSHmet == 4) && senstype == 9;
        const bool usemaskcb = (lp.showmaskcbmet == 2 || lp.enacbMask || lp.showmaskcbmet == 4) && senstype == 6;
        const bool usemasktm = (lp.showmasktmmet == 2 || lp.enatmMask || lp.showmasktmmet == 4) && senstype == 8;
        const bool usemaskall = (usemaskSH || usemaskcol || usemaskexp || usemaskcb  || usemasktm);

        if (usemaskall)
        {
            origblurmask.reset(new LabImage(bfw, bfh));

#ifdef _OPENMP
            #pragma omp parallel if (multiThread)
#endif
            {
                gaussianBlur(originalmask->L, origblurmask->L, bfw, bfh, radius);
                gaussianBlur(originalmask->a, origblurmask->a, bfw, bfh, radius);
                gaussianBlur(originalmask->b, origblurmask->b, bfw, bfh, radius);
            }
        }

        if (lp.equtm  && senstype == 8) //normalize luminance for Tone mapping , at this place we can use for others senstype!
        {
            float *datain = new float[bfh * bfw];
            float *data = new float[bfh * bfw];

#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int y = ystart; y < yend; y++)
                for (int x = xstart; x < xend; x++) {
                    datain[(y - ystart) * bfw + (x - xstart)] = original->L[y][x];
                    data[(y - ystart)* bfw + (x - xstart)] = bufexporig->L[y - ystart][x - xstart];
                }

            normalize_mean_dt(data, datain, bfh * bfw, 1.f);
#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int y = ystart; y < yend; y++)
                for (int x = xstart; x < xend; x++) {
                    bufexporig->L[y - ystart][x - xstart] = data[(y - ystart) * bfw + x - xstart];
                }

            delete [] datain;
            delete [] data;
        }

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
#ifdef _OPENMP
            #pragma omp for schedule(dynamic,16)
#endif

            for (int y = 0; y < bfh; y++)
            {
                for (int x = 0; x < bfw; x++) {
                    origblur->L[y][x] = original->L[y + ystart][x + xstart];
                    origblur->a[y][x] = original->a[y + ystart][x + xstart];
                    origblur->b[y][x] = original->b[y + ystart][x + xstart];
                }
            }

            gaussianBlur(origblur->L, origblur->L, bfw, bfh, radius);
            gaussianBlur(origblur->a, origblur->a, bfw, bfh, radius);
            gaussianBlur(origblur->b, origblur->b, bfw, bfh, radius);

        }

        const LabImage *maskptr = usemaskall ? origblurmask.get() : origblur.get();
        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * varsens * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * varsens * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
#ifdef __SSE2__
            float atan2Buffer[transformed->W] ALIGNED16;
#endif

#ifdef _OPENMP
            #pragma omp for schedule(dynamic,16)
#endif

            for (int y = ystart; y < yend; y++)
            {
                const int loy = cy + y;

#ifdef __SSE2__

                if (HHutili || senstype == 7) {
                    int i = xstart;

                    for (; i < xend - 3; i += 4) {
                        vfloat av = LVFU(origblur->a[y - ystart][i - xstart]);
                        vfloat bv = LVFU(origblur->b[y - ystart][i - xstart]);
                        STVFU(atan2Buffer[i], xatan2f(bv, av));
                    }

                    for (; i < xend; i++) {
                        atan2Buffer[i] = xatan2f(origblur->b[y - ystart][i - xstart], origblur->a[y - ystart][i - xstart]);
                    }
                }

#endif

                for (int x = xstart; x < xend; x++) {
                    const int lox = cx + x;

                    int zone = 0;
                    float localFactor = 1.f;

                    if (lp.shapmet == 0) {
                        calcTransition(lox, loy, ach, lp, zone, localFactor);
                    } else if (lp.shapmet == 1) {
                        calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                    }


                    if (zone == 0) { // outside selection and outside transition zone => no effect, keep original values
                        continue;
                    }

                    float rhue = 0;

                    if (HHutili || senstype == 7) {
#ifdef __SSE2__
                        rhue = atan2Buffer[x];
#else
                        rhue = xatan2f(origblur->b[y - ystart][x - xstart], origblur->a[y - ystart][x - xstart]);
#endif
                    }

                    const float rL = origblur->L[y - ystart][x - xstart] / 327.68f;
                    float rsob = 0.f;

                    if (blend2 && ((senstype == 1 && lp.struexp > 0.f) || (senstype == 0 && lp.struco > 0.f))) {
                        const float csob = xlogf(1.f + std::min(blend2[y - ystart][x - xstart] / 100.f, 60.f) + 0.001f);

                        float rs;

                        if (k) {
                            rs = sobelref / csob;
                        } else {
                            rs = csob / sobelref;
                        }

                        if (rs > 0.f && senstype == 1) {
                            rsob =  1.1f * lp.struexp * rs;
                        } else if (rs > 0.f && senstype == 0) {
                            rsob =  1.1f * lp.struco * rs;
                        }
                    }

                    const float dE = rsob + sqrt(kab * (SQR(refa - maskptr->a[y - ystart][x - xstart]) + SQR(refb - maskptr->b[y - ystart][x - xstart])) + kL * SQR(refL - maskptr->L[y - ystart][x - xstart]));

                    float cla = 0.f;
                    float clb = 0.f;

                    const float cli = buflight[y - ystart][x - xstart];
                    const float clc = (previewcol || previewexp || previewSH || previewcb) ? settings->previewselection * 100.f : bufchro[y - ystart][x - xstart];


                    if (senstype <= 1) {
                        cla = buf_a_cat[y - ystart][x - xstart];
                        clb = buf_b_cat[y - ystart][x - xstart];
                    }

                    float reducdE;
                    calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, varsens, reducdE);

                    const float realstrdE = reducdE * cli;
                    const float realstradE = reducdE * cla;
                    const float realstrbdE = reducdE * clb;
                    const float realstrchdE = reducdE * clc;
                    /* comment on processus deltaE
                            * the algo uses 3 different ways to manage deltaE according to the type of intervention
                            * if we call "applyproc" : the datas produced upstream in bfw, bfh coordinate by the function producing something curves, retinex, exposure, etc.

                            * direct : in this case we use directly the datas produced upstream by "applyproc", with only a regulation produce for deltaE by reducdE
                            * direct : we found in this case "applyproc" modify data with low amplitude : BlurNoise, CBDL, Denoise, Sharp, TM

                            * with first use of "buflight" on which is apply "applyproc", in this case we apply  realstrdE = reducdE * buflight with a function of type 328.f *  realstrdE
                            * in this case we found "applyproc" which result in direct use on Luminance : Exposure, Color and Light, Shadows highlight, SoftLight, Localcontrast

                            * with second use of "buflight" on which is apply "applyproc", in this case we apply  realstrdE = reducdE * buflight with a function of type fli = (100.f + realstrdE) / 100.f;
                            * in this case we found "applyproc" which result in large variations of L : Retinex

                            * if you change you must test before

                    */

                    if (rL > 0.1f) { //to avoid crash with very low gamut in rare cases ex : L=0.01 a=0.5 b=-0.9
                        switch (zone) {
                            case 1: { // inside transition zone
                                float factorx = localFactor;
                                float diflc = 0.f;
                                float newhr = 0.f;
                                float difL = 0.f;

                                if (senstype == 2) {
                                    const float lightc = bufexporig->L[y - ystart][x - xstart];
                                    const float fli = (100.f + realstrdE) / 100.f;
                                    transformed->L[y][x] = CLIP(original->L[y][x] + (lightc * fli - original->L[y][x]) * factorx);
                                } else if (senstype == 6 || senstype == 8 || senstype == 10) {
                                    difL = (bufexporig->L[y - ystart][x - xstart] - original->L[y][x]) * localFactor * reducdE;
                                    transformed->L[y][x] = CLIP(original->L[y][x] + difL);
                                } else if (senstype == 1 || senstype == 0 || senstype == 9 || senstype == 3 || senstype == 30) {
                                    if (HHutili) {
                                        const float hhro = bufhh[y - ystart][x - xstart];

                                        if (hhro != 0) {
                                            const float realhhdE = reducdE * hhro;
                                            const float addh = 0.01f * realhhdE * factorx;
                                            newhr = rhue + addh;

                                            if (newhr > rtengine::RT_PI_F) {
                                                newhr -= 2 * rtengine::RT_PI_F;
                                            } else if (newhr < -rtengine::RT_PI_F) {
                                                newhr += 2 * rtengine::RT_PI_F;
                                            }
                                        }
                                    }

                                    transformed->L[y][x] = CLIP(original->L[y][x] + 328.f * factorx * realstrdE);
                                    diflc = 328.f * factorx * realstrdE;
                                }

                                if (senstype == 7) {
                                    float difab = bufexporig->L[y - ystart][x - xstart] - sqrt(SQR(original->a[y][x]) + SQR(original->b[y][x]));
                                    float2 sincosval = xsincosf(rhue);
                                    float difa = difab * sincosval.y;
                                    float difb = difab * sincosval.x;
                                    difa *= factorx * (100.f + realstrchdE) / 100.f;
                                    difb *= factorx * (100.f + realstrchdE) / 100.f;
                                    transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                                    transformed->b[y][x] = CLIPC(original->b[y][x] + difb);
                                } else {
                                    float flia = 1.f;
                                    float flib = 1.f;
                                    const float chra = bufexporig->a[y - ystart][x - xstart];
                                    const float chrb = bufexporig->b[y - ystart][x - xstart];

                                    if (senstype == 2 || senstype == 3 || senstype == 30 || senstype == 8 || senstype == 9 || senstype == 6 || senstype == 10) {

                                        flia = flib = ((100.f + realstrchdE) / 100.f);
                                    } else if (senstype == 1) {
                                        flia = (100.f + realstradE + 100.f * realstrchdE) / 100.f;
                                        flib = (100.f + realstrbdE + 100.f * realstrchdE) / 100.f;

                                        if (previewcol || previewexp || previewSH) {
                                            flia = (100.f + realstradE + realstrchdE) / 100.f;
                                            flib = (100.f + realstrbdE + realstrchdE) / 100.f;
                                        }
                                    } else if (senstype == 0) {
                                        flia = (100.f + 0.3f * lp.strengrid * realstradE + realstrchdE) / 100.f;
                                        flib = (100.f + 0.3f * lp.strengrid * realstrbdE + realstrchdE) / 100.f;

                                        if (previewcol || previewexp || previewSH  || previewcb) {
                                            flia = (100.f + realstradE + realstrchdE) / 100.f;
                                            flib = (100.f + realstrbdE + realstrchdE) / 100.f;
                                        }
                                    }

                                    float difa = chra * flia - original->a[y][x];
                                    float difb = chrb * flib - original->b[y][x];
                                    difa *= factorx;
                                    difb *= factorx;

                                    transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                                    transformed->b[y][x] = CLIPC(original->b[y][x] + difb);

                                    if (senstype == 0 && HHutili) {
                                        const float tempa = transformed->a[y][x];
                                        const float tempb = transformed->b[y][x];
                                        const float hhro = bufhh[y - ystart][x - xstart];

                                        if (hhro != 0.f) {
                                            const float chromhr = sqrt(SQR(original->a[y][x] + difa) + SQR(original->b[y][x] + difb));
                                            float epsia = 0.f;
                                            float epsib = 0.f;

                                            if (original->a[y][x] == 0.f) {
                                                epsia = 0.001f;
                                            }

                                            if (original->b[y][x] == 0.f) {
                                                epsib = 0.001f;
                                            }

                                            const float faca = (original->a[y][x] + difa) / (original->a[y][x] + epsia);
                                            const float facb = (original->b[y][x] + difb) / (original->b[y][x] + epsib);
                                            const float2 sincosval = xsincosf(newhr);

                                            transformed->a[y][x] = CLIPC(chromhr * sincosval.y * faca) ;
                                            transformed->b[y][x] = CLIPC(chromhr * sincosval.x * facb);
                                            difa = transformed->a[y][x] - tempa;
                                            difb = transformed->b[y][x] - tempb;
                                        }
                                    }

                                    if (expshow || colshow || SHshow) {
                                        transformed->L[y][x] = CLIP(12000.f + diflc);
                                        transformed->a[y][x] = CLIPC(difa);
                                        transformed->b[y][x] = CLIPC(difb);
                                    } else if (cbshow || tmshow) {
                                        transformed->L[y][x] = CLIP(12000.f + difL);
                                        transformed->a[y][x] = CLIPC(difa);
                                        transformed->b[y][x] = CLIPC(difb);
                                    } else if (previewcol || previewexp || previewSH  || previewcb  || previewtm) {
                                        transformed->a[y][x] = 0.f;
                                        transformed->b[y][x] = (difb);
                                    }
                                }

                                break;

                            }

                            case 2: { // inside selection => full effect, no transition
                                float diflc = 0.f;
                                float newhr = 0.f;
                                float difL = 0.f;

                                if (senstype == 2) {
                                    const float lightc = bufexporig->L[y - ystart][x - xstart];
                                    const float fli = (100.f + realstrdE) / 100.f;
                                    transformed->L[y][x] = CLIP(original->L[y][x] + lightc * fli - original->L[y][x]);
                                } else if (senstype == 6 || senstype == 8  || senstype == 10) {
                                    difL = (bufexporig->L[y - ystart][x - xstart] - original->L[y][x]) * reducdE;
                                    transformed->L[y][x] = CLIP(original->L[y][x] + difL);
                                } else if (senstype == 1 || senstype == 0 || senstype == 9 || senstype == 3 || senstype == 30) {
                                    if (HHutili) {
                                        const float hhro = bufhh[y - ystart][x - xstart];

                                        if (hhro != 0) {
                                            const float realhhdE = reducdE * hhro;
                                            const float addh = 0.01f * realhhdE;
                                            newhr = rhue + addh;

                                            if (newhr > rtengine::RT_PI_F) {
                                                newhr -= 2 * rtengine::RT_PI_F;
                                            } else if (newhr < -rtengine::RT_PI_F) {
                                                newhr += 2 * rtengine::RT_PI_F;
                                            }
                                        }
                                    }

                                    transformed->L[y][x] = CLIP(original->L[y][x] + 328.f * realstrdE);//kch fach
                                    diflc = 328.f * realstrdE;
                                }

                                if (senstype == 7) {//cbdl chroma
                                    float difab = bufexporig->L[y - ystart][x - xstart] - sqrt(SQR(original->a[y][x]) + SQR(original->b[y][x]));
                                    float2 sincosval = xsincosf(rhue);
                                    float difa = difab * sincosval.y;
                                    float difb = difab * sincosval.x;
                                    difa *= (100.f + realstrchdE) / 100.f;
                                    difb *= (100.f + realstrchdE) / 100.f;
                                    transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                                    transformed->b[y][x] = CLIPC(original->b[y][x] + difb);
                                } else {
                                    float flia = 1.f;
                                    float flib = 1.f;
                                    const float chra = bufexporig->a[y - ystart][x - xstart];
                                    const float chrb = bufexporig->b[y - ystart][x - xstart];

                                    if (senstype == 2 || senstype == 3 || senstype == 30 || senstype == 8 || senstype == 9 || senstype == 6 || senstype == 10) {
                                        flia = flib = (100.f + realstrchdE) / 100.f;
                                    } else if (senstype == 1) {
                                        flia = (100.f + realstradE + 100.f * realstrchdE) / 100.f;
                                        flib = (100.f + realstrbdE + 100.f * realstrchdE) / 100.f;

                                        if (previewcol || previewexp || previewSH) {
                                            flia = (100.f + realstradE + realstrchdE) / 100.f;
                                            flib = (100.f + realstrbdE + realstrchdE) / 100.f;
                                        }
                                    } else if (senstype == 0) {
                                        flia = (100.f + 0.3f * lp.strengrid * realstradE + realstrchdE) / 100.f;
                                        flib = (100.f + 0.3f * lp.strengrid * realstrbdE + realstrchdE) / 100.f;

                                        if (previewcol || previewexp || previewSH) {
                                            flia = (100.f + realstradE + realstrchdE) / 100.f;
                                            flib = (100.f + realstrbdE + realstrchdE) / 100.f;
                                        }
                                    }

                                    float difa = chra * flia - original->a[y][x];
                                    float difb = chrb * flib - original->b[y][x];

                                    transformed->a[y][x] = CLIPC(original->a[y][x] + difa);
                                    transformed->b[y][x] = CLIPC(original->b[y][x] + difb);

                                    if (senstype == 0 && HHutili) {
                                        const float tempa = transformed->a[y][x];
                                        const float tempb = transformed->b[y][x];
                                        const float hhro = bufhh[y - ystart][x - xstart];

                                        if (hhro != 0.f) {
                                            const float chromhr = sqrt(SQR(original->a[y][x] + difa) + SQR(original->b[y][x] + difb));
                                            float epsia = 0.f;
                                            float epsib = 0.f;

                                            if (original->a[y][x] == 0.f) {
                                                epsia = 0.001f;
                                            }

                                            if (original->b[y][x] == 0.f) {
                                                epsib = 0.001f;
                                            }

                                            const float faca = (original->a[y][x] + difa) / (original->a[y][x] + epsia);
                                            const float facb = (original->b[y][x] + difb) / (original->b[y][x] + epsib);

                                            const float2 sincosval = xsincosf(newhr);
                                            transformed->a[y][x] = CLIPC(chromhr * sincosval.y * faca) ;
                                            transformed->b[y][x] = CLIPC(chromhr * sincosval.x * facb);
                                            difa = transformed->a[y][x] - tempa;
                                            difb = transformed->b[y][x] - tempb;
                                        }
                                    }

                                    if (expshow || colshow || SHshow) {
                                        transformed->L[y][x] = CLIP(12000.f + diflc);
                                        transformed->a[y][x] = CLIPC(difa);
                                        transformed->b[y][x] = CLIPC(difb);
                                    } else if (cbshow || tmshow) {
                                        transformed->L[y][x] = CLIP(12000.f + difL);
                                        transformed->a[y][x] = CLIPC(difa);
                                        transformed->b[y][x] = CLIPC(difb);
                                    } else if (previewcol || previewexp || previewSH || previewcb || previewtm) {
                                        transformed->a[y][x] = 0.f;
                                        transformed->b[y][x] = difb;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

void ImProcFunctions::InverseColorLight_Local(int sp, int senstype,  struct local_params & lp, LabImage * originalmask, LUTf & lightCurveloc, LUTf & hltonecurveloc, LUTf & shtonecurveloc, LUTf & tonecurveloc, LUTf & exlocalcurve, LUTf & cclocalcurve, float adjustr, bool localcutili, LUTf & lllocalcurve, bool locallutili, LabImage * original, LabImage * transformed, int cx, int cy, const float hueref, const float chromaref, const float lumaref, int sk)
{
    // BENCHFUN
    float ach = (float)lp.trans / 100.f;
    const float facc = (100.f + lp.chro) / 100.f; //chroma factor transition
    float varsens = lp.sens;

    if (senstype == 0) { //Color and Light
        varsens =  lp.sens;
    }

    if (senstype == 1) { //exposure
        varsens =  lp.sensex;
    }

    if (senstype == 2) { //shadows highlight
        varsens =  lp.senshs;
    }

    LabImage *temp = nullptr;
    LabImage *tempCL = nullptr;

    int GW = transformed->W;
    int GH = transformed->H;
    float refa = chromaref * cos(hueref);
    float refb = chromaref * sin(hueref);

    if (senstype == 2) { // Shadows highlight
        temp = new LabImage(GW, GH);
#ifdef _OPENMP
        #pragma omp parallel for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            for (int x = 0; x < transformed->W; x++) {
                temp->L[y][x] = original->L[y][x];
                temp->a[y][x] = original->a[y][x];
                temp->b[y][x] = original->b[y][x];
            }
        }

        ImProcFunctions::shadowsHighlights(temp, lp.hsena, 1, lp.highlihs, lp.shadowhs, lp.radiushs, sk, lp.hltonalhs, lp.shtonalhs);
    }

    if (senstype == 1) { //exposure
        temp = new LabImage(GW, GH);
#ifdef _OPENMP
        #pragma omp parallel for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            for (int x = 0; x < transformed->W; x++) {
                temp->a[y][x] = original->a[y][x];
                temp->b[y][x] = original->b[y][x];
                temp->L[y][x] = original->L[y][x];
            }
        }

        float meanorig = 0.f;
        ImProcFunctions::exlabLocal(lp, GH, GW, original, temp, hltonecurveloc, shtonecurveloc, tonecurveloc, meanorig);

        if (exlocalcurve) {
#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < temp->H; y++) {
                for (int x = 0; x < temp->W; x++) {
                    float lighn =  temp->L[y][x];
                    float lh = 0.5f * exlocalcurve[2.f * lighn]; // / ((lighn) / 1.9f) / 3.61f; //lh between 0 and 0 50 or more
                    temp->L[y][x] = lh;
                }
            }
        }

        if (lp.expchroma != 0.f) {
            float ch;
            ch = (1.f + 0.02f * lp.expchroma) ;
            float chprosl;

            if (ch <= 1.f) {//convert data curve near values of slider -100 + 100, to be used after to detection shape
                chprosl = 99.f * ch - 99.f;
            } else {
                float ampli = 70.f;
                chprosl = CLIPCHRO(ampli * ch - ampli);  //ampli = 25.f arbitrary empirical coefficient between 5 and 50
            }

#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < transformed->H; y++) {
                for (int x = 0; x < transformed->W; x++) {
                    float epsi = 0.f;

                    if (original->L[y][x] == 0.f) {
                        epsi = 0.001f;
                    }

                    float rapexp = temp->L[y][x] / (original->L[y][x] + epsi);
                    temp->a[y][x] *= 0.01f * (100.f + 100.f * chprosl * rapexp);
                    temp->b[y][x] *= 0.01f * (100.f + 100.f * chprosl * rapexp);
                }
            }
        }

        if (lp.war != 0) {
            ImProcFunctions::ciecamloc_02float(sp, temp);
        }
    }

    if (senstype == 0) { //Color and Light curves L C
        tempCL = new LabImage(GW, GH);
#ifdef _OPENMP
        #pragma omp parallel for schedule(dynamic,16)
#endif

        for (int y = 0; y < tempCL->H; y++) {
            for (int x = 0; x < tempCL->W; x++) {
                tempCL->a[y][x] = original->a[y][x];
                tempCL->b[y][x] = original->b[y][x];
                tempCL->L[y][x] = original->L[y][x];
            }
        }

        if (cclocalcurve  && localcutili) { // C=f(C) curve
#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < transformed->H; y++) {
                for (int x = 0; x < transformed->W; x++) {
                    //same as in "normal"
                    float chromat = sqrt(SQR(original->a[y][x]) +  SQR(original->b[y][x]));
                    float ch;
                    float ampli = 25.f;
                    ch = (cclocalcurve[chromat * adjustr ])  / ((chromat + 0.00001f) * adjustr); //ch between 0 and 0 50 or more
                    float chprocu = CLIPCHRO(ampli * ch - ampli);  //ampli = 25.f arbitrary empirical coefficient between 5 and 50
                    tempCL->a[y][x] = original->a[y][x] * (1.f + 0.01f * (chprocu));
                    tempCL->b[y][x] = original->b[y][x] * (1.f + 0.01f * (chprocu));

                }
            }

        }

        if (lllocalcurve && locallutili) {
#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < transformed->H; y++) {
                for (int x = 0; x < transformed->W; x++) {
                    float lighn =  original->L[y][x];
                    float lh = 0.5f * lllocalcurve[2.f * lighn];
                    tempCL->L[y][x] = lh;
                }
            }
        }

    }

    //balance deltaE
    float kL = lp.balance;
    float kab = 1.f;
    balancedeltaE(kL, kab);

    std::unique_ptr<LabImage> origblur(new LabImage(GW, GH));
    std::unique_ptr<LabImage> origblurmask;
    const bool usemaskcol = (lp.enaColorMaskinv) && senstype == 0;
    const bool usemaskexp = (lp.enaExpMaskinv) && senstype == 1;
    const bool usemasksh = (lp.enaSHMaskinv) && senstype == 2;
    const bool usemaskall = (usemaskcol || usemaskexp || usemasksh);

    float radius = 3.f / sk;

    if (usemaskall) {
        origblurmask.reset(new LabImage(GW, GH));

#ifdef _OPENMP
        #pragma omp parallel if (multiThread)
#endif
        {
            gaussianBlur(originalmask->L, origblurmask->L, GW, GH, radius);
            gaussianBlur(originalmask->a, origblurmask->a, GW, GH, radius);
            gaussianBlur(originalmask->b, origblurmask->b, GW, GH, radius);
        }
    }

    if (senstype == 1) {
        radius = (2.f + 0.2f * lp.blurexp) / sk;
    }

    if (senstype == 0) {
        radius = (2.f + 0.2f * lp.blurcol) / sk;
    }

    if (senstype == 2) {
        radius = (2.f + 0.2f * lp.blurSH) / sk;
    }

#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
        gaussianBlur(original->L, origblur->L, GW, GH, radius);
        gaussianBlur(original->a, origblur->a, GW, GH, radius);
        gaussianBlur(original->b, origblur->b, GW, GH, radius);

    }

#ifdef _OPENMP
    #pragma omp parallel if (multiThread)
#endif
    {
        const LabImage *maskptr = usemaskall ? origblurmask.get() : origblur.get();
        const int limscope = 80;
        const float mindE = 2.f + MINSCOPE * varsens * lp.thr;
        const float maxdE = 5.f + MAXSCOPE * varsens * (1 + 0.1f * lp.thr);
        const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
        const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);

#ifdef _OPENMP
        #pragma omp for schedule(dynamic,16)
#endif

        for (int y = 0; y < transformed->H; y++) {
            const int loy = cy + y;

            for (int x = 0; x < transformed->W; x++) {
                const int lox = cx + x;
                int zone = 0;

                float localFactor = 1.f;

                if (lp.shapmet == 0) {
                    calcTransition(lox, loy, ach, lp, zone, localFactor);
                } else if (lp.shapmet == 1) {
                    calcTransitionrect(lox, loy, ach, lp, zone, localFactor);//rect not good
                }

                float rL = origblur->L[y][x] / 327.68f;

                if (fabs(origblur->b[y][x]) < 0.01f) {
                    origblur->b[y][x] = 0.01f;
                }

                //  float dE = sqrt(kab * SQR(refa - origblur->a[y][x] / 327.68f) + kab * SQR(refb - origblur->b[y][x] / 327.68f) + kL * SQR(lumaref - rL));
                float dE = sqrt(kab * SQR(refa - maskptr->a[y][x] / 327.68f) + kab * SQR(refb - maskptr->b[y][x] / 327.68f) + kL * SQR(lumaref - maskptr->L[y][x] / 327.68f));

                float reducdE = 0.f;
                calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, varsens, reducdE);
                float th_r = 0.01f;

                if (rL > th_r) { //to avoid crash with very low gamut in rare cases ex : L=0.01 a=0.5 b=-0.9

                    switch (zone) {
                        case 2: { // outside selection and outside transition zone => no effect, keep original values
                            transformed->L[y][x] = original->L[y][x];
                            transformed->a[y][x] = original->a[y][x];
                            transformed->b[y][x] = original->b[y][x];
                            break;
                        }

                        case 1: { // inside transition zone
                            float difa = 0.f;
                            float difb = 0.f;
                            float factorx = 1.f - localFactor;

                            if (senstype == 0) {
                                float epsia = 0.f;
                                float epsib = 0.f;
                                float lumnew = original->L[y][x];
                                float difL = (tempCL->L[y][x] - original->L[y][x]) * reducdE;
                                difa = (tempCL->a[y][x] - original->a[y][x]) * reducdE;
                                difb = (tempCL->b[y][x] - original->b[y][x]) * reducdE;
                                difL *= factorx;
                                difa *= factorx;
                                difb *= factorx;

                                if (original->a[y][x] == 0.f) {
                                    epsia = 0.0001f;
                                }

                                if (original->b[y][x] == 0.f) {
                                    epsib = 0.0001f;
                                }

                                float facCa = 1.f + (difa / (original->a[y][x] + epsia));
                                float facCb = 1.f + (difb / (original->b[y][x] + epsib));

                                if (lp.sens < 75.f) {
                                    float lightcont;

                                    if ((lp.ligh != 0.f || lp.cont != 0)) {
                                        calclight(lumnew, lp.ligh, lumnew, lightCurveloc);  //replace L-curve
                                        lightcont = lumnew;

                                    } else {
                                        lightcont = lumnew;
                                    }

                                    float fac = (100.f + factorx * lp.chro * reducdE) / 100.f; //chroma factor transition
                                    float diflc = (lightcont - original->L[y][x]) * reducdE;

                                    diflc *= factorx; //transition lightness
                                    transformed->L[y][x] = CLIP(1.f * (original->L[y][x] + diflc + difL));

                                    transformed->a[y][x] = CLIPC(original->a[y][x] * fac * facCa) ;
                                    transformed->b[y][x] = CLIPC(original->b[y][x] * fac * facCb);
                                } else {
                                    float fac = (100.f + factorx * lp.chro) / 100.f; //chroma factor transition

                                    if ((lp.ligh != 0.f || lp.cont != 0)) {
                                        calclight(original->L[y][x], lp.ligh, lumnew, lightCurveloc);
                                    }

                                    float lightcont = lumnew ; //apply lightness

                                    float diflc = lightcont - original->L[y][x];
                                    diflc *= factorx;
                                    transformed->L[y][x] = CLIP(original->L[y][x] + diflc + difL);
                                    transformed->a[y][x] = CLIPC(original->a[y][x] * fac * facCa);
                                    transformed->b[y][x] = CLIPC(original->b[y][x] * fac * facCb);


                                }
                            } else if (senstype == 1 || senstype == 2) {
                                float diflc = (temp->L[y][x] - original->L[y][x]) * reducdE;
                                diflc *= factorx;
                                difa = (temp->a[y][x] - original->a[y][x]) * reducdE;
                                difb = (temp->b[y][x] - original->b[y][x]) * reducdE;
                                difa *= factorx;
                                difb *= factorx;
                                transformed->L[y][x] = CLIP(original->L[y][x] + diflc);
                                transformed->a[y][x] = CLIPC(original->a[y][x] + difa) ;
                                transformed->b[y][x] = CLIPC(original->b[y][x] + difb);

                            }

                            break;
                        }

                        case 0: { // inside selection => full effect, no transition
                            float diflc = 0.f;
                            float difa = 0.f;
                            float difb = 0.f;

                            if (senstype == 0) {
                                float epsia = 0.f;
                                float epsib = 0.f;
                                float lumnew = original->L[y][x];
                                float difL = (tempCL->L[y][x] - original->L[y][x]) * reducdE;
                                difa = (tempCL->a[y][x] - original->a[y][x]) * reducdE;
                                difb = (tempCL->b[y][x] - original->b[y][x]) * reducdE;

                                if (original->a[y][x] == 0.f) {
                                    epsia = 0.0001f;
                                }

                                if (original->b[y][x] == 0.f) {
                                    epsib = 0.0001f;
                                }

                                float facCa = 1.f + (difa / (original->a[y][x] + epsia));
                                float facCb = 1.f + (difb / (original->b[y][x] + epsib));

                                if (lp.sens < 75.f) {

                                    float lightcont;

                                    if ((lp.ligh != 0.f || lp.cont != 0)) {
                                        calclight(lumnew, lp.ligh, lumnew, lightCurveloc);  //replace L-curve
                                        lightcont = lumnew;

                                    } else {
                                        lightcont = lumnew;
                                    }

                                    float fac = (100.f + lp.chro * reducdE) / 100.f; //chroma factor transition
                                    diflc = (lightcont - original->L[y][x]) * reducdE;

                                    transformed->L[y][x] = CLIP(1.f * (original->L[y][x] + diflc + difL));

                                    transformed->a[y][x] = CLIPC(original->a[y][x] * fac * facCa) ;
                                    transformed->b[y][x] = CLIPC(original->b[y][x] * fac * facCb);


                                } else {
                                    if ((lp.ligh != 0.f || lp.cont != 0)) {
                                        calclight(original->L[y][x], lp.ligh, lumnew, lightCurveloc);
                                    }

                                    float lightcont = lumnew ;
                                    transformed->L[y][x] = CLIP(lightcont + difL) ;
                                    transformed->a[y][x] = CLIPC(original->a[y][x] * facc * facCa);
                                    transformed->b[y][x] = CLIPC(original->b[y][x] * facc * facCb);

                                }
                            } else if (senstype == 1  || senstype == 2) {
                                diflc = (temp->L[y][x] - original->L[y][x]) * reducdE;
                                difa = (temp->a[y][x] - original->a[y][x]) * reducdE;
                                difb = (temp->b[y][x] - original->b[y][x]) * reducdE;
                                transformed->L[y][x] = CLIP(original->L[y][x] + diflc);
                                transformed->a[y][x] = CLIPC(original->a[y][x] + difa) ;
                                transformed->b[y][x] = CLIPC(original->b[y][x] + difb);
                            }

                        }
                    }

                }

            }
        }
    }

    if (senstype == 1 || senstype == 2) {
        delete temp;
    }

    if (senstype == 0) {
        delete tempCL;
    }

}

void ImProcFunctions::calc_ref(int sp, LabImage * original, LabImage * transformed, int cx, int cy, int oW, int oH, int sk, double & huerefblur, double & chromarefblur, double & lumarefblur, double & hueref, double & chromaref, double & lumaref, double & sobelref, float & avg)
{
    if (params->locallab.enabled) {
        //always calculate hueref, chromaref, lumaref  before others operations use in normal mode for all modules exceprt denoise
        struct local_params lp;
        calcLocalParams(sp, oW, oH, params->locallab, lp, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        int begy = lp.yc - lp.lyT;
        int begx = lp.xc - lp.lxL;
        int yEn = lp.yc + lp.ly;
        int xEn = lp.xc + lp.lx;
        float avg2 = 0.f;
        int nc2 = 0;

        for (int y = 0; y < transformed->H ; y++) //{
            for (int x = 0; x < transformed->W; x++) {
                int lox = cx + x;
                int loy = cy + y;

                if (lox >= begx && lox < xEn && loy >= begy && loy < yEn) {
                    avg2 += original->L[y][x];
                    nc2++;
                }
            }

        avg2 /= 32768.f;
        avg = avg2 / nc2;
// double precision for large summations
        double aveA = 0.;
        double aveB = 0.;
        double aveL = 0.;
        double aveChro = 0.;
        double aveAblur = 0.;
        double aveBblur = 0.;
        double aveLblur = 0.;
        double aveChroblur = 0.;

        double avesobel = 0.;
// int precision for the counters
        int nab = 0;
        int nso = 0;
        int nsb = 0;
// single precision for the result
        float avA, avB, avL;
        int spotSize = 0.88623f * max(1,  lp.cir / sk);  //18
        //O.88623 = sqrt(PI / 4) ==> sqare equal to circle
        int spotSise2; // = 0.88623f * max (1,  lp.cir / sk); //18

        // very small region, don't use omp here
        LabImage *sobelL;
        LabImage *deltasobelL;
        LabImage *origsob;
        LabImage *origblur = nullptr;
        LabImage *blurorig = nullptr;

        int spotSi = 1 + 2 * max(1,  lp.cir / sk);

        if (spotSi < 5) {
            spotSi = 5;
        }

        spotSise2 = (spotSi - 1) / 2;

        JaggedArray<float> blend3(spotSi, spotSi);

        origsob = new LabImage(spotSi, spotSi);
        sobelL = new LabImage(spotSi, spotSi);
        deltasobelL = new LabImage(spotSi, spotSi);
        bool isdenoise = false;

        if ((lp.noiself > 0.f || lp.noiself0 > 0.f || lp.noiself2 > 0.f || lp.noiselc > 0.f || lp.noisecf > 0.f || lp.noisecc > 0.f) && lp.denoiena) {
            isdenoise = true;
        }

        if (isdenoise) {
            origblur = new LabImage(spotSi, spotSi);
            blurorig = new LabImage(spotSi, spotSi);

            for (int y = max(cy, (int)(lp.yc - spotSise2)); y < min(transformed->H + cy, (int)(lp.yc + spotSise2 + 1)); y++) {
                for (int x = max(cx, (int)(lp.xc - spotSise2)); x < min(transformed->W + cx, (int)(lp.xc + spotSise2 + 1)); x++) {
                    int yb = max(cy, (int)(lp.yc - spotSise2));

                    int xb = max(cx, (int)(lp.xc - spotSise2));

                    int z = y - yb;
                    int u = x - xb;
                    origblur->L[z][u] = original->L[y - cy][x - cx];
                    origblur->a[z][u] = original->a[y - cy][x - cx];
                    origblur->b[z][u] = original->b[y - cy][x - cx];

                }
            }

            float radius = 3.f / sk;
            {
                //No omp
                gaussianBlur(origblur->L, blurorig->L, spotSi, spotSi, radius);
                gaussianBlur(origblur->a, blurorig->a, spotSi, spotSi, radius);
                gaussianBlur(origblur->b, blurorig->b, spotSi, spotSi, radius);

            }

            for (int y = 0; y < spotSi; y++) {
                for (int x = 0; x < spotSi; x++) {
                    aveLblur += blurorig->L[y][x];
                    aveAblur += blurorig->a[y][x];
                    aveBblur += blurorig->b[y][x];
                    aveChroblur += sqrtf(SQR(blurorig->b[y - cy][x - cx]) + SQR(blurorig->a[y - cy][x - cx]));
                    nsb++;

                }
            }
        }

        //ref for luma, chroma, hue
        for (int y = max(cy, (int)(lp.yc - spotSize)); y < min(transformed->H + cy, (int)(lp.yc + spotSize + 1)); y++) {
            for (int x = max(cx, (int)(lp.xc - spotSize)); x < min(transformed->W + cx, (int)(lp.xc + spotSize + 1)); x++) {
                aveL += original->L[y - cy][x - cx];
                aveA += original->a[y - cy][x - cx];
                aveB += original->b[y - cy][x - cx];
                aveChro += sqrtf(SQR(original->b[y - cy][x - cx]) + SQR(original->a[y - cy][x - cx]));
                nab++;
            }
        }

        //ref for sobel
        for (int y = max(cy, (int)(lp.yc - spotSise2)); y < min(transformed->H + cy, (int)(lp.yc + spotSise2 + 1)); y++) {
            for (int x = max(cx, (int)(lp.xc - spotSise2)); x < min(transformed->W + cx, (int)(lp.xc + spotSise2 + 1)); x++) {
                int yb = max(cy, (int)(lp.yc - spotSise2));

                int xb = max(cx, (int)(lp.xc - spotSise2));

                int z = y - yb;
                int u = x - xb;
                origsob->L[z][u] = original->L[y - cy][x - cx];
                nso++;
            }
        }

        const float radius = 3.f / (sk * 1.4f); //0 to 70 ==> see skip

        SobelCannyLuma(sobelL->L, origsob->L, spotSi, spotSi, radius);
        int nbs = 0;

        for (int y = 0; y < spotSi ; y ++)
            for (int x = 0; x < spotSi ; x ++) {
                avesobel += sobelL->L[y][x];
                nbs++;
            }

        sobelref = avesobel / nbs;

        delete sobelL;

        delete deltasobelL;
        delete origsob;
        aveL = aveL / nab;
        aveA = aveA / nab;
        aveB = aveB / nab;
        aveChro = aveChro / nab;
        aveChro /= 327.68f;
        avA = aveA / 327.68f;
        avB = aveB / 327.68f;
        avL = aveL / 327.68f;
        hueref = xatan2f(avB, avA);    //mean hue

        if (isdenoise) {
            aveLblur = aveLblur / nsb;
            aveChroblur = aveChroblur / nsb;
            aveChroblur /= 327.68f;
            aveAblur = aveAblur / nsb;
            aveBblur = aveBblur / nsb;
            float avAblur = aveAblur / 327.68f;
            float avBblur = aveBblur / 327.68f;
            float avLblur = aveLblur / 327.68f;
            huerefblur = xatan2f(avBblur, avAblur);
            chromarefblur = aveChroblur;
            lumarefblur = avLblur;
        } else {
            huerefblur = 0.f;
            chromarefblur = 0.f;
            lumarefblur = 0.f;
        }

        chromaref = aveChro;
        lumaref = avL;

        //  printf("Calcref => sp=%i befend=%i huere=%2.1f chromare=%2.1f lumare=%2.1f sobelref=%2.1f\n", sp, befend, hueref, chromaref, lumaref, sobelref / 100.f);

        if (isdenoise) {
            delete origblur;
            delete blurorig;
        }

        if (lumaref > 95.f) {//to avoid crash
            lumaref = 95.f;
        }
    }
}
//doc fftw3 says optimum is with size 2^a * 3^b * 5^c * 7^d * 11^e * 13^f with e+f = 0 or 1
//number for size between 18144 and 1 ==> 18000 pixels cover 99% all sensor
const int fftw_size[] = {18144, 18000, 17920, 17836, 17820, 17640, 17600, 17550, 17500, 17496, 17472, 17325, 17280, 17248, 17199, 17150, 17010, 16896, 16875, 16848, 16807,
                         16800, 16640, 16632, 16500, 16464, 16384, 16380, 16250, 16200, 16170, 16128, 16038, 16000, 15925, 15876, 15840, 15795, 15750, 15680, 15625, 15600, 15552, 15435, 15400,
                         15360, 15309, 15288, 15120, 15092, 15000, 14976, 14850, 14784, 14742, 14700, 14625, 14580, 14560, 14553, 14336, 14406, 14400, 14256, 14175, 14112, 14080, 14040, 14000, 13860,
                         13824, 13750, 13720, 13650, 13608, 13500, 13475, 13440, 13377, 13365, 13312, 13230, 13200, 13125, 13122, 13104, 13000, 12960, 12936, 12800, 12740, 12672, 12636, 12600,
                         12544, 12500, 12480, 12474, 12375, 12348, 12320, 12288, 12285, 12250, 12150, 12096, 12005, 12000, 11907, 11880, 11760, 11700, 11664, 11648, 11550, 11520, 11466, 11375,
                         11340, 11319, 11264, 11250, 11232, 11200, 11088, 11025, 11000, 10976, 10935, 10920, 10800, 10780, 10752, 10692, 10584, 10560, 10530, 10400, 10395,  10368, 10290, 10240,
                         10206, 10192, 10125, 10080, 10000, 9984, 9900, 9604, 9856, 9828, 9800, 9750, 9720, 9702, 9625, 9600, 9555, 9504, 9477, 9450, 9408, 9375, 9360, 9261, 9240,
                         9216, 9100, 9072, 9000, 8960, 8918, 8910, 8820, 8800, 8775, 8750, 8748, 8736, 8640, 8624, 8575, 8505, 8448, 8424, 8400, 8320, 8316, 8250, 8232, 8192, 8190, 8125,
                         8100, 8085, 8064, 8019, 8000, 7938, 7920, 7875, 7840, 7800, 7776, 7700, 7680, 7644, 7560, 7546, 7500, 7488, 7425, 7392, 7371, 7350, 7290, 7280, 7203, 7200, 7168,
                         7128, 7056, 7040, 7020, 7000, 6930, 6912, 6875, 6860, 6825, 6804, 6750, 6720, 6656, 6615, 6600, 6561, 6552, 6500, 6480, 6468, 6400, 6370, 6336, 6318, 6300,
                         6272, 6250, 6240, 6237, 6174, 6160, 6144, 6125, 6075, 6048, 6000, 5940, 5880, 5850, 5832, 5824, 5775, 5760, 5670, 5632, 5625, 5616, 5600, 5544, 5500, 5488,
                         5460, 5400, 5390, 5376, 5346, 5292, 5280, 5265, 5250, 5200, 5184, 5145, 5120, 5103, 5096, 5040, 5000, 4992, 4950, 4928, 4914, 4900, 4875, 4860, 4851,  4802,
                         4800, 4752, 4725, 4704, 4680, 4620, 4608, 4550, 4536, 4500, 4480, 4459, 4455, 4410, 4400, 4375, 4374, 4368, 4320, 4312, 4224, 4212, 4200, 4160, 4158, 4125,
                         4116, 4096, 4095, 4050, 4032, 4000, 3969, 3960, 3920, 3900, 3888, 3850, 3840, 3822, 3780, 3773, 3750, 3744, 3696, 3675, 3645, 3640, 3600, 3584, 3564, 3528,
                         3520, 3510, 3500, 3465, 3456, 3430, 3402, 3375, 3360, 3328, 3300, 3276, 3250, 3240, 3234, 3200, 3185, 3168, 3159, 3150, 3136, 3125, 3120, 3087, 3080, 3072,
                         3024, 3000, 2970, 2940, 2925, 2916, 2912, 2880, 2835, 2816, 2808, 2800, 2772, 2750, 2744, 2730, 2700, 2695, 2688, 2673, 2646, 2640, 2625, 2600, 2592, 2560,
                         2548, 2520, 2500, 2496, 2475, 2464, 2457, 2450, 2430, 2401, 2400, 2376, 2352, 2340, 2310, 2304, 2275, 2268, 2250, 2240, 2205, 2200, 2187, 2184, 2160, 2156,
                         2112, 2106, 2100, 2080, 2079, 2058, 2048, 2025, 2016, 2000, 1980, 1960, 1950, 1944, 1936, 1925, 1920, 1911, 1890, 1875, 1872, 1848, 1820, 1800, 1792, 1782,
                         1764, 1760, 1755, 1750, 1728, 1715, 1701, 1680, 1664, 1650, 1638, 1625, 1620, 1617, 1600, 1584, 1575, 1568, 1560, 1540, 1536, 1512, 1500, 1485, 1470, 1458,
                         1456, 1440, 1408, 1404, 1400, 1386, 1375, 1372, 1365, 1350, 1344, 1323, 1320, 1300, 1296, 1280, 1274, 1260, 1250, 1248, 1232, 1225, 1215, 1200, 1188, 1176,
                         1170, 1155, 1152, 1134, 1125, 1120, 1100, 1092, 1080, 1078, 1056, 1053, 1050, 1040, 1029, 1024, 1008, 1000, 990, 980, 975, 972, 960, 945, 936, 924, 910, 900,
                         896, 891, 882, 880, 875, 864, 840, 832, 825, 819, 810, 800, 792, 784, 780, 770, 768, 756, 750, 735, 729, 728, 720, 704, 702, 700, 693, 686, 675, 672, 660,
                         650, 648, 640, 637, 630, 625, 624, 616, 600, 594, 588, 585, 576, 567, 560, 550, 546, 540, 539, 528, 525, 520, 512, 504, 500, 495, 490, 486, 480, 468, 462, 455,
                         450, 448, 441, 440, 432, 420, 416, 405, 400, 396, 392, 390, 385, 384, 378, 375, 364, 360, 352, 351, 350, 343, 336, 330, 325, 324, 320, 315, 312, 308, 300, 297,
                         294, 288, 280, 275, 273, 270, 264, 260, 256, 252, 250, 245, 243, 240, 234, 231, 225, 224, 220, 216, 210, 208, 200, 198, 196, 195, 192, 189, 182, 180, 176, 175,
                         168, 165, 162, 160, 156, 154, 150, 147, 144, 143, 140, 135, 132, 130, 128, 126, 125, 120, 117, 112, 110, 108, 105, 104, 100, 99, 98, 96, 91, 90, 88, 84, 81,
                         80, 78, 77, 75, 72, 70, 66, 65, 64, 63, 60, 56, 55, 54, 52, 50, 49, 48, 45, 44, 42, 40, 39, 36, 35, 33, 32, 30, 28, 27, 26, 25, 24, 22, 21, 20, 18, 16, 15,
                         14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
                        };

int N_fftwsize = sizeof(fftw_size) / sizeof(fftw_size[0]);







void ImProcFunctions::exposure_pde(float * dataor, float * datain, float * dataout, int bfw, int bfh, float thresh, float mod)
/* Jacques Desmis July 2019
** adapted from Ipol Copyright 2009-2011 IPOL Image Processing On Line http://www.ipol.im/
*/
{

    BENCHFUN
#ifdef _OPENMP

    if (multiThread) {
        fftwf_init_threads();
        fftwf_plan_with_nthreads(omp_get_max_threads());
    }

#endif
    fftwf_plan dct_fw, dct_bw;
    float *data_fft, *data_tmp, *data;

    if (NULL == (data_tmp = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    ImProcFunctions::discrete_laplacian_threshold(data_tmp, datain, bfw, bfh, thresh);

    if (NULL == (data_fft = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    if (NULL == (data = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    dct_fw = fftwf_plan_r2r_2d(bfh, bfw, data_tmp, data_fft, FFTW_REDFT10, FFTW_REDFT10, FFTW_ESTIMATE | FFTW_DESTROY_INPUT);
    fftwf_execute(dct_fw);

    fftwf_free(data_tmp);

    /* solve the Poisson PDE in Fourier space */
    /* 1. / (float) (bfw * bfh)) is the DCT normalisation term, see libfftw */
    ImProcFunctions::rex_poisson_dct(data_fft, bfw, bfh, 1. / (double)(bfw * bfh));

    dct_bw = fftwf_plan_r2r_2d(bfh, bfw, data_fft, data, FFTW_REDFT01, FFTW_REDFT01, FFTW_ESTIMATE | FFTW_DESTROY_INPUT);
    fftwf_execute(dct_bw);
    fftwf_destroy_plan(dct_fw);
    fftwf_destroy_plan(dct_bw);
    fftwf_free(data_fft);
    fftwf_cleanup();

    if (multiThread) {
        fftwf_cleanup_threads();
    }

    normalize_mean_dt(data, dataor, bfw * bfh, mod);
    {

#ifdef _OPENMP
        #pragma omp parallel for
#endif

        for (int y = 0; y < bfh ; y++) {
            for (int x = 0; x < bfw; x++) {
                dataout[y * bfw + x]   = CLIPLOC(data[y * bfw + x]);
            }
        }
    }
}


void ImProcFunctions::fftw_convol_blur(float * input, float * output, int bfw, int bfh, float radius, int fftkern, int algo)
{
    /*
        ** Jacques Desmis june 2019 - inspired by Copyright 2013 IPOL Image Processing On Line http://www.ipol.im/
        ** when I read documentation on various FFT blur we found 2 possibilities
        ** 0) kernel gauss is used with "normal" datas
        ** 1) kernel gauss is used with FFT
        ** fftkern allows to change 0) or 1) and test  It seems the good solution is with 0, but I keep the code in case of ??

        ** input real datas to blur
        ** output real datas blurred with radius
        ** bfw bfh width and high area
        ** radius = sigma for kernel
        ** n_x n_y relative width and high for kernel
        ** Gaussian blur is given by G(x,y) = (1/2*PI*sigma) * exp(-(x2 + y2) / 2* sigma2)
        ** its traduction in Fourier transform is G(x,y) =  exp((-sigma)*(PI * x2 + PI * y2)), for some authors it is not sigma but sigma^2..I have tried...huge diffrences with Gaussianblur
        ** after several test the only result that works very well is with fftkern = 0 and algo = 0, and as there is differences with Gaussianblur, I put an empirical correction in Ipretinex and Iplocalcontrast
        ** you can enabled or disabled this function with rtsettings.fftwsigma in options. By defaut empirical formula is disabled
        ** in fact no importance....if it is this function (for sigma) or another... we are not in research :)
    */
    BENCHFUN

#ifdef _OPENMP

    if (multiThread) {
        fftwf_init_threads();
        fftwf_plan_with_nthreads(omp_get_max_threads());
    }

#endif


    float *out; //for FFT datas
    float *kern = nullptr;//for kernel gauss
    float *outkern = nullptr;//for FFT kernel
    fftwf_plan p;
    fftwf_plan pkern;//plan for FFT
    int image_size, image_sizechange;
    float n_x = 1.f;
    float n_y = 1.f;//relative coordonates for kernel Gauss
    float radsig = 1.f;

    out = (float*) fftwf_malloc(sizeof(float) * (bfw * bfh));//allocate real datas for FFT

    if (fftkern == 1) { //allocate memory FFT if kernel fft = 1
        kern = new float[bfw * bfh];
        outkern = (float*) fftwf_malloc(sizeof(float) * (bfw * bfh));//allocate real datas for FFT
    }

    /*compute the Fourier transform of the input data*/

    p = fftwf_plan_r2r_2d(bfh, bfw, input, out, FFTW_REDFT10, FFTW_REDFT10,  FFTW_ESTIMATE);//FFT 2 dimensions forward  FFTW_MEASURE FFTW_ESTIMATE

    fftwf_execute(p);
    fftwf_destroy_plan(p);

    /*define the gaussian constants for the convolution kernel*/
    if (algo == 0) {
        n_x = rtengine::RT_PI / (double) bfw; //ipol
        n_y = rtengine::RT_PI / (double) bfh;
    } else if (algo == 1) {
        n_x = 1.f / (float) bfw; //gauss
        n_y = 1.f / (float) bfh;
        radsig = 1.f / (2.f * rtengine::RT_PI * radius * radius);//gauss
    }

    n_x = n_x * n_x;
    n_y = n_y * n_y;

    image_size = bfw * bfh;
    image_sizechange = 4 * image_size;

    if (fftkern == 1) { //convolution with FFT kernel
#ifdef _OPENMP
        #pragma omp parallel for
#endif

        for (int j = 0; j < bfh; j++) {
            int index = j * bfw;

            for (int i = 0; i < bfw; i++)
                if (algo == 0) {
                    kern[ i + index] = exp((float)(-radius) * (n_x * i * i + n_y * j * j)); //calculate Gauss kernel Ipol formula
                } else if (algo == 1) {
                    kern[ i + index] = radsig * exp((float)(-(n_x * i * i + n_y * j * j) / (2.f * radius * radius))); //calculate Gauss kernel  with Gauss formula
                }
        }

        /*compute the Fourier transform of the kernel data*/
        pkern = fftwf_plan_r2r_2d(bfh, bfw, kern, outkern, FFTW_REDFT10, FFTW_REDFT10, FFTW_ESTIMATE); //FFT 2 dimensions forward
        fftwf_execute(pkern);
        fftwf_destroy_plan(pkern);

#ifdef _OPENMP
        #pragma omp parallel for
#endif

        for (int j = 0; j < bfh; j++) {
            int index = j * bfw;

            for (int i = 0; i < bfw; i++) {
                out[i + index] *= outkern[i + index];    //apply Gauss kernel whith FFT
            }
        }

        fftwf_free(outkern);
        delete [] kern;

    } else if (fftkern == 0) {//whithout FFT kernel
        if (algo == 0) {
#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int j = 0; j < bfh; j++) {
                int index = j * bfw;

                for (int i = 0; i < bfw; i++) {
                    out[i + index] *= exp((float)(-radius) * (n_x * i * i + n_y * j * j));    //apply Gauss kernel whithout FFT - some authors says radius*radius but differences with Gaussianblur
                }
            }
        } else if (algo == 1) {
#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int j = 0; j < bfh; j++) {
                int index = j * bfw;

                for (int i = 0; i < bfw; i++) {
                    out[i + index] *= radsig * exp((float)(-(n_x * i * i + n_y * j * j) / (2.f * radius * radius)));    //calculate Gauss kernel  with Gauss formula
                }
            }
        }
    }

    p = fftwf_plan_r2r_2d(bfh, bfw, out, output, FFTW_REDFT01, FFTW_REDFT01, FFTW_ESTIMATE);//FFT 2 dimensions backward
    fftwf_execute(p);

    for (int index = 0; index < image_size; index++) { //restore datas
        output[index] /= image_sizechange;
        // output[index] = CLIPMAX(output[index]);
    }

    fftwf_destroy_plan(p);
    fftwf_free(out);

    if (multiThread) {
        fftwf_cleanup_threads();
    }
}

void ImProcFunctions::fftw_convol_blur2(float **input2, float **output2, int bfw, int bfh, float radius, int fftkern, int algo)
{
    MyMutex::MyLock lock(*fftwMutex);

    float *input = nullptr;

    if (NULL == (input = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

    float *output = nullptr;

    if (NULL == (output = (float *) fftwf_malloc(sizeof(float) * bfw * bfh))) {
        fprintf(stderr, "allocation error\n");
        abort();
    }

#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic,16)
#endif

    for (int y = 0; y < bfh; y++) {
        for (int x = 0; x < bfw; x++) {
            input[y * bfw + x] =  input2[y][x];
        }
    }

    ImProcFunctions::fftw_convol_blur(input, output, bfw, bfh, radius, fftkern, algo);

#ifdef _OPENMP
    #pragma omp parallel for schedule(dynamic,16)
#endif

    for (int y = 0; y < bfh; y++) {
        for (int x = 0; x < bfw; x++) {
            output2[y][x] = output[y * bfw + x];
        }
    }

    fftwf_free(input);
    fftwf_free(output);

}


void ImProcFunctions::fftw_tile_blur(int GW, int GH, int tilssize, int max_numblox_W, int min_numblox_W, float **tmp1, int numThreads, double radius)
{
    BENCHFUN
    float epsil = 0.001f / (tilssize * tilssize);
    fftwf_plan plan_forward_blox[2];
    fftwf_plan plan_backward_blox[2];

    array2D<float> tilemask_in(tilssize, tilssize);
    array2D<float> tilemask_out(tilssize, tilssize);

    float *Lbloxtmp  = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * tilssize * tilssize * sizeof(float)));
    float *fLbloxtmp = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * tilssize * tilssize * sizeof(float)));

    int nfwd[2] = {tilssize, tilssize};

    //for DCT:
    fftw_r2r_kind fwdkind[2] = {FFTW_REDFT10, FFTW_REDFT10};
    fftw_r2r_kind bwdkind[2] = {FFTW_REDFT01, FFTW_REDFT01};

    // Creating the plans with FFTW_MEASURE instead of FFTW_ESTIMATE speeds up the execute a bit
    plan_forward_blox[0]  = fftwf_plan_many_r2r(2, nfwd, max_numblox_W, Lbloxtmp, nullptr, 1, tilssize * tilssize, fLbloxtmp, nullptr, 1, tilssize * tilssize, fwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    plan_backward_blox[0] = fftwf_plan_many_r2r(2, nfwd, max_numblox_W, fLbloxtmp, nullptr, 1, tilssize * tilssize, Lbloxtmp, nullptr, 1, tilssize * tilssize, bwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    plan_forward_blox[1]  = fftwf_plan_many_r2r(2, nfwd, min_numblox_W, Lbloxtmp, nullptr, 1, tilssize * tilssize, fLbloxtmp, nullptr, 1, tilssize * tilssize, fwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    plan_backward_blox[1] = fftwf_plan_many_r2r(2, nfwd, min_numblox_W, fLbloxtmp, nullptr, 1, tilssize * tilssize, Lbloxtmp, nullptr, 1, tilssize * tilssize, bwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    fftwf_free(Lbloxtmp);
    fftwf_free(fLbloxtmp);
    const int border = MAX(2, tilssize / 16);

    for (int i = 0; i < tilssize; ++i) {
        float i1 = abs((i > tilssize / 2 ? i - tilssize + 1 : i));
        float vmask = (i1 < border ? SQR(sin((rtengine::RT_PI_F * i1) / (2 * border))) : 1.0f);
        float vmask2 = (i1 < 2 * border ? SQR(sin((rtengine::RT_PI_F * i1) / (2 * border))) : 1.0f);

        for (int j = 0; j < tilssize; ++j) {
            float j1 = abs((j > tilssize / 2 ? j - tilssize + 1 : j));
            tilemask_in[i][j] = (vmask * (j1 < border ? SQR(sin((rtengine::RT_PI_F * j1) / (2 * border))) : 1.0f)) + epsil;
            tilemask_out[i][j] = (vmask2 * (j1 < 2 * border ? SQR(sin((rtengine::RT_PI_F * j1) / (2 * border))) : 1.0f)) + epsil;

        }
    }

    float *LbloxArray[numThreads];
    float *fLbloxArray[numThreads];

    const int numblox_W = ceil((static_cast<float>(GW)) / (offset2)) + 2 * blkrad;
    const int numblox_H = ceil((static_cast<float>(GH)) / (offset2)) + 2 * blkrad;

    array2D<float> Lresult(GW, GH, ARRAY2D_CLEAR_DATA);
    array2D<float> totwt(GW, GH, ARRAY2D_CLEAR_DATA); //weight for combining DCT blocks

    for (int i = 0; i < numThreads; ++i) {
        LbloxArray[i]  = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * tilssize * tilssize * sizeof(float)));
        fLbloxArray[i] = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * tilssize * tilssize * sizeof(float)));
    }

#ifdef _OPENMP
    int masterThread = omp_get_thread_num();
#endif
#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
#ifdef _OPENMP
        int subThread = masterThread * 1 + omp_get_thread_num();
#else
        int subThread = 0;
#endif
        float *Lblox = LbloxArray[subThread];
        float *fLblox = fLbloxArray[subThread];
        float pBuf[GW + tilssize + 2 * blkrad * offset2] ALIGNED16;
#ifdef _OPENMP
        #pragma omp for
#endif

        for (int vblk = 0; vblk < numblox_H; ++vblk) {

            int top = (vblk - blkrad) * offset2;
            float * datarow = pBuf + blkrad * offset2;

            for (int i = 0; i < tilssize; ++i) {
                int row = top + i;
                int rr = row;

                if (row < 0) {
                    rr = MIN(-row, GH - 1);
                } else if (row >= GH) {
                    rr = MAX(0, 2 * GH - 2 - row);
                }

                for (int j = 0; j < GW; ++j) {
                    datarow[j] = (tmp1[rr][j]);
                }

                for (int j = -blkrad * offset2; j < 0; ++j) {
                    datarow[j] = datarow[MIN(-j, GW - 1)];
                }

                for (int j = GW; j < GW + tilssize + blkrad * offset2; ++j) {
                    datarow[j] = datarow[MAX(0, 2 * GW - 2 - j)];
                }//now we have a padded data row

                for (int hblk = 0; hblk < numblox_W; ++hblk) {
                    int left = (hblk - blkrad) * offset2;
                    int indx = (hblk) * tilssize; //index of block in malloc

                    if (top + i >= 0 && top + i < GH) {
                        int j;

                        for (j = 0; j < min((-left), tilssize); ++j) {
                            Lblox[(indx + i)*tilssize + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                        }

                        for (; j < min(tilssize, GW - left); ++j) {
                            Lblox[(indx + i)*tilssize + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                            totwt[top + i][left + j] += tilemask_in[i][j] * tilemask_out[i][j];
                        }

                        for (; j < tilssize; ++j) {
                            Lblox[(indx + i)*tilssize + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                        }
                    } else {
                        for (int j = 0; j < tilssize; ++j) {
                            Lblox[(indx + i)*tilssize + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                        }
                    }

                }

            }//end of filling block row

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
            //fftwf_print_plan (plan_forward_blox);
            if (numblox_W == max_numblox_W) {
                fftwf_execute_r2r(plan_forward_blox[0], Lblox, fLblox);    // DCT an entire row of tiles
            } else {
                fftwf_execute_r2r(plan_forward_blox[1], Lblox, fLblox);    // DCT an entire row of tiles
            }

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

            double n_x = rtengine::RT_PI / (double) tilssize;
            double n_y = rtengine::RT_PI / (double) tilssize;
            n_x = n_x * n_x;
            n_y = n_y * n_y;

            //radius = 30.f;
            for (int hblk = 0; hblk < numblox_W; ++hblk) {
                int blkstart = hblk * tilssize * tilssize;

                for (int j = 0; j < tilssize; j++) {
                    int index = j * tilssize;

                    for (int i = 0; i < tilssize; i++) {
                        fLblox[blkstart + index + i] *= exp((float)(-radius) * (n_x * i * i + n_y * j * j));
                    }
                }
            }//end of horizontal block loop

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

            //now perform inverse FT of an entire row of blocks
            if (numblox_W == max_numblox_W) {
                fftwf_execute_r2r(plan_backward_blox[0], fLblox, Lblox);    //for DCT
            } else {
                fftwf_execute_r2r(plan_backward_blox[1], fLblox, Lblox);    //for DCT
            }

            int topproc = (vblk - blkrad) * offset2;
            const int numblox_W = ceil((static_cast<float>(GW)) / (offset2));
            const float DCTnorm = 1.0f / (4 * tilssize * tilssize); //for DCT

            int imin = MAX(0, - topproc);
            int bottom = MIN(topproc + tilssize, GH);
            int imax = bottom - topproc;

            for (int i = imin; i < imax; ++i) {
                for (int hblk = 0; hblk < numblox_W; ++hblk) {
                    int left = (hblk - blkrad) * offset2;
                    int right  = MIN(left + tilssize, GW);
                    int jmin = MAX(0, -left);
                    int jmax = right - left;
                    int indx = hblk * tilssize;

                    for (int j = jmin; j < jmax; ++j) {
                        Lresult[topproc + i][left + j] += tilemask_out[i][j] * Lblox[(indx + i) * tilssize + j] * DCTnorm; //for DCT
                    }
                }
            }
        }//end of vertical block loop
    }
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#ifdef _OPENMP

    #pragma omp parallel for
#endif

    for (int i = 0; i < GH; ++i) {
        for (int j = 0; j < GW; ++j) {
            tmp1[i][j] = Lresult[i][j] / totwt[i][j];
            tmp1[i][j] = CLIPLOC(tmp1[i][j]);
        }
    }

    for (int i = 0; i < numThreads; ++i) {
        fftwf_free(LbloxArray[i]);
        fftwf_free(fLbloxArray[i]);
    }

    fftwf_destroy_plan(plan_forward_blox[0]);
    fftwf_destroy_plan(plan_backward_blox[0]);
    fftwf_destroy_plan(plan_forward_blox[1]);
    fftwf_destroy_plan(plan_backward_blox[1]);
    fftwf_cleanup();
}



void ImProcFunctions::fftw_denoise(int GW, int GH, int max_numblox_W, int min_numblox_W, float **tmp1, array2D<float> *Lin, int numThreads, const struct local_params & lp, int chrom)
{
    BENCHFUN

    fftwf_plan plan_forward_blox[2];
    fftwf_plan plan_backward_blox[2];

    array2D<float> tilemask_in(TS, TS);
    array2D<float> tilemask_out(TS, TS);

    float *Lbloxtmp  = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * TS * TS * sizeof(float)));
    float *fLbloxtmp = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * TS * TS * sizeof(float)));
    float params_Ldetail = 0.f;

    int nfwd[2] = {TS, TS};

    //for DCT:
    fftw_r2r_kind fwdkind[2] = {FFTW_REDFT10, FFTW_REDFT10};
    fftw_r2r_kind bwdkind[2] = {FFTW_REDFT01, FFTW_REDFT01};

    // Creating the plans with FFTW_MEASURE instead of FFTW_ESTIMATE speeds up the execute a bit
    plan_forward_blox[0]  = fftwf_plan_many_r2r(2, nfwd, max_numblox_W, Lbloxtmp, nullptr, 1, TS * TS, fLbloxtmp, nullptr, 1, TS * TS, fwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    plan_backward_blox[0] = fftwf_plan_many_r2r(2, nfwd, max_numblox_W, fLbloxtmp, nullptr, 1, TS * TS, Lbloxtmp, nullptr, 1, TS * TS, bwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    plan_forward_blox[1]  = fftwf_plan_many_r2r(2, nfwd, min_numblox_W, Lbloxtmp, nullptr, 1, TS * TS, fLbloxtmp, nullptr, 1, TS * TS, fwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    plan_backward_blox[1] = fftwf_plan_many_r2r(2, nfwd, min_numblox_W, fLbloxtmp, nullptr, 1, TS * TS, Lbloxtmp, nullptr, 1, TS * TS, bwdkind, FFTW_MEASURE | FFTW_DESTROY_INPUT);
    fftwf_free(Lbloxtmp);
    fftwf_free(fLbloxtmp);
    const int border = MAX(2, TS / 16);

    for (int i = 0; i < TS; ++i) {
        float i1 = abs((i > TS / 2 ? i - TS + 1 : i));
        float vmask = (i1 < border ? SQR(sin((rtengine::RT_PI_F * i1) / (2 * border))) : 1.0f);
        float vmask2 = (i1 < 2 * border ? SQR(sin((rtengine::RT_PI_F * i1) / (2 * border))) : 1.0f);

        for (int j = 0; j < TS; ++j) {
            float j1 = abs((j > TS / 2 ? j - TS + 1 : j));
            tilemask_in[i][j] = (vmask * (j1 < border ? SQR(sin((rtengine::RT_PI_F * j1) / (2 * border))) : 1.0f)) + epsilon;
            tilemask_out[i][j] = (vmask2 * (j1 < 2 * border ? SQR(sin((rtengine::RT_PI_F * j1) / (2 * border))) : 1.0f)) + epsilon;

        }
    }


    float *LbloxArray[numThreads];
    float *fLbloxArray[numThreads];



    const int numblox_W = ceil((static_cast<float>(GW)) / (offset)) + 2 * blkrad;
    const int numblox_H = ceil((static_cast<float>(GH)) / (offset)) + 2 * blkrad;


    //residual between input and denoised L channel
    array2D<float> Ldetail(GW, GH, ARRAY2D_CLEAR_DATA);
    array2D<float> totwt(GW, GH, ARRAY2D_CLEAR_DATA); //weight for combining DCT blocks

    for (int i = 0; i < numThreads; ++i) {
        LbloxArray[i]  = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * TS * TS * sizeof(float)));
        fLbloxArray[i] = reinterpret_cast<float*>(fftwf_malloc(max_numblox_W * TS * TS * sizeof(float)));
    }

#ifdef _OPENMP
    int masterThread = omp_get_thread_num();
#endif
#ifdef _OPENMP
    #pragma omp parallel
#endif
    {
#ifdef _OPENMP
        int subThread = masterThread * 1 + omp_get_thread_num();
#else
        int subThread = 0;
#endif
        float blurbuffer[TS * TS] ALIGNED64;
        float *Lblox = LbloxArray[subThread];
        float *fLblox = fLbloxArray[subThread];
        float pBuf[GW + TS + 2 * blkrad * offset] ALIGNED16;
        float nbrwt[TS * TS] ALIGNED64;
#ifdef _OPENMP
        #pragma omp for
#endif

        for (int vblk = 0; vblk < numblox_H; ++vblk) {

            int top = (vblk - blkrad) * offset;
            float * datarow = pBuf + blkrad * offset;

            for (int i = 0; i < TS; ++i) {
                int row = top + i;
                int rr = row;

                if (row < 0) {
                    rr = MIN(-row, GH - 1);
                } else if (row >= GH) {
                    rr = MAX(0, 2 * GH - 2 - row);
                }

                for (int j = 0; j < GW; ++j) {
                    datarow[j] = ((*Lin)[rr][j] - tmp1[rr][j]);
                }

                for (int j = -blkrad * offset; j < 0; ++j) {
                    datarow[j] = datarow[MIN(-j, GW - 1)];
                }

                for (int j = GW; j < GW + TS + blkrad * offset; ++j) {
                    datarow[j] = datarow[MAX(0, 2 * GW - 2 - j)];
                }//now we have a padded data row

                //now fill this row of the blocks with Lab high pass data
                for (int hblk = 0; hblk < numblox_W; ++hblk) {
                    int left = (hblk - blkrad) * offset;
                    int indx = (hblk) * TS; //index of block in malloc

                    if (top + i >= 0 && top + i < GH) {
                        int j;

                        for (j = 0; j < min((-left), TS); ++j) {
                            Lblox[(indx + i)*TS + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                        }

                        for (; j < min(TS, GW - left); ++j) {
                            Lblox[(indx + i)*TS + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                            totwt[top + i][left + j] += tilemask_in[i][j] * tilemask_out[i][j];
                        }

                        for (; j < TS; ++j) {
                            Lblox[(indx + i)*TS + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                        }
                    } else {
                        for (int j = 0; j < TS; ++j) {
                            Lblox[(indx + i)*TS + j] = tilemask_in[i][j] * datarow[left + j]; // luma data
                        }
                    }

                }

            }//end of filling block row

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
            //fftwf_print_plan (plan_forward_blox);
            if (numblox_W == max_numblox_W) {
                fftwf_execute_r2r(plan_forward_blox[0], Lblox, fLblox);    // DCT an entire row of tiles
            } else {
                fftwf_execute_r2r(plan_forward_blox[1], Lblox, fLblox);    // DCT an entire row of tiles
            }

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
            // now process the vblk row of blocks for noise reduction

//            float params_Ldetail = 0.f;
            float noisevar_Ldetail = 1.f;

            if (chrom == 0) {
                params_Ldetail = min(float(lp.noiseldetail), 99.9f);    // max out to avoid div by zero when using noisevar_Ldetail as divisor
                noisevar_Ldetail = SQR(static_cast<float>(SQR(100. - params_Ldetail) + 50.*(100. - params_Ldetail)) * TS * 0.5f);
            } else if (chrom == 1) {
                params_Ldetail = min(float(lp.noisechrodetail), 99.9f);
                //   noisevar_Ldetail = 100.f * pow((static_cast<float>(SQR(100. - params_Ldetail) + 50.*(100. - params_Ldetail)) * TS * 0.5f), 2);//to test ???
                noisevar_Ldetail = 100.f * pow((static_cast<float>(SQR(100. - params_Ldetail)) * TS * 0.5f), 2);//to test ???
            }

            //   float noisevar_Ldetail = SQR(static_cast<float>(SQR(100. - params_Ldetail) + 50.*(100. - params_Ldetail)) * TS * 0.5f);



            for (int hblk = 0; hblk < numblox_W; ++hblk) {
                ImProcFunctions::RGBtile_denoise(fLblox, hblk, noisevar_Ldetail, nbrwt, blurbuffer);
            }//end of horizontal block loop

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

            //now perform inverse FT of an entire row of blocks
            if (numblox_W == max_numblox_W) {
                fftwf_execute_r2r(plan_backward_blox[0], fLblox, Lblox);    //for DCT
            } else {
                fftwf_execute_r2r(plan_backward_blox[1], fLblox, Lblox);    //for DCT
            }

            int topproc = (vblk - blkrad) * offset;

            //add row of blocks to output image tile
            ImProcFunctions::RGBoutput_tile_row(Lblox, Ldetail, tilemask_out, GH, GW, topproc);

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

        }//end of vertical block loop

        //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    }
    //Threshold DCT from Alberto Grigio
    const int detail_thresh = lp.detailthr;
    array2D<float> mask;
    float scalea = 1.f;

    if (detail_thresh > 0) {
        mask(GW, GH);
        float thr = log2lin(float(detail_thresh) / 200.f, 100.f);
        buildBlendMask(tmp1, mask, GW, GH, thr);
        float r = 20.f / scalea;

        if (r > 0) {
            float **m = mask;
            gaussianBlur(m, m, GW, GH, r);
        }

        array2D<float> m2(GW, GH);
        const float alfa = 0.856f;
        const float beta = 1.f + std::sqrt(log2lin(thr, 100.f));
        buildGradientsMask(GW, GH, tmp1, m2, params_Ldetail / 100.f, 7, 3, alfa, beta, multiThread);

        for (int i = 0; i < GH; ++i) {
            for (int j = 0; j < GW; ++j) {
                mask[i][j] *= m2[i][j];
            }
        }
    }


//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#ifdef _OPENMP

    #pragma omp parallel for
#endif

    for (int i = 0; i < GH; ++i) {
        for (int j = 0; j < GW; ++j) {
            float d = Ldetail[i][j] / totwt[i][j];

            if (detail_thresh > 0) {
                d *= mask[i][j];
            }

            //may want to include masking threshold for large hipass data to preserve edges/detail
            tmp1[i][j] += d;
        }
    }

    mask.free();
//end Threshold DCT


    delete Lin;


    for (int i = 0; i < numThreads; ++i) {
        fftwf_free(LbloxArray[i]);
        fftwf_free(fLbloxArray[i]);
    }

    fftwf_destroy_plan(plan_forward_blox[0]);
    fftwf_destroy_plan(plan_backward_blox[0]);
    fftwf_destroy_plan(plan_forward_blox[1]);
    fftwf_destroy_plan(plan_backward_blox[1]);
    fftwf_cleanup();


}

void ImProcFunctions::DeNoise(int call, int del, float * slidL, float * slida, float * slidb, int aut,  bool noiscfactiv, const struct local_params& lp, LabImage* originalmaskbl, int levred, float huerefblur, float lumarefblur, float chromarefblur, LabImage* original, LabImage* transformed, int cx, int cy, int sk)
{

//local denoise
    //all these variables are to prevent use of denoise when non necessary
    // but with qualmet = 2 (default for best quality) we must denoise chroma with little values to prevent artifacts due to variations of Hue
    // but if user select volontary denoise, it is that choice the good (prioritary)
    bool execcolor = (lp.chro != 0.f || lp.ligh != 0.f || lp.cont != 0); // only if one slider ore more is engaged
    bool execbdl = (lp.mulloc[0] != 1.f || lp.mulloc[1] != 1.f || lp.mulloc[2] != 1.f || lp.mulloc[3] != 1.f || lp.mulloc[4] != 1.f || lp.mulloc[5] != 1.f) ;//only if user want cbdl
    bool execdenoi = noiscfactiv && ((lp.colorena && execcolor) || (lp.tonemapena && lp.strengt != 0.f) || (lp.cbdlena && execbdl) || (lp.sfena && lp.strng > 0.f) || (lp.lcena && lp.lcamount > 0.f) || (lp.sharpena && lp.shrad > 0.42) || (lp.retiena  && lp.str > 0.f)  || (lp.exposena && lp.expcomp != 0.f)  || (lp.expvib  && lp.past != 0.f));
    //  printf("OK 1 aut=%i\n", aut);


    if (((lp.noiself > 0.f || lp.noiself0 > 0.f || lp.noiself2 > 0.f || lp.noiselc > 0.f || lp.noisecf > 0.f || lp.noisecc > 0.f
            || lp.showmaskblmet == 2 || lp.enablMask || lp.showmaskblmet == 3 || lp.showmaskblmet == 4  || aut == 1 || aut == 2) && lp.denoiena) || execdenoi) {  // sk == 1 ??

        StopWatch Stop1("locallab Denoise called");

        if (aut == 0) {
            MyMutex::MyLock lock(*fftwMutex);
        }


        if (lp.noisecf >= 0.01f || lp.noisecc >= 0.01f || aut == 1 || aut == 2) {
            noiscfactiv = false;
            levred = 7;
        }

        int GW = transformed->W;
        int GH = transformed->H;


#ifdef _OPENMP
        const int numThreads = omp_get_max_threads();
#else
        const int numThreads = 1;

#endif

        if (call == 1  && GW >= mDEN && GH >= mDEN) {


            LabImage tmp1(transformed->W, transformed->H);
            LabImage tmp2(transformed->W, transformed->H);
            tmp2.clear();

            array2D<float> *Lin = nullptr;
            array2D<float> *Ain = nullptr;
            array2D<float> *Bin = nullptr;


            int GW = transformed->W;
            int GH = transformed->H;
            int max_numblox_W = ceil((static_cast<float>(GW)) / (offset)) + 2 * blkrad;
            // calculate min size of numblox_W.
            int min_numblox_W = ceil((static_cast<float>(GW)) / (offset)) + 2 * blkrad;


            for (int ir = 0; ir < GH; ir++)
                for (int jr = 0; jr < GW; jr++) {
                    tmp1.L[ir][jr] = original->L[ir][jr];
                    tmp1.a[ir][jr] = original->a[ir][jr];
                    tmp1.b[ir][jr] = original->b[ir][jr];
                }

            int DaubLen = 6;

            int levwavL = levred;
            int skip = 1;

            wavelet_decomposition Ldecomp(tmp1.L[0], tmp1.W, tmp1.H, levwavL, 1, skip, numThreads, DaubLen);
            wavelet_decomposition adecomp(tmp1.a[0], tmp1.W, tmp1.H, levwavL, 1, skip, numThreads, DaubLen);
            wavelet_decomposition bdecomp(tmp1.b[0], tmp1.W, tmp1.H, levwavL, 1, skip, numThreads, DaubLen);

            float madL[8][3];
            int edge = 2;

            if (!Ldecomp.memoryAllocationFailed) {
                #pragma omp parallel for collapse(2) schedule(dynamic,1)

                for (int lvl = 0; lvl < levred; lvl++) {
                    for (int dir = 1; dir < 4; dir++) {
                        int Wlvl_L = Ldecomp.level_W(lvl);
                        int Hlvl_L = Ldecomp.level_H(lvl);

                        float ** WavCoeffs_L = Ldecomp.level_coeffs(lvl);

                        madL[lvl][dir - 1] = SQR(Mad(WavCoeffs_L[dir], Wlvl_L * Hlvl_L));
                    }
                }

                float vari[levred];
                float mxsl = 0.f;
                //      float mxsfl = 0.f;

                if (aut == 0) {
                    if (levred == 7) {
                        edge = 2;
                        vari[0] = 8.f * SQR((lp.noiself0 / 125.0) * (1.0 + lp.noiself0 / 25.0));
                        vari[1] = 8.f * SQR((lp.noiself / 125.0) * (1.0 + lp.noiself / 25.0));
                        vari[2] = 8.f * SQR((lp.noiself2 / 125.0) * (1.0 + lp.noiself2 / 25.0));

                        vari[3] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                        vari[4] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                        vari[5] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                        vari[6] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                    } else if (levred == 4) {
                        edge = 3;
                        vari[0] = 8.f * SQR((lp.noiself0 / 125.0) * (1.0 + lp.noiself0 / 25.0));
                        vari[1] = 8.f * SQR((lp.noiself / 125.0) * (1.0 + lp.noiself / 25.0));
                        vari[2] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                        vari[3] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));

                    }
                } else if (aut == 1  || aut == 2) {
                    edge = 2;
                    vari[0] = SQR(slidL[0]);
                    vari[1] = SQR(slidL[1]);
                    vari[2] = SQR(slidL[2]);
                    //       float maxf01 = max(slidL[0], slidL[1]);
                    //       mxsfl = max(maxf01, slidL[2]);

                    vari[3] = SQR(slidL[3]);
                    vari[4] = SQR(slidL[4]);
                    vari[5] = SQR(slidL[5]);
                    vari[6] = SQR(slidL[6]);
                    float mxslid34 = max(slidL[3], slidL[4]);
                    float mxslid56 = max(slidL[5], slidL[6]);
                    mxsl = max(mxslid34, mxslid56);

                }

                /*
                for(int j=0;j<8;j++){
                printf("j=%i slidL=%f\n", j, slidL[j]);
                }

                printf("mxsl=%f\n", mxsl);
                */
//               if ((lp.noiself >= 0.1f ||  lp.noiself0 >= 0.1f ||  lp.noiself2 >= 0.1f || lp.noiselc >= 0.1f || mxsl >= 0.1f || mxsfl >= 0.1f)) {
                {
                    float kr3 = 0.f;
                    float kr4 = 0.f;
                    float kr5 = 0.f;

                    if (aut == 0 || aut == 1) {
                        if ((lp.noiselc < 30.f && aut == 0) || (mxsl < 30.f && aut == 1)) {
                            kr3 = 0.f;
                            kr4 = 0.f;
                            kr5 = 0.f;
                        } else if ((lp.noiselc < 50.f && aut == 0) || (mxsl < 50.f && aut == 1)) {
                            kr3 = 0.5f;
                            kr4 = 0.3f;
                            kr5 = 0.2f;
                        } else if ((lp.noiselc < 70.f && aut == 0) || (mxsl < 70.f && aut == 1)) {
                            kr3 = 0.7f;
                            kr4 = 0.5f;
                            kr5 = 0.3f;
                        } else {
                            kr3 = 1.f;
                            kr4 = 1.f;
                            kr5 = 1.f;
                        }
                    } else if (aut == 2) {
                        kr3 = 1.f;
                        kr4 = 1.f;
                        kr5 = 1.f;
                    }

                    vari[0] = max(0.0001f, vari[0]);
                    vari[1] = max(0.0001f, vari[1]);
                    vari[2] = max(0.0001f, vari[2]);
                    vari[3] = max(0.0001f, kr3 * vari[3]);

                    if (levred == 7) {
                        vari[4] = max(0.0001f, kr4 * vari[4]);
                        vari[5] = max(0.0001f, kr5 * vari[5]);
                        vari[6] = max(0.0001f, kr5 * vari[6]);
                    }


                    float* noisevarlum = new float[GH * GW];
                    int GW2 = (GW + 1) / 2;

                    float nvlh[13] = {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 0.7f, 0.5f}; //high value
                    float nvll[13] = {0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.35f, 0.4f, 0.45f, 0.7f, 0.8f, 1.f, 1.f, 1.f}; //low value

                    float seuillow = 3000.f;//low
                    float seuilhigh = 18000.f;//high
                    int i = 10 - lp.noiselequal;
                    float ac = (nvlh[i] - nvll[i]) / (seuillow - seuilhigh);
                    float bc = nvlh[i] - seuillow * ac;
                    //ac and bc for transition
#ifdef _OPENMP
                    #pragma omp parallel for

#endif

                    for (int ir = 0; ir < GH; ir++)
                        for (int jr = 0; jr < GW; jr++) {
                            float lN = tmp1.L[ir][jr];

                            if (lN < seuillow) {
                                noisevarlum[(ir >> 1)*GW2 + (jr >> 1)] =  nvlh[i];
                            } else if (lN < seuilhigh) {
                                noisevarlum[(ir >> 1)*GW2 + (jr >> 1)] = ac * lN + bc;
                            } else {
                                noisevarlum[(ir >> 1)*GW2 + (jr >> 1)] =  nvll[i];
                            }
                        }

                    /*
                    for(int j=0;j<8;j++){
                    printf("j=%i variL=%f\n", j, vari[j]);
                    }
                    */
                    if ((lp.noiselc < 0.02f && aut == 0) || (mxsl < 1.f && (aut == 1 || aut == 2))) {
                        WaveletDenoiseAllL(Ldecomp, noisevarlum, madL, vari, edge, numThreads);
                    } else {
                        WaveletDenoiseAll_BiShrinkL(Ldecomp, noisevarlum, madL, vari, edge, numThreads);
                        WaveletDenoiseAllL(Ldecomp, noisevarlum, madL, vari, edge, numThreads);
                    }

                    delete[] noisevarlum;

                }
            }


            float variC[levred];
            float variCb[levred];

            float noisecfr = lp.noisecf;
            float noiseccr = lp.noisecc;

            if (lp.adjch > 0.f) {
                noisecfr = lp.noisecf * ((100.f + lp.adjch) / 10.f);
                noiseccr = lp.noisecc + ((100.f + lp.adjch) / 10.f);
            }

            float noisecfb = lp.noisecf;
            float noiseccb = lp.noisecc;

            if (lp.adjch < 0.f) {
                noisecfb = lp.noisecf * ((100.f - lp.adjch) / 10.f);
                noiseccb = lp.noisecc * ((100.f - lp.adjch) / 10.f);
            }


            if (noisecfr < 0.f) {
                noisecfr = 0.0001f;
            }

            if (noiseccr < 0.f) {
                noiseccr = 0.0001f;
            }

            if (noisecfb < 0.f) {
                noisecfb = 0.0001f;
            }

            if (noiseccb < 0.f) {
                noiseccb = 0.0001f;
            }

            if (!adecomp.memoryAllocationFailed && !bdecomp.memoryAllocationFailed) {
                float maxcfine = 0.f;
                float maxccoarse = 0.f;

                if (aut == 0) {
                    if (levred == 7) {
                        edge = 2;
                        variC[0] = SQR(noisecfr);
                        variC[1] = SQR(noisecfr);
                        variC[2] = SQR(noisecfr);

                        variC[3] = SQR(noisecfr);
                        variC[4] = SQR(noisecfr);
                        variC[5] = SQR(noiseccr);
                        variC[6] = SQR(noiseccr);

                        variCb[0] = SQR(noisecfb);
                        variCb[1] = SQR(noisecfb);
                        variCb[2] = SQR(noisecfb);

                        variCb[3] = SQR(noisecfb);
                        variCb[4] = SQR(noisecfb);
                        variCb[5] = SQR(noiseccb);
                        variCb[6] = SQR(noiseccb);

                    } else if (levred == 4) {
                        edge = 3;
                        variC[0] = SQR(lp.noisecf / 10.0);
                        variC[1] = SQR(lp.noisecf / 10.0);
                        variC[2] = SQR(lp.noisecf / 10.0);
                        variC[3] = SQR(lp.noisecf / 10.0);

                        variCb[0] = SQR(lp.noisecf / 10.0);
                        variCb[1] = SQR(lp.noisecf / 10.0);
                        variCb[2] = SQR(lp.noisecf / 10.0);
                        variCb[3] = SQR(lp.noisecf / 10.0);

                    }
                } else if (aut == 1  || aut == 2) {
                    edge = 2;
                    variC[0] = SQR(slida[0]);
                    variC[1] = SQR(slida[1]);
                    variC[2] = SQR(slida[2]);
                    variC[3] = SQR(slida[3]);
                    variC[4] = SQR(slida[4]);
                    variC[5] = SQR(slida[5]);
                    variC[6] = SQR(slida[6]);
                    float maxc01 = max(slida[0], slida[1]);
                    float maxc23 = max(slida[2], slida[3]);
                    float max03 = max(maxc01, maxc23);
                    float maxrf = max(max03, slida[4]);
                    float maxrc = max(slida[5], slida[6]);

                    variCb[0] = SQR(slidb[0]);
                    variCb[1] = SQR(slidb[1]);
                    variCb[2] = SQR(slidb[2]);
                    variCb[3] = SQR(slidb[3]);
                    variCb[4] = SQR(slidb[4]);
                    variCb[5] = SQR(slidb[5]);
                    variCb[6] = SQR(slidb[6]);
                    float maxb01 = max(slidb[0], slidb[1]);
                    float maxb23 = max(slidb[2], slidb[3]);
                    float maxb03 = max(maxb01, maxb23);
                    float maxbf = max(maxb03, slidb[4]);
                    maxcfine = max(maxrf, maxbf);

                    float maxbc = max(slidb[5], slidb[6]);
                    maxccoarse = max(maxrc, maxbc);

                }

                /*
                for(int j=0;j<8;j++){
                printf("j=%i slida=%f\n", j, slida[j]);
                }
                */
                //    if (((lp.noisecf >= 0.1f && aut == 0) ||  (lp.noisecc >= 0.1f && aut == 0) || (noiscfactiv && aut == 0) || (maxcfine >= 0.1f && (aut == 1 || aut ==2)) || (maxccoarse > 0.1f && (aut == 1 || aut ==2)))) {
                {
                    float minic = 0.0001f;

                    if (noiscfactiv) {
                        minic = 0.1f;//only for artifact shape detection
                    }

                    float k1 = 0.f;
                    float k2 = 0.f;
                    float k3 = 0.f;

                    if (aut == 0 || aut == 1) {
                        if ((lp.noisecf < 0.2f && aut == 0) || (maxcfine < 0.2f && aut == 1)) {
                            k1 = 0.f;
                            k2 = 0.f;
                            k3 = 0.f;
                        } else if ((lp.noisecf < 0.3f && aut == 0) || (maxcfine < 0.3f && aut == 1)) {
                            k1 = 0.1f;
                            k2 = 0.0f;
                            k3 = 0.f;
                        } else if ((lp.noisecf < 0.5f && aut == 0) || (maxcfine < 0.5f && aut == 1)) {
                            k1 = 0.2f;
                            k2 = 0.1f;
                            k3 = 0.f;
                        } else if ((lp.noisecf < 0.8f && aut == 0) || (maxcfine < 0.8f && aut == 1)) {
                            k1 = 0.3f;
                            k2 = 0.25f;
                            k3 = 0.f;
                        } else if ((lp.noisecf < 1.f && aut == 0) || (maxcfine < 1.f && aut == 1)) {
                            k1 = 0.4f;
                            k2 = 0.25f;
                            k3 = 0.1f;
                        } else if ((lp.noisecf < 2.f && aut == 0) || (maxcfine < 2.f && aut == 1)) {
                            k1 = 0.5f;
                            k2 = 0.3f;
                            k3 = 0.15f;
                        } else if ((lp.noisecf < 3.f && aut == 0) || (maxcfine < 3.f && aut == 1)) {
                            k1 = 0.6f;
                            k2 = 0.45f;
                            k3 = 0.3f;
                        } else if ((lp.noisecf < 4.f && aut == 0) || (maxcfine < 4.f && aut == 1)) {
                            k1 = 0.7f;
                            k2 = 0.5f;
                            k3 = 0.4f;
                        } else if ((lp.noisecf < 5.f && aut == 0) || (maxcfine < 5.f && aut == 1)) {
                            k1 = 0.8f;
                            k2 = 0.6f;
                            k3 = 0.5f;
                        } else if ((lp.noisecf < 10.f && aut == 0) || (maxcfine < 10.f && aut == 1)) {
                            k1 = 0.85f;
                            k2 = 0.7f;
                            k3 = 0.6f;
                        } else if ((lp.noisecf < 20.f && aut == 0) || (maxcfine < 20.f && aut == 1)) {
                            k1 = 0.9f;
                            k2 = 0.8f;
                            k3 = 0.7f;
                        } else if ((lp.noisecf < 50.f && aut == 0) || (maxcfine < 50.f && aut == 1)) {
                            k1 = 1.f;
                            k2 = 1.f;
                            k3 = 0.9f;

                        } else {
                            k1 = 1.f;
                            k2 = 1.f;
                            k3 = 1.f;
                        }
                    } else if (aut == 2) {
                        k1 = 1.f;
                        k2 = 1.f;
                        k3 = 1.f;
                    }


                    variC[0] = max(minic, variC[0]);
                    variC[1] = max(minic, k1 * variC[1]);
                    variC[2] = max(minic, k2 * variC[2]);
                    variC[3] = max(minic, k3 * variC[3]);

                    variCb[0] = max(minic, variCb[0]);
                    variCb[1] = max(minic, k1 * variCb[1]);
                    variCb[2] = max(minic, k2 * variCb[2]);
                    variCb[3] = max(minic, k3 * variCb[3]);

                    if (levred == 7) {
                        float k4 = 0.f;
                        float k5 = 0.f;
                        float k6 = 0.f;

                        if ((lp.noisecc == 0.01f && aut == 0) || (maxccoarse == 0.1f && aut == 1)) {
                            k4 = 0.f;
                            k5 = 0.0f;
                        } else if ((lp.noisecc < 0.2f && aut == 0) || (maxccoarse < 0.2f && aut == 1)) {
                            k4 = 0.1f;
                            k5 = 0.0f;
                        } else if ((lp.noisecc < 0.5f && aut == 0) || (maxccoarse < 0.5f && aut == 1)) {
                            k4 = 0.15f;
                            k5 = 0.0f;
                        } else if ((lp.noisecc < 1.f && aut == 0) || (maxccoarse < 1.f && aut == 1)) {
                            k4 = 0.15f;
                            k5 = 0.1f;
                        } else if ((lp.noisecc < 3.f && aut == 0) || (maxccoarse < 3.f && aut == 1)) {
                            k4 = 0.3f;
                            k5 = 0.15f;
                        } else if ((lp.noisecc < 4.f && aut == 0) || (maxccoarse < 5.f && aut == 1)) {
                            k4 = 0.6f;
                            k5 = 0.4f;
                        } else if ((lp.noisecc < 6.f && aut == 0) || (maxccoarse < 6.f && aut == 1)) {
                            k4 = 0.8f;
                            k5 = 0.6f;
                        } else {
                            k4 = 1.f;
                            k5 = 1.f;
                        }

                        variC[4] = max(0.0001f, k4 * variC[4]);
                        variC[5] = max(0.0001f, k5 * variC[5]);
                        variCb[4] = max(0.0001f, k4 * variCb[4]);
                        variCb[5] = max(0.0001f, k5 * variCb[5]);

                        if ((lp.noisecc < 4.f  && aut == 0) || (maxccoarse < 4.f && aut == 1)) {
                            k6 = 0.f;
                        } else if ((lp.noisecc < 5.f && aut == 0) || (maxccoarse < 5.f && aut == 1)) {
                            k6 = 0.4f;
                        } else if ((lp.noisecc < 6.f  && aut == 0) || (maxccoarse < 6.f && aut == 1)) {
                            k6 = 0.7f;
                        } else {
                            k6 = 1.f;
                        }

                        variC[6] = max(0.0001f, k6 * variC[6]);
                        variCb[6] = max(0.0001f, k6 * variCb[6]);

                    }

                    float* noisevarchrom = new float[GH * GW];
                    //noisevarchrom in function chroma
                    int GW2 = (GW + 1) / 2;
                    float nvch = 0.6f;//high value
                    float nvcl = 0.1f;//low value

                    if ((lp.noisecf > 100.f  && aut == 0) || (maxcfine > 100.f && (aut == 1 || aut == 2))) {
                        nvch = 0.8f;
                        nvcl = 0.4f;
                    }

                    float seuil = 4000.f;//low
                    float seuil2 = 15000.f;//high
                    //ac and bc for transition
                    float ac = (nvch - nvcl) / (seuil - seuil2);
                    float bc = nvch - seuil * ac;
#ifdef _OPENMP
                    #pragma omp parallel for

#endif

                    for (int ir = 0; ir < GH; ir++)
                        for (int jr = 0; jr < GW; jr++) {
                            float cN = sqrt(SQR(tmp1.a[ir][jr]) + SQR(tmp1.b[ir][jr]));

                            if (cN < seuil) {
                                noisevarchrom[(ir >> 1)*GW2 + (jr >> 1)] =  nvch;
                            } else if (cN < seuil2) {
                                noisevarchrom[(ir >> 1)*GW2 + (jr >> 1)] = ac * cN + bc;
                            } else {
                                noisevarchrom[(ir >> 1)*GW2 + (jr >> 1)] =  nvcl;
                            }
                        }


                    float noisevarab_r = 100.f; //SQR(lp.noisecc / 10.0);

                    /*
                    for(int j=0;j<8;j++){
                    printf("j=%i variC=%f\n", j, variC[j]);
                    }
                    */
                    if ((lp.noisecc < 0.02f && aut == 0) || (maxccoarse < 0.1f && (aut == 1 || aut == 2)))  {
//                        printf("SANS SANS\n");
                        WaveletDenoiseAllAB(Ldecomp, adecomp, noisevarchrom, madL, variC, edge, noisevarab_r, true, false, false, numThreads);
                        WaveletDenoiseAllAB(Ldecomp, bdecomp, noisevarchrom, madL, variCb, edge, noisevarab_r, true, false, false, numThreads);
                    } else {
//                        printf("AVEC AV\n");

                        WaveletDenoiseAll_BiShrinkAB(Ldecomp, adecomp, noisevarchrom, madL, variC, edge, noisevarab_r, true, false, false, numThreads);
                        WaveletDenoiseAllAB(Ldecomp, adecomp, noisevarchrom, madL, variC, edge, noisevarab_r, true, false, false, numThreads);

                        WaveletDenoiseAll_BiShrinkAB(Ldecomp, bdecomp, noisevarchrom, madL, variCb, edge, noisevarab_r, true, false, false, numThreads);
                        WaveletDenoiseAllAB(Ldecomp, bdecomp, noisevarchrom, madL, variCb, edge, noisevarab_r, true, false, false, numThreads);
                    }

                    delete[] noisevarchrom;

                }
            }

            if (!Ldecomp.memoryAllocationFailed) {
                Lin = new array2D<float>(GW, GH);
#ifdef _OPENMP
                #pragma omp parallel for

#endif

                for (int i = 0; i < GH; ++i) {
                    for (int j = 0; j < GW; ++j) {
                        (*Lin)[i][j] = tmp1.L[i][j];
                    }
                }

                Ldecomp.reconstruct(tmp1.L[0]);
            }

            if (!Ldecomp.memoryAllocationFailed && aut == 0) {
                if ((lp.noiself >= 0.01f ||  lp.noiself0 >= 0.01f ||  lp.noiself2 >= 0.01f || lp.noiselc >= 0.01f)  && levred == 7  && lp.noiseldetail != 100.f) {
                    fftw_denoise(GW, GH, max_numblox_W, min_numblox_W, tmp1.L, Lin,  numThreads, lp, 0);
                }
            }

            if (!adecomp.memoryAllocationFailed) {
                Ain = new array2D<float>(GW, GH);
#ifdef _OPENMP
                #pragma omp parallel for

#endif

                for (int i = 0; i < GH; ++i) {
                    for (int j = 0; j < GW; ++j) {
                        (*Ain)[i][j] = tmp1.a[i][j];
                    }
                }

                adecomp.reconstruct(tmp1.a[0]);
            }


            if (!adecomp.memoryAllocationFailed && aut == 0) {
                if ((lp.noisecf >= 0.01f ||  lp.noisecc >= 0.01f)  && levred == 7  && lp.noisechrodetail != 100.f) {
                    fftw_denoise(GW, GH, max_numblox_W, min_numblox_W, tmp1.a, Ain,  numThreads, lp, 1);
                }
            }


            if (!bdecomp.memoryAllocationFailed) {

                Bin = new array2D<float>(GW, GH);
#ifdef _OPENMP
                #pragma omp parallel for

#endif

                for (int i = 0; i < GH; ++i) {
                    for (int j = 0; j < GW; ++j) {
                        (*Bin)[i][j] = tmp1.b[i][j];
                    }
                }

                bdecomp.reconstruct(tmp1.b[0]);
            }


            if (!bdecomp.memoryAllocationFailed && aut == 0) {
                if ((lp.noisecf >= 0.01f ||  lp.noisecc >= 0.01f)  && levred == 7  && lp.noisechrodetail != 100.f) {
                    fftw_denoise(GW, GH, max_numblox_W, min_numblox_W, tmp1.b, Bin,  numThreads, lp, 1);
                }

            }

            DeNoise_Local(call, lp,  originalmaskbl, levred, huerefblur, lumarefblur, chromarefblur, original, transformed, tmp1, cx, cy, sk);

        } else if (call == 2) { //simpleprocess

            int bfh = int (lp.ly + lp.lyT) + del; //bfw bfh real size of square zone
            int bfw = int (lp.lx + lp.lxL) + del;

            if (bfh >= mDEN && bfw >= mDEN) {
                LabImage bufwv(bfw, bfh);
                bufwv.clear(true);
                array2D<float> *Lin = nullptr;
                array2D<float> *Ain = nullptr;
                array2D<float> *Bin = nullptr;

                int max_numblox_W = ceil((static_cast<float>(bfw)) / (offset)) + 2 * blkrad;
                // calculate min size of numblox_W.
                int min_numblox_W = ceil((static_cast<float>(bfw)) / (offset)) + 2 * blkrad;
                // these are needed only for creation of the plans and will be freed before entering the parallel loop


                int begy = lp.yc - lp.lyT;
                int begx = lp.xc - lp.lxL;
                int yEn = lp.yc + lp.ly;
                int xEn = lp.xc + lp.lx;

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = 0; y < transformed->H ; y++) //{
                    for (int x = 0; x < transformed->W; x++) {
                        int lox = cx + x;
                        int loy = cy + y;

                        if (lox >= begx && lox < xEn && loy >= begy && loy < yEn) {
                            bufwv.L[loy - begy][lox - begx] = original->L[y][x];
                            bufwv.a[loy - begy][lox - begx] = original->a[y][x];
                            bufwv.b[loy - begy][lox - begx] = original->b[y][x];
                        }

                    }

                int DaubLen = 6;

                int levwavL = levred;
                int skip = 1;
                wavelet_decomposition Ldecomp(bufwv.L[0], bufwv.W, bufwv.H, levwavL, 1, skip, numThreads, DaubLen);
                wavelet_decomposition adecomp(bufwv.a[0], bufwv.W, bufwv.H, levwavL, 1, skip, numThreads, DaubLen);
                wavelet_decomposition bdecomp(bufwv.b[0], bufwv.W, bufwv.H, levwavL, 1, skip, numThreads, DaubLen);

                float madL[8][3];
                int edge = 2;

                if (!Ldecomp.memoryAllocationFailed) {
                    #pragma omp parallel for collapse(2) schedule(dynamic,1)

                    for (int lvl = 0; lvl < levred; lvl++) {
                        for (int dir = 1; dir < 4; dir++) {
                            int Wlvl_L = Ldecomp.level_W(lvl);
                            int Hlvl_L = Ldecomp.level_H(lvl);

                            float ** WavCoeffs_L = Ldecomp.level_coeffs(lvl);

                            madL[lvl][dir - 1] = SQR(Mad(WavCoeffs_L[dir], Wlvl_L * Hlvl_L));
                        }
                    }

                    float vari[levred];
                    float mxsl = 0.f;
                    //     float mxsfl = 0.f;

                    if (aut == 0) {
                        if (levred == 7) {
                            edge = 2;
                            vari[0] = 8.f * SQR((lp.noiself0 / 125.0) * (1.0 + lp.noiself0 / 25.0));
                            vari[1] = 8.f * SQR((lp.noiself / 125.0) * (1.0 + lp.noiself / 25.0));
                            vari[2] = 8.f * SQR((lp.noiself2 / 125.0) * (1.0 + lp.noiself2 / 25.0));

                            vari[3] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                            vari[4] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                            vari[5] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                            vari[6] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                        } else if (levred == 4) {
                            edge = 3;
                            vari[0] = 8.f * SQR((lp.noiself0 / 125.0) * (1.0 + lp.noiself0 / 25.0));
                            vari[1] = 8.f * SQR((lp.noiself / 125.0) * (1.0 + lp.noiself / 25.0));
                            vari[2] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));
                            vari[3] = 8.f * SQR((lp.noiselc / 125.0) * (1.0 + lp.noiselc / 25.0));

                        }
                    } else if (aut == 1 || aut == 2) {
                        edge = 2;
                        vari[0] = SQR(slidL[0]);
                        vari[1] = SQR(slidL[1]);
                        vari[2] = SQR(slidL[2]);
                        //    float maxf01 = max(slidL[0], slidL[1]);
                        //     mxsfl = max(maxf01, slidL[2]);

                        vari[3] = SQR(slidL[3]);
                        vari[4] = SQR(slidL[4]);
                        vari[5] = SQR(slidL[5]);
                        vari[6] = SQR(slidL[6]);
                        float mxslid34 = max(slidL[3], slidL[4]);
                        float mxslid56 = max(slidL[5], slidL[6]);
                        mxsl = max(mxslid34, mxslid56);

                    }



                    //        if ((lp.noiself >= 0.1f ||  lp.noiself0 >= 0.1f ||  lp.noiself2 >= 0.1f || lp.noiselc >= 0.1f  || mxsl >= 0.1f || mxsfl >= 0.1f)) {
                    {
                        float kr3 = 0.f;
                        float kr4 = 0.f;
                        float kr5 = 0.f;

                        if (aut == 0 || aut == 1) {
                            if ((lp.noiselc < 30.f && aut == 0) || (mxsl < 30.f && aut == 1)) {
                                kr3 = 0.f;
                                kr4 = 0.f;
                                kr5 = 0.f;
                            } else if ((lp.noiselc < 50.f && aut == 0) || (mxsl < 50.f && aut == 1)) {
                                kr3 = 0.5f;
                                kr4 = 0.3f;
                                kr5 = 0.2f;
                            } else if ((lp.noiselc < 70.f && aut == 0) || (mxsl < 70.f && aut == 1)) {
                                kr3 = 0.7f;
                                kr4 = 0.5f;
                                kr5 = 0.3f;
                            } else {
                                kr3 = 1.f;
                                kr4 = 1.f;
                                kr5 = 1.f;
                            }
                        } else if (aut == 2) {
                            kr3 = 1.f;
                            kr4 = 1.f;
                            kr5 = 1.f;

                        }

                        vari[0] = max(0.0001f, vari[0]);
                        vari[1] = max(0.0001f, vari[1]);
                        vari[2] = max(0.0001f, vari[2]);
                        vari[3] = max(0.0001f, kr3 * vari[3]);

                        if (levred == 7) {
                            vari[4] = max(0.0001f, kr4 * vari[4]);
                            vari[5] = max(0.0001f, kr5 * vari[5]);
                            vari[6] = max(0.0001f, kr5 * vari[6]);
                        }

                        //    float* noisevarlum = nullptr;  // we need a dummy to pass it to WaveletDenoiseAllL
                        float* noisevarlum = new float[bfh * bfw];
                        int bfw2 = (bfw + 1) / 2;

                        float nvlh[13] = {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 0.7f, 0.5f}; //high value
                        float nvll[13] = {0.1f, 0.15f, 0.2f, 0.25f, 0.3f, 0.35f, 0.4f, 0.45f, 0.7f, 0.8f, 1.f, 1.f, 1.f}; //low value

                        float seuillow = 3000.f;//low
                        float seuilhigh = 18000.f;//high
                        int i = 10 - lp.noiselequal;
                        float ac = (nvlh[i] - nvll[i]) / (seuillow - seuilhigh);
                        float bc = nvlh[i] - seuillow * ac;
                        //ac and bc for transition
#ifdef _OPENMP
                        #pragma omp parallel for

#endif

                        for (int ir = 0; ir < bfh; ir++)
                            for (int jr = 0; jr < bfw; jr++) {
                                float lN = bufwv.L[ir][jr];

                                if (lN < seuillow) {
                                    noisevarlum[(ir >> 1)*bfw2 + (jr >> 1)] =  nvlh[i];
                                } else if (lN < seuilhigh) {
                                    noisevarlum[(ir >> 1)*bfw2 + (jr >> 1)] = ac * lN + bc;
                                } else {
                                    noisevarlum[(ir >> 1)*bfw2 + (jr >> 1)] =  nvll[i];
                                }
                            }


                        if ((lp.noiselc < 0.02f  && aut == 0) || (mxsl < 1.f && (aut == 1 || aut == 2))) {
                            WaveletDenoiseAllL(Ldecomp, noisevarlum, madL, vari, edge, numThreads);
                        } else {
                            WaveletDenoiseAll_BiShrinkL(Ldecomp, noisevarlum, madL, vari, edge, numThreads);
                            WaveletDenoiseAllL(Ldecomp, noisevarlum, madL, vari, edge, numThreads);
                        }

                        delete [] noisevarlum;

                    }
                }


                float variC[levred];
                float variCb[levred];

                float noisecfr = lp.noisecf;
                float noiseccr = lp.noisecc;

                if (lp.adjch > 0.f) {
                    noisecfr = lp.noisecf * ((100.f + lp.adjch) / 10.f);
                    noiseccr = lp.noisecc + ((100.f + lp.adjch) / 10.f);
                }

                float noisecfb = lp.noisecf;
                float noiseccb = lp.noisecc;

                if (lp.adjch < 0.f) {
                    noisecfb = lp.noisecf * ((100.f - lp.adjch) / 10.f);
                    noiseccb = lp.noisecc * ((100.f - lp.adjch) / 10.f);
                }


                if (noisecfr < 0.f) {
                    noisecfr = 0.0001f;
                }

                if (noiseccr < 0.f) {
                    noiseccr = 0.0001f;
                }

                if (noisecfb < 0.f) {
                    noisecfb = 0.0001f;
                }

                if (noiseccb < 0.f) {
                    noiseccb = 0.0001f;
                }


                if (!adecomp.memoryAllocationFailed && !bdecomp.memoryAllocationFailed) {
                    float maxcfine = 0.f;
                    float maxccoarse = 0.f;

                    if (aut == 0) {

                        if (levred == 7) {
                            edge = 2;
                            variC[0] = SQR(noisecfr);
                            variC[1] = SQR(noisecfr);
                            variC[2] = SQR(noisecfr);

                            variC[3] = SQR(noisecfr);
                            variC[4] = SQR(noisecfr);
                            variC[5] = SQR(noiseccr);
                            variC[6] = SQR(noiseccr);

                            variCb[0] = SQR(noisecfb);
                            variCb[1] = SQR(noisecfb);
                            variCb[2] = SQR(noisecfb);

                            variCb[3] = SQR(noisecfb);
                            variCb[4] = SQR(noisecfb);
                            variCb[5] = SQR(noiseccb);
                            variCb[6] = SQR(noiseccb);

                        } else if (levred == 4) {
                            edge = 3;
                            variC[0] = SQR(lp.noisecf / 10.0);
                            variC[1] = SQR(lp.noisecf / 10.0);
                            variC[2] = SQR(lp.noisecf / 10.0);
                            variC[3] = SQR(lp.noisecf / 10.0);

                            variCb[0] = SQR(lp.noisecf / 10.0);
                            variCb[1] = SQR(lp.noisecf / 10.0);
                            variCb[2] = SQR(lp.noisecf / 10.0);
                            variCb[3] = SQR(lp.noisecf / 10.0);


                        }
                    } else if (aut == 1 || aut == 2) {
                        edge = 2;
                        variC[0] = SQR(slida[0]);
                        variC[1] = SQR(slida[1]);
                        variC[2] = SQR(slida[2]);
                        variC[3] = SQR(slida[3]);
                        variC[4] = SQR(slida[4]);
                        variC[5] = SQR(slida[5]);
                        variC[6] = SQR(slida[6]);
                        float maxc01 = max(slida[0], slida[1]);
                        float maxc23 = max(slida[2], slida[3]);
                        float max03 = max(maxc01, maxc23);
                        float maxrf = max(max03, slida[4]);
                        float maxrc = max(slida[5], slida[6]);

                        variCb[0] = SQR(slidb[0]);
                        variCb[1] = SQR(slidb[1]);
                        variCb[2] = SQR(slidb[2]);
                        variCb[3] = SQR(slidb[3]);
                        variCb[4] = SQR(slidb[4]);
                        variCb[5] = SQR(slidb[5]);
                        variCb[6] = SQR(slidb[6]);
                        float maxb01 = max(slidb[0], slidb[1]);
                        float maxb23 = max(slidb[2], slidb[3]);
                        float maxb03 = max(maxb01, maxb23);
                        float maxbf = max(maxb03, slidb[4]);
                        maxcfine = max(maxrf, maxbf);

                        float maxbc = max(slidb[5], slidb[6]);
                        maxccoarse = max(maxrc, maxbc);

                    }



                    //      if ((lp.noisecf >= 0.1f ||  lp.noisecc >= 0.1f  || noiscfactiv || maxcfine >= 0.1f || maxccoarse > 0.1f)) {
                    {
                        float minic = 0.0001f;

                        if (noiscfactiv) {
                            minic = 0.1f;//only for artifact shape detection
                        }

                        float k1 = 0.f;
                        float k2 = 0.f;
                        float k3 = 0.f;

                        if (aut == 0 || aut == 1) {
                            if ((lp.noisecf < 0.2f && aut == 0) || (maxcfine < 0.2f && aut == 1)) {
                                k1 = 0.f;
                                k2 = 0.f;
                                k3 = 0.f;
                            } else if ((lp.noisecf < 0.3f && aut == 0) || (maxcfine < 0.3f && aut == 1)) {
                                k1 = 0.1f;
                                k2 = 0.0f;
                                k3 = 0.f;
                            } else if ((lp.noisecf < 0.5f && aut == 0) || (maxcfine < 0.5f && aut == 1)) {
                                k1 = 0.2f;
                                k2 = 0.1f;
                                k3 = 0.f;
                            } else if ((lp.noisecf < 0.8f && aut == 0) || (maxcfine < 0.8f && aut == 1)) {
                                k1 = 0.3f;
                                k2 = 0.25f;
                                k3 = 0.f;
                            } else if ((lp.noisecf < 1.f && aut == 0) || (maxcfine < 1.f && aut == 1)) {
                                k1 = 0.4f;
                                k2 = 0.25f;
                                k3 = 0.1f;
                            } else if ((lp.noisecf < 2.f && aut == 0) || (maxcfine < 2.f && aut == 1)) {
                                k1 = 0.5f;
                                k2 = 0.3f;
                                k3 = 0.15f;
                            } else if ((lp.noisecf < 3.f && aut == 0) || (maxcfine < 3.f && aut == 1)) {
                                k1 = 0.6f;
                                k2 = 0.45f;
                                k3 = 0.3f;
                            } else if ((lp.noisecf < 4.f && aut == 0) || (maxcfine < 4.f && aut == 1)) {
                                k1 = 0.7f;
                                k2 = 0.5f;
                                k3 = 0.4f;
                            } else if ((lp.noisecf < 5.f && aut == 0) || (maxcfine < 5.f && aut == 1)) {
                                k1 = 0.8f;
                                k2 = 0.6f;
                                k3 = 0.5f;
                            } else if ((lp.noisecf < 10.f && aut == 0) || (maxcfine < 10.f && aut == 1)) {
                                k1 = 0.85f;
                                k2 = 0.7f;
                                k3 = 0.6f;
                            } else if ((lp.noisecf < 20.f && aut == 0) || (maxcfine < 20.f && aut == 1)) {
                                k1 = 0.9f;
                                k2 = 0.8f;
                                k3 = 0.7f;
                            } else if ((lp.noisecf < 50.f && aut == 0) || (maxcfine < 50.f && aut == 1)) {
                                k1 = 1.f;
                                k2 = 1.f;
                                k3 = 0.9f;

                            } else {
                                k1 = 1.f;
                                k2 = 1.f;
                                k3 = 1.f;
                            }
                        } else if (aut == 2) {
                            k1 = 1.f;
                            k2 = 1.f;
                            k3 = 1.f;
                        }

                        variC[0] = max(minic, variC[0]);
                        variC[1] = max(minic, k1 * variC[1]);
                        variC[2] = max(minic, k2 * variC[2]);
                        variC[3] = max(minic, k3 * variC[3]);

                        variCb[0] = max(minic, variCb[0]);
                        variCb[1] = max(minic, k1 * variCb[1]);
                        variCb[2] = max(minic, k2 * variCb[2]);
                        variCb[3] = max(minic, k3 * variCb[3]);

                        if (levred == 7) {
                            float k4 = 0.f;
                            float k5 = 0.f;
                            float k6 = 0.f;

                            if ((lp.noisecc == 0.01f && aut == 0) || (maxccoarse == 0.1f && aut == 1)) {
                                k4 = 0.f;
                                k5 = 0.0f;
                            } else if ((lp.noisecc < 0.2f && aut == 0) || (maxccoarse < 0.2f && aut == 1)) {
                                k4 = 0.1f;
                                k5 = 0.0f;
                            } else if ((lp.noisecc < 0.5f && aut == 0) || (maxccoarse < 0.5f && aut == 1)) {
                                k4 = 0.15f;
                                k5 = 0.0f;
                            } else if ((lp.noisecc < 1.f && aut == 0) || (maxccoarse < 1.f && aut == 1)) {
                                k4 = 0.15f;
                                k5 = 0.1f;
                            } else if ((lp.noisecc < 3.f && aut == 0) || (maxccoarse < 3.f && aut == 1)) {
                                k4 = 0.3f;
                                k5 = 0.15f;
                            } else if ((lp.noisecc < 4.f && aut == 0) || (maxccoarse < 5.f && aut == 1)) {
                                k4 = 0.6f;
                                k5 = 0.4f;
                            } else if ((lp.noisecc < 6.f && aut == 0) || (maxccoarse < 6.f && aut == 1)) {
                                k4 = 0.8f;
                                k5 = 0.6f;
                            } else {
                                k4 = 1.f;
                                k5 = 1.f;
                            }


                            variC[4] = max(0.0001f, k4 * variC[4]);
                            variC[5] = max(0.0001f, k5 * variC[5]);
                            variCb[4] = max(0.0001f, k4 * variCb[4]);
                            variCb[5] = max(0.0001f, k5 * variCb[5]);

                            if ((lp.noisecc < 4.f && aut == 0) || (maxccoarse < 4.f && aut == 1)) {
                                k6 = 0.f;
                            } else if ((lp.noisecc < 5.f && aut == 0) || (maxccoarse < 5.f && aut == 1)) {
                                k6 = 0.4f;
                            } else if ((lp.noisecc < 6.f && aut == 0) || (maxccoarse < 6.f && aut == 1)) {
                                k6 = 0.7f;
                            } else {
                                k6 = 1.f;
                            }

                            variC[6] = max(0.0001f, k6 * variC[6]);
                            variCb[6] = max(0.0001f, k6 * variCb[6]);
                        }

                        float* noisevarchrom = new float[bfh * bfw];
                        int bfw2 = (bfw + 1) / 2;
                        float nvch = 0.6f;//high value
                        float nvcl = 0.1f;//low value

                        if ((lp.noisecf > 100.f && aut == 0) || (maxcfine > 100.f && (aut == 1 || aut == 2))) {
                            nvch = 0.8f;
                            nvcl = 0.4f;
                        }

                        float seuil = 4000.f;//low
                        float seuil2 = 15000.f;//high
                        //ac and bc for transition
                        float ac = (nvch - nvcl) / (seuil - seuil2);
                        float bc = nvch - seuil * ac;
#ifdef _OPENMP
                        #pragma omp parallel for

#endif

                        for (int ir = 0; ir < bfh; ir++)
                            for (int jr = 0; jr < bfw; jr++) {
                                float cN = sqrt(SQR(bufwv.a[ir][jr]) + SQR(bufwv.b[ir][jr]));

                                if (cN < seuil) {
                                    noisevarchrom[(ir >> 1)*bfw2 + (jr >> 1)] = nvch;
                                } else if (cN < seuil2) {
                                    noisevarchrom[(ir >> 1)*bfw2 + (jr >> 1)] = ac * cN + bc;
                                } else {
                                    noisevarchrom[(ir >> 1)*bfw2 + (jr >> 1)] = nvcl;
                                }
                            }

                        float noisevarab_r = 100.f; //SQR(lp.noisecc / 10.0);
//                   printf("OK CHRO\n");

                        if ((lp.noisecc < 0.02f && aut == 0) || (maxccoarse < 0.1f && (aut == 1  || aut == 2)))  {
//                       printf("SANS Shrink\n");
                            WaveletDenoiseAllAB(Ldecomp, adecomp, noisevarchrom, madL, variC, edge, noisevarab_r, true, false, false, numThreads);
                            WaveletDenoiseAllAB(Ldecomp, bdecomp, noisevarchrom, madL, variCb, edge, noisevarab_r, true, false, false, numThreads);
                        } else {
//                       printf("avec Shrink\n");
                            WaveletDenoiseAll_BiShrinkAB(Ldecomp, adecomp, noisevarchrom, madL, variC, edge, noisevarab_r, true, false, false, numThreads);
                            WaveletDenoiseAllAB(Ldecomp, adecomp, noisevarchrom, madL, variC, edge, noisevarab_r, true, false, false, numThreads);

                            WaveletDenoiseAll_BiShrinkAB(Ldecomp, bdecomp, noisevarchrom, madL, variCb, edge, noisevarab_r, true, false, false, numThreads);
                            WaveletDenoiseAllAB(Ldecomp, bdecomp, noisevarchrom, madL, variCb, edge, noisevarab_r, true, false, false, numThreads);
                        }

                        delete[] noisevarchrom;
                    }
                }

                if (!Ldecomp.memoryAllocationFailed) {
                    Lin = new array2D<float>(bfw, bfh);

#ifdef _OPENMP
                    #pragma omp parallel for

#endif

                    for (int i = 0; i < bfh; ++i) {
                        for (int j = 0; j < bfw; ++j) {
                            (*Lin)[i][j] = bufwv.L[i][j];
                        }
                    }

                    Ldecomp.reconstruct(bufwv.L[0]);
                }


                if (!Ldecomp.memoryAllocationFailed && aut == 0) {


                    if ((lp.noiself >= 0.01f ||  lp.noiself0 >= 0.01f ||  lp.noiself2 >= 0.01f || lp.noiselc >= 0.01f) && levred == 7 && lp.noiseldetail != 100.f) {
                        fftw_denoise(bfw, bfh, max_numblox_W, min_numblox_W, bufwv.L, Lin,  numThreads, lp, 0);
                    }
                }


                if (!adecomp.memoryAllocationFailed) {
                    Ain = new array2D<float>(bfw, bfh);
#ifdef _OPENMP
                    #pragma omp parallel for

#endif

                    for (int i = 0; i < bfh; ++i) {
                        for (int j = 0; j < bfw; ++j) {
                            (*Ain)[i][j] = bufwv.a[i][j];
                        }
                    }

                    adecomp.reconstruct(bufwv.a[0]);
                }

                if (!adecomp.memoryAllocationFailed && aut == 0) {
                    if ((lp.noisecf >= 0.001f ||  lp.noisecc >= 0.001f) && levred == 7  && lp.noisechrodetail != 100.f) {
                        fftw_denoise(bfw, bfh, max_numblox_W, min_numblox_W, bufwv.a, Ain,  numThreads, lp, 1);
                    }
                }


                if (!bdecomp.memoryAllocationFailed) {
                    Bin = new array2D<float>(bfw, bfh);
#ifdef _OPENMP
                    #pragma omp parallel for

#endif

                    for (int i = 0; i < bfh; ++i) {
                        for (int j = 0; j < bfw; ++j) {
                            (*Bin)[i][j] = bufwv.b[i][j];
                        }
                    }

                    bdecomp.reconstruct(bufwv.b[0]);
                }

                if (!bdecomp.memoryAllocationFailed && aut == 0) {
                    if ((lp.noisecf >= 0.001f ||  lp.noisecc >= 0.001f) && levred == 7  && lp.noisechrodetail != 100.f) {
                        fftw_denoise(bfw, bfh, max_numblox_W, min_numblox_W, bufwv.b, Bin,  numThreads, lp, 1);
                    }
                }


                DeNoise_Local(call, lp,  originalmaskbl, levred, huerefblur, lumarefblur, chromarefblur, original, transformed, bufwv, cx, cy, sk);
            }
        }
    }

}


void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * original, LabImage * transformed, LabImage * reserved, int cx, int cy, int oW, int oH, int sk,
        const LocretigainCurve & locRETgainCcurve, const LocretitransCurve & locRETtransCcurve, LUTf & lllocalcurve, bool & locallutili, const LocLHCurve & loclhCurve,  const LocHHCurve & lochhCurve,
        LUTf & lmasklocalcurve, bool & localmaskutili,
        const LocCCmaskCurve & locccmasCurve, bool & lcmasutili, const  LocLLmaskCurve & locllmasCurve, bool & llmasutili, const  LocHHmaskCurve & lochhmasCurve, bool & lhmasutili,
        const LocCCmaskCurve & locccmasexpCurve, bool & lcmasexputili, const  LocLLmaskCurve & locllmasexpCurve, bool & llmasexputili, const  LocHHmaskCurve & lochhmasexpCurve, bool & lhmasexputili,
        const LocCCmaskCurve & locccmasSHCurve, bool & lcmasSHutili, const  LocLLmaskCurve & locllmasSHCurve, bool & llmasSHutili, const  LocHHmaskCurve & lochhmasSHCurve, bool & lhmasSHutili,
        const LocCCmaskCurve & locccmascbCurve, bool & lcmascbutili, const  LocLLmaskCurve & locllmascbCurve, bool & llmascbutili, const  LocHHmaskCurve & lochhmascbCurve, bool & lhmascbutili,
        const LocCCmaskCurve & locccmasretiCurve, bool & lcmasretiutili, const  LocLLmaskCurve & locllmasretiCurve, bool & llmasretiutili, const  LocHHmaskCurve & lochhmasretiCurve, bool & lhmasretiutili,
        const LocCCmaskCurve & locccmastmCurve, bool & lcmastmutili, const  LocLLmaskCurve & locllmastmCurve, bool & llmastmutili, const  LocHHmaskCurve & lochhmastmCurve, bool & lhmastmutili,
        const LocCCmaskCurve & locccmasblCurve, bool & lcmasblutili, const  LocLLmaskCurve & locllmasblCurve, bool & llmasblutili, const  LocHHmaskCurve & lochhmasblCurve, bool & lhmasblutili,
        const LocwavCurve & locwavCurve, bool & locwavutili,
        bool & LHutili, bool & HHutili, LUTf & cclocalcurve, bool & localcutili, bool & localexutili, LUTf & exlocalcurve, LUTf & hltonecurveloc, LUTf & shtonecurveloc, LUTf & tonecurveloc, LUTf & lightCurveloc, double & huerefblur, double & chromarefblur, double & lumarefblur, double & hueref, double & chromaref, double & lumaref, double & sobelref,
        int llColorMask, int llColorMaskinv, int llExpMask, int llExpMaskinv, int llSHMask, int llSHMaskinv, int llcbMask, int llretiMask, int llsoftMask, int lltmMask, int llblMask,
        float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax)
{
    /* comment on processus deltaE
            * the algo uses 3 different ways to manage deltaE according to the type of intervention
            * if we call "applyproc" : the datas produced upstream in bfw, bfh coordinate by the function producing something curves, retinex, exposure, etc.

            * direct : in this case we use directly the datas produced upstream by "applyproc", with only a regulation produce for deltaE by reducdE
            * direct : we found in this case "applyproc" modify data with low amplitude : BlurNoise, CBDL, Denoise, Sharp, TM

            * with first use of "buflight" on which is apply "applyproc", in this case we apply  realstrdE = reducdE * buflight with a function of type 328.f *  realstrdE
            * in this case we found "applyproc" which result in direct use on Luminance : Exposure, Color and Light, Shadows highlight, SoftLight, Local contrast

            * with second use of "buflight" on which is apply "applyproc", in this case we apply  realstrdE = reducdE * buflight with a function of type fli = (100.f + realstrdE) / 100.f;
            * in this case we found "applyproc" which result in large variations of L : Retinex

            * if you change you must test before

    */

    //general call of others functions : important return hueref, chromaref, lumaref
    if (params->locallab.enabled) {
        BENCHFUN
#ifdef _DEBUG
// init variables to display Munsell corrections
        MunsellDebugInfo* MunsDebugInfo = new MunsellDebugInfo();
#endif

        int del = 3; // to avoid crash with [loy - begy] and [lox - begx] and bfh bfw  // with gtk2 [loy - begy-1] [lox - begx -1 ] and del = 1

        struct local_params lp;
        calcLocalParams(sp, oW, oH, params->locallab, lp, llColorMask, llColorMaskinv, llExpMask, llExpMaskinv, llSHMask, llSHMaskinv, llcbMask, llretiMask, llsoftMask, lltmMask, llblMask);

        const float radius = lp.rad / (sk * 1.4f); //0 to 70 ==> see skip
        int strred = 1;//(lp.strucc - 1);

        float radiussob = strred / (sk * 1.4f);
        int levred;
        bool noiscfactiv = false;

        if (lp.qualmet == 2) { //suppress artifacts with quality enhanced
            levred = 4;
            noiscfactiv = true;
        }    else {
            levred = 7;
            noiscfactiv = false;
        }


        if (lp.excmet == 1  && call <= 3) {//exclude
            const int bfh = int (lp.ly + lp.lyT) + del; //bfw bfh real size of square zone
            const int bfw = int (lp.lx + lp.lxL) + del;
            const int begy = lp.yc - lp.lyT;
            const int begx = lp.xc - lp.lxL;
            const int yEn = lp.yc + lp.ly;
            const int xEn = lp.xc + lp.lx;
            LabImage bufreserv(bfw, bfh);
            array2D<float> bufsob(bfw, bfh);

#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = std::max(begy - cy, 0); y < std::min(yEn - cy, original->H); y++) {
                const int loy = cy + y;

                for (int x = std::max(begx - cx, 0); x < std::min(xEn - cx, original->W); x++) {
                    const int lox = cx + x;

                    bufsob[loy - begy][lox - begx] = bufreserv.L[loy - begy][lox - begx] = reserved->L[y][x];
                    bufreserv.a[loy - begy][lox - begx] = reserved->a[y][x];
                    bufreserv.b[loy - begy][lox - begx] = reserved->b[y][x];
                }
            }

            array2D<float> ble(bfw, bfh);
            SobelCannyLuma(ble, bufsob, bfw, bfh, radiussob, true);
            array2D<float> &guid = bufsob;

#ifdef _OPENMP
            #pragma omp parallel for
#endif

            for (int ir = 0; ir < bfh; ir++)
                for (int jr = 0; jr < bfw; jr++) {
                    ble[ir][jr] /= 32768.f;
                    guid[ir][jr] /= 32768.f;
                }

            const float blur = 25 / sk * (10.f + 0.8f * lp.struexp);

            rtengine::guidedFilter(guid, ble, ble, blur, 0.001, multiThread);

            double sombel = 0.f;
            const int ncsobel = bfh * bfw;
            float maxsob = -1.f;
            float minsob = 100000.f;

            array2D<float> &deltasobelL = guid;

#ifdef _OPENMP
            #pragma omp parallel for reduction(+:sombel) reduction(min:minsob) reduction(max:maxsob)
#endif

            for (int ir = 0; ir < bfh; ir++) {
                for (int jr = 0; jr < bfw; jr++) {
                    const float val = ble[ir][jr] * 32768.f;
                    sombel += val;
                    minsob = rtengine::min(maxsob, val);
                    maxsob = rtengine::max(minsob, val);
                    deltasobelL[ir][jr] = val;
                }
            }

            const float meansob = sombel / ncsobel;

            Exclude_Local(deltasobelL, hueref, chromaref, lumaref, sobelref, meansob, lp, original, transformed, &bufreserv, reserved, cx, cy, sk);

        }

//Prepare mask for Blur and noise and Denoise
        bool denoiz = false;

        if (((lp.noiself > 0.f || lp.noiself0 > 0.f || lp.noiself2 > 0.f || lp.noiselc > 0.f || lp.noisecf > 0.f || lp.noisecc > 0.f  || lp.bilat > 0.f)  && lp.denoiena)) {
            denoiz = true;
        }

        bool blurz = false;

        if (((radius > 1.5 * GAUSS_SKIP)  || lp.stren > 0.1 || lp.blmet == 1 || lp.guidb > 1 || lp.showmaskblmet == 2 || lp.enablMask || lp.showmaskblmet == 3 || lp.showmaskblmet == 4) && lp.blurena) {
            blurz = true;
        }

        const int GW = transformed->W;
        const int GH = transformed->H;

        LabImage * originalmaskbl = nullptr;
        std::unique_ptr<LabImage> bufmaskorigbl;
        std::unique_ptr<LabImage> bufmaskblurbl;
        std::unique_ptr<LabImage> bufgb;

        if (denoiz || blurz || lp.denoiena || lp.blurena) {
            bufgb.reset(new LabImage(GW, GH));

            if (lp.showmaskblmet == 2  || lp.enablMask || lp.showmaskblmet == 3 || lp.showmaskblmet == 4) {
                bufmaskorigbl.reset(new LabImage(GW, GH));
                bufmaskblurbl.reset(new LabImage(GW, GH));
                originalmaskbl = new LabImage(GW, GH);
            }

            array2D<float> ble(GW, GH);
            array2D<float> guid(GW, GH);
            float meanfab, fab;
            mean_fab(0, 0, GW, GH, bufgb.get(), original, fab, meanfab, lp.chromabl);

#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < GH; y++) {
                for (int x = 0; x < GW; x++) {
                    bufgb->L[y][x] = original->L[y][x];
                    bufgb->a[y][x] = original->a[y][x];
                    bufgb->b[y][x] = original->b[y][x];
                }
            }

            if (lp.showmaskblmet == 2  || lp.enablMask || lp.showmaskblmet == 3 || lp.showmaskblmet == 4) {
#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int ir = 0; ir < GH; ir++) {
                    for (int jr = 0; jr < GW; jr++) {
                        float kmaskLexp = 0;
                        float kmaskCH = 0;

                        if (locllmasblCurve  && llmasblutili) {
                            float ligh = bufgb->L[ir][jr] / 32768.f;
                            kmaskLexp = 32768.f * LIM01(1.f - locllmasblCurve[500.f * ligh]);
                        }

                        if (lp.showmaskblmet != 4) {
                            if (locccmasblCurve && lcmasblutili) {
                                float chromask = 0.0001f + sqrt(SQR((bufgb->a[ir][jr]) / fab) + SQR((bufgb->b[ir][jr]) / fab));
                                kmaskCH = LIM01(1.f - locccmasblCurve[500.f *  chromask]);
                            }
                        }

                        if (lochhmasblCurve && lhmasblutili) {
                            float huema = xatan2f(bufgb->b[ir][jr], bufgb->a[ir][jr]);
                            float h = Color::huelab_to_huehsv2(huema);
                            h += 1.f / 6.f;

                            if (h > 1.f) {
                                h -= 1.f;
                            }

                            float valHH = LIM01(1.f - lochhmasblCurve[500.f *  h]);

                            if (lp.showmaskblmet != 4) {
                                kmaskCH += valHH;
                            }

                            kmaskLexp += 32768.f * valHH;
                        }

                        bufmaskblurbl->L[ir][jr] = CLIPLOC(kmaskLexp);
                        bufmaskblurbl->a[ir][jr] = kmaskCH;
                        bufmaskblurbl->b[ir][jr] = kmaskCH;
                        ble[ir][jr] = bufmaskblurbl->L[ir][jr] / 32768.f;
                        float X, Y, Z;
                        float L = bufgb->L[ir][jr];
                        float a = bufgb->a[ir][jr];
                        float b = bufgb->b[ir][jr];
                        Color::Lab2XYZ(L, a, b, X, Y, Z);

                        guid[ir][jr] = Y / 32768.f;


                    }
                }

                if (lp.radmabl > 0.f) {
                    guidedFilter(guid, ble, ble, lp.radmabl * 10.f / sk, 0.001, multiThread, 4);
                }

                LUTf lutTonemaskbl(65536);
                calcGammaLut(lp.gammabl, lp.slomabl, lutTonemaskbl);

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int ir = 0; ir < GH; ir++)
                    for (int jr = 0; jr < GW; jr++) {
                        float L_;
                        bufmaskblurbl->L[ir][jr] = LIM01(ble[ir][jr]) * 32768.f;
                        L_ = 2.f * bufmaskblurbl->L[ir][jr];
                        bufmaskblurbl->L[ir][jr] = lutTonemaskbl[L_];
                    }

            }


            float lap = params->locallab.spots.at(sp).lapmaskbl;
            bool pde = params->locallab.spots.at(sp).laplac;

            if (lap > 0.f && (lp.enablMask || lp.showmaskblmet == 3)) {
                float *datain = new float[GH * GW];
                float *data_tmp = new float[GH * GW];

#ifdef _OPENMP
                #pragma omp parallel for
#endif

                for (int y = 0; y < GH; y++) {
                    for (int x = 0; x < GW; x++) {
                        datain[y * GW + x] =  bufmaskblurbl->L[y][x];
                    }
                }

                if (!pde) {
                    ImProcFunctions::discrete_laplacian_threshold(data_tmp, datain, GW, GH, 200.f * lap);
                } else {
                    ImProcFunctions::retinex_pde(datain, data_tmp, GW, GH, 12.f * lap, 1.f, nullptr, 0, 0, 1);
                }

#ifdef _OPENMP
                #pragma omp parallel for
#endif

                for (int y = 0; y < GH; y++) {
                    for (int x = 0; x < GW; x++) {
                        bufmaskblurbl->L[y][x] = data_tmp[y * GW + x];
                    }
                }

                delete [] datain;
                delete [] data_tmp;

            }


            float radiusb = 1.f / sk;

            if (lp.showmaskblmet == 2 || lp.enablMask || lp.showmaskblmet == 3 || lp.showmaskblmet == 4) {
                int invers = 0;

                if (lp.blurmet == 0) {
                    invers = 0;
                } else if (lp.blurmet == 1) {
                    invers = 1;
                }

#ifdef _OPENMP
                #pragma omp parallel
#endif
                {
                    gaussianBlur(bufmaskblurbl->L, bufmaskorigbl->L, GW, GH, radiusb);
                    gaussianBlur(bufmaskblurbl->a, bufmaskorigbl->a, GW, GH, 1.f + (0.5f * lp.radmabl) / sk);
                    gaussianBlur(bufmaskblurbl->b, bufmaskorigbl->b, GW, GH, 1.f + (0.5f * lp.radmabl) / sk);
                }

                if (lp.showmaskblmet == 0 || lp.showmaskblmet == 1 || lp.showmaskblmet == 2 || lp.showmaskblmet == 4 || lp.enablMask) {
                    blendmask(lp, 0, 0, cx, cy, GW, GH, bufgb.get(), original, bufmaskorigbl.get(), originalmaskbl, lp.blendmabl, invers);

                } else if (lp.showmaskblmet == 3) {
                    showmask(lp, 0, 0, cx, cy, GW, GH, bufgb.get(), transformed, bufmaskorigbl.get(), invers);
                    return;
                }

            }

//end mask



        }

        if (((radius > 1.5 * GAUSS_SKIP  && lp.rad > 1.6) || lp.stren > 0.1 || lp.blmet == 1 || lp.guidb > 0 || lp.showmaskblmet == 2 || lp.enablMask || lp.showmaskblmet == 3 || lp.showmaskblmet == 4) && lp.blurena) { // radius < GAUSS_SKIP means no gauss, just copy of original image
            std::unique_ptr<LabImage> tmp1;
            std::unique_ptr<LabImage> tmp2;
            const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            const int bfh = yend - ystart;
            const int bfw = xend - xstart;
            bool fft = params->locallab.spots.at(sp).fftwbl;
            int isogr = params->locallab.spots.at(sp).isogr;
            int strengr = params->locallab.spots.at(sp).strengr;
            int scalegr = params->locallab.spots.at(sp).scalegr;

            if (bfw >= mSP && bfh >= mSP) {

                // const int GW = transformed->W;
                //const int GH = transformed->H;
                JaggedArray<float> bufchroi(GW, GH);
                std::unique_ptr<LabImage> bufgbi(new LabImage(GW, GH));
                JaggedArray<float> bufchro(bfw, bfh);

                //here mask is used with plein image for normal and inverse
                //if it is possible to optimze with maskcalccol(), I don't to preserv lisibility
                if (lp.showmaskblmet == 0 || lp.showmaskblmet == 1  || lp.showmaskblmet == 2 || lp.showmaskblmet == 4 || lp.enablMask) {

                    if (lp.blurmet == 0) {
                        if (bfw > 0 && bfh > 0) {
                            tmp1.reset(new LabImage(bfw, bfh));
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = ystart; y < yend ; y++) {
                                for (int x = xstart; x < xend; x++) {
                                    tmp1->L[y - ystart][x - xstart] = original->L[y][x];
                                    tmp1->a[y - ystart][x - xstart] = original->a[y][x];
                                    tmp1->b[y - ystart][x - xstart] = original->b[y][x];
                                }
                            }
                        }
                    } else if (lp.blurmet == 1) {
                        tmp1.reset(new LabImage(transformed->W, transformed->H));
                        tmp2.reset(new LabImage(transformed->W, transformed->H));

                        for (int y = 0; y < GH ; y++) {
                            for (int x = 0; x < GW; x++) {
                                tmp2->L[y][x] = original->L[y][x];
                                tmp2->a[y][x] = original->a[y][x];
                                tmp2->b[y][x] = original->b[y][x];
                                bufgbi->L[y][x] = original->L[y][x];
                                bufgbi->a[y][x] = original->a[y][x];
                                bufgbi->b[y][x] = original->b[y][x];
                            }
                        }

                    }


                    if (lp.blurmet == 0  && lp.blmet == 0  && radius > (1.5 * GAUSS_SKIP) && lp.rad > 1.6) {
#ifdef _OPENMP
                        #pragma omp parallel
#endif
                        {
                            if (fft  && call == 2)
                            {
                                ImProcFunctions::fftw_convol_blur2(tmp1->L, tmp1->L, bfw, bfh, radius, 0, 0);
                                ImProcFunctions::fftw_convol_blur2(tmp1->a, tmp1->a, bfw, bfh, radius, 0, 0);
                                ImProcFunctions::fftw_convol_blur2(tmp1->b, tmp1->b, bfw, bfh, radius, 0, 0);
                            } else
                            {
                                gaussianBlur(tmp1->L, tmp1->L, bfw, bfh, radius);
                                gaussianBlur(tmp1->a, tmp1->a, bfw, bfh, radius);
                                gaussianBlur(tmp1->b, tmp1->b, bfw, bfh, radius);
                            }
                        }

                    } else if (lp.blurmet == 1  && lp.blmet == 0 && radius > (1.5 * GAUSS_SKIP) && lp.rad > 1.6) {

#ifdef _OPENMP
                        #pragma omp parallel
#endif
                        {
                            if (fft && call == 2)
                            {
                                ImProcFunctions::fftw_convol_blur2(tmp1->L, tmp1->L, GW, GH, radius, 0, 0);
                                ImProcFunctions::fftw_convol_blur2(tmp1->a, tmp1->a, GW, GH, radius, 0, 0);
                                ImProcFunctions::fftw_convol_blur2(tmp1->b, tmp1->b, GW, GH, radius, 0, 0);
                            } else
                            {
                                gaussianBlur(original->L, tmp1->L, GW, GH, radius);
                                gaussianBlur(original->a, tmp1->a, GW, GH, radius);
                                gaussianBlur(original->b, tmp1->b, GW, GH, radius);
                            }
                        }
                    }


                    //add noise
                    if (tmp1.get() && lp.stren > 0.1f  && lp.blmet == 0) {
                        float mean = 0.f;//0 best result
                        float variance = lp.stren ;
                        addGaNoise(tmp1.get(), tmp1.get(), mean, variance, sk) ;
                    }

                    //add grain
                    if (lp.blmet == 0 && strengr > 0) {
                        int wi = bfw;
                        int he = bfh;

                        if (lp.blurmet == 1) {
                            wi = GW;
                            he = GH;
                        }

                        if (tmp1.get()) {
                            Imagefloat *tmpImage = nullptr;
                            tmpImage = new Imagefloat(wi, he);

                            for (int y = 0; y < he ; y++) {
                                for (int x = 0; x < wi; x++) {
                                    tmpImage->g(y, x) = tmp1->L[y][x];
                                    tmpImage->r(y, x) = tmp1->a[y][x];
                                    tmpImage->b(y, x) = tmp1->b[y][x];
                                }
                            }


                            filmGrain(tmpImage, isogr, strengr, scalegr, wi, he);

                            for (int y = 0; y < he ; y++) {
                                for (int x = 0; x < wi; x++) {
                                    tmp1->L[y][x] = tmpImage->g(y, x);
                                    tmp1->a[y][x] = tmpImage->r(y, x);
                                    tmp1->b[y][x] = tmpImage->b(y, x);
                                }
                            }

                            delete tmpImage;
                        }
                    }

                    Median medianTypeL = Median::TYPE_3X3_STRONG;
                    Median medianTypeAB = Median::TYPE_3X3_STRONG;

                    if (lp.medmet == 0) {
                        medianTypeL = medianTypeAB = Median::TYPE_3X3_STRONG;
                    } else if (lp.medmet == 1) {
                        medianTypeL = medianTypeAB = Median::TYPE_5X5_STRONG;
                    } else if (lp.medmet == 2) {
                        medianTypeL = medianTypeAB = Median::TYPE_7X7;
                    } else if (lp.medmet == 3) {
                        medianTypeL = medianTypeAB = Median::TYPE_9X9;
                    }

                    if (lp.blurmet == 0  && lp.blmet == 1) {
                        float** tmL;
                        int wid = bfw;
                        int hei = bfh;
                        tmL = new float*[hei];

                        for (int i = 0; i < hei; ++i) {
                            tmL[i] = new float[wid];
                        }

                        Median_Denoise(tmp1->L, tmp1->L, bfw, bfh, medianTypeL, lp.it, multiThread, tmL);

                        if (!lp.actsp) {
                            Median_Denoise(tmp1->a, tmp1->a, bfw, bfh, medianTypeAB, lp.it, multiThread, tmL);
                            Median_Denoise(tmp1->b, tmp1->b, bfw, bfh, medianTypeAB, lp.it, multiThread, tmL);
                        }

                        for (int i = 0; i < hei; ++i) {
                            delete[] tmL[i];
                        }

                        delete[] tmL;

                    } else if (lp.blurmet == 1  && lp.blmet == 1) {
                        float** tmL;
                        int wid = GW;
                        int hei = GH;
                        tmL = new float*[hei];

                        for (int i = 0; i < hei; ++i) {
                            tmL[i] = new float[wid];
                        }

                        Median_Denoise(tmp2->L, tmp1->L, GW, GH, medianTypeL, lp.it, multiThread, tmL);

                        if (!lp.actsp) {
                            Median_Denoise(tmp2->a, tmp1->a, GW, GH, medianTypeAB, lp.it, multiThread, tmL);
                            Median_Denoise(tmp2->b, tmp1->b, GW, GH, medianTypeAB, lp.it, multiThread, tmL);
                        }

                        for (int i = 0; i < hei; ++i) {
                            delete[] tmL[i];
                        }

                        delete[] tmL;
                    }

                    if (lp.blurmet == 0  && lp.blmet == 2) {

                        if (lp.guidb > 0) {
                            lp.actsp = true;
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = ystart; y < yend ; y++) {
                                for (int x = xstart; x < xend; x++) {
                                    tmp1->L[y - ystart][x - xstart] = original->L[y][x];
                                    bufgb->L[y - ystart][x - xstart] = original->L[y][x];
                                }
                            }

                            array2D<float> LL(bfw, bfh);
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = 0; y < bfh ; y++) {
                                for (int x = 0; x < bfw; x++) {
                                    LL[y][x] = tmp1->L[y][x];
                                }
                            }

                            int r = max(int(lp.guidb / sk), 1);

                            const float epsil = 0.001f * std::pow(2, - lp.epsb);
                            rtengine::guidedFilterLog(10.f, LL, r, epsil, multiThread);
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = 0; y < bfh ; y++) {
                                for (int x = 0; x < bfw; x++) {
                                    tmp1->L[y][x] = LL[y][x];
                                }
                            }
                        }

                    } else if (lp.blurmet == 1  && lp.blmet == 2) {
                        if (lp.guidb > 0) {
                            lp.actsp = true;
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = 0; y < GH ; y++) {
                                for (int x = 0; x < GW; x++) {
                                    tmp1->L[y][x] = original->L[y][x];
                                    tmp2->L[y][x] = original->L[y][x];
                                }
                            }

                            array2D<float> LLI(GW, GH);
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = 0; y < GH ; y++) {
                                for (int x = 0; x < GW; x++) {
                                    LLI[y][x] = tmp1->L[y][x];
                                }
                            }

                            int r = max(int(lp.guidb / sk), 1);
                            const float epsil = 0.001f * std::pow(2, - lp.epsb);
                            rtengine::guidedFilterLog(10.f, LLI, r, epsil, multiThread);
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = 0; y < GH ; y++) {
                                for (int x = 0; x < GW; x++) {
                                    tmp1->L[y][x] = LLI[y][x];
                                }
                            }
                        }

                    }

                    if (lp.blurmet == 0) {
                        float minC = sqrt(SQR(tmp1->a[0][0]) + SQR(tmp1->b[0][0])) - sqrt(SQR(bufgb->a[0][0]) + SQR(bufgb->b[0][0]));
                        float maxC = minC;
#ifdef _OPENMP
                        #pragma omp parallel for reduction(max:maxC) reduction(min:minC) schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++) {
                            for (int jr = 0; jr < bfw; jr++) {
                                bufchro[ir][jr] = sqrt(SQR(tmp1->a[ir][jr]) + SQR(tmp1->b[ir][jr])) - sqrt(SQR(bufgb->a[ir][jr]) + SQR(bufgb->b[ir][jr]));
                                minC = rtengine::min(minC, bufchro[ir][jr]);
                                maxC = rtengine::max(maxC, bufchro[ir][jr]);
                            }
                        }

                        float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                        if (coefC == 0.f) {
                            coefC = 1.f;
                        }

#ifdef _OPENMP
                        #pragma omp parallel for
#endif

                        for (int y = 0; y < bfh; y++) {
                            for (int x = 0; x < bfw; x++) {
                                bufchro[y][x] /= coefC;
                            }
                        }

                    } else if (lp.blurmet == 1) {
                        float minC = sqrt(SQR(tmp1->a[0][0]) + SQR(tmp1->b[0][0])) - sqrt(SQR(bufgbi->a[0][0]) + SQR(bufgbi->b[0][0]));
                        float maxC = minC;
#ifdef _OPENMP
                        #pragma omp parallel for reduction(max:maxC) reduction(min:minC) schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < GH; ir++) {
                            for (int jr = 0; jr < GW; jr++) {
                                bufchroi[ir][jr] = sqrt(SQR(tmp1->a[ir][jr]) + SQR(tmp1->b[ir][jr])) - sqrt(SQR(bufgbi->a[ir][jr]) + SQR(bufgbi->b[ir][jr]));
                                minC = rtengine::min(minC, bufchroi[ir][jr]);
                                maxC = rtengine::max(maxC, bufchroi[ir][jr]);
                            }
                        }

                        float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                        if (coefC == 0.f) {
                            coefC = 1.f;
                        }

#ifdef _OPENMP
                        #pragma omp parallel for
#endif

                        for (int y = 0; y < GH; y++) {
                            for (int x = 0; x < GW; x++) {
                                bufchroi[y][x] /= coefC;
                            }
                        }

                    }

                    if (lp.blurmet == 0) { //blur and noise (center)

                        if (tmp1.get()) {
                            BlurNoise_Local(tmp1.get(), originalmaskbl, bufchro, hueref, chromaref, lumaref, lp, original, transformed, cx, cy, sk);
                        }
                    } else if (lp.blurmet == 1) {
                        if (tmp1.get()) {
                            InverseBlurNoise_Local(originalmaskbl, bufchroi, lp, hueref, chromaref, lumaref, original, transformed, tmp1.get(), cx, cy, sk);
                        }
                    }

                }
            }
        }

        //local impulse
        if ((lp.bilat > 0.f) && lp.denoiena) {
            const int bfh = int (lp.ly + lp.lyT) + del; //bfw bfh real size of square zone
            const int bfw = int (lp.lx + lp.lxL) + del;

            std::unique_ptr<LabImage> bufwv;

            if (call == 2) {//simpleprocess
                bufwv.reset(new LabImage(bfw, bfh)); //buffer for data in zone limit

                const int begy = lp.yc - lp.lyT;
                const int begx = lp.xc - lp.lxL;
                const int yEn = lp.yc + lp.ly;
                const int xEn = lp.xc + lp.lx;

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = rtengine::max(0, begy - cy); y < rtengine::min(transformed->H, yEn - cy); y++) {
                    const int loy = cy + y;

                    for (int x = rtengine::max(0, begx - cx); x < rtengine::min(transformed->W, xEn - cx); x++) {
                        const int lox = cx + x;
                        bufwv->L[loy - begy][lox - begx] = original->L[y][x];
                        bufwv->a[loy - begy][lox - begx] = original->a[y][x];
                        bufwv->b[loy - begy][lox - begx] = original->b[y][x];
                    }
                }
            } else {//dcrop.cc
                bufwv.reset(new LabImage(transformed->W, transformed->H));
                bufwv->CopyFrom(original);
            } //end dcrop

            const double threshold = lp.bilat / 20.0;

            if (bfh > 8 && bfw > 8) {
                ImProcFunctions::impulse_nr(bufwv.get(), threshold);
            }

            DeNoise_Local(call, lp,  originalmaskbl, levred, huerefblur, lumarefblur, chromarefblur, original, transformed, *(bufwv.get()), cx, cy, sk);
        }

//local denoise
        float slidL[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
        float slida[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
        float slidb[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
        int aut = 0;

        if (lp.denoiena) {
            DeNoise(call, del, slidL, slida, slidb, aut, noiscfactiv, lp, originalmaskbl, levred, huerefblur, lumarefblur, chromarefblur, original, transformed, cx, cy, sk);
        }

        if (denoiz || blurz || lp.denoiena || lp.blurena) {
            delete originalmaskbl;
        }

//begin cbdl
        if ((lp.mulloc[0] != 1.f || lp.mulloc[1] != 1.f || lp.mulloc[2] != 1.f || lp.mulloc[3] != 1.f || lp.mulloc[4] != 1.f || lp.mulloc[5] != 1.f || lp.clarityml != 0.f || lp.contresid != 0.f  || lp.enacbMask || lp.showmaskcbmet == 2 || lp.showmaskcbmet == 3 || lp.showmaskcbmet == 4) && lp.cbdlena) {
            if (call <= 3) { //call from simpleprocess dcrop improcc
                const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
                const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
                const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
                const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
                int bfh = yend - ystart;
                int bfw = xend - xstart;

                if (bfw > 65 && bfh > 65) {
                    array2D<float> bufsh(bfw, bfh);
                    array2D<float> &buflight = bufsh;
                    JaggedArray<float> bufchrom(bfw, bfh, true);
                    std::unique_ptr<LabImage> loctemp(new LabImage(bfw, bfh));
                    std::unique_ptr<LabImage> origcbdl(new LabImage(bfw, bfh));
                    std::unique_ptr<LabImage> bufmaskorigcb;
                    std::unique_ptr<LabImage> bufmaskblurcb;
                    std::unique_ptr<LabImage> originalmaskcb;

                    if (lp.showmaskcbmet == 2  || lp.enacbMask || lp.showmaskcbmet == 3 || lp.showmaskcbmet == 4) {
                        bufmaskorigcb.reset(new LabImage(bfw, bfh));
                        bufmaskblurcb.reset(new LabImage(bfw, bfh));
                        originalmaskcb.reset(new LabImage(bfw, bfh));
                    }

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = 0; y < bfh; y++) {
                        for (int x = 0; x < bfw; x++) {
                            loctemp->L[y][x] = original->L[y + ystart][x + xstart];
                        }
                    }

                    int inv = 0;
                    bool showmaske = false;
                    bool enaMask = false;
                    bool deltaE = false;
                    bool modmask = false;
                    bool zero = false;
                    bool modif = false;

                    if (lp.showmaskcbmet == 3) {
                        showmaske = true;
                    }

                    if (lp.enacbMask) {
                        enaMask = true;
                    }

                    if (lp.showmaskcbmet == 4) {
                        deltaE = true;
                    }

                    if (lp.showmaskcbmet == 2) {
                        modmask = true;
                    }

                    if (lp.showmaskcbmet == 1) {
                        modif = true;
                    }

                    if (lp.showmaskcbmet == 0) {
                        zero = true;
                    }

                    float chrom = lp.chromacbm;;
                    float rad = lp.radmacb;
                    float gamma = lp.gammacb;
                    float slope = lp.slomacb;
                    float blendm = lp.blendmacb;
                    float lap = params->locallab.spots.at(sp).lapmaskcb;
                    float pde = params->locallab.spots.at(sp).laplac;
                    LUTf dummy;
                    bool uti;
                    maskcalccol(false, pde, bfw, bfh, xstart, ystart, sk, cx, cy, loctemp.get(), bufmaskorigcb.get(), originalmaskcb.get(), original, inv, lp,
                                locccmascbCurve, lcmascbutili, locllmascbCurve, llmascbutili, lochhmascbCurve, lhmascbutili, multiThread,
                                enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);

                    if (lp.showmaskcbmet == 3) {
                        showmask(lp, xstart, ystart, cx, cy, bfw, bfh, loctemp.get(), transformed, bufmaskorigcb.get(), 0);

                        return;
                    }

                    constexpr float b_l = -5.f;
                    constexpr float t_l = 25.f;
                    constexpr float t_r = 120.f;
                    constexpr float b_r = 170.f;
                    constexpr double skinprot = 0.;
                    int choice = 0;

                    if (lp.showmaskcbmet == 0 || lp.showmaskcbmet == 1  || lp.showmaskcbmet == 2 || lp.showmaskcbmet == 4 || lp.enacbMask) {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int y = ystart; y < yend; y++) {
                            for (int x = xstart; x < xend; x++) {
                                bufsh[y - ystart][x - xstart] = origcbdl->L[y - ystart][x - xstart] = original->L[y][x];
                                loctemp->a[y - ystart][x - xstart] = origcbdl->a[y - ystart][x - xstart] = original->a[y][x];
                                loctemp->b[y - ystart][x - xstart] = origcbdl->b[y - ystart][x - xstart] = original->b[y][x];
                            }
                        }

                        if (lp.clarityml != 0.f && lp.mulloc[5] == 1.0) { //enabled last level to retrieve level 5 and residual image in case user not select level 5
                            lp.mulloc[5] = 1.001f;
                        }

                        if (lp.contresid != 0.f && lp.mulloc[5] == 1.0) { //enabled last level to retrieve level 5 and residual image in case user not select level 5
                            lp.mulloc[5] = 1.001f;
                        }

                        ImProcFunctions::cbdl_local_temp(bufsh, loctemp->L, bfw, bfh, lp.mulloc, 1.f, lp.threshol, lp.clarityml, lp.contresid, lp.blurcbdl, skinprot, false, b_l, t_l, t_r, b_r, choice, sk, multiThread);

                        if (lp.softradiuscb > 0.f) {
                            softproc(origcbdl.get(), loctemp.get(), lp.softradiuscb, bfh, bfw, 0.0001, 0.00001, 0.1f, sk, multiThread, 0);
                        }

                    }

                    transit_shapedetect(6, loctemp.get(), originalmaskcb.get(), buflight, bufchrom, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f, nullptr, lp, original, transformed, cx, cy, sk);

                    bool nochroma = (lp.showmaskcbmet == 2  || lp.showmaskcbmet == 1);

                    //chroma CBDL begin here
                    if (lp.chromacb > 0.f && !nochroma) {
#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++) {
                            for (int jr = 0; jr < bfw; jr++) {
                                bufsh[ir][jr] = sqrt(SQR(loctemp->a[ir][jr]) + SQR(loctemp->b[ir][jr]));
                            }
                        }

                        float multc[6];
                        float clarich = 0.5f * lp.clarityml;

                        if (clarich > 0.f && lp.mulloc[0] == 1.f) { //to enabled in case of user select only clarity
                            lp.mulloc[0] = 1.01f;
                        }

                        if (lp.contresid != 0.f && lp.mulloc[0] == 1.f) { //to enabled in case of user select only clarity
                            lp.mulloc[0] = 1.01f;
                        }

                        for (int lv = 0; lv < 6; lv++) {
                            multc[lv] = rtengine::max((lp.chromacb * ((float) lp.mulloc[lv] - 1.f)) + 1.f, 0.01f);
                        }

                        choice = 1;
                        ImProcFunctions::cbdl_local_temp(bufsh, loctemp->L, bfw, bfh, multc, rtengine::max(lp.chromacb, 1.f), lp.threshol, clarich, 0.f, lp.blurcbdl, skinprot, false,  b_l, t_l, t_r, b_r, choice, sk, multiThread);


                        float minC = loctemp->L[0][0] - sqrt(SQR(loctemp->a[0][0]) + SQR(loctemp->b[0][0]));
                        float maxC = minC;
#ifdef _OPENMP
                        #pragma omp parallel for reduction(max:maxC) reduction(min:minC) schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++) {
                            for (int jr = 0; jr < bfw; jr++) {
                                bufchrom[ir][jr] = (loctemp->L[ir][jr] - sqrt(SQR(loctemp->a[ir][jr]) + SQR(loctemp->b[ir][jr])));
                                minC = rtengine::min(minC, bufchrom[ir][jr]);
                                maxC = rtengine::max(maxC, bufchrom[ir][jr]);
                            }
                        }

                        float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                        if (coefC == 0.f) {
                            coefC = 1.f;
                        }




#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++) {
                            for (int jr = 0; jr < bfw; jr++) {
                                bufchrom[ir][jr] /= coefC;
                            }
                        }

                        transit_shapedetect(7, loctemp.get(), nullptr, buflight, bufchrom, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f, nullptr, lp, original, transformed, cx, cy, sk);
                    }
                }
            }
        }


//end cbdl_Local

//vibrance

        if (lp.expvib && (lp.past != 0.f  || lp.satur != 0.f)) { //interior ellipse renforced lightness and chroma  //locallutili
            if (call <= 3) { //simpleprocess, dcrop, improccoordinator
                const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
                const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
                const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
                const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
                const int bfh = yend - ystart;
                const int bfw = xend - xstart;

                if (bfw >= mSP && bfh >= mSP) {
                    JaggedArray<float> buflight(bfw, bfh);
                    JaggedArray<float> bufl_ab(bfw, bfh);
                    std::unique_ptr<LabImage> bufexporig(new LabImage(bfw, bfh));
                    std::unique_ptr<LabImage> bufexpfin(new LabImage(bfw, bfh));

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = ystart; y < yend; y++) {
                        for (int x = xstart; x < xend; x++) {
                            bufexporig->L[y - ystart][x - xstart] = original->L[y][x];
                            bufexporig->a[y - ystart][x - xstart] = original->a[y][x];
                            bufexporig->b[y - ystart][x - xstart] = original->b[y][x];
                        }
                    }

                    VibranceParams vibranceParams;
                    vibranceParams.enabled = params->locallab.spots.at(sp).expvibrance;
                    vibranceParams.pastels = params->locallab.spots.at(sp).pastels;
                    vibranceParams.saturated = params->locallab.spots.at(sp).saturated;
                    vibranceParams.psthreshold = params->locallab.spots.at(sp).psthreshold;
                    vibranceParams.protectskins = params->locallab.spots.at(sp).protectskins;
                    vibranceParams.avoidcolorshift = params->locallab.spots.at(sp).avoidcolorshift;
                    vibranceParams.pastsattog = params->locallab.spots.at(sp).pastsattog;
                    vibranceParams.skintonescurve = params->locallab.spots.at(sp).skintonescurve;

                    bufexpfin->CopyFrom(bufexporig.get());
                    ImProcFunctions::vibrance(bufexpfin.get(), vibranceParams, params->toneCurve.hrenabled, params->icm.workingProfile);

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = 0; y < bfh; y++) {
                        for (int x = 0; x < bfw; x++) {
                            buflight[y][x] = CLIPRET((bufexpfin->L[y][x] - bufexporig->L[y][x]) / 328.f);
                            bufl_ab[y][x] = CLIPRET((sqrt(SQR(bufexpfin->a[y][x]) + SQR(bufexpfin->b[y][x])) - sqrt(SQR(bufexporig->a[y][x]) + SQR(bufexporig->b[y][x]))) / 250.f);
                        }
                    }

                    bufexpfin.reset();
                    transit_shapedetect(2, bufexporig.get(), nullptr, buflight, bufl_ab, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f, nullptr, lp, original, transformed, cx, cy, sk);
                }
            }
        }


//Tone mapping

        if ((lp.strengt != 0.f || lp.showmasktmmet == 2 || lp.enatmMask || lp.showmasktmmet == 3 || lp.showmasktmmet == 4) && lp.tonemapena  && !params->epd.enabled) {
            if (call <= 3) { //simpleprocess dcrop improcc
                const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
                const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
                const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
                const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
                const int bfh = yend - ystart;
                const int bfw = xend - xstart;

                if (bfw >= mSP && bfh >= mSP) {
                    array2D<float> buflight(bfw, bfh);
                    JaggedArray<float> bufchro(bfw, bfh);
                    std::unique_ptr<LabImage> bufgb(new LabImage(bfw, bfh));
                    std::unique_ptr<LabImage> tmp1(new LabImage(bfw, bfh));
                    std::unique_ptr<LabImage> bufgbm(new LabImage(bfw, bfh));
                    std::unique_ptr<LabImage> tmp1m(new LabImage(bfw, bfh));
                    std::unique_ptr<LabImage> bufmaskorigtm;
                    std::unique_ptr<LabImage> bufmaskblurtm;
                    std::unique_ptr<LabImage> originalmasktm;

                    //       if (lp.showmasktmmet == 0 || lp.showmasktmmet == 2  || lp.enatmMask || lp.showmasktmmet == 3 || lp.showmasktmmet == 4) {
                    if (lp.showmasktmmet == 2  || lp.enatmMask || lp.showmasktmmet == 3 || lp.showmasktmmet == 4) {
                        bufmaskorigtm.reset(new LabImage(bfw, bfh));
                        bufmaskblurtm.reset(new LabImage(bfw, bfh));
                        originalmasktm.reset(new LabImage(bfw, bfh));
                    }

                    int itera = 0;

                    if (call == 1) {
                        //  itera = 5;
                    }

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = ystart; y < yend; y++) {
                        for (int x = xstart; x < xend; x++) {
                            bufgb->L[y - ystart][x - xstart] = original->L[y][x];
                            bufgb->a[y - ystart][x - xstart] = original->a[y][x];
                            bufgb->b[y - ystart][x - xstart] = original->b[y][x];
                            bufgbm->L[y - ystart][x - xstart] = original->L[y][x];
                            bufgbm->a[y - ystart][x - xstart] = original->a[y][x];
                            bufgbm->b[y - ystart][x - xstart] = original->b[y][x];
                        }
                    }

                    int inv = 0;
                    bool showmaske = false;
                    bool enaMask = false;
                    bool deltaE = false;
                    bool modmask = false;
                    bool zero = false;
                    bool modif = false;

                    if (lp.showmasktmmet == 3) {
                        showmaske = true;
                    }

                    if (lp.enatmMask) {
                        enaMask = true;
                    }

                    if (lp.showmasktmmet == 4) {
                        deltaE = true;
                    }

                    if (lp.showmasktmmet == 2) {
                        modmask = true;
                    }

                    if (lp.showmasktmmet == 1) {
                        modif = true;
                    }

                    if (lp.showmasktmmet == 0) {
                        zero = true;
                    }

                    float chrom = lp.chromatm;;
                    float rad = lp.radmatm;
                    float gamma = lp.gammatm;
                    float slope = lp.slomatm;
                    float blendm = lp.blendmatm;
                    float lap = params->locallab.spots.at(sp).lapmasktm;
                    float pde = params->locallab.spots.at(sp).laplac;

                    if (!params->locallab.spots.at(sp).enatmMaskaft) {
                        LUTf dummy;
                        bool uti;

                        maskcalccol(false, pde, bfw, bfh, xstart, ystart, sk, cx, cy, bufgbm.get(), bufmaskorigtm.get(), originalmasktm.get(), original, inv, lp,
                                    locccmastmCurve, lcmastmutili, locllmastmCurve, llmastmutili, lochhmastmCurve, lhmastmutili, multiThread,
                                    enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);

                        if (lp.showmasktmmet == 3) {
                            showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufgbm.get(), transformed, bufmaskorigtm.get(), 0);

                            return;
                        }
                    }

                    if (lp.showmasktmmet == 0 || lp.showmasktmmet == 1  || lp.showmasktmmet == 2 || lp.showmasktmmet == 4 || lp.showmasktmmet == 3 || lp.enatmMask) {



                        ImProcFunctions::EPDToneMaplocal(sp, bufgb.get(), tmp1.get(), itera, sk);//iterate to 0 calculate with edgstopping, improve result, call=1 dcrop we can put iterate to 5

                        tmp1m->CopyFrom(tmp1.get());//save current result
                        bool enatmMasktmap = params->locallab.spots.at(sp).enatmMaskaft;

                        if (enatmMasktmap) {
                            //calculate new values for original, originalmasktm, bufmaskorigtm...in function of tmp1
                            LUTf dummy;
                            bool uti;

                            maskcalccol(false, pde, bfw, bfh, xstart, ystart, sk, cx, cy, tmp1.get(), bufmaskorigtm.get(), originalmasktm.get(), original, inv, lp,
                                        locccmastmCurve, lcmastmutili, locllmastmCurve, llmastmutili, lochhmastmCurve, lhmastmutili, multiThread,
                                        enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);

                            if (lp.showmasktmmet == 3) {//dispaly mask
                                showmask(lp, xstart, ystart, cx, cy, bfw, bfh, tmp1.get(), transformed, bufmaskorigtm.get(), 0);

                                return;
                            }

                        }

                        tmp1->CopyFrom(tmp1m.get());//restore current result


                        float minL = tmp1->L[0][0] - bufgb->L[0][0];
                        float maxL = minL;
                        float minC = sqrt(SQR(tmp1->a[0][0]) + SQR(tmp1->b[0][0])) - sqrt(SQR(bufgb->a[0][0]) + SQR(bufgb->b[0][0]));
                        float maxC = minC;

#ifdef _OPENMP
                        #pragma omp parallel for reduction(max:maxL) reduction(min:minL) reduction(max:maxC) reduction(min:minC) schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++) {
                            for (int jr = 0; jr < bfw; jr++) {
                                buflight[ir][jr] = tmp1->L[ir][jr] - bufgb->L[ir][jr];
                                minL = rtengine::min(minL, buflight[ir][jr]);
                                maxL = rtengine::max(maxL, buflight[ir][jr]);
                                bufchro[ir][jr] = sqrt(SQR(tmp1->a[ir][jr]) + SQR(tmp1->b[ir][jr])) - sqrt(SQR(bufgb->a[ir][jr]) + SQR(bufgb->b[ir][jr]));
                                minC = rtengine::min(minC, bufchro[ir][jr]);
                                maxC = rtengine::max(maxC, bufchro[ir][jr]);
                            }
                        }

                        float coef = 0.01f * (max(fabs(minL), fabs(maxL)));
                        float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                        if (coef == 0.f) {
                            coef = 1.f;
                        }

                        if (coefC == 0.f) {
                            coefC = 1.f;
                        }


#ifdef _OPENMP
                        #pragma omp parallel for
#endif

                        for (int y = 0; y < bfh; y++) {
                            for (int x = 0; x < bfw; x++) {
                                buflight[y][x] /= coef;
                                bufchro[y][x] /= coefC;
                                //          guid[y][x] = (bufgb->L[y][x]) / 32768.f;
                                //          ble[y][x] = (tmp1->L[y][x] - bufgb->L[y][x]) / 32768.f;
                            }
                        }

                        /*
                                            if (lp.softradiustm > 0.f) {
                                                guidedFilter(guid, ble, ble, 0.1f * lp.softradiustm / sk, 0.0001, multiThread);
                                             //   softprocess(bufgb.get(), buflight, lp.softradiustm, bfh, bfw, sk, multiThread);
                                            }

                        #ifdef _OPENMP
                                            #pragma omp parallel for
                        #endif

                                            for (int y = 0; y < bfh; y++) {
                                                for (int x = 0; x < bfw; x++) {
                                                    tmp1->L[y][x] = 32768.f * LIM01(ble[y][x]) + bufgb->L[y][x];
                                                }
                                            }
                        */
                        //
                        //   transit_shapedetect_retinex(call, 4, bufgb.get(),bufmaskorigtm.get(), originalmasktm.get(), buflight, bufchro, hueref, chromaref, lumaref, lp, original, transformed, cx, cy, sk);

                        transit_shapedetect(8, tmp1.get(), originalmasktm.get(), buflight, bufchro, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f, nullptr, lp, original, transformed, cx, cy, sk);
                        bufgb.reset();
                    }
                }
            }
        }

//end TM


//shadow highlight

        if (! lp.invsh && (lp.highlihs > 0.f || lp.shadowhs > 0.f || lp.showmaskSHmet == 2 || lp.enaSHMask || lp.showmaskSHmet == 3 || lp.showmaskSHmet == 4) && call < 3  && lp.hsena) {
            const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            const int bfh = yend - ystart;
            const int bfw = xend - xstart;

            if (bfw >= mSP && bfh >= mSP) {

                std::unique_ptr<LabImage> bufexporig(new LabImage(bfw, bfh));
                std::unique_ptr<LabImage> bufexpfin(new LabImage(bfw, bfh));
                std::unique_ptr<LabImage> bufmaskorigSH;
                std::unique_ptr<LabImage> bufmaskblurSH;
                std::unique_ptr<LabImage> originalmaskSH;

                JaggedArray<float> buflight(bfw, bfh);
                JaggedArray<float> bufl_ab(bfw, bfh);

                if (call <= 3) { //simpleprocess, dcrop, improccoordinator
                    if (lp.showmaskSHmet == 2  || lp.enaSHMask || lp.showmaskSHmet == 3 || lp.showmaskSHmet == 4) {
                        bufmaskorigSH.reset(new LabImage(bfw, bfh));
                        bufmaskblurSH.reset(new LabImage(bfw, bfh));
                        originalmaskSH.reset(new LabImage(bfw, bfh));
                    }

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = 0; y < bfh; y++) {
                        for (int x = 0; x < bfw; x++) {
                            bufexporig->L[y][x] = original->L[y + ystart][x + xstart];
                        }
                    }

                    int inv = 0;
                    bool showmaske = false;
                    bool enaMask = false;
                    bool deltaE = false;
                    bool modmask = false;
                    bool zero = false;
                    bool modif = false;

                    if (lp.showmaskSHmet == 3) {
                        showmaske = true;
                    }

                    if (lp.enaSHMask) {
                        enaMask = true;
                    }

                    if (lp.showmaskSHmet == 4) {
                        deltaE = true;
                    }

                    if (lp.showmaskSHmet == 2) {
                        modmask = true;
                    }

                    if (lp.showmaskSHmet == 1) {
                        modif = true;
                    }

                    if (lp.showmaskSHmet == 0) {
                        zero = true;
                    }

                    float chrom = lp.chromaSH;
                    float rad = lp.radmaSH;
                    float gamma = lp.gammaSH;
                    float slope = lp.slomaSH;
                    float blendm = lp.blendmaSH;
                    float lap = params->locallab.spots.at(sp).lapmaskSH;
                    float pde = params->locallab.spots.at(sp).laplac;
                    LUTf dummy;
                    bool uti;

                    maskcalccol(false, pde, bfw, bfh, xstart, ystart, sk, cx, cy, bufexporig.get(), bufmaskorigSH.get(), originalmaskSH.get(), original, inv, lp,
                                locccmasSHCurve, lcmasSHutili, locllmasSHCurve, llmasSHutili, lochhmasSHCurve, lhmasSHutili, multiThread,
                                enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);

                    if (lp.showmaskSHmet == 3) {
                        showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufexporig.get(), transformed, bufmaskorigSH.get(), 0);

                        return;
                    }

                    if (lp.showmaskSHmet == 0 || lp.showmaskSHmet == 1  || lp.showmaskSHmet == 2 || lp.showmaskSHmet == 4 || lp.enaSHMask) {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int y = 0; y < bfh ; y++) {
                            for (int x = 0; x < bfw; x++) {
                                bufexporig->L[y][x] = original->L[y + ystart][x + xstart];
                                bufexporig->a[y][x] = original->a[y + ystart][x + xstart];
                                bufexporig->b[y][x] = original->b[y + ystart][x + xstart];
                                bufexpfin->L[y][x] = original->L[y + ystart][x + xstart];
                                bufexpfin->a[y][x] = original->a[y + ystart][x + xstart];
                                bufexpfin->b[y][x] = original->b[y + ystart][x + xstart];
                            }
                        }

                        ImProcFunctions::shadowsHighlights(bufexpfin.get(), lp.hsena, 1, lp.highlihs, lp.shadowhs, lp.radiushs, sk, lp.hltonalhs, lp.shtonalhs);

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++) {
                            for (int jr = 0; jr < bfw; jr++) {
                                buflight[ir][jr] = CLIPRET((bufexpfin->L[ir][jr] - bufexporig->L[ir][jr]) / 328.f);
                                bufl_ab[ir][jr] = CLIPRET((sqrt(SQR(bufexpfin->a[ir][jr]) + SQR(bufexpfin->b[ir][jr])) - sqrt(SQR(bufexporig->a[ir][jr]) + SQR(bufexporig->b[ir][jr]))) / 250.f);
                            }
                        }
                    }

                    transit_shapedetect(9, bufexpfin.get(), originalmaskSH.get(), buflight, bufl_ab, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f,  nullptr, lp, original, transformed, cx, cy, sk);
                }
            }
        } else  if (lp.invsh && (lp.highlihs > 0.f || lp.shadowhs > 0.f) && call < 3  && lp.hsena) {
            std::unique_ptr<LabImage> bufmaskblurcol;
            std::unique_ptr<LabImage> originalmaskSH;
            std::unique_ptr<LabImage> bufcolorig;
            int GW = transformed->W;
            int GH = transformed->H;
            bufcolorig.reset(new LabImage(GW, GH));

            if (lp.enaSHMaskinv || lp.showmaskSHmetinv == 1) {
                bufmaskblurcol.reset(new LabImage(GW, GH, true));
                originalmaskSH.reset(new LabImage(GW, GH));
            }

#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < GH ; y++) {
                for (int x = 0; x < GW; x++) {
                    bufcolorig->L[y][x] = original->L[y][x];
                }
            }

            int inv = 1;
            bool showmaske = false;
            bool enaMask = false;
            bool deltaE = false;
            bool modmask = false;
            bool zero = false;
            bool modif = false;

            if (lp.showmaskSHmetinv == 1) {
                showmaske = true;
            }

            if (lp.enaSHMaskinv) {
                enaMask = true;
            }

            if (lp.showmaskSHmetinv == 0) {
                zero = true;
            }

            float chrom = lp.chromaSH;
            float rad = lp.radmaSH;
            float gamma = lp.gammaSH;
            float slope = lp.slomaSH;
            float blendm = lp.blendmaSH;
            float lap = params->locallab.spots.at(sp).lapmaskSH;
            float pde = params->locallab.spots.at(sp).laplac;
            LUTf dummy;
            bool uti;

            maskcalccol(false, pde, GW, GH, 0, 0, sk, cx, cy, bufcolorig.get(), bufmaskblurcol.get(), originalmaskSH.get(), original, inv, lp,
                        locccmasSHCurve, lcmasSHutili, locllmasSHCurve, llmasSHutili, lochhmasSHCurve, lhmasSHutili, multiThread,
                        enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);


            if (lp.showmaskSHmetinv == 1) {
                showmask(lp, 0, 0, cx, cy, GW, GH, bufcolorig.get(), transformed, bufmaskblurcol.get(), inv);

                return;
            }

            float adjustr = 2.f;
            InverseColorLight_Local(sp, 2, lp, originalmaskSH.get(), lightCurveloc, hltonecurveloc, shtonecurveloc, tonecurveloc, exlocalcurve, cclocalcurve, adjustr, localcutili, lllocalcurve, locallutili, original, transformed, cx, cy, hueref, chromaref, lumaref, sk);
        }





// soft light and retinex_pde
        if (lp.strng > 0.f && call <= 3 && lp.sfena) {
            int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            int bfh = yend - ystart;
            int bfw = xend - xstart;
            //vriable for fast FFTW
            int bfhr = bfh;
            int bfwr = bfw;
            bool reduH = false;
            bool reduW = false;

            if (bfw >= mSP && bfh >= mSP) {

                if (lp.softmet == 1) {
                    /*
                                    for (int n=0; n< 17; n++){
                                        for(int m=0; m < 11; m++) {
                                            for(int l=0; l < 8; l++) {
                                                for(int p=0; p < 6; p++) {
                                                    for (int r=0; r < 2; r++){
                                                        int bon = pow(2, n) * pow(3, m) * pow(5, l) * pow(7, p) * pow(13, r);
                                                        if(bon >= 18000  && bon < 18200) printf("b=%i", bon);
                                                    }
                                                }
                                            }
                                        }
                                    }
                    */
                    int ftsizeH = 1;
                    int ftsizeW = 1;

                    for (int ft = 0; ft < N_fftwsize; ft++) { //find best values
                        if (fftw_size[ft] <= bfh) {
                            ftsizeH = fftw_size[ft];
                            break;
                        }
                    }

                    for (int ft = 0; ft < N_fftwsize; ft++) {
                        if (fftw_size[ft] <= bfw) {
                            ftsizeW = fftw_size[ft];
                            break;
                        }
                    }

                    // printf("FTsizeH =%i FTsizeW=%i \n", ftsizeH, ftsizeW);
                    //optimize with size fftw
                    if (ystart == 0 && yend < original->H) {
                        lp.ly -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend == original->H) {
                        lp.lyT -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend != original->H) {
                        if (lp.ly <= lp.lyT) {
                            lp.lyT -= (bfh - ftsizeH);
                        } else {
                            lp.ly -= (bfh - ftsizeH);
                        }
                    } else if (ystart == 0 && yend == original->H) {
                        bfhr = ftsizeH;
                        reduH = true;
                    }

                    if (xstart == 0 && xend < original->W) {
                        lp.lx -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend == original->W) {
                        lp.lxL -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend != original->W) {
                        if (lp.lx <= lp.lxL) {
                            lp.lxL -= (bfw - ftsizeW);
                        } else {
                            lp.lx -= (bfw - ftsizeW);
                        }
                    } else if (xstart == 0 && xend == original->W) {
                        bfwr = ftsizeW;
                        reduW = true;
                    }

                    //new values optimized
                    ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
                    yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
                    xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
                    xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
                    bfh = bfhr = yend - ystart;
                    bfw = bfwr = xend - xstart;

                    if (reduH) {
                        bfhr = ftsizeH;
                    }

                    if (reduW) {
                        bfwr = ftsizeW;
                    }

                    if (settings->verbose) {
                        printf("Nyst=%i Nyen=%i lp.yc=%f lp.lyT=%f  lp.ly=%f bfh=%i bfhr=%i origH=%i ftsizeH=%i\n", ystart, yend, lp.yc, lp.lyT, lp.ly, bfh, bfhr, original->H, ftsizeH);
                        printf("Nxst=%i Nxen=%i lp.xc=%f lp.lxL=%f  lp.lx=%f bfw=%i bfwr=%i origW=%i ftsizeW=%i\n", xstart, xend, lp.xc, lp.lxL, lp.lx, bfw, bfwr, original->W, ftsizeW);
                    }
                }

                std::unique_ptr<LabImage> bufexporig(new LabImage(bfw, bfh)); //buffer for data in zone limit
                std::unique_ptr<LabImage> bufexpfin(new LabImage(bfw, bfh)); //buffer for data in zone limit
                JaggedArray<float> buflight(bfw, bfh);
                JaggedArray<float> bufl_ab(bfw, bfh);

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = ystart; y < yend; y++) {
                    for (int x = xstart; x < xend; x++) {
                        bufexporig->L[y - ystart][x - xstart] = original->L[y][x];
                        bufexporig->a[y - ystart][x - xstart] = original->a[y][x];
                        bufexporig->b[y - ystart][x - xstart] = original->b[y][x];
                    }
                }

                bufexpfin->CopyFrom(bufexporig.get());
                SoftLightParams softLightParams;
                softLightParams.enabled = true;
                softLightParams.strength = lp.strng;

                if (lp.softmet == 0) {
                    ImProcFunctions::softLight(bufexpfin.get(), softLightParams);
                } else if (lp.softmet == 1) {
                    MyMutex::MyLock lock(*fftwMutex);

                    float *datain = new float[bfwr * bfhr];
                    float *dataout = new float[bfwr * bfhr];
                    float *dE = new float[bfwr * bfhr];

                    deltaEforLaplace(dE, lp, bfwr, bfhr, bufexpfin.get(), hueref, chromaref, lumaref);

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = 0; y < bfhr; y++) {
                        for (int x = 0; x < bfwr; x++) {
                            //      datain[y * bfwr + x] = temp->L[y][x] - bufexpfin->L[y][x];
                            datain[y * bfwr + x] = bufexpfin->L[y][x];
                        }
                    }

                    ImProcFunctions::retinex_pde(datain, dataout, bfwr, bfhr, 8.f * lp.strng, 1.f, dE, lp.showmasksoftmet, 1, 1);
#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = 0; y < bfhr; y++) {
                        for (int x = 0; x < bfwr; x++) {
                            //     bufexpfin->L[y][x] = dataout[y * bfwr + x] + bufexpfin->L[y][x];
                            bufexpfin->L[y][x] = dataout[y * bfwr + x];
                        }
                    }

                    delete [] datain;
                    delete [] dataout;
                    delete [] dE;
                }

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = 0; y < bfh; y++) {
                    for (int x = 0; x < bfw; x++) {
                        buflight[y][x] = CLIPRET((bufexpfin->L[y][x] - bufexporig->L[y][x]) / 328.f);
                        bufl_ab[y][x] = CLIPRET((sqrt(SQR(bufexpfin->a[y][x]) + SQR(bufexpfin->b[y][x])) - sqrt(SQR(bufexporig->a[y][x]) + SQR(bufexporig->b[y][x]))) / 250.f);
                    }
                }

                bufexpfin.reset();
                transit_shapedetect(3, bufexporig.get(), nullptr, buflight, bufl_ab, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f,  nullptr, lp, original, transformed, cx, cy, sk);
            }
        }


//local contrast
        bool wavcurve = false;

        if (locwavCurve && locwavutili) {
            if (lp.locmet == 1) {
                for (int i = 0; i < 500; i++) {
                    if (locwavCurve[i] != 0.5) {
                        wavcurve = true;
                    }
                }
            }
        }

        if ((lp.lcamount > 0.f || wavcurve || params->locallab.spots.at(sp).residcont != 0.f || params->locallab.spots.at(sp).clarilres != 0.f || params->locallab.spots.at(sp).claricres != 0.f) && call < 3  && lp.lcena) {
            int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            int bfh = yend - ystart;
            int bfw = xend - xstart;
            int bfhr = bfh;
            int bfwr = bfw;
            bool reduH = false;
            bool reduW = false;

            if (bfw >= mSP && bfh >= mSP) {

                if (lp.ftwlc) {
                    int ftsizeH = 1;
                    int ftsizeW = 1;

                    for (int ft = 0; ft < N_fftwsize; ft++) { //find best values
                        if (fftw_size[ft] <= bfh) {
                            ftsizeH = fftw_size[ft];
                            break;
                        }
                    }

                    for (int ft = 0; ft < N_fftwsize; ft++) {
                        if (fftw_size[ft] <= bfw) {
                            ftsizeW = fftw_size[ft];
                            break;
                        }
                    }

                    //printf("FTsizeH =%i FTsizeW=%i \n", ftsizeH, ftsizeW);
                    //optimize with size fftw
                    if (ystart == 0 && yend < original->H) {
                        lp.ly -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend == original->H) {
                        lp.lyT -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend != original->H) {
                        if (lp.ly <= lp.lyT) {
                            lp.lyT -= (bfh - ftsizeH);
                        } else {
                            lp.ly -= (bfh - ftsizeH);
                        }
                    } else if (ystart == 0 && yend == original->H) {
                        bfhr = ftsizeH;
                        reduH = true;
                    }

                    if (xstart == 0 && xend < original->W) {
                        lp.lx -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend == original->W) {
                        lp.lxL -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend != original->W) {
                        if (lp.lx <= lp.lxL) {
                            lp.lxL -= (bfw - ftsizeW);
                        } else {
                            lp.lx -= (bfw - ftsizeW);
                        }
                    } else if (xstart == 0 && xend == original->W) {
                        bfwr = ftsizeW;
                        reduW = true;
                    }

                    //new values optimized
                    ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
                    yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
                    xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
                    xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
                    bfh = bfhr = yend - ystart;
                    bfw = bfwr = xend - xstart;

                    if (reduH) {
                        bfhr = ftsizeH;
                    }

                    if (reduW) {
                        bfwr = ftsizeW;
                    }
                }

                array2D<float> buflight(bfw, bfh);
                JaggedArray<float> bufchro(bfw, bfh);
                std::unique_ptr<LabImage> bufgb(new LabImage(bfw, bfh));
                std::unique_ptr<LabImage> tmp1(new LabImage(bfw, bfh));

                std::unique_ptr<LabImage> tmpresid(new LabImage(bfw, bfh));
                std::unique_ptr<LabImage> tmpres(new LabImage(bfw, bfh));

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = ystart; y < yend; y++) {
                    for (int x = xstart; x < xend; x++) {
                        bufgb->L[y - ystart][x - xstart] = original->L[y][x];
                        bufgb->a[y - ystart][x - xstart] = original->a[y][x];
                        bufgb->b[y - ystart][x - xstart] = original->b[y][x];
                        tmp1->L[y - ystart][x - xstart] = original->L[y][x];
                        tmp1->a[y - ystart][x - xstart] = original->a[y][x];
                        tmp1->b[y - ystart][x - xstart] = original->b[y][x];
                        tmpresid->L[y - ystart][x - xstart] = original->L[y][x];
                        tmpresid->a[y - ystart][x - xstart] = original->a[y][x];
                        tmpresid->b[y - ystart][x - xstart] = original->b[y][x];
                        tmpres->L[y - ystart][x - xstart] = original->L[y][x];
                        tmpres->a[y - ystart][x - xstart] = original->a[y][x];
                        tmpres->b[y - ystart][x - xstart] = original->b[y][x];
                    }
                }

                if (lp.locmet == 0) {
                    LocalContrastParams localContrastParams;
                    LocallabParams locallabparams;
                    localContrastParams.enabled = true;
                    localContrastParams.radius = params->locallab.spots.at(sp).lcradius;
                    localContrastParams.amount = params->locallab.spots.at(sp).lcamount;
                    localContrastParams.darkness = params->locallab.spots.at(sp).lcdarkness;
                    localContrastParams.lightness = params->locallab.spots.at(sp).lightness;
                    bool fftwlc = false;

                    if (!lp.ftwlc || (lp.ftwlc && call != 2)) {
                        ImProcFunctions::localContrast(tmp1.get(), tmp1->L, localContrastParams, fftwlc, sk);
                    } else {
                        std::unique_ptr<LabImage> tmpfftw(new LabImage(bfwr, bfhr));
#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int y = 0; y < bfhr; y++) {
                            for (int x = 0; x < bfwr; x++) {
                                tmpfftw->L[y][x] = tmp1->L[y][x];
                                tmpfftw->a[y][x] = tmp1->a[y][x];
                                tmpfftw->b[y][x] = tmp1->b[y][x];
                            }
                        }

                        fftwlc = true;
                        ImProcFunctions::localContrast(tmpfftw.get(), tmpfftw->L, localContrastParams, fftwlc, sk);
#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int y = 0; y < bfhr; y++) {
                            for (int x = 0; x < bfwr; x++) {
                                tmp1->L[y][x] = tmpfftw->L[y][x];
                                tmp1->a[y][x] = tmpfftw->a[y][x];
                                tmp1->b[y][x] = tmpfftw->b[y][x];
                            }
                        }

                    }
                } else if (lp.locmet == 1) { //wavelet
                    int wavelet_level = params->locallab.spots.at(sp).levelwav;
                    float mL = (float)(params->locallab.spots.at(sp).clarilres / 100.f);
                    float mC = (float)(params->locallab.spots.at(sp).claricres / 100.f);
                    float softr = (float)(params->locallab.spots.at(sp).clarisoft);
                    float mL0;
                    float mC0;
#ifdef _OPENMP
                    const int numThreads = omp_get_max_threads();
#else
                    const int numThreads = 1;

#endif

                    int minwin = min(bfw, bfh);
                    int maxlevelspot = 9;

                    // adap maximum level wavelet to size of RT-spot
                    if (minwin * sk < 1024) {
                        maxlevelspot = 9;    //sampling wavelet 512
                    }

                    if (minwin * sk < 512) {
                        maxlevelspot = 8;    //sampling wavelet 256
                    }

                    if (minwin * sk < 256) {
                        maxlevelspot = 7;    //sampling 128
                    }

                    if (minwin * sk < 128) {
                        maxlevelspot = 6;
                    }

                    if (minwin * sk < 64) {
                        maxlevelspot = 5;
                    }

                    if (minwin * sk < 32) {
                        maxlevelspot = 4;
                    }

                    if (minwin * sk < 16) {
                        maxlevelspot = 3;
                    }

                    if (minwin * sk < 8) {
                        maxlevelspot = 2;
                    }

                    if (minwin * sk < 4) {
                        maxlevelspot = 1;
                    }

                    if (minwin * sk < 2) {
                        maxlevelspot = 0;
                    }


                    wavelet_level = min(wavelet_level, maxlevelspot);

                    bool exec = false;

                    if (mL != 0.f && mC == 0.f) {
                        mC = 0.0001f;
                        exec = true;
                    }

                    if (mC != 0.f && mL == 0.f) {
                        mL = 0.0001f;
                        exec = true;
                    }

                    if (mL != 0.f && mC != 0.f) {
                        exec = true;
                    }

                    if (mL != 0.f) {

                        wavelet_decomposition *wdspotresid = new wavelet_decomposition(tmpresid->L[0], tmpresid->W, tmpresid->H, wavelet_level, 1, sk, numThreads, 6);

                        if (wdspotresid->memoryAllocationFailed) {
                            return;
                        }

                        int maxlvlresid = wdspotresid->maxlevel();

                        if (maxlvlresid > 4) {//Clarity
                            for (int dir = 1; dir < 4; dir++) {
                                for (int level = 0; level < maxlvlresid; ++level) {
                                    int W_L = wdspotresid->level_W(level);
                                    int H_L = wdspotresid->level_H(level);
                                    float **wav_Lresid = wdspotresid->level_coeffs(level);

                                    for (int i = 0; i < W_L * H_L; i++) {
                                        wav_Lresid[dir][i] = 0.f;
                                    }
                                }
                            }
                        } else {//Sharp
                            float *wav_L0resid = wdspotresid->coeff0;
                            int W_L = wdspotresid->level_W(0);
                            int H_L = wdspotresid->level_H(0);

                            for (int i = 0; i < W_L * H_L; i++) {
                                wav_L0resid[i] = 0.f;
                            }
                        }

                        wdspotresid->reconstruct(tmpresid->L[0], 1.f);
                        delete wdspotresid;
                    }


                    if (mC != 0.f) {

                        wavelet_decomposition *wdspotresida = new wavelet_decomposition(tmpresid->a[0], tmpresid->W, tmpresid->H, wavelet_level, 1, sk, numThreads, 6);

                        if (wdspotresida->memoryAllocationFailed) {
                            return;
                        }

                        int maxlvlresid = wdspotresida->maxlevel();

                        if (maxlvlresid > 4) {//Clarity
                            for (int dir = 1; dir < 4; dir++) {
                                for (int level = 0; level < maxlvlresid; ++level) {
                                    int W_L = wdspotresida->level_W(level);
                                    int H_L = wdspotresida->level_H(level);
                                    float **wav_Lresida = wdspotresida->level_coeffs(level);

                                    for (int i = 0; i < W_L * H_L; i++) {
                                        wav_Lresida[dir][i] = 0.f;
                                    }
                                }
                            }
                        } else {//Sharp
                            float *wav_L0resida = wdspotresida->coeff0;
                            int W_L = wdspotresida->level_W(0);
                            int H_L = wdspotresida->level_H(0);

                            for (int i = 0; i < W_L * H_L; i++) {
                                wav_L0resida[i] = 0.f;
                            }
                        }

                        wdspotresida->reconstruct(tmpresid->a[0], 1.f);
                        delete wdspotresida;
                    }


                    if (mC != 0.f) {

                        wavelet_decomposition *wdspotresidb = new wavelet_decomposition(tmpresid->b[0], tmpresid->W, tmpresid->H, wavelet_level, 1, sk, numThreads, 6);

                        if (wdspotresidb->memoryAllocationFailed) {
                            return;
                        }

                        int maxlvlresid = wdspotresidb->maxlevel();

                        if (maxlvlresid > 4) {//Clarity
                            for (int dir = 1; dir < 4; dir++) {
                                for (int level = 0; level < maxlvlresid; ++level) {
                                    int W_L = wdspotresidb->level_W(level);
                                    int H_L = wdspotresidb->level_H(level);
                                    float **wav_Lresidb = wdspotresidb->level_coeffs(level);

                                    for (int i = 0; i < W_L * H_L; i++) {
                                        wav_Lresidb[dir][i] = 0.f;
                                    }
                                }
                            }
                        } else {//Sharp
                            float *wav_L0residb = wdspotresidb->coeff0;
                            int W_L = wdspotresidb->level_W(0);
                            int H_L = wdspotresidb->level_H(0);

                            for (int i = 0; i < W_L * H_L; i++) {
                                wav_L0residb[i] = 0.f;
                            }
                        }

                        wdspotresidb->reconstruct(tmpresid->b[0], 1.f);
                        delete wdspotresidb;
                    }

                    wavelet_decomposition *wdspot = new wavelet_decomposition(tmp1->L[0], tmp1->W, tmp1->H, wavelet_level, 1, sk, numThreads, 6);

                    if (wdspot->memoryAllocationFailed) {
                        return;
                    }

                    const float contrast = params->locallab.spots.at(sp).residcont;
                    int maxlvl = wdspot->maxlevel();

                    if (contrast != 0) {
                        int W_L = wdspot->level_W(0);
                        int H_L = wdspot->level_H(0);
                        float *wav_L0 = wdspot->coeff0;

                        double avedbl = 0.0; // use double precision for large summations

#ifdef _OPENMP
                        #pragma omp parallel for reduction(+:avedbl) if (multiThread)
#endif

                        for (int i = 0; i < W_L * H_L; i++) {
                            avedbl += wav_L0[i];
                        }

                        float ave = avedbl / double(W_L * H_L);

                        float avg = ave / 32768.f;
                        avg = LIM01(avg);
                        double contreal = 0.6 * contrast;
                        DiagonalCurve resid_contrast({
                            DCT_NURBS,
                            0, 0,
                            avg - avg * (0.6 - contreal / 250.0), avg - avg * (0.6 + contreal / 250.0),
                            avg + (1. - avg) * (0.6 - contreal / 250.0), avg + (1. - avg) * (0.6 + contreal / 250.0),
                            1, 1
                        });
#ifdef _OPENMP
                        #pragma omp parallel for if (multiThread)
#endif

                        for (int i = 0; i < W_L * H_L; i++) {
                            float buf = LIM01(wav_L0[i] / 32768.f);
                            buf = resid_contrast.getVal(buf);
                            buf *= 32768.f;
                            wav_L0[i] = buf;
                        }

                    }


                    float mean[10];
                    float meanN[10];
                    float sigma[10];
                    float sigmaN[10];
                    float MaxP[10];
                    float MaxN[10];
                    Evaluate2(*wdspot, mean, meanN, sigma, sigmaN, MaxP, MaxN);

                    if (locwavCurve && locwavutili) {
                        for (int dir = 1; dir < 4; dir++) {
                            for (int level = 0; level < maxlvl; ++level) {
                                int W_L = wdspot->level_W(level);
                                int H_L = wdspot->level_H(level);
                                float **wav_L = wdspot->level_coeffs(level);

                                if (MaxP[level] > 0.f && mean[level] != 0.f && sigma[level] != 0.f) {
                                    float insigma = 0.666f; //SD
                                    float logmax = log(MaxP[level]); //log Max
                                    float rapX = (mean[level] + sigma[level]) / MaxP[level]; //rapport between sD / max
                                    float inx = log(insigma);
                                    float iny = log(rapX);
                                    float rap = inx / iny; //koef
                                    float asig = 0.166f / sigma[level];
                                    float bsig = 0.5f - asig * mean[level];
                                    float amean = 0.5f / mean[level];

#ifdef _OPENMP
                                    #pragma omp parallel for if (multiThread)
#endif

                                    for (int i = 0; i < W_L * H_L; i++) {
                                        if (locwavCurve && locwavutili) {
                                            float absciss;
                                            float &val = wav_L[dir][i];

                                            if (fabsf(val) >= (mean[level] + sigma[level])) { //for max
                                                float valcour = xlogf(fabsf(val));
                                                float valc = valcour - logmax;
                                                float vald = valc * rap;
                                                absciss = xexpf(vald);
                                            } else if (fabsf(val) >= mean[level]) {
                                                absciss = asig * fabsf(val) + bsig;
                                            } else {
                                                absciss = amean * fabsf(val);
                                            }

                                            float kc = locwavCurve[absciss * 500.f] - 0.5f;
                                            float reduceeffect = kc <= 0.f ? 1.f : 1.5f;

                                            float kinterm = 1.f + reduceeffect * kc;
                                            kinterm = kinterm <= 0.f ? 0.01f : kinterm;

                                            val *=  kinterm;
                                        }
                                    }
                                }
                            }
                        }
                    }

                    wdspot->reconstruct(tmp1->L[0], 1.f);
                    delete wdspot;

                    const float satur = params->locallab.spots.at(sp).residchro;

                    if (satur != 0.f) {

                        wavelet_decomposition *wdspota = new wavelet_decomposition(tmp1->a[0], tmp1->W, tmp1->H, wavelet_level, 1, sk, numThreads, 6);

                        if (wdspota->memoryAllocationFailed) {
                            return;
                        }

                        float *wav_ab0a = wdspota->coeff0;
                        //      int maxlvla = wdspota->maxlevel();
                        int W_La = wdspota->level_W(0);
                        int H_La = wdspota->level_H(0);

#ifdef _OPENMP
                        #pragma omp parallel for if (multiThread)
#endif

                        for (int i = 0; i < W_La * H_La; i++) {
                            wav_ab0a[i] *= (1.f + sin(rtengine::RT_PI * (satur / 200.f)));//more progressive than linear
                            wav_ab0a[i] = CLIPC(wav_ab0a[i]);
                        }

                        wdspota->reconstruct(tmp1->a[0], 1.f);
                        delete wdspota;

                        wavelet_decomposition *wdspotb = new wavelet_decomposition(tmp1->b[0], tmp1->W, tmp1->H, wavelet_level, 1, sk, numThreads, 6);

                        if (wdspotb->memoryAllocationFailed) {
                            return;
                        }

                        float *wav_ab0b = wdspotb->coeff0;
                        //      int maxlvlb = wdspotb->maxlevel();
                        int W_Lb = wdspotb->level_W(0);
                        int H_Lb = wdspotb->level_H(0);

#ifdef _OPENMP
                        #pragma omp parallel for if (multiThread)
#endif

                        for (int i = 0; i < W_Lb * H_Lb; i++) {
                            wav_ab0b[i] *= (1.f + sin(rtengine::RT_PI * (satur / 200.f)));
                            wav_ab0b[i] = CLIPC(wav_ab0b[i]);
                        }

                        wdspotb->reconstruct(tmp1->b[0], 1.f);
                        delete wdspotb;

                    }


                    float thr = 0.001f;
                    int flag = 0;

                    if (maxlvl <= 4) {
                        mL0 = 0.f;
                        mC0 = 0.f;
                        mL = -1.5f * mL;//increase only for sharpen
                        mC = -mC;
                        thr = 1.f;
                        flag = 0;

                    } else if (maxlvl > 4) {
                        mL0 = mL;
                        mC0 = mC;
                        thr = 1.f;
                        flag = 0;
                    } else {
                        mL0 = mL = mC0 = mC = 0.f;
                    }

                    if (exec) {
#ifdef _OPENMP
                        #pragma omp parallel for
#endif

                        for (int x = 0; x < bfh; x++)
                            for (int y = 0; y < bfw; y++) {
                                tmp1->L[x][y] = CLIPLOC((1.f + mL0) * tmp1->L[x][y] - mL * tmpresid->L[x][y]);
                                tmp1->a[x][y] = CLIPC((1.f + mC0) * tmp1->a[x][y] - mC * tmpresid->a[x][y]);
                                tmp1->b[x][y] = CLIPC((1.f + mC0) * tmp1->b[x][y] - mC * tmpresid->b[x][y]);
                            }

                        if (softr > 0.f && fabs(mL) > 0.001f) {
                            softproc(tmpres.get(), tmp1.get(), softr, bfh, bfw, 0.0001, 0.00001, thr, sk, multiThread, flag);
                        }
                    }
                }

                float minL =  tmp1->L[0][0] - bufgb->L[0][0];
                float maxL = minL;
                float minC = sqrt(SQR(tmp1->a[0][0]) + SQR(tmp1->b[0][0])) - sqrt(SQR(bufgb->a[0][0]) + SQR(bufgb->b[0][0]));
                float maxC = minC;

#ifdef _OPENMP
                #pragma omp parallel for reduction(max:maxL) reduction(min:minL) reduction(min:minC) reduction(max:maxC)schedule(dynamic,16)
#endif

                for (int ir = 0; ir < bfhr; ir++) {
                    for (int jr = 0; jr < bfwr; jr++) {
                        buflight[ir][jr] =  tmp1->L[ir][jr] - bufgb->L[ir][jr];
                        bufchro[ir][jr] = sqrt(SQR(tmp1->a[ir][jr]) + SQR(tmp1->b[ir][jr])) - sqrt(SQR(bufgb->a[ir][jr]) + SQR(bufgb->b[ir][jr]));
                        minL = rtengine::min(minL, buflight[ir][jr]);
                        maxL = rtengine::max(maxL, buflight[ir][jr]);
                        minC = rtengine::min(minC, bufchro[ir][jr]);
                        maxC = rtengine::max(maxC, bufchro[ir][jr]);
                    }
                }

                float coef = 0.01f * (max(fabs(minL), fabs(maxL)));

                if (coef == 0.f) { //prevent bad behavior
                    coef = 1.f;
                }

                float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                if (coefC == 0.f) { //prevent bad behavior
                    coefC = 1.f;
                }

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = 0; y < bfhr; y++) {
                    for (int x = 0; x < bfwr; x++) {
                        buflight[y][x] /= coef;
                        bufchro[y][x] /= coefC;
                    }
                }

                bufgb.reset();
                transit_shapedetect(10, tmp1.get(), nullptr, buflight, bufchro, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f, nullptr, lp, original, transformed, cx, cy, sk);
                tmp1.reset();
            }
        }

        if (!lp.invshar && lp.shrad > 0.42 && call < 3 && lp.sharpena && sk == 1) { //interior ellipse for sharpening, call = 1 and 2 only with Dcrop and simpleprocess
            int bfh = call == 2 ? int (lp.ly + lp.lyT) + del : original->H; //bfw bfh real size of square zone
            int bfw = call == 2 ? int (lp.lx + lp.lxL) + del : original->W;
            JaggedArray<float> loctemp(bfw, bfh);

            if (call == 2) { //call from simpleprocess
                JaggedArray<float> bufsh(bfw, bfh, true);
                JaggedArray<float> hbuffer(bfw, bfh);
                int begy = lp.yc - lp.lyT;
                int begx = lp.xc - lp.lxL;
                int yEn = lp.yc + lp.ly;
                int xEn = lp.xc + lp.lx;

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = 0; y < transformed->H ; y++) {
                    for (int x = 0; x < transformed->W; x++) {
                        int lox = cx + x;
                        int loy = cy + y;

                        if (lox >= begx && lox < xEn && loy >= begy && loy < yEn) {
                            bufsh[loy - begy][lox - begx] = original->L[y][x];
                        }
                    }
                }

                //sharpen only square area instaed of all image
                ImProcFunctions::deconvsharpeningloc(bufsh, hbuffer, bfw, bfh, loctemp, params->locallab.spots.at(sp).shardamping, (double)params->locallab.spots.at(sp).sharradius, params->locallab.spots.at(sp).shariter, params->locallab.spots.at(sp).sharamount, params->locallab.spots.at(sp).sharcontrast, (double)params->locallab.spots.at(sp).sharblur);
            } else { //call from dcrop.cc
                ImProcFunctions::deconvsharpeningloc(original->L, shbuffer, bfw, bfh, loctemp, params->locallab.spots.at(sp).shardamping, (double)params->locallab.spots.at(sp).sharradius, params->locallab.spots.at(sp).shariter, params->locallab.spots.at(sp).sharamount, params->locallab.spots.at(sp).sharcontrast, (double)params->locallab.spots.at(sp).sharblur);
            }

            //sharpen ellipse and transition
            Sharp_Local(call, loctemp, 0, hueref, chromaref, lumaref, lp, original, transformed, cx, cy, sk);

        } else if (lp.invshar && lp.shrad > 0.42 && call < 3 && lp.sharpena && sk == 1) {
            int GW = original->W;
            int GH = original->H;
            JaggedArray<float> loctemp(GW, GH);

            ImProcFunctions::deconvsharpeningloc(original->L, shbuffer, GW, GH, loctemp, params->locallab.spots.at(sp).shardamping, (double)params->locallab.spots.at(sp).sharradius, params->locallab.spots.at(sp).shariter, params->locallab.spots.at(sp).sharamount, params->locallab.spots.at(sp).sharcontrast, (double)params->locallab.spots.at(sp).sharblur);


            InverseSharp_Local(loctemp, hueref, lumaref, chromaref, lp, original, transformed, cx, cy, sk);
        }

        //      }
//&& lp.retiena

        //  if (lp.dehaze > 0 && lp.str < 0.2f  && lp.retiena) {
        if (lp.dehaze > 0 && lp.retiena) {
            int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            int bfh = yend - ystart;
            int bfw = xend - xstart;

            if (bfh >= mSP && bfw >= mSP) {
                std::unique_ptr<LabImage> bufexporig(new LabImage(bfw, bfh)); //buffer for data in zone limit
                std::unique_ptr<LabImage> bufexpfin(new LabImage(bfw, bfh)); //buffer for data in zone limit
                JaggedArray<float> buflight(bfw, bfh);
                JaggedArray<float> bufl_ab(bfw, bfh);

#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = ystart; y < yend; y++) {
                    for (int x = xstart; x < xend; x++) {
                        bufexporig->L[y - ystart][x - xstart] = original->L[y][x];
                        bufexporig->a[y - ystart][x - xstart] = original->a[y][x];
                        bufexporig->b[y - ystart][x - xstart] = original->b[y][x];
                    }
                }

                bufexpfin->CopyFrom(bufexporig.get());
                //calc dehaze
                Imagefloat *tmpImage = nullptr;

                if (lp.dehaze > 0) {
                    DehazeParams dehazeParams;
                    dehazeParams.enabled = true;
                    dehazeParams.strength = lp.dehaze;
                    dehazeParams.showDepthMap = false;
                    dehazeParams.depth = lp.depth;
                    dehazeParams.luminance = params->locallab.spots.at(sp).lumonly;
                    tmpImage = new Imagefloat(bfw, bfh);
                    lab2rgb(*bufexpfin, *tmpImage, params->icm.workingProfile);
                    dehaze(tmpImage, dehazeParams);
                    rgb2lab(*tmpImage, *bufexpfin, params->icm.workingProfile);

                    delete tmpImage;
                }


#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = 0; y < bfh; y++) {
                    for (int x = 0; x < bfw; x++) {
                        buflight[y][x] = CLIPRET((bufexpfin->L[y][x] - bufexporig->L[y][x]));
                        bufl_ab[y][x] = CLIPRET((sqrt(SQR(bufexpfin->a[y][x]) + SQR(bufexpfin->b[y][x])) - sqrt(SQR(bufexporig->a[y][x]) + SQR(bufexporig->b[y][x]))));
                    }
                }

                float minL = bufexpfin->L[0][0] - bufexporig->L[0][0];
                float maxL = minL;
                float minC = sqrt(SQR(bufexpfin->a[0][0]) + SQR(bufexpfin->b[0][0])) - sqrt(SQR(bufexporig->a[0][0]) + SQR(bufexporig->b[0][0]));
                float maxC = minC;

#ifdef _OPENMP
                #pragma omp parallel for reduction(min:minL) reduction(min:minC) reduction(max:maxL) reduction(max:maxC) schedule(dynamic,16)
#endif

                for (int ir = 0; ir < bfh; ir++) {
                    for (int jr = 0; jr < bfw; jr++) {
                        buflight[ir][jr] = bufexpfin->L[ir][jr] - bufexporig->L[ir][jr];
                        bufl_ab[ir][jr] = sqrt(SQR(bufexpfin->a[ir][jr]) + SQR(bufexpfin->b[ir][jr])) - sqrt(SQR(bufexporig->a[ir][jr]) + SQR(bufexporig->b[ir][jr]));
                        minL = rtengine::min(minL, buflight[ir][jr]);
                        maxL = rtengine::max(maxL, buflight[ir][jr]);
                        minC = rtengine::min(minC, bufl_ab[ir][jr]);
                        maxC = rtengine::max(maxC, bufl_ab[ir][jr]);
                    }
                }

                float coef = 0.01f * (max(fabs(minL), fabs(maxL)));
                float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                if (coef == 0.f) {
                    coef = 1.f;
                }

                if (coefC == 0.f) {
                    coefC = 1.f;
                }


                for (int ir = 0; ir < bfh; ir++) {
                    for (int jr = 0; jr < bfw; jr++) {
                        buflight[ir][jr] /= coef;
                        bufl_ab[ir][jr] /= coefC;
                    }
                }

                bufexpfin.reset();
                transit_shapedetect(30, bufexporig.get(), nullptr, buflight, bufl_ab, nullptr, nullptr, nullptr, false, hueref, chromaref, lumaref, sobelref, 0.f,  nullptr, lp, original, transformed, cx, cy, sk);
            }
        }

        lp.invret = false;//always disabled inverse RETI   too complex todo !!

        if (lp.str >= 0.2f  && lp.retiena && call != 2) {
            int GW = transformed->W;
            int GH = transformed->H;
            LabImage *bufreti = nullptr;
            LabImage *bufmask = nullptr;
            LabImage *buforig = nullptr;
            LabImage *buforigmas = nullptr;

            if (GW >= mSP && GH >= mSP)

            {

                array2D<float> buflight(GW, GH);
                JaggedArray<float> bufchro(GW, GH);

                int Hd, Wd;
                Hd = GH;
                Wd = GW;

                if (!lp.invret && call != 2) {

                    Hd = GH;
                    Wd = GW;
                    bufreti = new LabImage(GW, GH);
                    bufmask = new LabImage(GW, GH);

                    if (!lp.enaretiMasktmap && lp.enaretiMask) {
                        buforig = new LabImage(GW, GH);
                        buforigmas = new LabImage(GW, GH);
                    }

#ifdef _OPENMP
                    #pragma omp parallel for
#endif

                    for (int ir = 0; ir < GH; ir++) //fill with 0
                        for (int jr = 0; jr < GW; jr++) {
                            bufreti->L[ir][jr] = 0.f;
                            bufreti->a[ir][jr] = 0.f;
                            bufreti->b[ir][jr] = 0.f;
                            buflight[ir][jr] = 0.f;
                            bufchro[ir][jr] = 0.f;
                        }

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = 0; y < transformed->H ; y++) //{
                        for (int x = 0; x < transformed->W; x++) {
                            bufreti->L[y][x] = original->L[y][x];
                            bufreti->a[y][x] = original->a[y][x];
                            bufreti->b[y][x] = original->b[y][x];
                            bufmask->L[y][x] = original->L[y][x];
                            bufmask->a[y][x] = original->a[y][x];
                            bufmask->b[y][x] = original->b[y][x];

                            if (!lp.enaretiMasktmap && lp.enaretiMask) {
                                buforig->L[y][x] = original->L[y][x];
                                buforig->a[y][x] = original->a[y][x];
                                buforig->b[y][x] = original->b[y][x];
                            }

                        }
                }

                float raddE = params->locallab.spots.at(sp).softradiusret;

                //calc dE and reduction to use in MSR to reduce artifacts
                const int limscope = 80;
                const float mindE = 4.f + MINSCOPE * lp.sensh * lp.thr;
                const float maxdE = 5.f + MAXSCOPE * lp.sensh * (1 + 0.1f * lp.thr);
                const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
                const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);
                const float refa = chromaref * cos(hueref);
                const float refb = chromaref * sin(hueref);


                float *reducDE[Hd] ALIGNED16;
                float *reducDEBuffer = new float[Hd * Wd];

                for (int i = 0; i < Hd; i++) {
                    reducDE[i] = &reducDEBuffer[i * Wd];
                }

//                float minreduc = 1000000.f;
//                float maxreduc = -1000000.f;
                float ade = 0.01f * raddE;
                float bde = 100.f - raddE;
                float sensibefore = ade * lp.sensh + bde;//we can change sensitivity 0.1 90 or 0.3 70 or 0.4 60
#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = 0; y < transformed->H ; y++)
                    for (int x = 0; x < transformed->W; x++) {
                        float dE = sqrt(SQR(refa - bufreti->a[y][x] / 327.68f) + SQR(refb - bufreti->b[y][x] / 327.68f) +  SQR(lumaref - bufreti->b[y][x] / 327.68f));
                        float reducdE;
                        calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sensibefore, reducdE);
                        reducDE[y][x] = CLIPdE(reducdE);
//                           if(reducDE[y][x] > maxreduc) maxreduc = reducDE[y][x];
//                           if(reducDE[y][x] < minreduc) minreduc = reducDE[y][x];

                    }

//                printf("reducdemax=%f reducmin=%f\n", maxreduc, minreduc);
                float *orig[Hd] ALIGNED16;
                float *origBuffer = new float[Hd * Wd];

                for (int i = 0; i < Hd; i++) {
                    orig[i] = &origBuffer[i * Wd];
                }

                float *orig1[Hd] ALIGNED16;
                float *origBuffer1 = new float[Hd * Wd];

                for (int i = 0; i < Hd; i++) {
                    orig1[i] = &origBuffer1[i * Wd];
                }



                LabImage *tmpl = nullptr;

                if (!lp.invret && call != 2) {


#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int ir = 0; ir < Hd; ir += 1)
                        for (int jr = 0; jr < Wd; jr += 1) {
                            orig[ir][jr] = bufreti->L[ir][jr];
                            orig1[ir][jr] = bufreti->L[ir][jr];
                        }

                    tmpl = new LabImage(Wd, Hd);

                }  else {

                    Imagefloat *tmpImage = nullptr;
                    bufreti = new LabImage(Wd, Hd);

                    if (lp.dehaze > 0) {
                        const float depthcombi = 0.5f * lp.depth + 0.5f * (0.3f * params->locallab.spots.at(sp).neigh + 0.15f * (500.f - params->locallab.spots.at(sp).vart));
                        DehazeParams dehazeParams;
                        dehazeParams.enabled = true;
                        dehazeParams.strength = 0.9f * lp.dehaze + 0.3f * lp.str;
                        dehazeParams.showDepthMap = false;
                        dehazeParams.depth = LIM(depthcombi, 0.f, 100.f);
                        dehazeParams.luminance = params->locallab.spots.at(sp).lumonly;

                        tmpImage = new Imagefloat(Wd, Hd);
                        lab2rgb(*original, *tmpImage, params->icm.workingProfile);
                        dehaze(tmpImage, dehazeParams);
                        rgb2lab(*tmpImage, *bufreti, params->icm.workingProfile);

                        delete tmpImage;
#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1) {
                            for (int jr = 0; jr < Wd; jr += 1) {
                                orig[ir][jr] = original->L[ir][jr];
                                orig1[ir][jr] = bufreti->L[ir][jr];
                            }
                        }

                        delete bufreti;
                        bufreti = nullptr;
                    } else {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1) {
                            for (int jr = 0; jr < Wd; jr += 1) {
                                orig[ir][jr] = original->L[ir][jr];
                                orig1[ir][jr] = transformed->L[ir][jr];
                            }
                        }
                    }

                    tmpl = new LabImage(transformed->W, transformed->H);
                }

                //    float minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax;
                bool fftw = lp.ftwreti;
                //fftw = false;
                //for Retinex Mask are incorporated in MSR
                ImProcFunctions::MSRLocal(sp, fftw, 1, reducDE, bufreti, bufmask, buforig, buforigmas, orig, tmpl->L, orig1, Wd, Hd, Wd, Hd, params->locallab, sk, locRETgainCcurve, locRETtransCcurve, 0, 4, 1.f, minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax,
                                          locccmasretiCurve, lcmasretiutili, locllmasretiCurve, llmasretiutili, lochhmasretiCurve, lhmasretiutili, llretiMask, transformed, lp.enaretiMasktmap, lp.enaretiMask);
#ifdef _OPENMP
                #pragma omp parallel for
#endif

                for (int ir = 0; ir < Hd; ir += 1)
                    for (int jr = 0; jr < Wd; jr += 1) {
                        tmpl->L[ir][jr] = orig[ir][jr];
                    }

                if (lp.equret) { //equilibrate luminance before / after MSR
                    float *datain = new float[Hd * Wd];
                    float *data = new float[Hd * Wd];
#ifdef _OPENMP
                    #pragma omp parallel for
#endif

                    for (int ir = 0; ir < Hd; ir += 1)
                        for (int jr = 0; jr < Wd; jr += 1) {
                            datain[ir * Wd + jr] = orig1[ir][jr];
                            data[ir * Wd + jr] = orig[ir][jr];
                        }

                    normalize_mean_dt(data, datain, Hd * Wd, 1.f);
#ifdef _OPENMP
                    #pragma omp parallel for
#endif

                    for (int ir = 0; ir < Hd; ir += 1)
                        for (int jr = 0; jr < Wd; jr += 1) {
                            tmpl->L[ir][jr] = data[ir * Wd + jr];
                        }

                    delete [] datain;
                    delete [] data;
                }


                if (!lp.invret) {
                    float minL = tmpl->L[0][0] - bufreti->L[0][0];
                    float maxL = minL;
#ifdef _OPENMP
                    #pragma omp parallel for reduction(min:minL) reduction(max:maxL) schedule(dynamic,16)
#endif

                    for (int ir = 0; ir < Hd; ir++) {
                        for (int jr = 0; jr < Wd; jr++) {
                            buflight[ir][jr] = tmpl->L[ir][jr] - bufreti->L[ir][jr];
                            minL = rtengine::min(minL, buflight[ir][jr]);
                            maxL = rtengine::max(maxL, buflight[ir][jr]);
                        }
                    }

                    float coef = 0.01f * (max(fabs(minL), fabs(maxL)));


                    for (int ir = 0; ir < Hd; ir++) {
                        for (int jr = 0; jr < Wd; jr++) {
                            buflight[ir][jr] /= coef;
                        }
                    }

                    transit_shapedetect_retinex(call, 4, bufreti, bufmask, buforigmas, buflight, bufchro, hueref, chromaref, lumaref, lp, original, transformed, cx, cy, sk);

                } else {
                    InverseReti_Local(lp, hueref, chromaref, lumaref, original, transformed, tmpl, cx, cy, 0, sk);
                }


                if (params->locallab.spots.at(sp).chrrt > 0) {

                    if (!lp.invret && call == 1) {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1)
                            for (int jr = 0; jr < Wd; jr += 1) {

                                orig[ir][jr] = sqrt(SQR(bufreti->a[ir][jr]) + SQR(bufreti->b[ir][jr]));
                                orig1[ir][jr] = sqrt(SQR(bufreti->a[ir][jr]) + SQR(bufreti->b[ir][jr]));
                            }

                    }  else {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < GH; ir += 1)
                            for (int jr = 0; jr < GW; jr += 1) {
                                orig[ir][jr] = sqrt(SQR(original->a[ir][jr]) + SQR(original->b[ir][jr]));
                                orig1[ir][jr] = sqrt(SQR(transformed->a[ir][jr]) + SQR(transformed->b[ir][jr]));
                            }
                    }

                    float maxChro = orig1[0][0];
#ifdef _OPENMP
                    #pragma omp parallel for reduction(max:maxChro) schedule(dynamic,16)
#endif

                    for (int ir = 0; ir < Hd; ir++) {
                        for (int jr = 0; jr < Wd; jr++) {
                            maxChro = rtengine::max(maxChro, orig1[ir][jr]);
                        }
                    }

                    float divchro = maxChro;

                    //first step change saturation whithout Retinex ==> gain of time and memory
                    float satreal = lp.str * params->locallab.spots.at(sp).chrrt / 100.f;

                    if (params->locallab.spots.at(sp).chrrt <= 0.2f) {
                        satreal /= 10.f;
                    }

                    DiagonalCurve reti_satur({
                        DCT_NURBS,
                        0, 0,
                        0.2, 0.2 + satreal / 250.0,
                        0.6,  min(1.0, 0.6 + satreal / 250.0),
                        1, 1
                    });
                    bool fftw = false;

                    if (params->locallab.spots.at(sp).chrrt > 40.f) { //second step active Retinex Chroma
                        ImProcFunctions::MSRLocal(sp, fftw, 0, nullptr, bufreti, bufmask, buforig, buforigmas, orig, tmpl->L, orig1, Wd, Hd, Wd, Hd, params->locallab, sk, locRETgainCcurve, locRETtransCcurve, 1, 4, 0.8f, minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax,
                                                  locccmasretiCurve, lcmasretiutili, locllmasretiCurve, llmasretiutili, lochhmasretiCurve, lhmasretiutili, llretiMask, transformed, lp.enaretiMasktmap, lp.enaretiMask);
                    }

                    if (!lp.invret && call == 1) {

#ifdef _OPENMP
                        #pragma omp parallel for
#endif

                        for (int ir = 0; ir < Hd; ir += 1)
                            for (int jr = 0; jr < Wd; jr += 1) {
                                const float Chprov = orig1[ir][jr];
                                float2 sincosval;
                                sincosval.y = Chprov == 0.0f ? 1.f : bufreti->a[ir][jr] / Chprov;
                                sincosval.x = Chprov == 0.0f ? 0.f : bufreti->b[ir][jr] / Chprov;

                                if (params->locallab.spots.at(sp).chrrt <= 40.f) { //first step
                                    float buf = LIM01(orig[ir][jr] / divchro);
                                    buf = reti_satur.getVal(buf);
                                    buf *= divchro;
                                    orig[ir][jr] = buf;
                                }

                                tmpl->a[ir][jr] = orig[ir][jr] * sincosval.y;
                                tmpl->b[ir][jr] = orig[ir][jr] * sincosval.x;
                            }

                        float minC = sqrt(SQR(tmpl->a[0][0]) + SQR(tmpl->b[0][0])) - orig1[0][0];
                        float maxC = minC;
#ifdef _OPENMP
                        #pragma omp parallel for reduction(min:minC) reduction(max:maxC) schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir++) {
                            for (int jr = 0; jr < Wd; jr++) {
                                bufchro[ir][jr] = sqrt(SQR(tmpl->a[ir][jr]) + SQR(tmpl->b[ir][jr])) - orig1[ir][jr];
                                minC = rtengine::min(minC, bufchro[ir][jr]);
                                maxC = rtengine::max(maxC, bufchro[ir][jr]);
                            }
                        }

                        float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                        if (coefC == 0.f) {
                            coefC = 1.f;
                        }

                        for (int ir = 0; ir < Hd; ir++) {
                            for (int jr = 0; jr < Wd; jr++) {
                                bufchro[ir][jr] /= coefC;
                            }
                        }
                    } else {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1)
                            for (int jr = 0; jr < Wd; jr += 1) {
                                float Chprov = orig1[ir][jr];
                                float2 sincosval;
                                sincosval.y = Chprov == 0.0f ? 1.f : transformed->a[ir][jr] / Chprov;
                                sincosval.x = Chprov == 0.0f ? 0.f : transformed->b[ir][jr] / Chprov;
                                tmpl->a[ir][jr] = orig[ir][jr] * sincosval.y;
                                tmpl->b[ir][jr] = orig[ir][jr] * sincosval.x;

                            }
                    }


                    if (!lp.invret) {
                        transit_shapedetect_retinex(call, 5, tmpl, bufmask, buforigmas, buflight, bufchro, hueref, chromaref, lumaref, lp, original, transformed, cx, cy, sk);
                    } else {
                        InverseReti_Local(lp, hueref, chromaref, lumaref, original, transformed, tmpl, cx, cy, 1, sk);
                    }

                }

                delete tmpl;
                delete [] reducDEBuffer;
                delete [] origBuffer;
                delete [] origBuffer1;

                if (bufmask) {
                    delete bufmask;
                }

                if (!lp.enaretiMasktmap && lp.enaretiMask) {
                    if (buforig) {
                        delete buforig;
                    }

                    if (buforigmas) {
                        delete buforigmas;
                    }
                }

                if (bufreti) {
                    delete  bufreti;
                }

            }
        }



        if (lp.str >= 0.2f  && lp.retiena && call == 2) {
            int GW = transformed->W;
            int GH = transformed->H;
            int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            int bfh = yend - ystart;
            int bfw = xend - xstart;

            LabImage *bufreti = nullptr;
            LabImage *bufmask = nullptr;
            LabImage *buforig = nullptr;
            LabImage *buforigmas = nullptr;
            int bfhr = bfh;
            int bfwr = bfw;
            bool reduH = false;
            bool reduW = false;

            if (bfw >= mSP && bfh > mSP) {

                if (lp.ftwreti) {
                    int ftsizeH = 1;
                    int ftsizeW = 1;

                    for (int ft = 0; ft < N_fftwsize; ft++) { //find best values for FFTW
                        if (fftw_size[ft] <= bfh) {
                            ftsizeH = fftw_size[ft];
                            break;
                        }
                    }

                    for (int ft = 0; ft < N_fftwsize; ft++) {
                        if (fftw_size[ft] <= bfw) {
                            ftsizeW = fftw_size[ft];
                            break;
                        }
                    }


                    if (ystart == 0 && yend < original->H) {
                        lp.ly -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend == original->H) {
                        lp.lyT -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend != original->H) {
                        if (lp.ly <= lp.lyT) {
                            lp.lyT -= (bfh - ftsizeH);
                        } else {
                            lp.ly -= (bfh - ftsizeH);
                        }
                    } else if (ystart == 0 && yend == original->H) {
                        bfhr = ftsizeH;
                        reduH = true;
                    }

                    if (xstart == 0 && xend < original->W) {
                        lp.lx -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend == original->W) {
                        lp.lxL -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend != original->W) {
                        if (lp.lx <= lp.lxL) {
                            lp.lxL -= (bfw - ftsizeW);
                        } else {
                            lp.lx -= (bfw - ftsizeW);
                        }
                    } else if (xstart == 0 && xend == original->W) {
                        bfwr = ftsizeW;
                        reduW = true;
                    }


                    //new values optimized
                    ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
                    yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
                    xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
                    xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
                    bfh = bfhr = yend - ystart;
                    bfw = bfwr = xend - xstart;

                    if (reduH) {
                        bfhr = ftsizeH;
                    }

                    if (reduW) {
                        bfwr = ftsizeW;
                    }

                    if (settings->verbose) {
                        printf("Nyst=%i Nyen=%i lp.yc=%f lp.lyT=%f  lp.ly=%f bfh=%i bfhr=%i origH=%i ftsizeH=%i\n", ystart, yend, lp.yc, lp.lyT, lp.ly, bfh, bfhr, original->H, ftsizeH);
                        printf("Nxst=%i Nxen=%i lp.xc=%f lp.lxL=%f  lp.lx=%f bfw=%i bfwr=%i origW=%i ftsizeW=%i\n", xstart, xend, lp.xc, lp.lxL, lp.lx, bfw, bfwr, original->W, ftsizeW);
                    }
                }


                array2D<float> buflight(bfw, bfh);
                JaggedArray<float> bufchro(bfw, bfh);

                int Hd, Wd;
                Hd = GH;
                Wd = GW;

                if (!lp.invret && call == 2) {

                    Hd = bfh;
                    Wd = bfw;
                    bufreti = new LabImage(bfw, bfh);
                    bufmask = new LabImage(bfw, bfh);

                    if (!lp.enaretiMasktmap && lp.enaretiMask) {
                        buforig = new LabImage(bfw, bfh);
                        buforigmas = new LabImage(bfw, bfh);
                    }

#ifdef _OPENMP
                    #pragma omp parallel for
#endif

                    for (int ir = 0; ir < bfh; ir++) //fill with 0
                        for (int jr = 0; jr < bfw; jr++) {
                            bufreti->L[ir][jr] = 0.f;
                            bufreti->a[ir][jr] = 0.f;
                            bufreti->b[ir][jr] = 0.f;
                            buflight[ir][jr] = 0.f;
                            bufchro[ir][jr] = 0.f;
                        }


#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = ystart; y < yend; y++) {
                        for (int x = xstart; x < xend; x++) {
                            bufreti->L[y - ystart][x - xstart] = original->L[y][x];
                            bufreti->a[y - ystart][x - xstart] = original->a[y][x];
                            bufreti->b[y - ystart][x - xstart] = original->b[y][x];
                            bufmask->L[y - ystart][x - xstart] = original->L[y][x];
                            bufmask->a[y - ystart][x - xstart] = original->a[y][x];
                            bufmask->b[y - ystart][x - xstart] = original->b[y][x];

                            if (!lp.enaretiMasktmap && lp.enaretiMask) {
                                buforig->L[y - ystart][x - xstart] = original->L[y][x];
                                buforig->a[y - ystart][x - xstart] = original->a[y][x];
                                buforig->b[y - ystart][x - xstart] = original->b[y][x];
                            }
                        }
                    }
                }

                float raddE = params->locallab.spots.at(sp).softradiusret;

                //calc dE and reduction to use in MSR to reduce artifacts
                const int limscope = 80;
                const float mindE = 4.f + MINSCOPE * lp.sensh * lp.thr;
                const float maxdE = 5.f + MAXSCOPE * lp.sensh * (1 + 0.1f * lp.thr);
                const float mindElim = 2.f + MINSCOPE * limscope * lp.thr;
                const float maxdElim = 5.f + MAXSCOPE * limscope * (1 + 0.1f * lp.thr);
                const float refa = chromaref * cos(hueref);
                const float refb = chromaref * sin(hueref);


                float *reducDE[Hd] ALIGNED16;
                float *reducDEBuffer = new float[Hd * Wd];

                for (int i = 0; i < Hd; i++) {
                    reducDE[i] = &reducDEBuffer[i * Wd];
                }

                float ade = 0.01f * raddE;
                float bde = 100.f - raddE;
                float sensibefore = ade * lp.sensh + bde;//we can change sensitivity 0.1 90 or 0.3 70 or 0.4 60
#ifdef _OPENMP
                #pragma omp parallel for schedule(dynamic,16)
#endif

                for (int y = ystart; y < yend ; y++)
                    for (int x = xstart; x < xend; x++) {
                        float dE = sqrt(SQR(refa - bufreti->a[y - ystart][x - xstart] / 327.68f) + SQR(refb - bufreti->b[y - ystart][x - xstart] / 327.68f) +  SQR(lumaref - bufreti->b[y - ystart][x - xstart] / 327.68f));
                        float reducdE;
                        calcreducdE(dE, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sensibefore, reducdE);
                        reducDE[y - ystart][x - xstart] = CLIPdE(reducdE);

                    }

                float *orig[Hd] ALIGNED16;
                float *origBuffer = new float[Hd * Wd];

                for (int i = 0; i < Hd; i++) {
                    orig[i] = &origBuffer[i * Wd];
                }

                float *orig1[Hd] ALIGNED16;
                float *origBuffer1 = new float[Hd * Wd];

                for (int i = 0; i < Hd; i++) {
                    orig1[i] = &origBuffer1[i * Wd];
                }

                LabImage *tmpl = nullptr;

                if (!lp.invret && call == 2) {


#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int ir = 0; ir < Hd; ir += 1)
                        for (int jr = 0; jr < Wd; jr += 1) {
                            orig[ir][jr] = bufreti->L[ir][jr];
                            orig1[ir][jr] = bufreti->L[ir][jr];
                        }

                    tmpl = new LabImage(Wd, Hd);

                }  else {

                    Imagefloat *tmpImage = nullptr;
                    bufreti = new LabImage(Wd, Hd);

                    if (lp.dehaze > 0) {
                        const float depthcombi = 0.5f * lp.depth + 0.5f * (0.3f * params->locallab.spots.at(sp).neigh + 0.15f * (500.f - params->locallab.spots.at(sp).vart));
                        DehazeParams dehazeParams;
                        dehazeParams.enabled = true;
                        dehazeParams.strength = 0.9f * lp.dehaze + 0.3f * lp.str;
                        dehazeParams.showDepthMap = false;
                        dehazeParams.depth = LIM(depthcombi, 0.f, 100.f);
                        dehazeParams.luminance = params->locallab.spots.at(sp).lumonly;

                        tmpImage = new Imagefloat(Wd, Hd);
                        lab2rgb(*original, *tmpImage, params->icm.workingProfile);
                        dehaze(tmpImage, dehazeParams);
                        rgb2lab(*tmpImage, *bufreti, params->icm.workingProfile);

                        delete tmpImage;
#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1) {
                            for (int jr = 0; jr < Wd; jr += 1) {
                                orig[ir][jr] = original->L[ir][jr];
                                orig1[ir][jr] = bufreti->L[ir][jr];
                            }
                        }

                        delete bufreti;
                        bufreti = nullptr;
                    } else {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1) {
                            for (int jr = 0; jr < Wd; jr += 1) {
                                orig[ir][jr] = original->L[ir][jr];
                                orig1[ir][jr] = transformed->L[ir][jr];
                            }
                        }
                    }

                    tmpl = new LabImage(transformed->W, transformed->H);
                }

                //   float minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax;
                bool fftw = lp.ftwreti;
                //for Retinex Mask are incorporated in MSR

                ImProcFunctions::MSRLocal(sp, fftw, 1, reducDE, bufreti, bufmask, buforig, buforigmas, orig, tmpl->L, orig1, Wd, Hd, bfwr, bfhr, params->locallab, sk, locRETgainCcurve, locRETtransCcurve, 0, 4, 1.f, minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax,
                                          locccmasretiCurve, lcmasretiutili, locllmasretiCurve, llmasretiutili, lochhmasretiCurve, lhmasretiutili, llretiMask, transformed, lp.enaretiMasktmap, lp.enaretiMask);

#ifdef _OPENMP
                #pragma omp parallel for
#endif

                for (int ir = 0; ir < Hd; ir += 1)
                    for (int jr = 0; jr < Wd; jr += 1) {
                        tmpl->L[ir][jr] = orig[ir][jr];
                    }


                if (lp.equret) { //equilibrate luminance before / after MSR
                    float *datain = new float[Hd * Wd];
                    float *data = new float[Hd * Wd];
#ifdef _OPENMP
                    #pragma omp parallel for
#endif

                    for (int ir = 0; ir < Hd; ir += 1)
                        for (int jr = 0; jr < Wd; jr += 1) {
                            datain[ir * Wd + jr] = orig1[ir][jr];
                            data[ir * Wd + jr] = orig[ir][jr];
                        }

                    normalize_mean_dt(data, datain, Hd * Wd, 1.f);
#ifdef _OPENMP
                    #pragma omp parallel for
#endif

                    for (int ir = 0; ir < Hd; ir += 1)
                        for (int jr = 0; jr < Wd; jr += 1) {
                            tmpl->L[ir][jr] = data[ir * Wd + jr];
                        }

                    delete [] datain;
                    delete [] data;
                }



                if (!lp.invret) {
                    float minL = tmpl->L[0][0] - bufreti->L[0][0];
                    float maxL = minL;
#ifdef _OPENMP
                    #pragma omp parallel for reduction(min:minL) reduction(max:maxL) schedule(dynamic,16)
#endif

                    for (int ir = 0; ir < Hd; ir++) {
                        for (int jr = 0; jr < Wd; jr++) {
                            buflight[ir][jr] = tmpl->L[ir][jr] - bufreti->L[ir][jr];
                            minL = rtengine::min(minL, buflight[ir][jr]);
                            maxL = rtengine::max(maxL, buflight[ir][jr]);
                        }
                    }

                    float coef = 0.01f * (max(fabs(minL), fabs(maxL)));

                    if (coef == 0.f) {
                        coef = 1.f;
                    }


                    for (int ir = 0; ir < Hd; ir++) {
                        for (int jr = 0; jr < Wd; jr++) {
                            buflight[ir][jr] /= coef;
                        }
                    }



                    /*
                                    if (lp.softradiusret > 0.f && lp.scalereti != 1) {
                                    //    softprocess(bufreti, buflight, lp.softradiusret, Hd, Wd, sk, 0.01, 0.001, 0.0001f, multiThread);
                                       //softproc(bufreti, tmpl, lp.softradiusret, bfh, bfw, 0.0001, 0.00001, 0.0001f, sk, multiThread);
                                    }
                    */
                    transit_shapedetect_retinex(call, 4, bufreti, bufmask, buforigmas, buflight, bufchro, hueref, chromaref, lumaref, lp, original, transformed, cx, cy, sk);

                } else {
                    InverseReti_Local(lp, hueref, chromaref, lumaref, original, transformed, tmpl, cx, cy, 0, sk);
                }

                if (params->locallab.spots.at(sp).chrrt > 0) {

                    if (!lp.invret && call == 2) {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1)
                            for (int jr = 0; jr < Wd; jr += 1) {

                                orig[ir][jr] = sqrt(SQR(bufreti->a[ir][jr]) + SQR(bufreti->b[ir][jr]));
                                orig1[ir][jr] = sqrt(SQR(bufreti->a[ir][jr]) + SQR(bufreti->b[ir][jr]));
                            }

                    }  else {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < GH; ir += 1)
                            for (int jr = 0; jr < GW; jr += 1) {
                                orig[ir][jr] = sqrt(SQR(original->a[ir][jr]) + SQR(original->b[ir][jr]));
                                orig1[ir][jr] = sqrt(SQR(transformed->a[ir][jr]) + SQR(transformed->b[ir][jr]));
                            }
                    }

                    float maxChro = orig1[0][0];
#ifdef _OPENMP
                    #pragma omp parallel for reduction(max:maxChro) schedule(dynamic,16)
#endif

                    for (int ir = 0; ir < Hd; ir++) {
                        for (int jr = 0; jr < Wd; jr++) {
                            maxChro = rtengine::max(maxChro, orig1[ir][jr]);
                        }
                    }

                    float divchro = maxChro;

                    //first step change saturation whithout Retinex ==> gain of time and memory
                    float satreal = lp.str * params->locallab.spots.at(sp).chrrt / 100.f;

                    if (params->locallab.spots.at(sp).chrrt <= 0.2f) {
                        satreal /= 10.f;
                    }

                    DiagonalCurve reti_satur({
                        DCT_NURBS,
                        0, 0,
                        0.2, 0.2 + satreal / 250.0,
                        0.6,  min(1.0, 0.6 + satreal / 250.0),
                        1, 1
                    });
                    bool fftw = false;

                    if (params->locallab.spots.at(sp).chrrt > 40.f) { //second step active Retinex Chroma
                        ImProcFunctions::MSRLocal(sp, fftw, 0, nullptr, bufreti, bufmask, buforig, buforigmas, orig, tmpl->L, orig1, Wd, Hd, Wd, Hd, params->locallab, sk, locRETgainCcurve, locRETtransCcurve, 1, 4, 0.8f, minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax,
                                                  locccmasretiCurve, lcmasretiutili, locllmasretiCurve, llmasretiutili, lochhmasretiCurve, lhmasretiutili, llretiMask, transformed, lp.enaretiMasktmap, lp.enaretiMask);
                    }

                    if (!lp.invret && call == 2) {

#ifdef _OPENMP
                        #pragma omp parallel for
#endif

                        for (int ir = 0; ir < Hd; ir += 1)
                            for (int jr = 0; jr < Wd; jr += 1) {
                                const float Chprov = orig1[ir][jr];
                                float2 sincosval;
                                sincosval.y = Chprov == 0.0f ? 1.f : bufreti->a[ir][jr] / Chprov;
                                sincosval.x = Chprov == 0.0f ? 0.f : bufreti->b[ir][jr] / Chprov;

                                if (params->locallab.spots.at(sp).chrrt <= 40.f) { //first step
                                    float buf = LIM01(orig[ir][jr] / divchro);
                                    buf = reti_satur.getVal(buf);
                                    buf *= divchro;
                                    orig[ir][jr] = buf;
                                }

                                tmpl->a[ir][jr] = orig[ir][jr] * sincosval.y;
                                tmpl->b[ir][jr] = orig[ir][jr] * sincosval.x;
                            }

                        float minC = sqrt(SQR(tmpl->a[0][0]) + SQR(tmpl->b[0][0])) - orig1[0][0];
                        float maxC = minC;
#ifdef _OPENMP
                        #pragma omp parallel for reduction(min:minC) reduction(max:maxC) schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir++) {
                            for (int jr = 0; jr < Wd; jr++) {
                                bufchro[ir][jr] = sqrt(SQR(tmpl->a[ir][jr]) + SQR(tmpl->b[ir][jr])) - orig1[ir][jr];
                                minC = rtengine::min(minC, bufchro[ir][jr]);
                                maxC = rtengine::max(maxC, bufchro[ir][jr]);
                            }
                        }

                        float coefC = 0.01f * (max(fabs(minC), fabs(maxC)));

                        if (coefC == 0.f) {
                            coefC = 1.f;
                        }

                        for (int ir = 0; ir < Hd; ir++) {
                            for (int jr = 0; jr < Wd; jr++) {
                                bufchro[ir][jr] /= coefC;
                            }
                        }
                    } else {

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < Hd; ir += 1)
                            for (int jr = 0; jr < Wd; jr += 1) {
                                float Chprov = orig1[ir][jr];
                                float2 sincosval;
                                sincosval.y = Chprov == 0.0f ? 1.f : transformed->a[ir][jr] / Chprov;
                                sincosval.x = Chprov == 0.0f ? 0.f : transformed->b[ir][jr] / Chprov;
                                tmpl->a[ir][jr] = orig[ir][jr] * sincosval.y;
                                tmpl->b[ir][jr] = orig[ir][jr] * sincosval.x;

                            }
                    }


                    if (!lp.invret) {
                        transit_shapedetect_retinex(call, 5, tmpl, bufmask, buforigmas, buflight, bufchro, hueref, chromaref, lumaref, lp, original, transformed, cx, cy, sk);
                    } else {
                        InverseReti_Local(lp, hueref, chromaref, lumaref, original, transformed, tmpl, cx, cy, 1, sk);
                    }

                }

                delete tmpl;
                delete [] reducDEBuffer;
                delete [] origBuffer;
                delete [] origBuffer1;

                if (bufmask) {
                    delete bufmask;
                }

                if (!lp.enaretiMasktmap && lp.enaretiMask) {
                    if (buforig) {
                        delete buforig;
                    }

                    if (buforigmas) {
                        delete buforigmas;
                    }
                }

                if (bufreti) {
                    delete  bufreti;
                }
            }
        }

        if (!lp.invex  && (lp.exposena && (lp.expcomp != 0.f || lp.war != 0 || lp.laplacexp > 0.1f || params->locallab.spots.at(sp).fatamount > 1.f || lp.showmaskexpmet == 2 || lp.enaExpMask || lp.showmaskexpmet == 3 || lp.showmaskexpmet == 4  || lp.showmaskexpmet == 5 || (exlocalcurve  && localexutili)))) { //interior ellipse renforced lightness and chroma  //locallutili
            int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            int bfh = yend - ystart;
            int bfw = xend - xstart;
            //variable for fast FFTW
            int bfhr = bfh;
            int bfwr = bfw;
            bool reduH = false;
            bool reduW = false;

            if (bfw >= mSP && bfh >= mSP) {

                if (lp.expmet == 1) {
                    int ftsizeH = 1;
                    int ftsizeW = 1;

                    for (int ft = 0; ft < N_fftwsize; ft++) { //find best values
                        if (fftw_size[ft] <= bfh) {
                            ftsizeH = fftw_size[ft];
                            break;
                        }
                    }

                    for (int ft = 0; ft < N_fftwsize; ft++) {
                        if (fftw_size[ft] <= bfw) {
                            ftsizeW = fftw_size[ft];
                            break;
                        }
                    }

                    //optimize with size fftw
                    if (ystart == 0 && yend < original->H) {
                        lp.ly -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend == original->H) {
                        lp.lyT -= (bfh - ftsizeH);
                    } else if (ystart != 0 && yend != original->H) {
                        if (lp.ly <= lp.lyT) {
                            lp.lyT -= (bfh - ftsizeH);
                        } else {
                            lp.ly -= (bfh - ftsizeH);
                        }
                    } else if (ystart == 0 && yend == original->H) {
                        bfhr = ftsizeH;
                        reduH = true;
                    }

                    if (xstart == 0 && xend < original->W) {
                        lp.lx -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend == original->W) {
                        lp.lxL -= (bfw - ftsizeW);
                    } else if (xstart != 0 && xend != original->W) {
                        if (lp.lx <= lp.lxL) {
                            lp.lxL -= (bfw - ftsizeW);
                        } else {
                            lp.lx -= (bfw - ftsizeW);
                        }
                    } else if (xstart == 0 && xend == original->W) {
                        bfwr = ftsizeW;
                        reduW = true;
                    }

                    //new values optimized
                    ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
                    yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
                    xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
                    xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
                    bfh = bfhr = yend - ystart;
                    bfw = bfwr = xend - xstart;

                    if (reduH) {
                        bfhr = ftsizeH;
                    }

                    if (reduW) {
                        bfwr = ftsizeW;
                    }
                }

                std::unique_ptr<LabImage> bufexporig(new LabImage(bfw, bfh));
                std::unique_ptr<LabImage> bufexpfin(new LabImage(bfw, bfh));
                std::unique_ptr<LabImage> bufmaskblurexp;
                std::unique_ptr<LabImage> originalmaskexp;


                array2D<float> buflight(bfw, bfh);
                JaggedArray<float> bufl_ab(bfw, bfh);
                JaggedArray<float> buf_a_cat(bfw, bfh);
                JaggedArray<float> buf_b_cat(bfw, bfh);
                array2D<float> blend2;

                if (call <= 3) { //simpleprocess, dcrop, improccoordinator
                    float meansob = 0.f;

                    if (lp.showmaskexpmet == 2  || lp.enaExpMask || lp.showmaskexpmet == 3 || lp.showmaskexpmet == 5) {
                        bufmaskblurexp.reset(new LabImage(bfw, bfh));
                        originalmaskexp.reset(new LabImage(bfw, bfh));
                    }

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = ystart; y < yend; y++) {
                        for (int x = xstart; x < xend; x++) {
                            bufexporig->L[y - ystart][x - xstart] = original->L[y][x];
                        }
                    }

                    const int spotSi = rtengine::max(1 + 2 * max(1, lp.cir / sk), 5);

                    if (bfw > 2 * spotSi && bfh > 2 * spotSi && lp.struexp > 0.f) {
                        blend2(bfw, bfh);
                        ImProcFunctions::blendstruc(bfw, bfh, bufexporig.get(), 3.f / (sk * 1.4f), 0.5f * lp.struexp, blend2, sk, multiThread);

                        if (lp.showmaskexpmet == 4) {
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = ystart; y < yend ; y++) {
                                for (int x = xstart; x < xend; x++) {
                                    const int lox = cx + x;
                                    const int loy = cy + y;
                                    int zone = 0;
                                    float localFactor = 1.f;
                                    const float achm = lp.trans / 100.f;

                                    if (lp.shapmet == 0) {
                                        calcTransition(lox, loy, achm, lp, zone, localFactor);
                                    } else if (lp.shapmet == 1) {
                                        calcTransitionrect(lox, loy, achm, lp, zone, localFactor);
                                    }

                                    if (zone > 0) {
                                        transformed->L[y][x] = CLIP(blend2[y - ystart][x - xstart]);
                                        transformed->a[y][x] = 0.f;
                                        transformed->b[y][x] = 0.f;
                                    }
                                }
                            }

                            return;
                        }
                    }

                    float meanorig = 0.f;

                    for (int ir = 0; ir < bfh; ir++)
                        for (int jr = 0; jr < bfw; jr++) {
                            meanorig += bufexporig->L[ir][jr];
                        }

                    meanorig /= (bfh * bfw);

                    int inv = 0;
                    bool showmaske = false;
                    bool enaMask = false;
                    bool deltaE = false;
                    bool modmask = false;
                    bool zero = false;
                    bool modif = false;

                    if (lp.showmaskexpmet == 3) {
                        showmaske = true;
                    }

                    if (lp.enaExpMask) {
                        enaMask = true;
                    }

                    if (lp.showmaskexpmet == 5) {
                        deltaE = true;
                    }

                    if (lp.showmaskexpmet == 2) {
                        modmask = true;
                    }

                    if (lp.showmaskexpmet == 1) {
                        modif = true;
                    }

                    if (lp.showmaskexpmet == 0) {
                        zero = true;
                    }

                    float chrom = lp.chromaexp;
                    float rad = lp.radmaexp;
                    float gamma = lp.gammaexp;
                    float slope = lp.slomaexp;
                    float blendm = lp.blendmaexp;
                    float lap = params->locallab.spots.at(sp).lapmaskexp;
                    float pde = params->locallab.spots.at(sp).laplac;
                    LUTf dummy;
                    bool uti;

                    maskcalccol(false, pde, bfw, bfh, xstart, ystart, sk, cx, cy, bufexporig.get(), bufmaskblurexp.get(), originalmaskexp.get(), original, inv, lp,
                                locccmasexpCurve, lcmasexputili, locllmasexpCurve, llmasexputili, lochhmasexpCurve, lhmasexputili, multiThread,
                                enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);

                    if (lp.showmaskexpmet == 3) {
                        showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufexporig.get(), transformed, bufmaskblurexp.get(), 0);

                        return;
                    }

                    if (lp.showmaskexpmet == 4) {
                        return;
                    }

                    if (lp.showmaskexpmet == 0 || lp.showmaskexpmet == 1  || lp.showmaskexpmet == 2  || lp.showmaskexpmet == 5 || lp.enaExpMask) {
#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int y = 0; y < bfh; y++) {
                            for (int x = 0; x < bfw; x++) {
                                bufexpfin->L[y][x] = original->L[y + ystart][x + xstart];
                                bufexpfin->a[y][x] = original->a[y + ystart][x + xstart];
                                bufexpfin->b[y][x] = original->b[y + ystart][x + xstart];
                            }
                        }



                        if (exlocalcurve && localexutili) {// L=f(L) curve enhanced
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int ir = 0; ir < bfh; ir++)
                                for (int jr = 0; jr < bfw; jr++) {
                                    bufexpfin->L[ir][jr] = 0.5f * exlocalcurve[2.f * bufexporig->L[ir][jr]];
                                }

                            if (lp.expcomp == 0.f) {
                                lp.expcomp = 0.1f;    // to enabled
                            }

                            ImProcFunctions::exlabLocal(lp, bfh, bfw, bufexpfin.get(), bufexpfin.get(), hltonecurveloc, shtonecurveloc, tonecurveloc, meanorig);


                        } else {

                            ImProcFunctions::exlabLocal(lp, bfh, bfw, bufexporig.get(), bufexpfin.get(), hltonecurveloc, shtonecurveloc, tonecurveloc, meanorig);
                        }

//exposure_pde
                        if (lp.expmet == 1) {

                            float enablefat = false;
                            Imagefloat *tmpImagefat = nullptr;

                            if (params->locallab.spots.at(sp).fatamount > 1.f) {
                                enablefat = true;
                            }

                            if (enablefat) {
                                FattalToneMappingParams fatParams;
                                fatParams.enabled = true;
                                fatParams.threshold = params->locallab.spots.at(sp).fatdetail;
                                fatParams.amount = params->locallab.spots.at(sp).fatamount;
                                fatParams.anchor = params->locallab.spots.at(sp).fatanchor;
                                int nlev = params->locallab.spots.at(sp).fatlevel;
                                tmpImagefat = new Imagefloat(bfwr, bfhr);
                                lab2rgb(*bufexpfin, *tmpImagefat, params->icm.workingProfile);
                                ToneMapFattal02(tmpImagefat, fatParams, nlev);
                                rgb2lab(*tmpImagefat, *bufexpfin, params->icm.workingProfile);
                                delete tmpImagefat;
                            }


                            if (lp.laplacexp > 0.1f) {
                                MyMutex::MyLock lock(*fftwMutex);
                                float *datain = new float[bfwr * bfhr];
                                float *dataout = new float[bfwr * bfhr];
                                float *dataor = new float[bfwr * bfhr];
                                float gam = params->locallab.spots.at(sp).gamm;
                                float igam = 1.f / gam;


                                if (params->locallab.spots.at(sp).exnoiseMethod == "med" || params->locallab.spots.at(sp).exnoiseMethod == "medhi") {


                                    if (lp.blac < -100.f && lp.linear > 0.01f) {
                                        Median med = Median:: TYPE_3X3_SOFT;
                                        float evnoise = lp.blac - lp.linear * 2000.f;

                                        if (params->locallab.spots.at(sp).exnoiseMethod == "med") {
                                            evnoise *= 0.4f;
                                        }

                                        //soft denoise, user must use Local Denoise to best result
                                        if (evnoise < - 18000.f) {
                                            med = Median::TYPE_5X5_STRONG;
                                        } else if (evnoise < - 15000.f) {
                                            med = Median::TYPE_5X5_SOFT;
                                        } else if (evnoise < - 10000.f) {
                                            med = Median::TYPE_3X3_STRONG;
                                        } else {
                                            med = Median:: TYPE_3X3_SOFT;
                                        }

                                        Median_Denoise(bufexpfin->L, bufexpfin->L, bfwr, bfhr, med, 1, multiThread);
                                        Median_Denoise(bufexpfin->a, bufexpfin->a, bfwr, bfhr, Median::TYPE_3X3_SOFT, 1, multiThread);
                                        Median_Denoise(bufexpfin->b, bufexpfin->b, bfwr, bfhr, Median::TYPE_3X3_SOFT, 1, multiThread);

                                    }

                                }

#ifdef _OPENMP
                                #pragma omp parallel for schedule(dynamic,16)
#endif

                                for (int y = 0; y < bfhr; y++) {
                                    for (int x = 0; x < bfwr; x++) {
                                        float L = LIM01(bufexpfin->L[y][x] / 32768.f);//change gamma for Laplacian

                                        L = pow(L, gam);
                                        L *= 32768.f;
                                        datain[y * bfwr + x] = L;
                                        dataor[y * bfwr + x] = L;
                                    }
                                }

                                //call PDE equation - with Laplacian threshold
                                ImProcFunctions::exposure_pde(dataor, datain, dataout, bfwr, bfhr, 12.f * lp.laplacexp, lp.balanexp);
#ifdef _OPENMP
                                #pragma omp parallel for schedule(dynamic,16)
#endif

                                for (int y = 0; y < bfhr; y++) {
                                    for (int x = 0; x < bfwr; x++) {
                                        float Y = dataout[y * bfwr + x] / 32768.f;//inverse Laplacian gamma
                                        Y = pow(Y, igam);
                                        Y *= 32768.f;
                                        bufexpfin->L[y][x] = Y;
                                    }
                                }

                                delete [] datain;
                                delete [] dataout;
                                delete [] dataor;
                            }
                        }

                        //shadows with ipshadowshighlight
                        if (lp.shadex > 0) {
                            ImProcFunctions::shadowsHighlights(bufexpfin.get(), true, 1, 0, lp.shadex, 40, sk, 0, lp.shcomp);
                        }

                        //cat02
                        if (params->locallab.spots.at(sp).warm != 0) {
                            ImProcFunctions::ciecamloc_02float(sp, bufexpfin.get());
                        }


                        constexpr float ampli = 70.f;
                        const float ch = (1.f + 0.02f * lp.expchroma);
                        const float chprosl = ch <= 1.f ? 99.f * ch - 99.f : CLIPCHRO(ampli * ch - ampli);

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++) {
                            for (int jr = 0; jr < bfw; jr++) {
                                const float epsi = bufexporig->L[ir][jr] == 0.f ? 0.001f : 0.f;
                                const float rapexp = bufexpfin->L[ir][jr] / (bufexporig->L[ir][jr] + epsi);

                                if (rapexp >= 1.f) {
                                    bufl_ab[ir][jr] = chprosl * rapexp;
                                } else {
                                    bufl_ab[ir][jr] = chprosl * rapexp;
                                }
                            }
                        }

                        if (lp.softradiusexp > 0.f && lp.expmet == 0) {
                            softproc(bufexporig.get(), bufexpfin.get(), lp.softradiusexp, bfh, bfw, 0.0001, 0.00001, 0.1f, sk, multiThread, 0);
                            //     softprocess(bufexporig.get(), buflight, lp.softradiusexp, bfh, bfw, sk, multiThread);
                        }

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++)
                            for (int jr = 0; jr < bfw; jr++) {
                                buflight[ir][jr] = CLIPRET((bufexpfin->L[ir][jr] - bufexporig->L[ir][jr]) / 328.f);
                                buf_a_cat[ir][jr] = CLIPRET((bufexpfin->a[ir][jr] - bufexporig->a[ir][jr]) / 328.f);
                                buf_b_cat[ir][jr] = CLIPRET((bufexpfin->b[ir][jr] - bufexporig->b[ir][jr]) / 328.f);
                            }

                        if (lp.softradiusexp > 0.f) {
                            //     softprocess(bufexporig.get(), buflight, lp.softradiusexp, bfh, bfw, sk, multiThread);
                        }
                    }

                    bufexpfin.reset();
                    transit_shapedetect(1, bufexporig.get(), originalmaskexp.get(), buflight, bufl_ab, buf_a_cat, buf_b_cat, nullptr, false, hueref, chromaref, lumaref, sobelref, meansob, blend2, lp, original, transformed, cx, cy, sk);
                    bufexporig.reset();

                }
            }
        }

//inverse
        else if (lp.invex  && (lp.expcomp != 0.0 || lp.war != 0 || (exlocalcurve  && localexutili)) && lp.exposena) {
            float adjustr = 2.f;
            std::unique_ptr<LabImage> bufmaskblurexp;
            std::unique_ptr<LabImage> originalmaskexp;
            std::unique_ptr<LabImage> bufexporig;
            int GW = transformed->W;
            int GH = transformed->H;
            bufexporig.reset(new LabImage(GW, GH));

            if (lp.enaExpMaskinv || lp.showmaskexpmetinv == 1) {
                bufmaskblurexp.reset(new LabImage(GW, GH, true));
                originalmaskexp.reset(new LabImage(GW, GH));
            }

#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < GH ; y++) {
                for (int x = 0; x < GW; x++) {
                    bufexporig->L[y][x] = original->L[y][x];
                }
            }

            int inv = 1;
            bool showmaske = false;
            bool enaMask = false;
            bool deltaE = false;
            bool modmask = false;
            bool zero = false;
            bool modif = false;

            if (lp.showmaskexpmetinv == 1) {
                showmaske = true;
            }

            if (lp.enaExpMaskinv) {
                enaMask = true;
            }

            if (lp.showmaskexpmetinv == 0) {
                zero = true;
            }

            float chrom = lp.chromaexp;
            float rad = lp.radmaexp;
            float gamma = lp.gammaexp;
            float slope = lp.slomaexp;
            float blendm = lp.blendmaexp;
            float lap = params->locallab.spots.at(sp).lapmaskexp;
            float pde = params->locallab.spots.at(sp).laplac;
            LUTf dummy;
            bool uti;

            maskcalccol(false, pde, GW, GH, 0, 0, sk, cx, cy, bufexporig.get(), bufmaskblurexp.get(), originalmaskexp.get(), original, inv, lp,
                        locccmasexpCurve, lcmasexputili, locllmasexpCurve, llmasexputili, lochhmasexpCurve, lhmasexputili, multiThread,
                        enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);

            if (lp.showmaskexpmetinv == 1) {
                showmask(lp, 0, 0, cx, cy, GW, GH, bufexporig.get(), transformed, bufmaskblurexp.get(), inv);

                return;
            }

            InverseColorLight_Local(sp, 1, lp, originalmaskexp.get(), lightCurveloc, hltonecurveloc, shtonecurveloc, tonecurveloc, exlocalcurve, cclocalcurve, adjustr, localcutili, lllocalcurve, locallutili, original, transformed, cx, cy, hueref, chromaref, lumaref, sk);
        }


//local color and light
        const float factor = LocallabParams::LABGRIDL_CORR_MAX * 3.276f;
        const float scaling = LocallabParams::LABGRIDL_CORR_SCALE;
        const float scaledirect = LocallabParams::LABGRIDL_DIRECT_SCALE;
        float a_scale = (lp.highA - lp.lowA) / factor / scaling;
        float a_base = lp.lowA / scaling;
        float b_scale = (lp.highB - lp.lowB) / factor / scaling;
        float b_base = lp.lowB / scaling;
        bool ctoning = (a_scale != 0.f || b_scale != 0.f || a_base != 0.f || b_base != 0.f);

        if (!lp.inv  && (lp.chro != 0 || lp.ligh != 0.f || lp.cont != 0 || ctoning || lp.qualcurvemet != 0 || lp.showmaskcolmet == 2 || lp.enaColorMask || lp.showmaskcolmet == 3  || lp.showmaskcolmet == 4 || lp.showmaskcolmet == 5) && lp.colorena) { // || lllocalcurve)) { //interior ellipse renforced lightness and chroma  //locallutili
            /*
            //test for fftw blur with tiles  fftw_tile_blur....not good we can see tiles - very long time
                        int GW = original->W;
                        int GH = original->H;
                        MyMutex::MyLock lock (*fftwMutex);

                        double radius = 100.f;
                        int tilssize = 64;
            #ifdef _OPENMP
                        const int numThreads = omp_get_max_threads();
            #else
                        const int numThreads = 1;

            #endif
                        int max_numblox_W = ceil((static_cast<float>(GW)) / (offset2)) + 2 * blkrad;
                            // calculate min size of numblox_W.
                        int min_numblox_W = ceil((static_cast<float>(GW)) / (offset2)) + 2 * blkrad;
                        fftw_tile_blur(GW, GH, tilssize , max_numblox_W, min_numblox_W, original->L, numThreads, radius);
            */


//test for fftw blur with fftw_convol_blur: good result speedup moderate , but less used of memory than gaussianblur

//with FFTW curious results ex with playraw23_hombre.pef -  size 4942*3276
// with size 4942*3276 time for tIF 3200ms
// with size 4941*3275 time for TIF 950ms...no differences in TIF and with 4928*3250  (2^6 * 7 * 11) * (2 * 5^3 * 13) = 520ms
// "step" to reproduce about 6 pixels
//another strange with DSCF1337.RAF 4012*6018  time 1318ms
// with 4004*6016 time 1091ms
//with 4004*6013 time 4057ms...steps seem also about 6 or 8
//NEF D200 best with 3888 * 2607 instead of 3892 2608
//D700 4275*2835 instead 4276*2836
//PANA LX100 4120*3095 instead of 4120*3096
//I have compared many things with FFTF COS -0.5 2*n -0.5, prime factor decomposition....nothing found
//I have read doc...nothing about that
//doc says optimum is with size 2^a * 3^b * 5^c * 7^d * 11^e * 13^f with e+f = 0 or 1
//we must found a number below of size as this
//combinaison
//see above fftw_size

            /*
                        int GW = 4928/SQR(sk); //original->W-lp.ligh;//for test change size W
                        int GH = 3250/SQR(sk);//original->H- lp.cont;//test for chnage size H
                        printf("Gw=%i Gh=%i\n", GW, GH);
                        MyMutex::MyLock lock (*fftwMutex);


                        float *datain = nullptr; //new float[GW*GH];
                        datain = (float*) fftwf_malloc(sizeof(float) * (GW * GH));//allocate real datas for FFT

                        float *dataout = new float[GW*GH];
                        float radius = 500.f;
            #ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
            #endif
                                for (int y = 0; y < GH; y++) {
                                    for (int x = 0; x < GW; x++) {
                                        datain[y * GW + x] =original->L[y][x];
                                    }
                                }
                        fftw_convol_blur(datain, dataout, GW, GH, radius, 0);
            #ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
            #endif
                                for (int y = 0; y < GH; y++) {
                                    for (int x = 0; x < GW; x++) {
                                       original->L[y][x] = dataout[y * GW + x];
                                    }
                                }

                        delete [] dataout;
                        fftwf_free(datain);
            */


            const int ystart = std::max(static_cast<int>(lp.yc - lp.lyT) - cy, 0);
            const int yend = std::min(static_cast<int>(lp.yc + lp.ly) - cy, original->H);
            const int xstart = std::max(static_cast<int>(lp.xc - lp.lxL) - cx, 0);
            const int xend = std::min(static_cast<int>(lp.xc + lp.lx) - cx, original->W);
            const int bfh = yend - ystart;
            const int bfw = xend - xstart;

            if (bfw >= mSP && bfh >= mSP) {
                std::unique_ptr<LabImage> bufcolorig;
                std::unique_ptr<LabImage> bufcolfin;
                std::unique_ptr<LabImage> bufmaskblurcol;
                std::unique_ptr<LabImage> originalmaskcol;

                array2D<float> buflight(bfw, bfh, true);
                JaggedArray<float> bufchro(bfw, bfh, true);
                JaggedArray<float> bufhh(bfw, bfh, true);

                array2D<float> blend2;
                JaggedArray<float> buf_a(bfw, bfh, true);
                JaggedArray<float> buf_b(bfw, bfh, true);

                float adjustr = 1.0f;

                //adapt chroma to working profile
                if (params->icm.workingProfile == "ProPhoto")   {
                    adjustr = 1.2f;   // 1.2 instead 1.0 because it's very rare to have C>170..
                } else if (params->icm.workingProfile == "Adobe RGB")  {
                    adjustr = 1.8f;
                } else if (params->icm.workingProfile == "sRGB")       {
                    adjustr = 2.0f;
                } else if (params->icm.workingProfile == "WideGamut")  {
                    adjustr = 1.2f;
                } else if (params->icm.workingProfile == "Beta RGB")   {
                    adjustr = 1.4f;
                } else if (params->icm.workingProfile == "BestRGB")    {
                    adjustr = 1.4f;
                } else if (params->icm.workingProfile == "BruceRGB")   {
                    adjustr = 1.8f;
                }

                if (call <= 3) { //simpleprocess, dcrop, improccoordinator
                    float meansob = 0.f;
                    bufcolorig.reset(new LabImage(bfw, bfh));
                    bufcolfin.reset(new LabImage(bfw, bfh));

                    if (lp.showmaskcolmet == 2  || lp.enaColorMask || lp.showmaskcolmet == 3 || lp.showmaskcolmet == 5) {
                        bufmaskblurcol.reset(new LabImage(bfw, bfh, true));
                        originalmaskcol.reset(new LabImage(bfw, bfh));
                    }

#ifdef _OPENMP
                    #pragma omp parallel for schedule(dynamic,16)
#endif

                    for (int y = 0; y < bfh ; y++) {
                        for (int x = 0; x < bfw; x++) {
                            bufcolorig->L[y][x] = original->L[y + ystart][x + xstart];
                            bufcolfin->L[y][x] = original->L[y + ystart][x + xstart];
                        }
                    }

                    const int spotSi = std::max(1 + 2 * max(1,  lp.cir / sk), 5);
                    const bool blend = bfw > 2 * spotSi && bfh > 2 * spotSi && lp.struco > 0.f;

                    if (blend) {
                        blend2(bfw, bfh);
                        ImProcFunctions::blendstruc(bfw, bfh, bufcolorig.get(), 3.f / (sk * 1.4f), 0.5f * lp.struco, blend2, sk, multiThread);

                        if (lp.showmaskcolmet == 4) {
#ifdef _OPENMP
                            #pragma omp parallel for schedule(dynamic,16)
#endif

                            for (int y = ystart; y < yend ; y++) {
                                for (int x = xstart; x < xend; x++) {
                                    const int lox = cx + x;
                                    const int loy = cy + y;
                                    int zone = 0;
                                    float localFactor = 1.f;
                                    const float achm = lp.trans / 100.f;

                                    if (lp.shapmet == 0) {
                                        calcTransition(lox, loy, achm, lp, zone, localFactor);
                                    } else if (lp.shapmet == 1) {
                                        calcTransitionrect(lox, loy, achm, lp, zone, localFactor);
                                    }

                                    if (zone > 0) {
                                        transformed->L[y][x] = CLIP(blend2[y - ystart][x - xstart]);
                                        transformed->a[y][x] = 0.f;
                                        transformed->b[y][x] = 0.f;
                                    }
                                }
                            }

                            return;
                        }

                    }

                    int inv = 0;
                    bool showmaske = false;
                    bool enaMask = false;
                    bool deltaE = false;
                    bool modmask = false;
                    bool zero = false;
                    bool modif = false;

                    if (lp.showmaskcolmet == 3) {
                        showmaske = true;
                    }

                    if (lp.enaColorMask) {
                        enaMask = true;
                    }

                    if (lp.showmaskcolmet == 5) {
                        deltaE = true;
                    }

                    if (lp.showmaskcolmet == 2) {
                        modmask = true;
                    }

                    if (lp.showmaskcolmet == 1) {
                        modif = true;
                    }

                    if (lp.showmaskcolmet == 0) {
                        zero = true;
                    }

                    float chrom = lp.chromacol;;
                    float rad = lp.radmacol;
                    float gamma = lp.gammacol;
                    float slope = lp.slomacol;
                    float blendm = lp.blendmacol;
                    float lap = params->locallab.spots.at(sp).lapmaskcol;
                    float pde = params->locallab.spots.at(sp).laplac;
//LUTf & lmasklocalcurve, bool & localmaskutili
                    maskcalccol(false, pde, bfw, bfh, xstart, ystart, sk, cx, cy, bufcolorig.get(), bufmaskblurcol.get(), originalmaskcol.get(), original, inv, lp,
                                locccmasCurve, lcmasutili, locllmasCurve, llmasutili, lochhmasCurve, lhmasutili, multiThread,
                                enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmasklocalcurve, localmaskutili);

                    if (lp.showmaskcolmet == 3) {
                        showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufcolorig.get(), transformed, bufmaskblurcol.get(), 0);

                        return;
                    }

                    if (lp.showmaskcolmet == 4) {
                        return;
                    }

                    if (lp.showmaskcolmet == 0 || lp.showmaskcolmet == 1 || lp.showmaskcolmet == 2 || lp.showmaskcolmet == 5 || lp.enaColorMask) {

                        float chprosl = 1.f;

                        if (lp.chro != 0.f) {
                            const float ch = (1.f + 0.01f * lp.chro) ;

                            if (ch <= 1.f) {
                                chprosl = 99.f * ch - 99.f;
                            } else {
                                constexpr float ampli = 70.f;
                                chprosl = CLIPCHRO(ampli * ch - ampli);
                            }
                        }

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++)
                            for (int jr = 0; jr < bfw; jr++) {
                                float bufcolcalca = bufcolorig->a[ir][jr];
                                float bufcolcalcb = bufcolorig->b[ir][jr];
                                float bufcolcalcL = bufcolorig->L[ir][jr];

                                float chprocu = 1.f;

                                if (cclocalcurve  && lp.qualcurvemet != 0 && localcutili) { // C=f(C) curve
                                    const float chromat = sqrt(SQR(bufcolcalca) +  SQR(bufcolcalcb));
                                    const float ch = cclocalcurve[chromat * adjustr] / ((chromat + 0.00001f) * adjustr); //ch between 0 and 0 50 or more
                                    constexpr float ampli = 25.f;
                                    chprocu = CLIPCHRO(ampli * ch - ampli);
                                }

                                bufchro[ir][jr] = chprosl + chprocu;

                                if (lochhCurve && HHutili && lp.qualcurvemet != 0) {
                                    const float hhforcurv = xatan2f(bufcolcalcb, bufcolcalca);
                                    const float valparam = float ((lochhCurve[500.f * Color::huelab_to_huehsv2(hhforcurv)] - 0.5f));  //get H=f(H)  1.7 optimisation !
                                    bufhh[ir][jr] = CLIPRET(200.f * valparam);
                                }


                                if (lp.ligh != 0.f || lp.cont != 0) {
                                    calclight(bufcolcalcL, lp.ligh, bufcolcalcL, lightCurveloc);  //replace L-curve
                                }

                                if (lllocalcurve && locallutili  && lp.qualcurvemet != 0) {// L=f(L) curve enhanced
                                    bufcolcalcL = 0.5f * lllocalcurve[bufcolcalcL * 2.f];
                                }

                                if (loclhCurve && LHutili && lp.qualcurvemet != 0) {
                                    const float rhue = xatan2f(bufcolcalcb, bufcolcalca);
                                    float l_r = bufcolcalcL / 32768.f; //Luminance Lab in 0..1
                                    const float valparam = loclhCurve[500.f * Color::huelab_to_huehsv2(rhue)] - 0.5f;  //get l_r=f(H)

                                    if (valparam > 0.f) {
                                        l_r = (1.f - valparam) * l_r + valparam * (1.f - SQR(((SQR(1.f - min(l_r, 1.0f))))));
                                    } else {
                                        constexpr float khu = 1.9f; //in reserve in case of!
                                        //for negative
                                        l_r *= (1.f + khu * valparam);
                                    }

                                    bufcolcalcL = l_r * 32768.f;

                                }

                                if (ctoning) {
                                    if (lp.gridmet == 0) {
                                        bufcolcalca += bufcolcalcL * a_scale + a_base;
                                        bufcolcalcb += bufcolcalcL * b_scale + b_base;
                                    } else if (lp.gridmet == 1) {
                                        bufcolcalca += scaledirect * a_scale;
                                        bufcolcalcb += scaledirect * b_scale;
                                    }

                                    bufcolcalca = CLIPC(bufcolcalca);
                                    bufcolcalcb = CLIPC(bufcolcalcb);

                                }

                                // buflight[ir][jr] = CLIPRET((bufcolcalcL - bufcolorig->L[ir][jr]) / 328.f);
                                buf_a[ir][jr] = CLIPRET((bufcolcalca - bufcolorig->a[ir][jr]) / 328.f);;
                                buf_b[ir][jr] = CLIPRET((bufcolcalcb - bufcolorig->b[ir][jr]) / 328.f);;
                                bufcolfin->L[ir][jr] = bufcolcalcL;

                                //      }
                            }

                        if (lp.softradiuscol > 0.f) {
                            softproc(bufcolorig.get(), bufcolfin.get(), lp.softradiuscol, bfh, bfw, 0.0001, 0.00001, 0.1f, sk, multiThread, 0);
                            //  softprocess(bufcolorig.get(), buflight, lp.softradiuscol, bfh, bfw, sk, multiThread);
                        }

#ifdef _OPENMP
                        #pragma omp parallel for schedule(dynamic,16)
#endif

                        for (int ir = 0; ir < bfh; ir++)
                            for (int jr = 0; jr < bfw; jr++) {
                                buflight[ir][jr] = CLIPRET((bufcolfin->L[ir][jr] - bufcolorig->L[ir][jr]) / 328.f);
                            }

                    }

                    float **temp = nullptr;

                    if (blend) {
                        temp = blend2;
                    }

                    transit_shapedetect(0, bufcolorig.get(), originalmaskcol.get(), buflight, bufchro, buf_a, buf_b, bufhh, HHutili, hueref, chromaref, lumaref, sobelref, meansob, temp, lp, original, transformed, cx, cy, sk);

                }
            }
        }

//inverse
        else if (lp.inv  && (lp.chro != 0 || lp.ligh != 0 || exlocalcurve) && lp.colorena) {
            float adjustr = 1.0f;

//adapt chroma to working profile
            if (params->icm.workingProfile == "ProPhoto")   {
                adjustr = 1.2f;   // 1.2 instead 1.0 because it's very rare to have C>170..
            } else if (params->icm.workingProfile == "Adobe RGB")  {
                adjustr = 1.8f;
            } else if (params->icm.workingProfile == "sRGB")       {
                adjustr = 2.0f;
            } else if (params->icm.workingProfile == "WideGamut")  {
                adjustr = 1.2f;
            } else if (params->icm.workingProfile == "Beta RGB")   {
                adjustr = 1.4f;
            } else if (params->icm.workingProfile == "BestRGB")    {
                adjustr = 1.4f;
            } else if (params->icm.workingProfile == "BruceRGB")   {
                adjustr = 1.8f;
            }

            std::unique_ptr<LabImage> bufmaskblurcol;
            std::unique_ptr<LabImage> originalmaskcol;
            std::unique_ptr<LabImage> bufcolorig;
            int GW = transformed->W;
            int GH = transformed->H;
            bufcolorig.reset(new LabImage(GW, GH));

            if (lp.enaColorMaskinv || lp.showmaskcolmetinv == 1) {
                bufmaskblurcol.reset(new LabImage(GW, GH, true));
                originalmaskcol.reset(new LabImage(GW, GH));
            }

#ifdef _OPENMP
            #pragma omp parallel for schedule(dynamic,16)
#endif

            for (int y = 0; y < GH ; y++) {
                for (int x = 0; x < GW; x++) {
                    bufcolorig->L[y][x] = original->L[y][x];
                }
            }

            int inv = 1;
            bool showmaske = false;
            bool enaMask = false;
            bool deltaE = false;
            bool modmask = false;
            bool zero = false;
            bool modif = false;

            if (lp.showmaskcolmetinv == 1) {
                showmaske = true;
            }

            if (lp.enaColorMaskinv) {
                enaMask = true;
            }

            if (lp.showmaskcolmetinv == 0) {
                zero = true;
            }

            float chrom = lp.chromacol;
            float rad = lp.radmacol;
            float gamma = lp.gammacol;
            float slope = lp.slomacol;
            float blendm = lp.blendmacol;
            float lap = params->locallab.spots.at(sp).lapmaskcol;
            float pde = params->locallab.spots.at(sp).laplac;
            LUTf dummy;
            bool uti;
            maskcalccol(false, pde, GW, GH, 0, 0, sk, cx, cy, bufcolorig.get(), bufmaskblurcol.get(), originalmaskcol.get(), original, inv, lp,
                        locccmasCurve, lcmasutili, locllmasCurve, llmasutili, lochhmasCurve, lhmasutili, multiThread,
                        enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, dummy, uti);


            if (lp.showmaskcolmetinv == 1) {
                showmask(lp, 0, 0, cx, cy, GW, GH, bufcolorig.get(), transformed, bufmaskblurcol.get(), inv);

                return;
            }

            if (lp.showmaskcolmetinv == 0 || lp.enaColorMaskinv) {
                InverseColorLight_Local(sp, 0, lp, originalmaskcol.get(), lightCurveloc, hltonecurveloc, shtonecurveloc, tonecurveloc, exlocalcurve, cclocalcurve, adjustr, localcutili, lllocalcurve, locallutili, original, transformed, cx, cy, hueref, chromaref, lumaref, sk);
            }
        }

// Gamut and Munsell control - very important do not desactivated to avoid crash
        if (params->locallab.spots.at(sp).avoid) {
            const float ach = (float)lp.trans / 100.f;

            TMatrix wiprof = ICCStore::getInstance()->workingSpaceInverseMatrix(params->icm.workingProfile);
            const float wip[3][3] = {
                {static_cast<float>(wiprof[0][0]), static_cast<float>(wiprof[0][1]), static_cast<float>(wiprof[0][2])},
                {static_cast<float>(wiprof[1][0]), static_cast<float>(wiprof[1][1]), static_cast<float>(wiprof[1][2])},
                {static_cast<float>(wiprof[2][0]), static_cast<float>(wiprof[2][1]), static_cast<float>(wiprof[2][2])}
            };
            const bool highlight = params->toneCurve.hrenabled;
            const bool needHH = (lp.chro != 0.f);
#ifdef _OPENMP
            #pragma omp parallel if (multiThread)
#endif
            {
#ifdef __SSE2__
                float atan2Buffer[transformed->W] ALIGNED16;
                float sqrtBuffer[transformed->W] ALIGNED16;
                float sincosyBuffer[transformed->W] ALIGNED16;
                float sincosxBuffer[transformed->W] ALIGNED16;
                vfloat c327d68v = F2V(327.68f);
                vfloat onev = F2V(1.f);
#endif

#ifdef _OPENMP
#ifdef _DEBUG
                #pragma omp for schedule(dynamic,16) firstprivate(MunsDebugInfo)
#else
                #pragma omp for schedule(dynamic,16)
#endif
#endif

                for (int y = 0; y < transformed->H; y++) {
                    const int loy = cy + y;
                    const bool isZone0 = loy > lp.yc + lp.ly || loy < lp.yc - lp.lyT; // whole line is zone 0 => we can skip a lot of processing

                    if (isZone0) { // outside selection and outside transition zone => no effect, keep original values

                        continue;
                    }

#ifdef __SSE2__
                    int i = 0;

                    for (; i < transformed->W - 3; i += 4) {
                        vfloat av = LVFU(transformed->a[y][i]);
                        vfloat bv = LVFU(transformed->b[y][i]);

                        if (needHH) { // only do expensive atan2 calculation if needed
                            STVF(atan2Buffer[i], xatan2f(bv, av));
                        }

                        vfloat Chprov1v = vsqrtf(SQRV(bv) + SQRV(av));
                        STVF(sqrtBuffer[i], Chprov1v / c327d68v);
                        vfloat sincosyv = av / Chprov1v;
                        vfloat sincosxv = bv / Chprov1v;
                        vmask selmask = vmaskf_eq(Chprov1v, ZEROV);
                        sincosyv = vself(selmask, onev, sincosyv);
                        sincosxv = vselfnotzero(selmask, sincosxv);
                        STVF(sincosyBuffer[i], sincosyv);
                        STVF(sincosxBuffer[i], sincosxv);
                    }

                    for (; i < transformed->W; i++) {
                        float aa = transformed->a[y][i];
                        float bb = transformed->b[y][i];

                        if (needHH) { // only do expensive atan2 calculation if needed
                            atan2Buffer[i] = xatan2f(bb, aa);
                        }

                        float Chprov1 = sqrtf(SQR(bb) + SQR(aa));
                        sqrtBuffer[i] = Chprov1 / 327.68f;

                        if (Chprov1 == 0.0f) {
                            sincosyBuffer[i] = 1.f;
                            sincosxBuffer[i] = 0.0f;
                        } else {
                            sincosyBuffer[i] = aa / Chprov1;
                            sincosxBuffer[i] = bb / Chprov1;
                        }

                    }

#endif

                    for (int x = 0; x < transformed->W; x++) {
                        int lox = cx + x;
                        int zone = 0;
                        float localFactor = 1.f;

                        if (lp.shapmet == 0) {
                            calcTransition(lox, loy, ach, lp, zone, localFactor);
                        } else if (lp.shapmet == 1) {
                            calcTransitionrect(lox, loy, ach, lp, zone, localFactor);
                        }

                        if (zone == 0) { // outside selection and outside transition zone => no effect, keep original values
                            continue;
                        }

                        float Lprov1 = transformed->L[y][x] / 327.68f;
                        float2 sincosval;
#ifdef __SSE2__
                        float HH = atan2Buffer[x]; // reading HH from line buffer even if line buffer is not filled is faster than branching
                        float Chprov1 = sqrtBuffer[x];
                        sincosval.y = sincosyBuffer[x];
                        sincosval.x = sincosxBuffer[x];
                        float chr = 0.f;

#else
                        float aa = transformed->a[y][x];
                        float bb = transformed->b[y][x];
                        float HH = 0.f, chr = 0.f;

                        if (needHH) { // only do expensive atan2 calculation if needed
                            HH = xatan2f(bb, aa);
                        }

                        float Chprov1 = sqrtf(SQR(aa) + SQR(bb)) / 327.68f;

                        if (Chprov1 == 0.0f) {
                            sincosval.y = 1.f;
                            sincosval.x = 0.0f;
                        } else {
                            sincosval.y = aa / (Chprov1 * 327.68f);
                            sincosval.x = bb / (Chprov1 * 327.68f);
                        }

#endif

#ifdef _DEBUG
                        bool neg = false;
                        bool more_rgb = false;
                        Chprov1 = min(Chprov1, chr);

                        Color::gamutLchonly(sincosval, Lprov1, Chprov1, wip, highlight, 0.15f, 0.92f, neg, more_rgb);
#else
                        Color::pregamutlab(Lprov1, HH, chr);
                        Chprov1 = min(Chprov1, chr);
                        Color::gamutLchonly(sincosval, Lprov1, Chprov1, wip, highlight, 0.15f, 0.92f);
#endif

                        transformed->L[y][x] = Lprov1 * 327.68f;
                        transformed->a[y][x] = 327.68f * Chprov1 * sincosval.y;
                        transformed->b[y][x] = 327.68f * Chprov1 * sincosval.x;

                        if (needHH) {
                            float Lprov2 = original->L[y][x] / 327.68f;
                            float correctionHue = 0.f; // Munsell's correction
                            float correctlum = 0.f;
                            float memChprov = sqrtf(SQR(original->a[y][x]) + SQR(original->b[y][x])) / 327.68f;
                            float Chprov = sqrtf(SQR(transformed->a[y][x]) + SQR(transformed->b[y][x])) / 327.68f;
#ifdef _DEBUG
                            Color::AllMunsellLch(true, Lprov1, Lprov2, HH, Chprov, memChprov, correctionHue, correctlum, MunsDebugInfo);
#else
                            Color::AllMunsellLch(true, Lprov1, Lprov2, HH, Chprov, memChprov, correctionHue, correctlum);
#endif

                            if (fabs(correctionHue) < 0.015f) {
                                HH += correctlum;    // correct only if correct Munsell chroma very little.
                            }

                            sincosval = xsincosf(HH + correctionHue);

                            transformed->a[y][x] = 327.68f * Chprov * sincosval.y; // apply Munsell
                            transformed->b[y][x] = 327.68f * Chprov * sincosval.x;
                        }
                    }
                }
            }
        }

#ifdef _DEBUG
        delete MunsDebugInfo;
#endif

    }

}

}