Wavelet - added damper to directionnal contrast

rtdata/languages/default

@@ -820,6 +820,7 @@ HISTORY_MSG_EDGEFFECT;Edge Damper
 HISTORY_MSG_SIGMAFIN;Final contrast Damper
 HISTORY_MSG_SIGMATON;Toning Damper
 HISTORY_MSG_SIGMACOL;Chroma Damper
+HISTORY_MSG_SIGMADIR;Dir Damper
 HISTORY_NEWSNAPSHOT;Add
 HISTORY_NEWSNAPSHOT_TOOLTIP;Shortcut: <b>Alt-s</b>
 HISTORY_SNAPSHOT;Snapshot

rtengine/ipwavelet.cc

@@ -116,6 +116,7 @@ struct cont_params {
     float sigmafin;
     float sigmaton;
     float sigmacol;
+    float sigmadir;
     int ite;
     int contmet;
     bool opaW;
@@ -197,6 +198,7 @@ void ImProcFunctions::ip_wavelet(LabImage * lab, LabImage * dst, int kall, const
     cp.sigmafin = params->wavelet.sigmafin;
     cp.sigmaton = params->wavelet.sigmaton;
     cp.sigmacol = params->wavelet.sigmacol;
+    cp.sigmadir = params->wavelet.sigmadir;
 
     if (params->wavelet.TMmethod == "cont") {
         cp.contmet = 1;
@@ -3768,7 +3770,52 @@ void ImProcFunctions::ContAllL(float *koeLi[12], float *maxkoeLi, bool lipschitz
     }
 
     if (cp.bam && cp.finena) {
+        float effect = cp.sigmadir;
+        float offs = 1.f;
+        float mea[10];
+        float * beta = new float[W_L * H_L];
+
+        for (int co = 0; co < H_L * W_L; co++) {
+            beta[co] = 1.f;
+        }
+
+        calceffect(level, mean, sigma, mea, effect, offs);
+
+
+        for (int co = 0; co < H_L * W_L; co++) {
+            float WavCL = std::fabs(WavCoeffs_L[dir][co]);
+
+            if (WavCL < mea[0]) {
+                beta[co] = 0.05f;
+            } else if (WavCL < mea[1]) {
+                beta[co] = 0.2f;
+            } else if (WavCL < mea[2]) {
+                beta[co] = 0.7f;
+            } else if (WavCL < mea[3]) {
+                beta[co] = 1.f;    //standard
+            } else if (WavCL < mea[4]) {
+                beta[co] = 1.f;
+            } else if (WavCL < mea[5]) {
+                beta[co] = 0.8f;    //+sigma
+            } else if (WavCL < mea[6]) {
+                beta[co] = 0.6f;
+            } else if (WavCL < mea[7]) {
+                beta[co] = 0.4f;
+            } else if (WavCL < mea[8]) {
+                beta[co] = 0.2f;    // + 2 sigma
+            } else if (WavCL < mea[9]) {
+                beta[co] = 0.1f;
+            } else {
+                beta[co] = 0.01f;
+            }
+        }
+
+
         if (cp.opaW && cp.BAmet == 2) {
+
+
+
+
             int iteration = cp.ite;
             int itplus = 7 + iteration;
             int itmoins = 7 - iteration;
@@ -3804,7 +3851,7 @@ void ImProcFunctions::ContAllL(float *koeLi[12], float *maxkoeLi, bool lipschitz
                         kba = 1.f - k2;
                     }
 
-                    WavCoeffs_L[dir][i] *= (kba);
+                    WavCoeffs_L[dir][i] *= (1.f + (kba -1.f) * beta[i]);
                 }
             }
         }
@@ -3863,11 +3910,11 @@ void ImProcFunctions::ContAllL(float *koeLi[12], float *maxkoeLi, bool lipschitz
                         kba = 1.f - bal / k2;
                     }
 
-                    WavCoeffs_L[dir][i] *= (kba);
+                    WavCoeffs_L[dir][i] *= (1.f + (kba -1.f) * beta[i]);
                 }
             }
         }
-
+        delete[] beta;
     }
 
     // to see each level of wavelet ...level from 0 to 8

rtengine/procparams.cc

@@ -2266,6 +2266,7 @@ WaveletParams::WaveletParams() :
     sigmafin(1.0),
     sigmaton(1.0),
     sigmacol(1.0),
+    sigmadir(1.0),
     iter(0),
     expcontrast(false),
     expchroma(false),
@@ -2383,6 +2384,7 @@ bool WaveletParams::operator ==(const WaveletParams& other) const
         && sigmafin == other.sigmafin
         && sigmaton == other.sigmaton
         && sigmacol == other.sigmacol
