Improve mask with deltaE image and scope

rtdata/languages/default

@@ -1022,6 +1022,7 @@ HISTORY_MSG_781;Local - Local contrast Wavelet level
 HISTORY_MSG_782;Local - Blur Denoise Mask Wavelet levels
 HISTORY_MSG_783;Local - Color Mask Wavelet levels
 HISTORY_MSG_784;Local - Mask DeltaE
+HISTORY_MSG_785;Local - Mask Scope DeltaE
 HISTORY_MSG_CLAMPOOG;Clip out-of-gamut colors
 HISTORY_MSG_COLORTONING_LABGRID_VALUE;CT - Color correction
 HISTORY_MSG_COLORTONING_LABREGION_AB;CT - Color correction
@@ -2126,6 +2127,9 @@ TP_LOCALLAB_GAMMASKCOL;Gamma mask
 TP_LOCALLAB_SLOMASKCOL;Slope mask
 TP_LOCALLAB_SHAMASKCOL;Shadows mask
 TP_LOCALLAB_LAPMASKCOL;Laplacian threshold mask
+TP_LOCALLAB_SCOPEMASK;Scope Mask DeltaE Image
+TP_LOCALLAB_MASFRAME;Mask
+TP_LOCALLAB_MASFRAME_TOOLTIP;For all masks.\nTake into account deltaE image to avoid retouching the selection area when sliders gamma mask, slope mask, chroma mask and contrast curves and levels contrasts curves are used
 TP_LOCALLAB_WAMASKCOL;Mask Wavelet level
 TP_LOCALLAB_CSTHRESHOLDBLUR;Mask Wavelet level
 TP_LOCALLAB_LAPLACC;Mask Laplacian solve PDE

rtengine/improcfun.h

@@ -193,8 +193,12 @@ public:
                  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,
-                 const LocwavCurve & loclmasCurvecolwav, bool & lmasutilicolwav, int level_bl, int level_hl, int level_br, int level_hr
+                 const LocwavCurve & loclmasCurvecolwav, bool & lmasutilicolwav, int level_bl, int level_hl, int level_br, int level_hr,
-);
+                 bool delt, const float hueref, const float chromaref, const float lumaref,
+                 float maxdE, float mindE, float maxdElim,  float mindElim, float iterat, float limscope, int scope);
+                 
+    void deltaEforMask(float **rdE, int bfw, int bfh, LabImage* bufcolorig, const float hueref, const float chromaref, const float lumaref,
+                          float maxdE, float mindE, float maxdElim,  float mindElim, float iterat, float limscope, int scope);
     void discrete_laplacian_threshold(float * data_out, const float * data_in, size_t nx, size_t ny, float t);
     void rex_poisson_dct(float * data, size_t nx, size_t ny, double m);
     void mean_dt(const float * data, size_t size, double * mean_p, double * dt_p);

rtengine/iplocallab.cc

@@ -2359,6 +2359,54 @@ static void blendmask(const local_params& lp, int xstart, int ystart, int cx, in
     }
 }
 
