Save provisory work on toning

rtdata/languages/default

@@ -821,6 +821,8 @@ HISTORY_MSG_SIGMAFIN;Final contrast Damper
 HISTORY_MSG_SIGMATON;Toning Damper
 HISTORY_MSG_SIGMACOL;Chroma Damper
 HISTORY_MSG_SIGMADIR;Dir Damper
+HISTORY_MSG_RANGEAB;Range ab
+HISTORY_MSG_PROTAB;Protection
 HISTORY_NEWSNAPSHOT;Add
 HISTORY_NEWSNAPSHOT_TOOLTIP;Shortcut: <b>Alt-s</b>
 HISTORY_SNAPSHOT;Snapshot
@@ -2287,7 +2289,9 @@ TP_WAVELET_OPACITYWL;Local contrast
 TP_WAVELET_OPACITYWL_TOOLTIP;Modify the final local contrast at the end of the wavelet treatment.\n\nThe left side represents the smallest local contrast, progressing to the largest local contrast on the right.
 TP_WAVELET_PASTEL;Pastel chroma
 TP_WAVELET_PROC;Process
+TP_WAVELET_PROTAB;Protection
 TP_WAVELET_RADIUS;Radius Shadows - Highlight
+TP_WAVELET_RANGEAB;Range a and b %
 TP_WAVELET_RE1;Reinforced
 TP_WAVELET_RE2;Unchanged
 TP_WAVELET_RE3;Reduced

rtengine/ipwavelet.cc

@@ -146,6 +146,19 @@ struct cont_params {
     float balchrom;
     float chromfi;
     float chromco;
+    float factor;
+    float scaling;
+    float scaledirect;
+    float a_scale;
+    float a_base;
+    float b_scale;
+    float b_base;
+    float a_high;
+    float a_low;
+    float b_high;
+    float b_low;
+    float rangeab;
+    float protab;
 };
 
 int wavNestedLevels = 1;
@@ -318,6 +331,20 @@ void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int kall, const
         cp.mulC[m] = waparams.ch[m];
     }
 
+    cp.factor = WaveletParams::LABGRID_CORR_MAX * 3.276f;
+    cp.scaling = WaveletParams::LABGRID_CORR_SCALE;
+    cp.scaledirect = WaveletParams::LABGRIDL_DIRECT_SCALE;
+    cp.a_scale = (params->wavelet.labgridAHigh - params->wavelet.labgridALow) / cp.factor / cp.scaling;
+    cp.a_base = params->wavelet.labgridALow / cp.scaling;
+    cp.b_scale = (params->wavelet.labgridBHigh - params->wavelet.labgridBLow) / cp.factor / cp.scaling;
+    cp.b_base = params->wavelet.labgridBLow / cp.scaling;
+    cp.a_high = 3.276f * params->wavelet.labgridAHigh;
+    cp.a_low = 3.276f * params->wavelet.labgridALow;
+    cp.b_high = 3.276f * params->wavelet.labgridBHigh;
+    cp.b_low = 3.276f * params->wavelet.labgridBLow;
+    cp.rangeab = params->wavelet.rangeab;
+    cp.protab = params->wavelet.protab;
+
     if (waOpacityCurveRG) {
         cp.opaRG = true;
     }
@@ -3851,7 +3878,7 @@ void ImProcFunctions::ContAllL(float *koeLi[12], float *maxkoeLi, bool lipschitz
                         kba = 1.f - k2;
                     }
 
-                    WavCoeffs_L[dir][i] *= (1.f + (kba -1.f) * beta[i]);
+                    WavCoeffs_L[dir][i] *= (1.f + (kba - 1.f) * beta[i]);
                 }
             }
         }
@@ -3910,10 +3937,11 @@ void ImProcFunctions::ContAllL(float *koeLi[12], float *maxkoeLi, bool lipschitz
                         kba = 1.f - bal / k2;
                     }
 
-                    WavCoeffs_L[dir][i] *= (1.f + (kba -1.f) * beta[i]);
+                    WavCoeffs_L[dir][i] *= (1.f + (kba - 1.f) * beta[i]);
                 }
             }
         }
+
         delete[] beta;
     }
 