+        && sigmadir == other.sigmadir
         && iter == other.iter
         && expcontrast == other.expcontrast
         && expchroma == other.expchroma
@@ -3529,6 +3531,7 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
         saveToKeyfile(!pedited || pedited->wavelet.sigmafin, "Wavelet", "Sigmafin", wavelet.sigmafin, keyFile);
         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.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);
@@ -4712,6 +4715,7 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
             assignFromKeyfile(keyFile, "Wavelet", "Sigmafin", pedited, wavelet.sigmafin, pedited->wavelet.sigmafin);
             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", "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);

rtengine/procparams.h

@@ -1224,6 +1224,7 @@ struct WaveletParams {
     double sigmafin;
     double sigmaton;
     double sigmacol;
+    double sigmadir;
     int iter;
     bool expcontrast;
     bool expchroma;

rtgui/paramsedited.cc

@@ -478,6 +478,7 @@ void ParamsEdited::set(bool v)
     wavelet.sigmafin = v;
     wavelet.sigmaton = v;
     wavelet.sigmacol = v;
+    wavelet.sigmadir = v;
     wavelet.median = v;
     wavelet.medianlev = v;
     wavelet.linkedg = v;
@@ -1092,6 +1093,7 @@ void ParamsEdited::initFrom(const std::vector<rtengine::procparams::ProcParams>&
         wavelet.sigmafin = wavelet.sigmafin && p.wavelet.sigmafin == other.wavelet.sigmafin;
         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.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;
@@ -2915,6 +2917,10 @@ void ParamsEdited::combine(rtengine::procparams::ProcParams& toEdit, const rteng
         toEdit.wavelet.sigmacol = mods.wavelet.sigmacol;
     }
 
+    if (wavelet.sigmadir) {
+        toEdit.wavelet.sigmadir = mods.wavelet.sigmadir;
+    }
+
     if (wavelet.iter) {
         toEdit.wavelet.iter = mods.wavelet.iter;
     }

rtgui/paramsedited.h

@@ -502,6 +502,7 @@ struct WaveletParamsEdited {
     bool sigmafin;
     bool sigmaton;
     bool sigmacol;
+    bool sigmadir;
     bool median;
     bool medianlev;
     bool linkedg;

rtgui/wavelet.cc

@@ -115,6 +115,7 @@ Wavelet::Wavelet() :
     sigmafin(Gtk::manage(new Adjuster(M("TP_WAVELET_SIGMAFIN"), 0.025, 2.5, 0.01, 1.))),
     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.))),
     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))),
@@ -215,6 +216,7 @@ Wavelet::Wavelet() :
     EvWavsigmafin = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_SIGMAFIN");
     EvWavsigmaton = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_SIGMATON");
     EvWavsigmacol = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_SIGMACOL");
+    EvWavsigmadir = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_SIGMADIR");
 
     expsettings->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expsettings));
 
@@ -1001,6 +1003,7 @@ Wavelet::Wavelet() :
 
     iter->setAdjusterListener(this);
     iter->set_tooltip_text(M("TP_WAVELET_ITER_TOOLTIP"));
+    sigmadir->setAdjusterListener(this);
 
 //    Gtk::HSeparator* const separatorbalend = Gtk::manage(new  Gtk::HSeparator());
 
@@ -1041,6 +1044,7 @@ Wavelet::Wavelet() :
     dirBox->pack_start(*balance);
     dirBox->pack_start(*opacityCurveEditorW, Gtk::PACK_SHRINK, 2);
     dirBox->pack_start(*iter);
+    dirBox->pack_start(*sigmadir);
     dirBox->pack_start(*tmr);
     dirFrame->add(*dirBox);
 
@@ -1454,6 +1458,7 @@ void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
     sigmafin->setValue(pp->wavelet.sigmafin);
     sigmaton->setValue(pp->wavelet.sigmaton);
     sigmacol->setValue(pp->wavelet.sigmacol);