+void ImProcFunctions::deltaEforMask(float **rdE, int bfw, int bfh, LabImage* bufcolorig, const float hueref, const float chromaref, const float lumaref,
+                                    float maxdE, float mindE, float maxdElim,  float mindElim, float iterat, float limscope, int scope)
+{
+    const float refa = chromaref * cos(hueref);
+    const float refb = chromaref * sin(hueref);
+    const float refL = lumaref;
+
+    float reducdE = 1.f;
+#ifdef _OPENMP
+    #pragma omp parallel for
+#endif
+
+    for (int y = 0; y < bfh; y++) {
+        for (int x = 0; x < bfw; x++) {
+            float tempdE = sqrt((SQR(refa - bufcolorig->a[y][x] / 327.68f) + SQR(refb - bufcolorig->b[y][x] / 327.68f)) +  SQR(refL - bufcolorig->L[y][x] / 327.68f));
+
+            if (tempdE > maxdE) {
+                reducdE = 0.f;
+            } else if (tempdE > mindE && tempdE <= maxdE) {
+                const float ar = 1.f / (mindE - maxdE);
+                const float br = - ar * maxdE;
+                reducdE = pow(ar * tempdE + br, iterat);
+            } else {
+                reducdE = 1.f;
+            }
+
+            if (scope > limscope) {
+                if (tempdE > maxdElim) {
+                    reducdE = 0.f;
+                } else if (tempdE > mindElim && tempdE <= maxdElim) {
+                    const float arlim = 1.f / (mindElim - maxdElim);
+                    const float brlim = - arlim * maxdElim;
+                    const float reducdElim = pow(arlim * tempdE + 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;
+                }
+            }
+
+//            if(scope == 100) reducdE = 1.f;
+            rdE[y][x] = reducdE ;
+        }
+    }
+}
+
+
 
 static void deltaEforLaplace(float *dE, const local_params& lp, int bfw, int bfh, LabImage* bufexporig, const float hueref, const float chromaref, const float lumaref)
 {
@@ -2845,7 +2893,9 @@ void ImProcFunctions::maskcalccol(bool invmask, bool pde, int bfw, int bfh, int
                                   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,
-                                  const LocwavCurve & loclmasCurvecolwav, bool & lmasutilicolwav, int level_bl, int level_hl, int level_br, int level_hr
+                                  const LocwavCurve & loclmasCurvecolwav, bool & lmasutilicolwav, int level_bl, int level_hl, int level_br, int level_hr,
+                                  bool delt, const float hueref, const float chromaref, const float lumaref,
+                                  float maxdE, float mindE, float maxdElim,  float mindElim, float iterat, float limscope, int scope
                                  )
 {
     array2D<float> ble(bfw, bfh);
@@ -2953,6 +3003,9 @@ void ImProcFunctions::maskcalccol(bool invmask, bool pde, int bfw, int bfh, int
                 }
             }
         }
+        std::unique_ptr<LabImage> bufprov(new LabImage(bfw, bfh));
+
+        bufprov->CopyFrom(bufmaskblurcol);
 
         if (rad > 0.f) {
             guidedFilter(guid, ble, ble, rad * 10.f / sk, 0.001, multiThread, 4);
@@ -3017,6 +3070,35 @@ void ImProcFunctions::maskcalccol(bool invmask, bool pde, int bfw, int bfh, int
 
         }
 
+        if (delt) {
+            float *rdE[bfh] ALIGNED16;
+            float *rdEBuffer = new float[bfh * bfw];
+
+            for (int i = 0; i < bfh; i++) {
+                rdE[i] = &rdEBuffer[i * bfw];
+            }
+
+            deltaEforMask(rdE, bfw, bfh, bufcolorig, hueref, chromaref, lumaref, maxdE, mindE, maxdElim, mindElim, iterat, limscope, scope);
+            // printf("rde1=%f rde2=%f\n", rdE[1][1], rdE[100][100]);
+            std::unique_ptr<LabImage> delta(new LabImage(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++) {
+                    delta->L[ir][jr] = bufmaskblurcol->L[ir][jr] - bufprov->L[ir][jr];
+                    delta->a[ir][jr] = bufmaskblurcol->a[ir][jr] - bufprov->a[ir][jr];
+                    delta->b[ir][jr] = bufmaskblurcol->b[ir][jr] - bufprov->b[ir][jr];
+
+                    bufmaskblurcol->L[ir][jr] = bufprov->L[ir][jr] + rdE[ir][jr] * delta->L[ir][jr];
+                    bufmaskblurcol->a[ir][jr] = bufprov->a[ir][jr] + rdE[ir][jr] * delta->a[ir][jr];
+                    bufmaskblurcol->b[ir][jr] = bufprov->b[ir][jr] + rdE[ir][jr] * delta->b[ir][jr];
+                }
+
+            delete [] rdEBuffer;
+
+        }
 
         if (lap > 0.f) {
             float *datain = new float[bfh * bfw];
@@ -7056,6 +7138,7 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
         std::unique_ptr<LabImage> bufmaskorigbl;
         std::unique_ptr<LabImage> bufmaskblurbl;
         std::unique_ptr<LabImage> bufgb;
+        std::unique_ptr<LabImage> bufprov;
 
         if (denoiz || blurz || lp.denoiena || lp.blurena) {
             bufgb.reset(new LabImage(GW, GH));
@@ -7063,6 +7146,7 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
             if (lp.showmaskblmet == 2  || lp.enablMask || lp.showmaskblmet == 3 || lp.showmaskblmet == 4) {
                 bufmaskorigbl.reset(new LabImage(GW, GH));
                 bufmaskblurbl.reset(new LabImage(GW, GH));
+                bufprov.reset(new LabImage(GW, GH));
                 originalmaskbl = new LabImage(GW, GH);
             }
 
@@ -7135,9 +7219,12 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
 
                         guid[ir][jr] = Y / 32768.f;
 
+                        bufprov->L[ir][jr] = bufmaskblurbl->L[ir][jr];
+                        bufprov->a[ir][jr] = bufmaskblurbl->a[ir][jr];
+                        bufprov->b[ir][jr] = bufmaskblurbl->b[ir][jr];
+                    }
+                }
 
-                    }
-                }
 
                 if (lp.radmabl > 0.f) {
                     guidedFilter(guid, ble, ble, lp.radmabl * 10.f / sk, 0.001, multiThread, 4);
@@ -7210,6 +7297,47 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
                 wavcontrast4(bufmaskblurbl->L, contrast, GW, GH, level_bl, level_hl, level_br, level_hr, sk, numThreads, loclmasCurveblwav, lmasutiliblwav, maxlvl);
             }
 
+// deltae Mask with scope
+            bool delt = params->locallab.spots.at(sp).deltae;
+            int sco = params->locallab.spots.at(sp).scopemask;
+            const int limscope = 80;
+            const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+            const float maxdE = 5.f + MAXSCOPE * sco * (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);
+
+            if (delt) {
+                float *rdE[GH] ALIGNED16;
+                float *rdEBuffer = new float[GH * GW];
+
+                for (int i = 0; i < GH; i++) {
+                    rdE[i] = &rdEBuffer[i * GW];
+                }
+
+                deltaEforMask(rdE, GW, GH, bufgb.get(), hueref, chromaref, lumaref, maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco);
+                // printf("rde1=%f rde2=%f\n", rdE[1][1], rdE[100][100]);
+                std::unique_ptr<LabImage> delta(new LabImage(GW, GH));
+#ifdef _OPENMP
+                #pragma omp parallel for schedule(dynamic,16)
+#endif
+
+                for (int ir = 0; ir < GH; ir++)
+                    for (int jr = 0; jr < GW; jr++) {
+                        delta->L[ir][jr] = bufmaskblurbl->L[ir][jr] - bufprov->L[ir][jr];
+                        delta->a[ir][jr] = bufmaskblurbl->a[ir][jr] - bufprov->a[ir][jr];
+                        delta->b[ir][jr] = bufmaskblurbl->b[ir][jr] - bufprov->b[ir][jr];
+
+                        bufmaskblurbl->L[ir][jr] = bufprov->L[ir][jr] + rdE[ir][jr] * delta->L[ir][jr];
+                        bufmaskblurbl->a[ir][jr] = bufprov->a[ir][jr] + rdE[ir][jr] * delta->a[ir][jr];
+                        bufmaskblurbl->b[ir][jr] = bufprov->b[ir][jr] + rdE[ir][jr] * delta->b[ir][jr];
+                    }
+
+                delete [] rdEBuffer;
+
+            }
+
+
+//
             float lap = params->locallab.spots.at(sp).lapmaskbl;
             bool pde = params->locallab.spots.at(sp).laplac;
 
@@ -7781,10 +7909,22 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
                     float lap = params->locallab.spots.at(sp).lapmaskcb;
                     float pde = params->locallab.spots.at(sp).laplac;
                     LocwavCurve dummy;
+                    bool delt = params->locallab.spots.at(sp).deltae;
+                    int sco = params->locallab.spots.at(sp).scopemask;
+
+                    const int limscope = 80;
+                    const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+                    const float maxdE = 5.f + MAXSCOPE * sco * (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);
                     bool lmasutilicolwav = false;
+
                     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, lmaskcblocalcurve, localmaskcbutili, dummy, lmasutilicolwav, 1, 1, 5, 5);