@@ -4131,6 +4159,25 @@ void ImProcFunctions::ContAllAB(LabImage * labco, int maxlvl, float ** varhue, f
         float effect = cp.sigmaton;
         float betaab = 0.f;
         float offs = 1.f;
+        float protec = 0.01f * cp.protab;
+      //  printf("rangeab=%f \n", 0.01f * cp.rangeab);
+      //  printf("protab=%f \n", 0.01f * cp.protab);
+        float aref1 = cp.a_high;
+        float bref1 = cp.b_high;
+        float aref2 = cp.a_low;
+        float bref2 = cp.b_low;
+     //   printf("a1=%f b1=%f a2=%f b2=%f\n", aref1, bref1, aref2, bref2);
+
+        float arefplus1 = aref1 * (1.f + 0.1f * cp.rangeab);
+        float arefmoins1 = aref1 * (1.f - 0.1f * cp.rangeab);
+        float brefplus1 = bref1 * (1.f + 0.1f * cp.rangeab);
+        float brefmoins1 = bref1 * (1.f - 0.1f * cp.rangeab);
+     //   printf("a1+=%f a1-=%f b+=%f b-=%f\n", arefplus1, arefmoins1, brefplus1, brefmoins1);
+
+        float arefplus2 = aref2 * (1.f + 0.1f * cp.rangeab);
+        float arefmoins2 = aref2 * (1.f - 0.1f * cp.rangeab);
+        float brefplus2 = bref2 * (1.f + 0.1f * cp.rangeab);
+        float brefmoins2 = bref2 * (1.f - 0.1f * cp.rangeab);
 
         calceffect(level, meanab, sigmaab, mea, effect, offs);
 
@@ -4161,8 +4208,30 @@ void ImProcFunctions::ContAllAB(LabImage * labco, int maxlvl, float ** varhue, f
                 betaab = 0.0f;
             }
 
+            float kreduc1 = 1.f;
+            float kreduc2 = 1.f;
+            int ii = co / W_ab;
+            int jj = co - ii * W_ab;
+            cp.protab = 0.f;// always disabled provisory...
+            if (cp.protab > 0.f) {
 
-            float beta = (1024.f + 50.f * mulOpacity * betaab) / 1024.f ;
+                if ((labco->a[ii * 2][jj * 2] > arefmoins1) && (labco->a[ii * 2][jj * 2] < arefplus1)
+                        && (labco->b[ii * 2][jj * 2] > brefmoins1) && (labco->b[ii * 2][jj * 2] < brefplus1)) {
+                    kreduc1 = protec;
+                 //   printf("p ");
+                }
+
+                if ((labco->a[ii * 2][jj * 2] > arefmoins2) && (labco->a[ii * 2][jj * 2] < arefplus2)
+                        && (labco->b[ii * 2][jj * 2] > brefmoins2) && (labco->b[ii * 2][jj * 2] < brefplus2)) {
+                    kreduc2 = protec;
+                  //  printf("P ");
+                }
+
+
+                // printf("pa1=%f pa2=%f\n", kreduc1, kredu2);
+            }
+
+            float beta = (1024.f + 50.f * mulOpacity * betaab * kreduc1 * kreduc2) / 1024.f ;
 
             WavCoeffs_ab[dir][co] *= beta;
         }

rtengine/procparams.cc

@@ -2148,6 +2148,10 @@ bool ColorManagementParams::operator !=(const ColorManagementParams& other) cons
     return !(*this == other);
 }
 