+    sigmadir->setValue(pp->wavelet.sigmadir);
 
     for (int i = 0; i < 9; i++) {
         correction[i]->setValue(pp->wavelet.c[i]);
@@ -1574,6 +1579,7 @@ void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
         sigmafin->setEditedState(pedited->wavelet.sigmafin ? Edited : UnEdited);
         sigmaton->setEditedState(pedited->wavelet.sigmaton ? Edited : UnEdited);
         sigmacol->setEditedState(pedited->wavelet.sigmacol ? Edited : UnEdited);
+        sigmadir->setEditedState(pedited->wavelet.sigmadir ? Edited : UnEdited);
         threshold->setEditedState(pedited->wavelet.threshold ? Edited : UnEdited);
         threshold2->setEditedState(pedited->wavelet.threshold2 ? Edited : UnEdited);
         edgedetect->setEditedState(pedited->wavelet.edgedetect ? Edited : UnEdited);
@@ -1848,6 +1854,7 @@ void Wavelet::write(ProcParams* pp, ParamsEdited* pedited)
     pp->wavelet.sigmafin = sigmafin->getValue();
     pp->wavelet.sigmaton = sigmaton->getValue();
     pp->wavelet.sigmacol = sigmacol->getValue();
+    pp->wavelet.sigmadir = sigmadir->getValue();
 
     for (int i = 0; i < 9; i++) {
         pp->wavelet.c[i] = (int) correction[i]->getValue();
@@ -1957,6 +1964,7 @@ void Wavelet::write(ProcParams* pp, ParamsEdited* pedited)
         pedited->wavelet.sigmafin        = sigmafin->getEditedState();
         pedited->wavelet.sigmaton        = sigmaton->getEditedState();
         pedited->wavelet.sigmacol        = sigmacol->getEditedState();
+        pedited->wavelet.sigmadir        = sigmadir->getEditedState();
         pedited->wavelet.wavclCurve      = !clshape->isUnChanged();
         pedited->wavelet.expcontrast     = !expcontrast->get_inconsistent();
         pedited->wavelet.expchroma       = !expchroma->get_inconsistent();
@@ -2140,6 +2148,7 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
     sigmafin->setDefault(defParams->wavelet.sigmafin);
     sigmaton->setDefault(defParams->wavelet.sigmaton);
     sigmacol->setDefault(defParams->wavelet.sigmacol);
+    sigmadir->setDefault(defParams->wavelet.sigmadir);
     sigma->setDefault(defParams->wavelet.sigma);
     offset->setDefault(defParams->wavelet.offset);
     lowthr->setDefault(defParams->wavelet.lowthr);
@@ -2265,6 +2274,7 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
         sigmafin->setDefaultEditedState(pedited->wavelet.sigmafin ? Edited : UnEdited);
         sigmaton->setDefaultEditedState(pedited->wavelet.sigmaton ? Edited : UnEdited);
         sigmacol->setDefaultEditedState(pedited->wavelet.sigmacol ? Edited : UnEdited);
+        sigmadir->setDefaultEditedState(pedited->wavelet.sigmadir ? Edited : UnEdited);
         level0noise->setDefaultEditedState(pedited->wavelet.level0noise ? Edited : UnEdited);
         level1noise->setDefaultEditedState(pedited->wavelet.level1noise ? Edited : UnEdited);
         level2noise->setDefaultEditedState(pedited->wavelet.level2noise ? Edited : UnEdited);
@@ -2330,6 +2340,7 @@ void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedit
         sigmafin->setDefaultEditedState(Irrelevant);
         sigmaton->setDefaultEditedState(Irrelevant);
         sigmacol->setDefaultEditedState(Irrelevant);
+        sigmadir->setDefaultEditedState(Irrelevant);
 
         for (int i = 0; i < 9; i++) {
             correction[i]->setDefaultEditedState(Irrelevant);
@@ -2871,6 +2882,7 @@ void Wavelet::setBatchMode(bool batchMode)
     sigmafin->showEditedCB();
     sigmaton->showEditedCB();
     sigmacol->showEditedCB();
+    sigmadir->showEditedCB();
     level0noise->showEditedCB();
     level1noise->showEditedCB();
     level2noise->showEditedCB();
@@ -3026,6 +3038,8 @@ void Wavelet::adjusterChanged(Adjuster* a, double newval)
             listener->panelChanged(EvWavsigmaton, sigmaton->getTextValue());
         } else if (a == sigmacol) {
             listener->panelChanged(EvWavsigmacol, sigmacol->getTextValue());
+        } else if (a == sigmadir) {
+            listener->panelChanged(EvWavsigmadir, sigmadir->getTextValue());
         } else if (a == greenhigh) {
             listener->panelChanged(EvWavgreenhigh, greenhigh->getTextValue());
         } else if (a == bluehigh) {

rtgui/wavelet.h

@@ -96,6 +96,7 @@ private:
     rtengine::ProcEvent EvWavsigmafin;
     rtengine::ProcEvent EvWavsigmaton;
     rtengine::ProcEvent EvWavsigmacol;
+    rtengine::ProcEvent EvWavsigmadir;
 
     void foldAllButMe(GdkEventButton* event, MyExpander *expander);
 
@@ -224,6 +225,7 @@ private:
     Adjuster* const sigmafin;
     Adjuster* const sigmaton;
     Adjuster* const sigmacol;
+    Adjuster* const sigmadir;
     
     Adjuster* greenlow;
     Adjuster* bluelow;