+                                enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmaskcblocalcurve, localmaskcbutili, dummy, lmasutilicolwav, 1, 1, 5, 5,
+                                delt, hueref, chromaref, lumaref,
+                                maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                               );
 
                     if (lp.showmaskcbmet == 3) {
                         showmask(lp, xstart, ystart, cx, cy, bfw, bfh, loctemp.get(), transformed, bufmaskorigcb.get(), 0);
@@ -8060,10 +8200,21 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
                     if (!params->locallab.spots.at(sp).enatmMaskaft) {
                         LocwavCurve dummy;
                         bool lmasutilicolwav = false;
+                        bool delt = params->locallab.spots.at(sp).deltae;
+                        int sco = params->locallab.spots.at(sp).scopemask;
+
+                        const int limscope = 80;
+                        const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+                        const float maxdE = 5.f + MAXSCOPE * sco * (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);
 
                         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, lmasktmlocalcurve, localmasktmutili, dummy, lmasutilicolwav, 1, 1, 5, 5);
+                                    enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmasktmlocalcurve, localmasktmutili, dummy, lmasutilicolwav, 1, 1, 5, 5,
+                                    delt, hueref, chromaref, lumaref,
+                                    maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                                   );
 
                         if (lp.showmasktmmet == 3) {
                             showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufgbm.get(), transformed, bufmaskorigtm.get(), 0);
@@ -8085,10 +8236,21 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
                             //calculate new values for original, originalmasktm, bufmaskorigtm...in function of tmp1
                             LocwavCurve dummy;
                             bool lmasutilicolwav = false;
+                            bool delt = params->locallab.spots.at(sp).deltae;
+                            int sco = params->locallab.spots.at(sp).scopemask;
+
+                            const int limscope = 80;
+                            const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+                            const float maxdE = 5.f + MAXSCOPE * sco * (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);
 
                             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, lmasktmlocalcurve, localmasktmutili, dummy, lmasutilicolwav, 1, 1, 5, 5);
+                                        enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmasktmlocalcurve, localmasktmutili, dummy, lmasutilicolwav, 1, 1, 5, 5,
+                                        delt, hueref, chromaref, lumaref,
+                                        maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                                       );
 
                             if (lp.showmasktmmet == 3) {//dispaly mask
                                 showmask(lp, xstart, ystart, cx, cy, bfw, bfh, tmp1.get(), transformed, bufmaskorigtm.get(), 0);
@@ -8254,10 +8416,21 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
                     float pde = params->locallab.spots.at(sp).laplac;
                     LocwavCurve dummy;
                     bool lmasutilicolwav = false;
+                    bool delt = params->locallab.spots.at(sp).deltae;
+                    int sco = params->locallab.spots.at(sp).scopemask;
+
+                    const int limscope = 80;
+                    const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+                    const float maxdE = 5.f + MAXSCOPE * sco * (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);
 
                     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, lmaskSHlocalcurve, localmaskSHutili, dummy, lmasutilicolwav, 1, 1, 5, 5);
+                                enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmaskSHlocalcurve, localmaskSHutili, dummy, lmasutilicolwav, 1, 1, 5, 5,
+                                delt, hueref, chromaref, lumaref,
+                                maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                               );
 
                     if (lp.showmaskSHmet == 3) {
                         showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufexporig.get(), transformed, bufmaskorigSH.get(), 0);
@@ -8351,10 +8524,21 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
             float pde = params->locallab.spots.at(sp).laplac;
             LocwavCurve dummy;
             bool lmasutilicolwav = false;
+            bool delt = params->locallab.spots.at(sp).deltae;
+            int sco = params->locallab.spots.at(sp).scopemask;
+
+            const int limscope = 80;
+            const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+            const float maxdE = 5.f + MAXSCOPE * sco * (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);
 
             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, lmaskSHlocalcurve, localmaskSHutili, dummy, lmasutilicolwav, 1, 1, 5, 5);