+const double WaveletParams::LABGRID_CORR_MAX = 12800.f;
+const double WaveletParams::LABGRID_CORR_SCALE = 3.276f;
+const double WaveletParams::LABGRIDL_DIRECT_SCALE = 41950.;
+
 WaveletParams::WaveletParams() :
     ccwcurve{
         static_cast<double>(FCT_MinMaxCPoints),
@@ -2267,6 +2271,8 @@ WaveletParams::WaveletParams() :
     sigmaton(1.0),
     sigmacol(1.0),
     sigmadir(1.0),
+    rangeab(20.0),
+    protab(0.0),
     iter(0),
     expcontrast(false),
     expchroma(false),
@@ -2279,6 +2285,10 @@ WaveletParams::WaveletParams() :
     exptoning(false),
     expnoise(false),
     expclari(false),
+    labgridALow(0.0),
+    labgridBLow(0.0),
+    labgridAHigh(0.0),
+    labgridBHigh(0.0),
     Lmethod(4),
     CLmethod("all"),
     Backmethod("grey"),
@@ -2385,7 +2395,13 @@ bool WaveletParams::operator ==(const WaveletParams& other) const
         && sigmaton == other.sigmaton
         && sigmacol == other.sigmacol
         && sigmadir == other.sigmadir
+        && rangeab == other.rangeab
+        && protab == other.protab
         && iter == other.iter
+        && labgridALow == other.labgridALow
+        && labgridBLow == other.labgridBLow
+        && labgridAHigh == other.labgridAHigh
+        && labgridBHigh == other.labgridBHigh
         && expcontrast == other.expcontrast
         && expchroma == other.expchroma
         && [this, &other]() -> bool
@@ -3532,6 +3548,8 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
         saveToKeyfile(!pedited || pedited->wavelet.sigmaton, "Wavelet", "Sigmaton", wavelet.sigmaton, keyFile);
         saveToKeyfile(!pedited || pedited->wavelet.sigmacol, "Wavelet", "Sigmacol", wavelet.sigmacol, keyFile);
         saveToKeyfile(!pedited || pedited->wavelet.sigmadir, "Wavelet", "Sigmadir", wavelet.sigmadir, keyFile);
+        saveToKeyfile(!pedited || pedited->wavelet.rangeab, "Wavelet", "Rangeab", wavelet.rangeab, keyFile);
+        saveToKeyfile(!pedited || pedited->wavelet.protab, "Wavelet", "Protab", wavelet.protab, keyFile);
         saveToKeyfile(!pedited || pedited->wavelet.iter, "Wavelet", "Iter", wavelet.iter, keyFile);
         saveToKeyfile(!pedited || pedited->wavelet.thres, "Wavelet", "MaxLev", wavelet.thres, keyFile);
         saveToKeyfile(!pedited || pedited->wavelet.Tilesmethod, "Wavelet", "TilesMethod", wavelet.Tilesmethod, keyFile);
@@ -3563,6 +3581,10 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
         saveToKeyfile(!pedited || pedited->wavelet.exptoning, "Wavelet", "Exptoning", wavelet.exptoning, keyFile);
         saveToKeyfile(!pedited || pedited->wavelet.expnoise, "Wavelet", "Expnoise", wavelet.expnoise, keyFile);
         saveToKeyfile(!pedited || pedited->wavelet.expclari, "Wavelet", "Expclari", wavelet.expclari, keyFile);
+        saveToKeyfile(!pedited || pedited->wavelet.labgridALow, "Wavelet", "LabGridALow", wavelet.labgridALow, keyFile);
+        saveToKeyfile(!pedited || pedited->wavelet.labgridBLow, "Wavelet", "LabGridBLow", wavelet.labgridBLow, keyFile);
+        saveToKeyfile(!pedited || pedited->wavelet.labgridAHigh, "Wavelet", "LabGridAHigh", wavelet.labgridAHigh, keyFile);
+        saveToKeyfile(!pedited || pedited->wavelet.labgridBHigh, "Wavelet", "LabGridBHigh", wavelet.labgridBHigh, keyFile);
 
         for (int i = 0; i < 9; i++) {
             std::stringstream ss;
@@ -4716,6 +4738,8 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
             assignFromKeyfile(keyFile, "Wavelet", "Sigmaton", pedited, wavelet.sigmaton, pedited->wavelet.sigmaton);
             assignFromKeyfile(keyFile, "Wavelet", "Sigmacol", pedited, wavelet.sigmacol, pedited->wavelet.sigmacol);
             assignFromKeyfile(keyFile, "Wavelet", "Sigmadir", pedited, wavelet.sigmadir, pedited->wavelet.sigmadir);
+            assignFromKeyfile(keyFile, "Wavelet", "Rangeab", pedited, wavelet.rangeab, pedited->wavelet.rangeab);
+            assignFromKeyfile(keyFile, "Wavelet", "Protab", pedited, wavelet.protab, pedited->wavelet.protab);
             assignFromKeyfile(keyFile, "Wavelet", "Iter", pedited, wavelet.iter, pedited->wavelet.iter);
             assignFromKeyfile(keyFile, "Wavelet", "Median", pedited, wavelet.median, pedited->wavelet.median);
             assignFromKeyfile(keyFile, "Wavelet", "Medianlev", pedited, wavelet.medianlev, pedited->wavelet.medianlev);
@@ -4740,6 +4764,10 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
             assignFromKeyfile(keyFile, "Wavelet", "Showmask", pedited, wavelet.showmask, pedited->wavelet.showmask);
             assignFromKeyfile(keyFile, "Wavelet", "Oldsh", pedited, wavelet.oldsh, pedited->wavelet.oldsh);
             assignFromKeyfile(keyFile, "Wavelet", "TMr", pedited, wavelet.tmr, pedited->wavelet.tmr);
+            assignFromKeyfile(keyFile, "Wavelet", "LabGridALow", pedited, wavelet.labgridALow, pedited->wavelet.labgridALow);
+            assignFromKeyfile(keyFile, "Wavelet", "LabGridBLow", pedited, wavelet.labgridBLow, pedited->wavelet.labgridBLow);
+            assignFromKeyfile(keyFile, "Wavelet", "LabGridAHigh", pedited, wavelet.labgridAHigh, pedited->wavelet.labgridAHigh);
+            assignFromKeyfile(keyFile, "Wavelet", "LabGridBHigh", pedited, wavelet.labgridBHigh, pedited->wavelet.labgridBHigh);
 
             if (ppVersion < 331) { // wavelet.Lmethod was a string before version 331
                 Glib::ustring temp;

rtengine/procparams.h

@@ -1225,6 +1225,8 @@ struct WaveletParams {
     double sigmaton;
     double sigmacol;
     double sigmadir;
+    double rangeab;
+    double protab;
     int iter;
     bool expcontrast;
     bool expchroma;
@@ -1237,7 +1239,13 @@ struct WaveletParams {
     bool exptoning;
     bool expnoise;
     bool expclari;
-
+    double labgridALow;
+    double labgridBLow;
+    double labgridAHigh;
+    double labgridBHigh;
+    static const double LABGRID_CORR_MAX;
+    static const double LABGRID_CORR_SCALE;
+    static const double LABGRIDL_DIRECT_SCALE;
     int Lmethod;
     Glib::ustring CLmethod;
     Glib::ustring Backmethod;

rtgui/paramsedited.cc

@@ -479,6 +479,8 @@ void ParamsEdited::set(bool v)
     wavelet.sigmaton = v;
     wavelet.sigmacol = v;
     wavelet.sigmadir = v;
+    wavelet.rangeab = v;
+    wavelet.protab = v;
     wavelet.median = v;
     wavelet.medianlev = v;
     wavelet.linkedg = v;
@@ -586,6 +588,10 @@ void ParamsEdited::set(bool v)
     wavelet.expresid = v;
     wavelet.exptoning = v;
     wavelet.expnoise = v;
+    wavelet.labgridALow = v;
+    wavelet.labgridBLow = v;
+    wavelet.labgridAHigh = v;
+    wavelet.labgridBHigh = v;
 
     for (int i = 0; i < 9; i++) {
         wavelet.c[i] = v;
@@ -1094,6 +1100,8 @@ void ParamsEdited::initFrom(const std::vector<rtengine::procparams::ProcParams>&
         wavelet.sigmaton = wavelet.sigmaton && p.wavelet.sigmaton == other.wavelet.sigmaton;
         wavelet.sigmacol = wavelet.sigmacol && p.wavelet.sigmacol == other.wavelet.sigmacol;
         wavelet.sigmadir = wavelet.sigmadir && p.wavelet.sigmadir == other.wavelet.sigmadir;
+        wavelet.rangeab = wavelet.rangeab && p.wavelet.rangeab == other.wavelet.rangeab;
+        wavelet.protab = wavelet.protab && p.wavelet.protab == other.wavelet.protab;
         wavelet.median = wavelet.median && p.wavelet.median == other.wavelet.median;
         wavelet.medianlev = wavelet.medianlev && p.wavelet.medianlev == other.wavelet.medianlev;
         wavelet.linkedg = wavelet.linkedg && p.wavelet.linkedg == other.wavelet.linkedg;
@@ -1197,6 +1205,10 @@ void ParamsEdited::initFrom(const std::vector<rtengine::procparams::ProcParams>&
         wavelet.exptoning = wavelet.exptoning && p.wavelet.exptoning == other.wavelet.exptoning;
         wavelet.expnoise = wavelet.expnoise && p.wavelet.expnoise == other.wavelet.expnoise;
         wavelet.expclari = wavelet.expclari && p.wavelet.expclari == other.wavelet.expclari;
+        wavelet.labgridALow = wavelet.labgridALow && p.wavelet.labgridALow == other.wavelet.labgridALow;
+        wavelet.labgridBLow = wavelet.labgridBLow && p.wavelet.labgridBLow == other.wavelet.labgridBLow;
+        wavelet.labgridAHigh = wavelet.labgridAHigh && p.wavelet.labgridAHigh == other.wavelet.labgridAHigh;
+        wavelet.labgridBHigh = wavelet.labgridBHigh && p.wavelet.labgridBHigh == other.wavelet.labgridBHigh;
 
         for (int level = 0; level < 9; ++level) {
             wavelet.c[level] = wavelet.c[level] && p.wavelet.c[level] == other.wavelet.c[level];
@@ -2897,6 +2909,22 @@ void ParamsEdited::combine(rtengine::procparams::ProcParams& toEdit, const rteng
         toEdit.wavelet.enabled = mods.wavelet.enabled;
     }
 
+    if (wavelet.labgridALow) {
+        toEdit.wavelet.labgridALow = mods.wavelet.labgridALow;
+    }
+
+    if (wavelet.labgridBLow) {
+        toEdit.wavelet.labgridBLow = mods.wavelet.labgridBLow;
+    }
+
+    if (wavelet.labgridAHigh) {
+        toEdit.wavelet.labgridAHigh = mods.wavelet.labgridAHigh;
+    }
+
+    if (wavelet.labgridBHigh) {
+        toEdit.wavelet.labgridBHigh = mods.wavelet.labgridBHigh;
+    }
+
     if (wavelet.strength) {
         toEdit.wavelet.strength = mods.wavelet.strength;
     }
@@ -2921,6 +2949,14 @@ void ParamsEdited::combine(rtengine::procparams::ProcParams& toEdit, const rteng
         toEdit.wavelet.sigmadir = mods.wavelet.sigmadir;
     }
 
+    if (wavelet.rangeab) {
+        toEdit.wavelet.rangeab = mods.wavelet.rangeab;
+    }
+
+    if (wavelet.protab) {
+        toEdit.wavelet.protab = mods.wavelet.protab;
+    }
+
     if (wavelet.iter) {
         toEdit.wavelet.iter = mods.wavelet.iter;
     }

rtgui/paramsedited.h

@@ -503,6 +503,8 @@ struct WaveletParamsEdited {
     bool sigmaton;
     bool sigmacol;
     bool sigmadir;
+    bool rangeab;
+    bool protab;
     bool median;
     bool medianlev;
     bool linkedg;
@@ -607,6 +609,11 @@ struct WaveletParamsEdited {
     bool exptoning;
     bool expnoise;
     bool expclari;
+    bool labgridALow;
+    bool labgridBLow;
+    bool labgridAHigh;
+    bool labgridBHigh;
+    
 };
 
 struct DirPyrEqualizerParamsEdited {

rtgui/wavelet.cc

@@ -27,6 +27,7 @@
 #include "rtimage.h"
 #include "options.h"
 #include "eventmapper.h"
+#include "labgrid.h"
 #include "../rtengine/color.h"
 
 using namespace rtengine;
@@ -116,6 +117,8 @@ Wavelet::Wavelet() :
     sigmaton(Gtk::manage(new Adjuster(M("TP_WAVELET_SIGMAFIN"), 0.025, 2.5, 0.01, 1.))),
     sigmacol(Gtk::manage(new Adjuster(M("TP_WAVELET_SIGMAFIN"), 0.025, 2.5, 0.01, 1.))),
     sigmadir(Gtk::manage(new Adjuster(M("TP_WAVELET_SIGMAFIN"), 0.025, 2.5, 0.01, 1.))),
+    rangeab(Gtk::manage(new Adjuster(M("TP_WAVELET_RANGEAB"), 0., 100., 0.1, 20.))),
+    protab(Gtk::manage(new Adjuster(M("TP_WAVELET_PROTAB"), 0., 100., 0.5, 0.))),
     hueskin(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_HUESKIN"), -314., 314., -5., 25., 170., 120., 0, false))),
     hueskin2(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_HUESKY"), -314., 314., -260., -250, -130., -140., 0, false))),
     hllev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_HIGHLIGHT"), 0., 100., 50., 75., 100., 98., 0, false))),
@@ -168,6 +171,7 @@ Wavelet::Wavelet() :
     chroFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_CHROFRAME")))),
     fincFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_FINCFRAME")))),
     dirFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_DIRFRAME")))),
+    tonFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_TONFRAME")))),
     wavLabels(Gtk::manage(new Gtk::Label("---", Gtk::ALIGN_CENTER))),
     labmC(Gtk::manage(new Gtk::Label(M("TP_WAVELET_CTYPE") + ":"))),
     labmNP(Gtk::manage(new Gtk::Label(M("TP_WAVELET_NPTYPE") + ":"))),
@@ -217,6 +221,11 @@ Wavelet::Wavelet() :
     EvWavsigmaton = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_SIGMATON");
     EvWavsigmacol = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_SIGMACOL");
     EvWavsigmadir = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_SIGMADIR");
+    EvWavLabGridValue = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVLABGRID_VALUE");
+    EvWavrangeab = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_RANGEAB");
+    EvWavprotab = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_PROTAB");
+
+    labgrid = Gtk::manage(new LabGrid(EvWavLabGridValue, M("TP_WAVELET_LABGRID_VALUES")));
 
     expsettings->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expsettings));
 
@@ -497,6 +506,8 @@ Wavelet::Wavelet() :
 // Toning
     ToolParamBlock* const tonBox = Gtk::manage(new ToolParamBlock());
     sigmaton->setAdjusterListener(this);
+    rangeab->setAdjusterListener(this);
+    protab->setAdjusterListener(this);
 
     opaCurveEditorG->setCurveListener(this);
 
@@ -515,6 +526,15 @@ Wavelet::Wavelet() :
     opaCurveEditorG->curveListComplete();
     opaCurveEditorG->show();
     tonBox->pack_start(*sigmaton);
+    
+    tonFrame->set_label_align(0.025, 0.5);
+    ToolParamBlock* const ton2Box = Gtk::manage(new ToolParamBlock());
+    ton2Box->pack_start(*labgrid, Gtk::PACK_EXPAND_WIDGET, 2);
+    ton2Box->pack_start(*rangeab);
+    ton2Box->pack_start(*protab);
+    tonFrame->add(*ton2Box);
+//    tonBox->pack_start(*tonFrame);
+
     tonBox->pack_start(*opaCurveEditorG, Gtk::PACK_SHRINK, 2);
 
     opacityCurveEditorG->setCurveListener(this);
@@ -1157,6 +1177,13 @@ void Wavelet::neutral_pressed()
     }
 }
 
+void Wavelet::setListener(ToolPanelListener *tpl)
+{
+    ToolPanel::setListener(tpl);
+    labgrid->setListener(tpl);
+}
+
+
 void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
 {
 
@@ -1443,6 +1470,7 @@ void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
     mergeC->setValue(pp->wavelet.mergeC);
     softrad->setValue(pp->wavelet.softrad);
     softradend->setValue(pp->wavelet.softradend);
+    labgrid->setParams(pp->wavelet.labgridALow / WaveletParams::LABGRID_CORR_MAX, pp->wavelet.labgridBLow / WaveletParams::LABGRID_CORR_MAX, pp->wavelet.labgridAHigh / WaveletParams::LABGRID_CORR_MAX, pp->wavelet.labgridBHigh / WaveletParams::LABGRID_CORR_MAX, false);
 
     ballum->setValue(pp->wavelet.ballum);
     balchrom->setValue(pp->wavelet.balchrom);
@@ -1459,6 +1487,8 @@ void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
     sigmaton->setValue(pp->wavelet.sigmaton);
     sigmacol->setValue(pp->wavelet.sigmacol);
     sigmadir->setValue(pp->wavelet.sigmadir);
+    rangeab->setValue(pp->wavelet.rangeab);
+    protab->setValue(pp->wavelet.protab);
 
     for (int i = 0; i < 9; i++) {
         correction[i]->setValue(pp->wavelet.c[i]);
@@ -1534,6 +1564,7 @@ void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
         if (!pedited->wavelet.ushamethod) {
             ushamethod->set_active_text(M("GENERAL_UNCHANGED"));
         }
+        labgrid->setEdited(pedited->wavelet.labgridALow || pedited->wavelet.labgridBLow || pedited->wavelet.labgridAHigh || pedited->wavelet.labgridBHigh);
 
         set_inconsistent(multiImage && !pedited->wavelet.enabled);
         ccshape->setUnChanged(!pedited->wavelet.ccwcurve);
@@ -1580,6 +1611,8 @@ void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
         sigmaton->setEditedState(pedited->wavelet.sigmaton ? Edited : UnEdited);
         sigmacol->setEditedState(pedited->wavelet.sigmacol ? Edited : UnEdited);
         sigmadir->setEditedState(pedited->wavelet.sigmadir ? Edited : UnEdited);
+        rangeab->setEditedState(pedited->wavelet.rangeab ? Edited : UnEdited);
+        protab->setEditedState(pedited->wavelet.protab ? Edited : UnEdited);
         threshold->setEditedState(pedited->wavelet.threshold ? Edited : UnEdited);
         threshold2->setEditedState(pedited->wavelet.threshold2 ? Edited : UnEdited);
         edgedetect->setEditedState(pedited->wavelet.edgedetect ? Edited : UnEdited);
@@ -1828,6 +1861,11 @@ void Wavelet::write(ProcParams* pp, ParamsEdited* pedited)
     pp->wavelet.ballum         = ballum->getValue();
     pp->wavelet.chromfi        = chromfi->getValue();
     pp->wavelet.chromco        = chromco->getValue();
+    labgrid->getParams(pp->wavelet.labgridALow, pp->wavelet.labgridBLow, pp->wavelet.labgridAHigh, pp->wavelet.labgridBHigh);
+    pp->wavelet.labgridALow *= WaveletParams::LABGRID_CORR_MAX;
+    pp->wavelet.labgridAHigh *= WaveletParams::LABGRID_CORR_MAX;
+    pp->wavelet.labgridBLow *= WaveletParams::LABGRID_CORR_MAX;
+    pp->wavelet.labgridBHigh *= WaveletParams::LABGRID_CORR_MAX;
 
     pp->wavelet.greenlow       = greenlow->getValue();
     pp->wavelet.bluelow        = bluelow->getValue();
@@ -1855,6 +1893,8 @@ void Wavelet::write(ProcParams* pp, ParamsEdited* pedited)
     pp->wavelet.sigmaton = sigmaton->getValue();
     pp->wavelet.sigmacol = sigmacol->getValue();
     pp->wavelet.sigmadir = sigmadir->getValue();
+    pp->wavelet.rangeab = rangeab->getValue();
+    pp->wavelet.protab = protab->getValue();
 
     for (int i = 0; i < 9; i++) {
         pp->wavelet.c[i] = (int) correction[i]->getValue();
@@ -1965,6 +2005,8 @@ void Wavelet::write(ProcParams* pp, ParamsEdited* pedited)
         pedited->wavelet.sigmaton        = sigmaton->getEditedState();
         pedited->wavelet.sigmacol        = sigmacol->getEditedState();
         pedited->wavelet.sigmadir        = sigmadir->getEditedState();
+        pedited->wavelet.rangeab         = rangeab->getEditedState();
+        pedited->wavelet.protab          = protab->getEditedState();
         pedited->wavelet.wavclCurve      = !clshape->isUnChanged();
         pedited->wavelet.expcontrast     = !expcontrast->get_inconsistent();
         pedited->wavelet.expchroma       = !expchroma->get_inconsistent();
@@ -1975,6 +2017,7 @@ void Wavelet::write(ProcParams* pp, ParamsEdited* pedited)
         pedited->wavelet.exptoning       = !exptoning->get_inconsistent();
         pedited->wavelet.expnoise        = !expnoise->get_inconsistent();
         pedited->wavelet.expclari        = !expclari->get_inconsistent();
+        pedited->wavelet.labgridALow = pedited->wavelet.labgridBLow = pedited->wavelet.labgridAHigh = pedited->wavelet.labgridBHigh = labgrid->getEdited();
 
         for (int i = 0; i < 9; i++) {
             pedited->wavelet.c[i]        = correction[i]->getEditedState();
@@ -2150,6 +2193,8 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
     sigmacol->setDefault(defParams->wavelet.sigmacol);
     sigmadir->setDefault(defParams->wavelet.sigmadir);
     sigma->setDefault(defParams->wavelet.sigma);
+    rangeab->setDefault(defParams->wavelet.rangeab);
+    protab->setDefault(defParams->wavelet.protab);
     offset->setDefault(defParams->wavelet.offset);
     lowthr->setDefault(defParams->wavelet.lowthr);
     rescon->setDefault(defParams->wavelet.rescon);
@@ -2198,6 +2243,7 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
     balchrom->setDefault(defParams->wavelet.balchrom);
     chromfi->setDefault(defParams->wavelet.chromfi);
     chromco->setDefault(defParams->wavelet.chromco);
+    labgrid->setDefault(defParams->wavelet.labgridALow / WaveletParams::LABGRID_CORR_MAX, defParams->wavelet.labgridBLow / WaveletParams::LABGRID_CORR_MAX, defParams->wavelet.labgridAHigh / WaveletParams::LABGRID_CORR_MAX, defParams->wavelet.labgridBHigh / WaveletParams::LABGRID_CORR_MAX);
 
     greenlow->setDefault(defParams->wavelet.greenlow);
     bluelow->setDefault(defParams->wavelet.bluelow);
@@ -2225,6 +2271,7 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
         balchrom->setDefaultEditedState(pedited->wavelet.balchrom ? Edited : UnEdited);
         chromfi->setDefaultEditedState(pedited->wavelet.chromfi ? Edited : UnEdited);
         chromco->setDefaultEditedState(pedited->wavelet.chromco ? Edited : UnEdited);
+        labgrid->setEdited((pedited->wavelet.labgridALow || pedited->wavelet.labgridBLow || pedited->wavelet.labgridAHigh || pedited->wavelet.labgridBHigh) ? Edited : UnEdited);
 
         sigma->setDefault(defParams->wavelet.sigma);
         offset->setDefault(defParams->wavelet.offset);
@@ -2275,6 +2322,8 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
         sigmaton->setDefaultEditedState(pedited->wavelet.sigmaton ? Edited : UnEdited);
         sigmacol->setDefaultEditedState(pedited->wavelet.sigmacol ? Edited : UnEdited);
         sigmadir->setDefaultEditedState(pedited->wavelet.sigmadir ? Edited : UnEdited);
+        rangeab->setDefaultEditedState(pedited->wavelet.rangeab ? Edited : UnEdited);
+        protab->setDefaultEditedState(pedited->wavelet.protab ? Edited : UnEdited);
         level0noise->setDefaultEditedState(pedited->wavelet.level0noise ? Edited : UnEdited);
         level1noise->setDefaultEditedState(pedited->wavelet.level1noise ? Edited : UnEdited);
         level2noise->setDefaultEditedState(pedited->wavelet.level2noise ? Edited : UnEdited);
@@ -2341,6 +2390,9 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
         sigmaton->setDefaultEditedState(Irrelevant);
         sigmacol->setDefaultEditedState(Irrelevant);
         sigmadir->setDefaultEditedState(Irrelevant);
+        rangeab->setDefaultEditedState(Irrelevant);
+        protab->setDefaultEditedState(Irrelevant);
+        labgrid->setEdited(Edited);
 
         for (int i = 0; i < 9; i++) {
             correction[i]->setDefaultEditedState(Irrelevant);
@@ -2883,6 +2935,8 @@ void Wavelet::setBatchMode(bool batchMode)
     sigmaton->showEditedCB();
     sigmacol->showEditedCB();
     sigmadir->showEditedCB();
+    rangeab->showEditedCB();
+    protab->showEditedCB();
     level0noise->showEditedCB();
     level1noise->showEditedCB();
     level2noise->showEditedCB();
@@ -3036,6 +3090,10 @@ void Wavelet::adjusterChanged(Adjuster* a, double newval)
             listener->panelChanged(EvWavsigmafin, sigmafin->getTextValue());
         } else if (a == sigmaton) {
             listener->panelChanged(EvWavsigmaton, sigmaton->getTextValue());
+        } else if (a == rangeab) {
+            listener->panelChanged(EvWavrangeab, rangeab->getTextValue());
+        } else if (a == protab) {
+            listener->panelChanged(EvWavprotab, protab->getTextValue());
         } else if (a == sigmacol) {
             listener->panelChanged(EvWavsigmacol, sigmacol->getTextValue());
         } else if (a == sigmadir) {

rtgui/wavelet.h

@@ -33,6 +33,7 @@ class CurveEditorGroup;
 class DiagonalCurveEditor;
 class EditDataProvider;
 class FlatCurveEditor;
+class LabGrid;
 
 class Wavelet final :
     public ToolParamBlock,
@@ -97,8 +98,14 @@ private:
     rtengine::ProcEvent EvWavsigmaton;
     rtengine::ProcEvent EvWavsigmacol;
     rtengine::ProcEvent EvWavsigmadir;
+    rtengine::ProcEvent EvWavLabGridValue;
+    rtengine::ProcEvent EvWavrangeab;
+    rtengine::ProcEvent EvWavprotab;
+
+    LabGrid *labgrid;
 
     void foldAllButMe(GdkEventButton* event, MyExpander *expander);
+    void setListener(ToolPanelListener *tpl) override;
 
     void colorForValue(double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller* caller) override;
     void BAmethodChanged();
@@ -226,6 +233,8 @@ private:
     Adjuster* const sigmaton;
     Adjuster* const sigmacol;
     Adjuster* const sigmadir;
+    Adjuster* const rangeab;
+    Adjuster* const protab;
 
     Adjuster* greenlow;
     Adjuster* bluelow;
@@ -304,6 +313,7 @@ private:
     Gtk::Frame* const chroFrame;
     Gtk::Frame* const fincFrame;
     Gtk::Frame* const dirFrame;
+    Gtk::Frame* const tonFrame;
 
     Gtk::Label* const wavLabels;
     Gtk::Label* const labmC;