+                        enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmaskSHlocalcurve, localmaskSHutili, dummy, lmasutilicolwav, 1, 1, 5, 5,
+                        delt, hueref, chromaref, lumaref,
+                        maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                       );
 
 
             if (lp.showmaskSHmetinv == 1) {
@@ -10323,10 +10507,21 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
                     float pde = params->locallab.spots.at(sp).laplac;
                     LocwavCurve dummy;
                     bool lmasutilicolwav = false;
+                    bool delt = params->locallab.spots.at(sp).deltae;
+                    int sco = params->locallab.spots.at(sp).scopemask;
+
+                    const int limscope = 80;
+                    const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+                    const float maxdE = 5.f + MAXSCOPE * sco * (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);
 
                     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, lmaskexplocalcurve, localmaskexputili, dummy, lmasutilicolwav, 1, 1, 5, 5);
+                                enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmaskexplocalcurve, localmaskexputili, dummy, lmasutilicolwav, 1, 1, 5, 5,
+                                delt, hueref, chromaref, lumaref,
+                                maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                               );
 
                     if (lp.showmaskexpmet == 3) {
                         showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufexporig.get(), transformed, bufmaskblurexp.get(), 0);
@@ -10590,10 +10785,21 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
             float pde = params->locallab.spots.at(sp).laplac;
             LocwavCurve dummy;
             bool lmasutilicolwav = false;
+            bool delt = params->locallab.spots.at(sp).deltae;
+            int sco = params->locallab.spots.at(sp).scopemask;
+
+            const int limscope = 80;
+            const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+            const float maxdE = 5.f + MAXSCOPE * sco * (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);
 
             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, lmaskexplocalcurve, localmaskexputili, dummy, lmasutilicolwav, 1, 1, 5, 5);
+                        enaMask, showmaske, deltaE, modmask, zero, modif, chrom, rad, lap, gamma, slope, blendm, lmaskexplocalcurve, localmaskexputili, dummy, lmasutilicolwav, 1, 1, 5, 5,
+                        delt, hueref, chromaref, lumaref,
+                        maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                       );
 
             if (lp.showmaskexpmetinv == 1) {
                 showmask(lp, 0, 0, cx, cy, GW, GH, bufexporig.get(), transformed, bufmaskblurexp.get(), inv);
@@ -10831,16 +11037,26 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
                     float lap = params->locallab.spots.at(sp).lapmaskcol;
                     float pde = params->locallab.spots.at(sp).laplac;
 //                    int wavlevel = params->locallab.spots.at(sp).shadmaskcol;
-
+                    bool delt = params->locallab.spots.at(sp).deltae;
+                    int sco = params->locallab.spots.at(sp).scopemask;
                     int level_bl = params->locallab.spots.at(sp).csthresholdcol.getBottomLeft();
                     int level_hl = params->locallab.spots.at(sp).csthresholdcol.getTopLeft();
                     int level_br = params->locallab.spots.at(sp).csthresholdcol.getBottomRight();
                     int level_hr = params->locallab.spots.at(sp).csthresholdcol.getTopRight();
 
+                    const int limscope = 80;
+                    const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+                    const float maxdE = 5.f + MAXSCOPE * sco * (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);
+
                     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, loclmasCurvecolwav, lmasutilicolwav,
-                                level_bl, level_hl, level_br, level_hr);
+                                level_bl, level_hl, level_br, level_hr,
+                                delt, hueref, chromaref, lumaref,
+                                maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                               );
 
                     if (lp.showmaskcolmet == 3) {
                         showmask(lp, xstart, ystart, cx, cy, bfw, bfh, bufcolorig.get(), transformed, bufmaskblurcol.get(), 0);
@@ -11045,11 +11261,22 @@ void ImProcFunctions::Lab_Local(int call, int sp, float** shbuffer, LabImage * o
             int level_hl = params->locallab.spots.at(sp).csthresholdcol.getTopLeft();
             int level_br = params->locallab.spots.at(sp).csthresholdcol.getBottomRight();
             int level_hr = params->locallab.spots.at(sp).csthresholdcol.getTopRight();
+            bool delt = params->locallab.spots.at(sp).deltae;
+            int sco = params->locallab.spots.at(sp).scopemask;
+
+            const int limscope = 80;
+            const float mindE = 2.f + MINSCOPE * sco * lp.thr;
+            const float maxdE = 5.f + MAXSCOPE * sco * (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);
 
             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, lmasklocalcurve, localmaskutili, loclmasCurvecolwav, lmasutilicolwav,
-                        level_bl, level_hl, level_br, level_hr);
+                        level_bl, level_hl, level_br, level_hr,
+                        delt, hueref, chromaref, lumaref,
+                        maxdE, mindE, maxdElim, mindElim, lp.iterat, limscope, sco
+                       );
 
 
             if (lp.showmaskcolmetinv == 1) {

rtengine/procevents.h

@@ -811,6 +811,7 @@ enum ProcEventCode {
     EvlocallabcsThresholdblur = 781,
     EvlocallabcsThresholdcol = 782,
     Evlocallabdeltae = 783,
+    EvLocallabSpotscopemask = 784,
     NUMOFEVENTS
 };
 

rtengine/procparams.cc

@@ -2434,6 +2434,7 @@ LocallabParams::LocallabSpot::LocallabSpot() :
     avoid(false),
     laplac(false),
     deltae(false),
+    scopemask(50),
     // Color & Light
     expcolor(false),
     curvactiv(false),
@@ -2731,6 +2732,7 @@ bool LocallabParams::LocallabSpot::operator ==(const LocallabSpot& other) const
         && avoid == other.avoid
         && laplac == other.laplac
         && deltae == other.deltae
+        && scopemask == other.scopemask
         // Color & Light
         && expcolor == other.expcolor
         && curvactiv == other.curvactiv
@@ -4014,6 +4016,7 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
                 saveToKeyfile(!pedited || pedited->locallab.spots.at(i).avoid, "Locallab", "Avoid_" + std::to_string(i), spot.avoid, keyFile);
                 saveToKeyfile(!pedited || pedited->locallab.spots.at(i).laplac, "Locallab", "Laplac_" + std::to_string(i), spot.laplac, keyFile);
                 saveToKeyfile(!pedited || pedited->locallab.spots.at(i).deltae, "Locallab", "Deltae_" + std::to_string(i), spot.deltae, keyFile);
+                saveToKeyfile(!pedited || pedited->locallab.spots.at(i).scopemask, "Locallab", "Scopemask_" + std::to_string(i), spot.scopemask, keyFile);
                 // Color & Light
                 saveToKeyfile(!pedited || pedited->locallab.spots.at(i).expcolor, "Locallab", "Expcolor_" + std::to_string(i), spot.expcolor, keyFile);
                 saveToKeyfile(!pedited || pedited->locallab.spots.at(i).curvactiv, "Locallab", "Curvactiv_" + std::to_string(i), spot.curvactiv, keyFile);
@@ -5412,6 +5415,7 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
                 assignFromKeyfile(keyFile, "Locallab", "Avoid_" + std::to_string(i), pedited, spot.avoid, spotEdited.avoid);
                 assignFromKeyfile(keyFile, "Locallab", "Laplac_" + std::to_string(i), pedited, spot.laplac, spotEdited.laplac);
                 assignFromKeyfile(keyFile, "Locallab", "Deltae_" + std::to_string(i), pedited, spot.deltae, spotEdited.deltae);
+                assignFromKeyfile(keyFile, "Locallab", "Scopemask_" + std::to_string(i), pedited, spot.scopemask, spotEdited.scopemask);
                 // Color & Light
                 assignFromKeyfile(keyFile, "Locallab", "Expcolor_" + std::to_string(i), pedited, spot.expcolor, spotEdited.expcolor);
                 assignFromKeyfile(keyFile, "Locallab", "Curvactiv_" + std::to_string(i), pedited, spot.curvactiv, spotEdited.curvactiv);

rtengine/procparams.h

@@ -981,6 +981,7 @@ struct LocallabParams {
         bool avoid;
         bool laplac;
         bool deltae;
+        int scopemask;
         // Color & Light
         bool expcolor;
         bool curvactiv;

rtengine/refreshmap.cc

@@ -810,7 +810,8 @@ int refreshmap[rtengine::NUMOFEVENTS] = {
     LUMINANCECURVE,          //EvlocallabcsThreshold
     LUMINANCECURVE,          //EvlocallabcsThresholdblur
     LUMINANCECURVE,          //EvlocallabcsThresholdcol
-    LUMINANCECURVE          //Evlocallabdeltae
+    LUMINANCECURVE,          //Evlocallabdeltae
+    LUMINANCECURVE          //EvLocallabSpotscopemask
 };
 
 namespace rtengine

rtgui/controlspotpanel.cc

@@ -68,6 +68,7 @@ ControlSpotPanel::ControlSpotPanel():
     balan_(Gtk::manage(new Adjuster(M("TP_LOCALLAB_BALAN"), 0.2, 2.5, 0.1, 1.0, Gtk::manage(new RTImage("rawtherapee-logo-16.png")), Gtk::manage(new RTImage("circle-white-small.png"))))),
     transitweak_(Gtk::manage(new Adjuster(M("TP_LOCALLAB_TRANSITWEAK"), 0.5, 10.0, 0.1, 1.0))),
     transitgrad_(Gtk::manage(new Adjuster(M("TP_LOCALLAB_TRANSITGRAD"), -1.0, 1.0, 0.01, 0.0))),
+    scopemask_(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SCOPEMASK"), 0, 100, 1, 50))),
 
     avoid_(Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_AVOID")))),
     laplac_(Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_LAPLACC")))),
@@ -245,9 +246,11 @@ ControlSpotPanel::ControlSpotPanel():
     if(showtooltip) transit_->set_tooltip_text(M("TP_LOCALLAB_TRANSIT_TOOLTIP"));
     if(showtooltip) transitweak_->set_tooltip_text(M("TP_LOCALLAB_TRANSITWEAK_TOOLTIP"));
     if(showtooltip) transitgrad_->set_tooltip_text(M("TP_LOCALLAB_TRANSITGRAD_TOOLTIP"));
+    if(showtooltip) scopemask_->set_tooltip_text(M("TP_LOCALLAB_SCOPEMASK_TOOLTIP"));
     transit_->setAdjusterListener(this);
     transitweak_->setAdjusterListener(this);
     transitgrad_->setAdjusterListener(this);
+    scopemask_->setAdjusterListener(this);
 
     transitBox->pack_start(*transit_);
     transitBox->pack_start(*transitweak_);
@@ -273,12 +276,21 @@ ControlSpotPanel::ControlSpotPanel():
     avoidConn_  = avoid_->signal_toggled().connect(
             sigc::mem_fun(*this, &ControlSpotPanel::avoidChanged));
     pack_start(*avoid_);
+    
+    Gtk::Frame* const maskFrame = Gtk::manage(new Gtk::Frame(M("TP_LOCALLAB_MASFRAME")));
+    maskFrame->set_label_align(0.025, 0.5);
+    if(showtooltip) maskFrame->set_tooltip_text(M("TP_LOCALLAB_MASFRAME_TOOLTIP"));
+    ToolParamBlock* const maskBox = Gtk::manage(new ToolParamBlock());
+    
     laplacConn_  = laplac_->signal_toggled().connect(
             sigc::mem_fun(*this, &ControlSpotPanel::laplacChanged));
-    pack_start(*laplac_);
+    maskBox->pack_start(*laplac_);
     deltaeConn_  = deltae_->signal_toggled().connect(
             sigc::mem_fun(*this, &ControlSpotPanel::deltaeChanged));
-//    pack_start(*deltae_);
+    maskBox->pack_start(*deltae_);
+    maskBox->pack_start(*scopemask_);
+    maskFrame->add(*maskBox);
+    pack_start(*maskFrame);
 
     show_all();
 
@@ -582,6 +594,7 @@ void ControlSpotPanel::load_ControlSpot_param()
     balan_->setValue((double)row[spots_.balan]);
     transitweak_->setValue((double)row[spots_.transitweak]);
     transitgrad_->setValue((double)row[spots_.transitgrad]);
+    scopemask_->setValue((double)row[spots_.scopemask]);
     avoid_->set_active(row[spots_.avoid]);
     laplac_->set_active(row[spots_.laplac]);
     deltae_->set_active(row[spots_.deltae]);
@@ -1013,6 +1026,14 @@ void ControlSpotPanel::adjusterChanged(Adjuster* a, double newval)
         }
     }
 
+    if (a == scopemask_) {
+        row[spots_.scopemask] = scopemask_->getIntValue();
+
+        if (listener) {
+            listener->panelChanged(EvLocallabSpotscopemask, scopemask_->getTextValue());
+        }
+    }
+
 }
 
 void ControlSpotPanel::avoidChanged()
@@ -1151,6 +1172,7 @@ void ControlSpotPanel::disableParamlistener(bool cond)
     balan_->block(cond);
     transitweak_->block(cond);
     transitgrad_->block(cond);
+    scopemask_->block(cond);
     avoidConn_.block(cond);
     laplacConn_.block(cond);
     deltaeConn_.block(cond);
@@ -1180,6 +1202,7 @@ void ControlSpotPanel::setParamEditable(bool cond)
     balan_->set_sensitive(cond);
     transitweak_->set_sensitive(cond);
     transitgrad_->set_sensitive(cond);
+    scopemask_->set_sensitive(cond);
     avoid_->set_sensitive(cond);
     laplac_->set_sensitive(cond);
     deltae_->set_sensitive(cond);
@@ -1815,6 +1838,7 @@ ControlSpotPanel::SpotRow* ControlSpotPanel::getSpot(const int id)
             r->balan = row[spots_.balan];
             r->transitweak = row[spots_.transitweak];
             r->transitgrad = row[spots_.transitgrad];
+            r->scopemask = row[spots_.scopemask];
             r->avoid = row[spots_.avoid];
             r->laplac = row[spots_.laplac];
             r->deltae = row[spots_.deltae];
@@ -1943,6 +1967,7 @@ void ControlSpotPanel::addControlSpot(SpotRow* newSpot)
     row[spots_.balan] = newSpot->balan;
     row[spots_.transitweak] = newSpot->transitweak;
     row[spots_.transitgrad] = newSpot->transitgrad;
+    row[spots_.scopemask] = newSpot->scopemask;
     row[spots_.avoid] = newSpot->avoid;
     row[spots_.laplac] = newSpot->laplac;
     row[spots_.deltae] = newSpot->deltae;
@@ -1990,6 +2015,7 @@ int ControlSpotPanel::updateControlSpot(SpotRow* spot)
             row[spots_.balan] = spot->balan;
             row[spots_.transitweak] = spot->transitweak;
             row[spots_.transitgrad] = spot->transitgrad;
+            row[spots_.scopemask] = spot->scopemask;
             row[spots_.avoid] = spot->avoid;
             row[spots_.laplac] = spot->laplac;
             row[spots_.deltae] = spot->deltae;
@@ -2083,6 +2109,7 @@ ControlSpotPanel::SpotEdited* ControlSpotPanel::getEditedStates()
     se->balan = balan_->getEditedState();
     se->transitweak = transitweak_->getEditedState();
     se->transitgrad = transitgrad_->getEditedState();
+    se->scopemask = scopemask_->getEditedState();
     se->avoid = !avoid_->get_inconsistent();
     se->laplac = !laplac_->get_inconsistent();
     se->deltae = !deltae_->get_inconsistent();
@@ -2154,6 +2181,7 @@ void ControlSpotPanel::setEditedStates(SpotEdited* se)
     balan_->setEditedState(se->balan ? Edited : UnEdited);
     transitweak_->setEditedState(se->transitweak ? Edited : UnEdited);
     transitgrad_->setEditedState(se->transitgrad ? Edited : UnEdited);
+    scopemask_->setEditedState(se->scopemask ? Edited : UnEdited);
     avoid_->set_inconsistent(multiImage && !se->avoid);
     laplac_->set_inconsistent(multiImage && !se->laplac);
     deltae_->set_inconsistent(multiImage && !se->deltae);
@@ -2201,6 +2229,7 @@ void ControlSpotPanel::setDefaults(const rtengine::procparams::ProcParams * defP
     balan_->setDefault(defSpot->balan);
     transitweak_->setDefault(defSpot->transitweak);
     transitgrad_->setDefault(defSpot->transitgrad);
+    scopemask_->setDefault(defSpot->scopemask);
 
     // Set default edited states for adjusters
     if (!pedited) {
@@ -2220,6 +2249,7 @@ void ControlSpotPanel::setDefaults(const rtengine::procparams::ProcParams * defP
         balan_->setDefaultEditedState(Irrelevant);
         transitweak_->setDefaultEditedState(Irrelevant);
         transitgrad_->setDefaultEditedState(Irrelevant);
+        scopemask_->setDefaultEditedState(Irrelevant);
     } else {
         const LocallabParamsEdited::LocallabSpotEdited* defSpotState = new LocallabParamsEdited::LocallabSpotEdited(true);
 
@@ -2243,6 +2273,7 @@ void ControlSpotPanel::setDefaults(const rtengine::procparams::ProcParams * defP
         balan_->setDefaultEditedState(defSpotState->balan ? Edited : UnEdited);
         transitweak_->setDefaultEditedState(defSpotState->transitweak ? Edited : UnEdited);
         transitgrad_->setDefaultEditedState(defSpotState->transitgrad ? Edited : UnEdited);
+        scopemask_->setDefaultEditedState(defSpotState->scopemask ? Edited : UnEdited);
     }
 }
 
@@ -2267,6 +2298,7 @@ void ControlSpotPanel::setBatchMode(bool batchMode)
     balan_->showEditedCB();
     transitweak_->showEditedCB();
     transitgrad_->showEditedCB();
+    scopemask_->showEditedCB();
 
     // Set batch mode for comboBoxText
     shape_->append(M("GENERAL_UNCHANGED"));
@@ -2306,6 +2338,7 @@ ControlSpotPanel::ControlSpots::ControlSpots()
     add(balan);
     add(transitweak);
     add(transitgrad);
+    add(scopemask);
     add(avoid);
     add(laplac);
     add(deltae);

rtgui/controlspotpanel.h

@@ -65,6 +65,7 @@ public:
         double balan;
         double transitweak;
         double transitgrad;
+        int scopemask;
         bool avoid;
         bool laplac;
         bool deltae;
@@ -98,6 +99,7 @@ public:
         bool balan;
         bool transitweak;
         bool transitgrad;
+        bool scopemask;
         bool avoid;
         bool laplac;
         bool deltae;
@@ -315,6 +317,7 @@ private:
         Gtk::TreeModelColumn<double> balan;
         Gtk::TreeModelColumn<double> transitweak;
         Gtk::TreeModelColumn<double> transitgrad;
+        Gtk::TreeModelColumn<int> scopemask;
         Gtk::TreeModelColumn<bool> avoid;
         Gtk::TreeModelColumn<bool> laplac;
         Gtk::TreeModelColumn<bool> deltae;
@@ -381,6 +384,7 @@ private:
     Adjuster* const balan_;
     Adjuster* const transitweak_;
     Adjuster* const transitgrad_;
+    Adjuster* const scopemask_;
 
     Gtk::CheckButton* const avoid_;
     sigc::connection avoidConn_;

rtgui/locallab.cc

@@ -2804,6 +2804,7 @@ void Locallab::read(const ProcParams* pp, const ParamsEdited* pedited)
         r->balan = pp->locallab.spots.at(i).balan;
         r->transitweak = pp->locallab.spots.at(i).transitweak;
         r->transitgrad = pp->locallab.spots.at(i).transitgrad;
+        r->scopemask = pp->locallab.spots.at(i).scopemask;
         r->avoid = pp->locallab.spots.at(i).avoid;
         r->laplac = pp->locallab.spots.at(i).laplac;
         r->deltae = pp->locallab.spots.at(i).deltae;
@@ -2933,6 +2934,7 @@ void Locallab::write(ProcParams* pp, ParamsEdited* pedited)
             r->balan = newSpot->balan;
             r->transitweak = newSpot->transitweak;
             r->transitgrad = newSpot->transitgrad;
+            r->scopemask = newSpot->scopemask;
             r->avoid = newSpot->avoid;
             r->laplac = newSpot->laplac;
             r->deltae = newSpot->deltae;
@@ -3151,6 +3153,7 @@ void Locallab::write(ProcParams* pp, ParamsEdited* pedited)
             r->balan = newSpot->balan;
             r->transitweak = newSpot->transitweak;
             r->transitgrad = newSpot->transitgrad;
+            r->scopemask = newSpot->scopemask;
             r->avoid = newSpot->avoid;
             r->laplac = newSpot->laplac;
             r->deltae = newSpot->deltae;
@@ -3267,6 +3270,7 @@ void Locallab::write(ProcParams* pp, ParamsEdited* pedited)
                     pp->locallab.spots.at(pp->locallab.selspot).balan = r->balan;
                     pp->locallab.spots.at(pp->locallab.selspot).transitweak = r->transitweak;
                     pp->locallab.spots.at(pp->locallab.selspot).transitgrad = r->transitgrad;
+                    pp->locallab.spots.at(pp->locallab.selspot).scopemask = r->scopemask;
                     pp->locallab.spots.at(pp->locallab.selspot).avoid = r->avoid;
                     pp->locallab.spots.at(pp->locallab.selspot).laplac = r->laplac;
                     pp->locallab.spots.at(pp->locallab.selspot).deltae = r->deltae;
@@ -3647,6 +3651,7 @@ void Locallab::write(ProcParams* pp, ParamsEdited* pedited)
                         pe->locallab.spots.at(pp->locallab.selspot).iter = pe->locallab.spots.at(pp->locallab.selspot).iter || se->iter;
                         pe->locallab.spots.at(pp->locallab.selspot).transitweak = pe->locallab.spots.at(pp->locallab.selspot).transitweak || se->transitweak;
                         pe->locallab.spots.at(pp->locallab.selspot).transitgrad = pe->locallab.spots.at(pp->locallab.selspot).transitgrad || se->transitgrad;
+                        pe->locallab.spots.at(pp->locallab.selspot).scopemask = pe->locallab.spots.at(pp->locallab.selspot).scopemask || se->scopemask;
                         pe->locallab.spots.at(pp->locallab.selspot).balan = pe->locallab.spots.at(pp->locallab.selspot).balan || se->balan;
                         pe->locallab.spots.at(pp->locallab.selspot).avoid = pe->locallab.spots.at(pp->locallab.selspot).avoid || se->avoid;
                         pe->locallab.spots.at(pp->locallab.selspot).laplac = pe->locallab.spots.at(pp->locallab.selspot).laplac || se->laplac;
@@ -3950,6 +3955,7 @@ void Locallab::write(ProcParams* pp, ParamsEdited* pedited)
                         pedited->locallab.spots.at(pp->locallab.selspot).balan = pedited->locallab.spots.at(pp->locallab.selspot).balan || se->balan;
                         pedited->locallab.spots.at(pp->locallab.selspot).transitweak = pedited->locallab.spots.at(pp->locallab.selspot).transitweak || se->transitweak;
                         pedited->locallab.spots.at(pp->locallab.selspot).transitgrad = pedited->locallab.spots.at(pp->locallab.selspot).transitgrad || se->transitgrad;
+                        pedited->locallab.spots.at(pp->locallab.selspot).scopemask = pedited->locallab.spots.at(pp->locallab.selspot).scopemask || se->scopemask;
                         pedited->locallab.spots.at(pp->locallab.selspot).avoid = pedited->locallab.spots.at(pp->locallab.selspot).avoid || se->avoid;
                         pedited->locallab.spots.at(pp->locallab.selspot).laplac = pedited->locallab.spots.at(pp->locallab.selspot).laplac || se->laplac;
                         pedited->locallab.spots.at(pp->locallab.selspot).deltae = pedited->locallab.spots.at(pp->locallab.selspot).deltae || se->deltae;
@@ -8513,6 +8519,7 @@ void Locallab::updateLocallabGUI(const rtengine::procparams::ProcParams* pp, con
                 se->balan = spotState->balan;
                 se->transitweak = spotState->transitweak;
                 se->transitgrad = spotState->transitgrad;
+                se->scopemask = spotState->scopemask;
                 se->avoid = spotState->avoid;
                 se->laplac = spotState->laplac;
                 se->deltae = spotState->deltae;

rtgui/paramsedited.cc

@@ -975,6 +975,7 @@ void ParamsEdited::initFrom(const std::vector<rtengine::procparams::ProcParams>&
                 locallab.spots.at(j).avoid = locallab.spots.at(j).avoid && pSpot.avoid == otherSpot.avoid;
                 locallab.spots.at(j).laplac = locallab.spots.at(j).laplac && pSpot.laplac == otherSpot.laplac;
                 locallab.spots.at(j).deltae = locallab.spots.at(j).deltae && pSpot.deltae == otherSpot.deltae;
+                locallab.spots.at(j).scopemask = locallab.spots.at(j).scopemask && pSpot.scopemask == otherSpot.scopemask;
                 // Color & Light
                 locallab.spots.at(j).expcolor = locallab.spots.at(j).expcolor && pSpot.expcolor == otherSpot.expcolor;
                 locallab.spots.at(j).curvactiv = locallab.spots.at(j).curvactiv && pSpot.curvactiv == otherSpot.curvactiv;
@@ -2794,6 +2795,10 @@ void ParamsEdited::combine(rtengine::procparams::ProcParams& toEdit, const rteng
             toEdit.locallab.spots.at(i).transitgrad = mods.locallab.spots.at(i).transitgrad;
         }
 
+        if (locallab.spots.at(i).scopemask) {
+            toEdit.locallab.spots.at(i).scopemask = mods.locallab.spots.at(i).scopemask;
+        }
+
         if (locallab.spots.at(i).avoid) {
             toEdit.locallab.spots.at(i).avoid = mods.locallab.spots.at(i).avoid;
         }
@@ -4817,6 +4822,7 @@ LocallabParamsEdited::LocallabSpotEdited::LocallabSpotEdited(bool v) :
     avoid(v),
     laplac(v),
     deltae(v),
+    scopemask(v),
     // Color & Light
     expcolor(v),
     curvactiv(v),
@@ -5111,6 +5117,7 @@ void LocallabParamsEdited::LocallabSpotEdited::set(bool v)
     avoid = v;
     laplac = v;
     deltae = v;
+    scopemask = v;
     // Color & Light
     expcolor = v;
     curvactiv = v;

rtgui/paramsedited.h

@@ -393,6 +393,7 @@ public:
         bool avoid;
         bool laplac;
         bool deltae;
+        bool scopemask;
         // Color & Light
         bool expcolor;
         bool curvactiv;