liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rawTherapee/rtgui/wavelet.cc
Desmis a578423378
Abstract Profile - Contrast enhancement -- Selective Editing Cam16 and JzCzHz - improvments (#7111) 
* Init levels trc GUI

* Levels TRC

* Complete with gamma based attenuation

* Limit RGB channel Slope with checkbox

* Improve GUI and code channel TRC

* Change default values - compexity levels RGB channels

* Relative gamma mode RGB channel TRC

* Change label and ponderation rolloff

* Change rolloff level

* Threshold attenuation

* Threshold attenuation 2 part

* GUI Link R G B

* Linked RGB with Green slope - RGB channels

* Set Freeman TM functions with ImProcFunctions

* First GUI Abstract profile highlight attenuation

* GUI AP part 2

* Restore olg GUI AP

* Expander AP primaries adn illuminant

* Disable RGB channel TRC

* Expander contrast AP

* Slider attenuation response

* Save work GUI local contrast

* Save GUI part 2 AP curve

* Local contrast GUI Abstract Profile

* Move Abstract profile in toolpanel and ICMpanel

* rtengine variable contrast

* Variable contrast 2

* Variable contrast engine 3

* Variable contrast engine 4

* Variable contrast engine

* Detail levels pyramid

* Engine residual contrast

* Residual contrast

* Change settings detail levels

* Expander refinement - new tooltips - low resid contrast

* Change contrast profile and labels

* Remove warning message GUI Gtk

* Gamutcontrol code - disabled

* Improve with calceffect

* Other improvement variable contrast

* Offset variable contrast

* Range offset - comment code

* Parametric inva fot lut

* Clean cmakelist.txt

* Change contrast profiles

* Comment code ipwavelet

* Added orthogonal Daubechies scaling D20

* Change strenght curve - tooltip Daubechies

* Forgotten changes

* Comment code

* Move variable in process - take into account highlight attenuation

* Display label maximum preview and preset selection

* Remove console message

* harmonize levels wavelets iplocallab

* Tooltips contrast enhancement

* Change tooltip Contrast profile

* Chnage tooltip Contrast

* Message warning preview size

* Change gamma TRC values in GUI

* Remove itanium architecture support for windows as PR 7105

* Change windows.yml and appimage.yml

* Windows.yml apseimprov

* Clean and comment ipwavelet

* Clean comment icmpanel.cc

* Harmonize local contrast wavelet Selective editing with Abstract profile

* Harmonize with AP - offset

* vanishing moment D20 - Selective editing wavelet

* Offset only in advanced mode

* GUI expander contrast enable and pyrwavtrc

* Clean and comment code

* merge with dev

* Prepare sigmoid based

* Contrast sigmoid GUI

* Skew sigmoid GUI

* Sigmoid tone mapper in iplocallab

* Change GUI settings

* White-point and black-point auto

* Change EvDCP to ALLNORAW as others events DCP

* Change default skew

* Change settings - enable scale Yb

* Display white point - advanced mode

* Improve GUI

* Clean unused variable

* new sigmoid Q in cam16

* Change tooltips and default sigmoid Q settings

* Sigmoid Jz

* Clean code Jz and sigmoid

* Harmonize Sigmoid Q and Sigmoid RGB

* Harmonize Sigmoid Jz

* Clean code

* Improve labels wit cd/m2

* Slope base Q methode first

* GUI slope based Q

* Change default settings and tooltips

* Change tooltips

* Clean code - change default setting

* Change default local contrast & wavelet to wavelet & basic mode

* Fixed bad assignation slopesmoq

* Improve sigmoid and slope based Q - GUI for Log encoding Color appearance

* Remove wrong change

* various small improvments

* Allows black and white AP and SDA in basic mode

* Change  the writing of wGamma and wSlope - attenuates the effect of the first 2 AP contrast profiles

* Clean code wgamma wslope

* Set curve Cam16 in basic mode

* Change position curve in GUI cam16

* Enable tonecurve1 in colorappearance & lighting in standard mode

* Fixed bug scale yb scene - ciecam curve - change default contrast enhancement

* not reset curve shape ciecam in strandard

* Change label Tone mapping operators and tooltips

* Change some labels and tooltips - Appearance - Mask and Mofifications - Recovery Based On Luminance Mask

* Forgotten changes

* Clean locallabtools2.cc

* Maxlevel wavelet minimum to 5

* Reset mask and modifications in SE wavelet and all tools in Global

* Show modified areas SE wavelet

* Tooltip show wavelets decomposition

* Fixed another bad behavior in Global - changes also in color & light for merge file

* Change behavior fullimage - global as in PR GHS

* Disable all mask and modifications in Global but remain active in fullimage and normal

* Set expander expanded = true

* Chane contrast enhancement coef

* Replace VBox trcWavVBox by ToolParamBlock trcWavFBox

* Forgotten code in icmpanel read pedited opacityShapeWLI - hope solve batch mode

* Change RGB Slope behavior with link

* No access to last level contrast enhancement

* Move Abstract Profile tooltip to title

The tooltip was popping up when the cursor was over almost any part of
the tool which was inconvenient. Now, the tooltip only appears when
hovering over the title.

* Improve Color Management expanders behavior

By default, collapse Abstract Profile and leave it's sub-expanders
expanded.

Keep the expanded state of all the sub-expanders during the editing
session.

Fix the right-click behavior. The clicked expander should be expanded
and all siblings, if any, should be collapsed.

* Fix RGB slope tone mapping RGB linkage

Synchronize the red, green, and blue values before updating the preview
to avoid using incorrect values to generate the preview.

* Fix SE CAM tone mapping slider defocus

Avoid unnecessarily hiding then showing the adjusters in tone mapping so
that focus is not lost while adjusting the adjusters.

* Delete history kslopesmo - remove IcmOpacityCurveWL

* change the tooltips as suggested by Lawrence

* Review L37 - change strengthjz strengthlc - MIDDLE_GREY MIDDLE_GREYjz - artifacts ciecam

* Change name Tone map freeman functions

* Remove gamutcont - rename localcont - change allocation memory wdspot

* Clean procparams

* remove sigmoidsenscie - logcieq

* Added * to three labels 'sigmoid' - change tooltip which shows the incompatibility with 5.11

* Forgotten correction suggested by Lawrence

* Compatibility 5.11 log encoding - sigmoid part 1

* Compatibility 5.11 part 2

* Compatibility 5.11 - step 3

* Compatibility 5.11 - step 4

* Compatibility 5.11 step xx

* Compatibility 5.11 - combobox operators Q and J

* Compatibility 5.11 Cam16 GUI first part

* Improve GUI Cam16 sigmoid compatibility

* Compatibility 5.11 Jz - sigmoid - step 1

* Compatibility 5.11 Jz gui step 2

* Compatibility 5.11 Jz GUI step x

* Compatibility 5.11 Jz - history - etc.

* Various change labels - history ...

* Improve GUI - hide show 5.11 5.12

* Jz 5.11 in iplocallab - step 1

* Compatibility 5.11 iplocallab cam16 step 1

* Improve GUI hide show 511 512

* Solved - I hope - GUI problem with tone mapper Q and J 5.11 and 5.12

* Compatibility 5.11 iplocallab Cam16 step 2

* Improve GUI compatibility 5.11 labels tooltips

* Small improvments GUI - labels - history...

* Fixed typo in paramsedited.cc clcurve issue 7283

* Change tooltips method 5.12 - 5.11 for cam16 and Jz  brightness Q or J

* Clean and refine code

* Various change dafult language  and CAM16 CAM02 replace by Cam16 Cam02

* Change modeQJ method for 5.11 in function ppversion

* Change labels as suggested by Wayne PR 7111

* Others changes suggested for label

* Change tooltips as suggested in PR

* Use unique pointer instead of manual management

* Update rtdata/languages/default

Co-authored-by: Lawrence37 <45837045+Lawrence37@users.noreply.github.com>

* Change all Cam16 references to CAM16

* Change convention uppercase and lowercase in frame - checkbox

* Improve tooltips for Tone Mapping Operators

* Another change CIECAM and uppercase lowercase in checkbox

* Remove appimage and windows yml

---------

Co-authored-by: Lawrence Lee <45837045+Lawrence37@users.noreply.github.com>
2025-01-19 07:52:32 +01:00

4509 lines
183 KiB
C++
Raw Blame History

/*
* This file is part of RawTherapee.
*
* 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 <https://www.gnu.org/licenses/>.
*
* 2014 - 2020 Jacques Desmis <jdesmis@gmail.com>
*/
#include "wavelet.h"
#include <cmath>
#include "curveeditor.h"
#include "curveeditorgroup.h"
#include "editcallbacks.h"
#include "guiutils.h"
#include "rtimage.h"
#include "options.h"
#include "eventmapper.h"
#include "labgrid.h"
#include "rtengine/color.h"
#include <unistd.h>
using namespace rtengine;
using namespace rtengine::procparams;
const Glib::ustring Wavelet::TOOL_NAME = "wavelet";
namespace
{
GradientMilestone makeHsvGm(double position, float h, float s, float v)
{
float r;
float g;
float b;
Color::hsv2rgb01(h, s, v, r, g, b);
return GradientMilestone(position, r, g, b);
}
std::vector<GradientMilestone> makeWholeHueRange()
{
std::vector<GradientMilestone> res;
res.reserve(7);
for (int i = 0; i < 7; ++i) {
const float x = static_cast<float>(i) / 6.0f;
res.push_back(makeHsvGm(x, x, 0.5f, 0.5f));
}
return res;
}
}
Wavelet::Wavelet() :
FoldableToolPanel(this, TOOL_NAME, M("TP_WAVELET_LABEL"), true, true),
curveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_CONTEDIT"))),
//curveEditorC(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_CONTRASTEDIT"))),
CCWcurveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_CCURVE"))),
curveEditorbl(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_BLCURVE"))),
curveEditorRES(new CurveEditorGroup(options.lastWaveletCurvesDir)),
curveEditorGAM(new CurveEditorGroup(options.lastWaveletCurvesDir)),
separatorNeutral(Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL))),
separatoredge(Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL))),
opaCurveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_COLORT"))),
opacityCurveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_OPACITY"))),
CurveEditorwavnoise(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_DENOISE"))),
CurveEditorwavnoiseh(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_DENOISEH"))),
CurveEditorwavguid(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_DENOISEGUID"))),
CurveEditorwavhue(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_DENOISEHUE"))),
opacityCurveEditorW(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_OPACITYW"))),
opacityCurveEditorWL(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_OPACITYWL"))),
median(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_MEDI")))),
medianlev(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_MEDILEV")))),
linkedg(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_LINKEDG")))),
cbenab(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_CBENAB")))),
lipst(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_LIPST")))),
avoid(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_AVOID")))),
tmr(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_BALCHRO")))),
showmask(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_SHOWMASK")))),
oldsh(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_OLDSH")))),
neutralchButton(Gtk::manage(new Gtk::Button(M("TP_WAVELET_NEUTRAL")))),
sigma(Gtk::manage(new Adjuster(M("TP_WAVELET_SIGMA"), 0.05, 2.5, 0.01, 1.))),
offset(Gtk::manage(new Adjuster(M("TP_WAVELET_WAVOFFSET"), 0.33, 1.66, 0.01, 1., Gtk::manage(new RTImage("circle-black-small")), Gtk::manage(new RTImage("circle-white-small"))))),
lowthr(Gtk::manage(new Adjuster(M("TP_WAVELET_WAVLOWTHR"), 20., 100., 0.5, 40.))),
rescon(Gtk::manage(new Adjuster(M("TP_WAVELET_RESCON"), -100, 100, 1, 0))),
resconH(Gtk::manage(new Adjuster(M("TP_WAVELET_RESCONH"), 0, 100, 1, 0))),
reschro(Gtk::manage(new Adjuster(M("TP_WAVELET_RESCHRO"), -100, 100, 1, 0))),
resblur(Gtk::manage(new Adjuster(M("TP_WAVELET_RESBLUR"), 0, 100, 1, 0))),
resblurc(Gtk::manage(new Adjuster(M("TP_WAVELET_RESBLURC"), 0, 100, 1, 0))),
bluwav(Gtk::manage(new Adjuster(M("TP_WAVELET_BLUWAV"), 0.05, 2.5, 0.5, 1.))),
tmrs(Gtk::manage(new Adjuster(M("TP_WAVELET_TMSTRENGTH"), -1.0, 2.0, 0.01, 0.0))),
edgs(Gtk::manage(new Adjuster(M("TP_WAVELET_TMEDGS"), 0.1, 4.0, 0.01, 1.4))),
scale(Gtk::manage(new Adjuster(M("TP_WAVELET_TMSCALE"), 0.1, 10.0, 0.01, 1.0))),
gamma(Gtk::manage(new Adjuster(M("TP_WAVELET_COMPGAMMA"), 0.4, 2.0, 0.01, 1.0))),
sup(Gtk::manage(new Adjuster(M("TP_WAVELET_SUPE"), -100, 350, 1, 0))),
sky(Gtk::manage(new Adjuster(M("TP_WAVELET_SKY"), -100., 100.0, 1., 0.))),
thres(Gtk::manage(new Adjuster(M("TP_WAVELET_LEVELS"), 5, 9, 1, 7))),//3
chroma(Gtk::manage(new Adjuster(M("TP_WAVELET_CHRO"), 1, 9, 1, 5))),
chro(Gtk::manage(new Adjuster(M("TP_WAVELET_CHR"), 0., 100., 1., 0.))),
contrast(Gtk::manage(new Adjuster(M("TP_WAVELET_CONTRA"), -100, 100, 1, 0))),
thr(Gtk::manage(new Adjuster(M("TP_WAVELET_THR"), 0, 100, 1, 30))),
thrH(Gtk::manage(new Adjuster(M("TP_WAVELET_THRH"), 0, 100, 1, 70))),
radius(Gtk::manage(new Adjuster(M("TP_WAVELET_RADIUS"), 0, 100, 1, 40))),
skinprotect(Gtk::manage(new Adjuster(M("TP_WAVELET_SKIN"), -100, 100, 1, 0.))),
edgrad(Gtk::manage(new Adjuster(M("TP_WAVELET_EDRAD"), 0, 100, 1, 15))),
edgeffect(Gtk::manage(new Adjuster(M("TP_WAVELET_EDEFFECT"), 0.05, 2.5, 0.01, 1.))),
edgval(Gtk::manage(new Adjuster(M("TP_WAVELET_EDVAL"), 0, 100, 1, 0))),
edgthresh(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGTHRESH"), -50, 100, 1, 10))),
strength(Gtk::manage(new Adjuster(M("TP_WAVELET_STRENGTH"), 0, 100, 1, 100))),
balance(Gtk::manage(new Adjuster(M("TP_WAVELET_BALANCE"), -30, 100, 1, 0))),
iter(Gtk::manage(new Adjuster(M("TP_WAVELET_ITER"), -3, 3, 1, 0))),
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.))),
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))),
bllev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LOWLIGHT"), 0., 100., 0., 2., 50., 25., 0, false))),
pastlev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_PASTEL"), 0., 70., 0., 2., 30., 20., 0, false))),
satlev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_SAT"), 0., 130., 30., 45., 130., 100., 0, false))),
edgcont(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_EDGCONT"), 0., 100., 0, 10, 75, 40, 0., false))),
level0noise(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LEVZERO"), -30., 100., 0., M("TP_WAVELET_STREN"), 1., 0., 100., 0., M("TP_WAVELET_NOIS"), 1., nullptr, false))),
level1noise(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LEVONE"), -30., 100., 0., M("TP_WAVELET_STREN"), 1., 0., 100., 0., M("TP_WAVELET_NOIS"), 1., nullptr, false))),
level2noise(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LEVTWO"), -30., 100., 0., M("TP_WAVELET_STREN"), 1., 0., 100., 0., M("TP_WAVELET_NOIS"), 1., nullptr, false))),
level3noise(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LEVTHRE"), -30., 100., 0., M("TP_WAVELET_STREN"), 1., 0., 100., 0., M("TP_WAVELET_NOIS"), 1., nullptr, false))),
leveldenoise(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LEVFOUR"), 0., 100., 0., M("TP_WAVELET_DEN5THR"), 1, 0., 100., 0., M("TP_WAVELET_NOIS"), 1., nullptr, false))),
levelsigm(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LEVELSIGM"), 0.05, 3., 1., M("TP_WAVELET_LEVELHIGH"), 1, 0.05, 3., 1., M("TP_WAVELET_LEVELLOW"), 1., nullptr, false))),
sigm(Gtk::manage(new Adjuster(M("TP_WAVELET_SIGM"), 0.05, 3.5, 0.01, 1.))),
levden(Gtk::manage(new Adjuster(M("TP_WAVELET_LEVDEN"), 0., 100., 0.5, 0.))),
thrden(Gtk::manage(new Adjuster(M("TP_WAVELET_DENLH"), 0., 100., 0.5, 0.))),
limden(Gtk::manage(new Adjuster(M("TP_WAVELET_LIMDEN"), 0., 1., 0.01, 0.))),
threshold(Gtk::manage(new Adjuster(M("TP_WAVELET_THRESHOLD"), 1, 9, 1, 4))),
// threshold2(Gtk::manage(new Adjuster(M("TP_WAVELET_THRESHOLD2"), 1, 9, 1, 4))),
threshold2(Gtk::manage(new Adjuster(M("TP_WAVELET_THRESHOLD2"), 3, 9, 1, 5))),
edgedetect(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEDETECT"), 0, 100, 1, 90))),
edgedetectthr(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEDETECTTHR"), 0, 100, 1, 20))),
edgedetectthr2(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEDETECTTHR2"), -10, 100, 1, 0))),
edgesensi(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGESENSI"), 0, 100, 1, 60))),
edgeampli(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEAMPLI"), 0, 100, 1, 10))),
ballum(Gtk::manage(new Adjuster(M("TP_WAVELET_BALLUM"), -2., 10., 0.5, 7., Gtk::manage(new RTImage("circle-white-small")), Gtk::manage(new RTImage("circle-black-small"))))),
balchrom(Gtk::manage(new Adjuster(M("TP_WAVELET_BALCHROM"), -100., 100., 1., 0., Gtk::manage(new RTImage("circle-blue-yellow-small")), Gtk::manage(new RTImage("circle-red-green-small"))))),
chromfi(Gtk::manage(new Adjuster(M("TP_WAVELET_CHROMFI"), 0.0, 150., 0.01, 0.))),
chromco(Gtk::manage(new Adjuster(M("TP_WAVELET_CHROMCO"), 0, 100., 0.01, 0.))),
mergeL(Gtk::manage(new Adjuster(M("TP_WAVELET_MERGEL"), -50, 100, 1, 20))),
mergeC(Gtk::manage(new Adjuster(M("TP_WAVELET_MERGEC"), -50, 100, 1, 20))),
softrad(Gtk::manage(new Adjuster(M("TP_WAVELET_SOFTRAD"), 0.0, 100., 0.5, 0.))),
softradend(Gtk::manage(new Adjuster(M("TP_WAVELET_SOFTRAD"), 0.0, 1000., 1., 0.))),
strend(Gtk::manage(new Adjuster(M("TP_WAVELET_STREND"), 0.0, 100., 1.0, 50.))),
detend(Gtk::manage(new Adjuster(M("TP_WAVELET_DETEND"), -10, 10, 1, 0))),
thrend(Gtk::manage(new Adjuster(M("TP_WAVELET_THREND"), 0.0, 100., 0.5, 0.))),
chrwav(Gtk::manage(new Adjuster(M("TP_WAVELET_CHRWAV"), 0., 100., 0.5, 0.))),
Lmethod(Gtk::manage(new MyComboBoxText())),
CHmethod(Gtk::manage(new MyComboBoxText())),
CHSLmethod(Gtk::manage(new MyComboBoxText())),
EDmethod(Gtk::manage(new MyComboBoxText())),
BAmethod(Gtk::manage(new MyComboBoxText())),
NPmethod(Gtk::manage(new MyComboBoxText())),
TMmethod(Gtk::manage(new MyComboBoxText())),
HSmethod(Gtk::manage(new MyComboBoxText())),
CLmethod(Gtk::manage(new MyComboBoxText())),
Backmethod(Gtk::manage(new MyComboBoxText())),
complexmethod(Gtk::manage(new MyComboBoxText())),
Tilesmethod(Gtk::manage(new MyComboBoxText())),
daubcoeffmethod(Gtk::manage(new MyComboBoxText())),
Dirmethod(Gtk::manage(new MyComboBoxText())),
Medgreinf(Gtk::manage(new MyComboBoxText())),
ushamethod(Gtk::manage(new MyComboBoxText())),
//denmethod(Gtk::manage(new MyComboBoxText())),
mixmethod(Gtk::manage(new MyComboBoxText())),
quamethod(Gtk::manage(new MyComboBoxText())),
slimethod(Gtk::manage(new MyComboBoxText())),
chanMixerHLFrame(Gtk::manage(new Gtk::Frame(M("TP_COLORTONING_HIGHLIGHT")))),
chanMixerMidFrame(Gtk::manage(new Gtk::Frame(M("TP_COLORTONING_MIDTONES")))),
chanMixerShadowsFrame(Gtk::manage(new Gtk::Frame(M("TP_COLORTONING_SHADOWS")))),
shFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_SHFRAME")))),
contFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_CONTFRAME")))),
blurFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_BLURFRAME")))),
chromaFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_CHROMAFRAME")))),
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")))),
guidFrame(Gtk::manage(new Gtk::Frame(M("TP_WAVELET_GUIDFRAME")))),
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") + ":"))),
usharpLabel(Gtk::manage(new Gtk::Label(M("TP_WAVELET_USHARP") + ":"))),
expchroma(Gtk::manage(new MyExpander(true, M("TP_WAVELET_LEVCH")))),
expcontrast(Gtk::manage(new MyExpander(true, M("TP_WAVELET_LEVF")))),
expedge(Gtk::manage(new MyExpander(true, M("TP_WAVELET_EDGE")))),
expfinal(Gtk::manage(new MyExpander(true, M("TP_WAVELET_FINAL")))),
expgamut(Gtk::manage(new MyExpander(false, M("TP_WAVELET_CONTR")))),
expnoise(Gtk::manage(new MyExpander(true, M("TP_WAVELET_NOISE")))),
expresid(Gtk::manage(new MyExpander(true, M("TP_WAVELET_RESID")))),
expsettings(Gtk::manage(new MyExpander(false, M("TP_WAVELET_SETTINGS")))),
exptoning(Gtk::manage(new MyExpander(true, M("TP_WAVELET_TON")))),
expclari(Gtk::manage(new MyExpander(true, M("TP_WAVELET_CLARI")))),
expbl(Gtk::manage(new MyExpander(true, M("TP_WAVELET_BL")))),
neutrHBox(Gtk::manage(new Gtk::Box())),
usharpHBox(Gtk::manage(new Gtk::Box())),
ctboxch(Gtk::manage(new Gtk::Box())),
quaHBox(Gtk::manage(new Gtk::Box())),
sliHBox(Gtk::manage(new Gtk::Box())),
//denHBox(Gtk::manage(new Gtk::Box())),
mixHBox(Gtk::manage(new Gtk::Box())),
ctboxBA(Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL)))
{
CurveListener::setMulti(true);
auto m = ProcEventMapper::getInstance();
EvWavenaclari = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVCLARI");
EvWavushamet = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVUSHAMET");
EvWavballum = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVBALLUM");
EvWavbalchrom = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVBALCHROM");
EvWavchromfi = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVCHROMFI");
EvWavchromco = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVCHROMCO");
EvWavmergeL = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVMERGEL");
EvWavmergeC = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVMERGEC");
EvWavsoftrad = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSOFTRAD");
EvWavsoftradend = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSOFTRADEND");
EvWavshowmask = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSHOWMASK");
EvWavedgs = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVEDGS");
EvWavscale = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSCALE");
EvWavradius = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVRADIUS");
EvWavsigma = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSIGMA");
EvWavenabl = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVBL");
EvWavchrwav = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVCHR");
EvWavoldsh = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVOLDSH");
EvWavoffset = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVOFFSET");
EvWavlowthr = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVLOWTHR");
EvWavbluwav = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_BLUWAV");
EvWavblshape = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_BLSHAPE");
EvWavresblur = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_BLURWAV");
EvWavresblurc = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_BLURCWAV");
EvWavedgeffect = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_EDGEFFECT");
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");
EvWavLabGridValue = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVLABGRID_VALUE");
EvWavrangeab = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_RANGEAB");
EvWavprotab = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_PROTAB");
//EvWavlevelshc = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_LEVELSHC");
EvWavcomplexmet = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_COMPLEX");
EvWavsigm = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSIGM");
EvWavdenoise = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVDENOISE");
//EvWavdenmethod = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVDENMET");
EvWavmixmethod = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVMIXMET");
EvWavquamethod = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVQUAMET");
EvWavlevden = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVLEVDEN");
EvWavdenoiseh = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVDENOISEH");
EvWavstrend = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSTREND");
EvWavdetend = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVDETEND");
EvWavlevdenois = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVDENLH");
EvWavslimethod = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVSLIMET");
EvWavthrend = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVTHREND");
EvWavguid = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVGUIDH");
EvWavhue = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVHUE");
EvWavthrden = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVTHRDEN");
EvWavlevelsigm = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVLEVELSIGM");
EvWavlimden = m->newEvent(DIRPYREQUALIZER, "HISTORY_MSG_WAVLIMDEN");
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));
expcontrast->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expcontrast));
enableContrastConn = expcontrast->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expcontrast));
expchroma->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expchroma));
enableChromaConn = expchroma->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expchroma));
exptoning->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), exptoning));
enableToningConn = exptoning->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), exptoning));
expnoise->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expnoise));
enableNoiseConn = expnoise->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expnoise));
expedge->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expedge));
enableEdgeConn = expedge->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expedge));
expbl->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expbl));
enabletmConn = expbl->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expbl));
expgamut->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expgamut));
expresid->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expresid));
enableResidConn = expresid->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expresid));
expfinal->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expfinal));
enableFinalConn = expfinal->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expfinal));
expclari->signal_button_release_event().connect_notify(sigc::bind(sigc::mem_fun(this, &Wavelet::foldAllButMe), expclari));
enableclariConn = expclari->signal_enabled_toggled().connect(sigc::bind(sigc::mem_fun(this, &Wavelet::enableToggled), expclari));
// Wavelet Settings
ToolParamBlock* const settingsBox = Gtk::manage(new ToolParamBlock());
strength->setAdjusterListener(this);
thres->set_tooltip_text(M("TP_WAVELET_LEVELS_TOOLTIP"));
thres->setAdjusterListener(this);
complexmethod->append(M("TP_WAVELET_COMPNORMAL"));
complexmethod->append(M("TP_WAVELET_COMPEXPERT"));
complexmethodconn = complexmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::complexmethodChanged));
complexmethod->set_tooltip_text(M("TP_WAVELET_COMPLEX_TOOLTIP"));
Gtk::Box* const complexHBox = Gtk::manage(new Gtk::Box());
Gtk::Label* const complexLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_COMPLEXLAB") + ":"));
complexHBox->pack_start(*complexLabel, Gtk::PACK_SHRINK, 4);
complexHBox->pack_start(*complexmethod);
Tilesmethod->append(M("TP_WAVELET_TILESFULL"));
Tilesmethod->append(M("TP_WAVELET_TILESBIG"));
// Tilesmethod->append(M("TP_WAVELET_TILESLIT"));
Tilesmethodconn = Tilesmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::TilesmethodChanged));
Tilesmethod->set_tooltip_text(M("TP_WAVELET_TILES_TOOLTIP"));
Gtk::Box* const tilesizeHBox = Gtk::manage(new Gtk::Box());
Gtk::Label* const tilesizeLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_TILESIZE") + ":"));
tilesizeHBox->pack_start(*tilesizeLabel, Gtk::PACK_SHRINK, 4);
tilesizeHBox->pack_start(*Tilesmethod);
daubcoeffmethod->set_sensitive(true);
daubcoeffmethod->append(M("TP_WAVELET_DAUB2"));
daubcoeffmethod->append(M("TP_WAVELET_DAUB4"));
daubcoeffmethod->append(M("TP_WAVELET_DAUB6"));
daubcoeffmethod->append(M("TP_WAVELET_DAUB10"));
daubcoeffmethod->append(M("TP_WAVELET_DAUB14"));
daubcoeffmethod->append(M("TP_WAVELET_DAUB20"));
daubcoeffmethodconn = daubcoeffmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::daubcoeffmethodChanged));
daubcoeffmethod->set_tooltip_text(M("TP_WAVELET_DAUB_TOOLTIP"));
Gtk::Label* const daubcoeffLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_DAUB") + ":"));
Gtk::Box* const daubcoeffHBox = Gtk::manage(new Gtk::Box());
daubcoeffHBox->pack_start(*daubcoeffLabel, Gtk::PACK_SHRINK, 4);
daubcoeffHBox->pack_start(*daubcoeffmethod);
Backmethod->append(M("TP_WAVELET_B0"));
Backmethod->append(M("TP_WAVELET_B1"));
Backmethod->append(M("TP_WAVELET_B2"));
Backmethodconn = Backmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::BackmethodChanged));
Gtk::Box* const backgroundHBox = Gtk::manage(new Gtk::Box());
Gtk::Label* const backgroundLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_BACKGROUND") + ":"));
backgroundHBox->pack_start(*backgroundLabel, Gtk::PACK_SHRINK, 4);
backgroundHBox->pack_start(*Backmethod);
CLmethod->append(M("TP_WAVELET_LEVDIR_ONE"));
CLmethod->append(M("TP_WAVELET_LEVDIR_INF"));
CLmethod->append(M("TP_WAVELET_LEVDIR_SUP"));
CLmethod->append(M("TP_WAVELET_LEVDIR_ALL"));
CLmethodconn = CLmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::CLmethodChanged));
Gtk::Box* const levdirMainHBox = Gtk::manage(new Gtk::Box());
Gtk::Label* const levdirMainLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_PROC") + ":"));
levdirMainHBox->pack_start(*levdirMainLabel, Gtk::PACK_SHRINK, 4);
levdirMainHBox->pack_start(*CLmethod); //same
Lmethod->set_sensitive(false);
Lmethod->append(M("TP_WAVELET_1"));
Lmethod->append(M("TP_WAVELET_2"));
Lmethod->append(M("TP_WAVELET_3"));
Lmethod->append(M("TP_WAVELET_4"));
Lmethod->append(M("TP_WAVELET_5"));
Lmethod->append(M("TP_WAVELET_6"));
Lmethod->append(M("TP_WAVELET_7"));
Lmethod->append(M("TP_WAVELET_8"));
Lmethod->append(M("TP_WAVELET_9"));
Lmethod->append(M("TP_WAVELET_SUPE"));
Lmethod->append(M("TP_WAVELET_RESID"));
Lmethod->set_active(0);
Dirmethod->set_sensitive(false);
Dirmethod->append(M("TP_WAVELET_DONE"));
Dirmethod->append(M("TP_WAVELET_DTWO"));
Dirmethod->append(M("TP_WAVELET_DTHR"));
Dirmethod->append(M("TP_WAVELET_DALL"));
Lmethodconn = Lmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::LmethodChanged));
Dirmethodconn = Dirmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::DirmethodChanged));
Gtk::Box* const levdirSubHBox = Gtk::manage(new Gtk::Box());
levdirSubHBox->pack_start(*Lmethod);
levdirSubHBox->pack_start(*Dirmethod, Gtk::PACK_EXPAND_WIDGET, 2); // same, but 2 not 4?
settingsBox->pack_start(*complexHBox);
settingsBox->pack_start(*strength);
settingsBox->pack_start(*thres);
settingsBox->pack_start(*tilesizeHBox);
settingsBox->pack_start(*daubcoeffHBox);
settingsBox->pack_start(*backgroundHBox);
settingsBox->pack_start(*levdirMainHBox);
settingsBox->pack_start(*levdirSubHBox);
// Contrast
ToolParamBlock* const levBox = Gtk::manage(new ToolParamBlock());
Gtk::Box* const buttonBox = Gtk::manage(new Gtk::Box());
buttonBox->set_spacing(10);
buttonBox->set_homogeneous(true);
levBox->pack_start(*buttonBox, Gtk::PACK_SHRINK, 2);
Gtk::Button* const contrastMinusButton = Gtk::manage(new Gtk::Button(M("TP_WAVELET_CONTRAST_MINUS")));
buttonBox->pack_start(*contrastMinusButton);
contrastMinusPressedConn = contrastMinusButton->signal_pressed().connect(sigc::mem_fun(*this, &Wavelet::contrastMinusPressed));
Gtk::Button* const neutralButton = Gtk::manage(new Gtk::Button(M("TP_WAVELET_NEUTRAL")));
buttonBox->pack_start(*neutralButton);
neutralPressedConn = neutralButton->signal_pressed().connect(sigc::mem_fun(*this, &Wavelet::neutralPressed));
Gtk::Button* const contrastPlusButton = Gtk::manage(new Gtk::Button(M("TP_WAVELET_CONTRAST_PLUS")));
buttonBox->pack_start(*contrastPlusButton);
contrastPlusPressedConn = contrastPlusButton->signal_pressed().connect(sigc::mem_fun(*this, &Wavelet::contrastPlusPressed));
buttonBox->show_all_children();
for (int i = 0; i < 9; i++) {
Glib::ustring ss;
switch (i) {
case 0:
ss = Glib::ustring::compose("%1 (%2)", (i + 1), M("TP_WAVELET_FINEST"));
break;
case 8:
ss = Glib::ustring::compose("%1 (%2)", (i + 1), M("TP_WAVELET_LARGEST"));
break;
default:
ss = Glib::ustring::compose("%1", (i + 1));
}
correction[i] = Gtk::manage(new Adjuster(std::move(ss), -100, 350, 1, 0));
correction[i]->setAdjusterListener(this);
levBox->pack_start(*correction[i]);
}
levBox->pack_start(*sup);
sup->setAdjusterListener(this);
Gtk::Separator* const separatorcont = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
levBox->pack_start(*separatorcont);
sigma->setAdjusterListener(this);
levBox->pack_start(*sigma, Gtk::PACK_SHRINK);
offset->setAdjusterListener(this);
levBox->pack_start(*offset, Gtk::PACK_SHRINK);
sigma->set_tooltip_text(M("TP_WAVELET_SIGMA_TOOLTIP"));
offset->set_tooltip_text(M("TP_WAVELET_OFFSET_TOOLTIP"));
lowthr->setAdjusterListener(this);
lowthr->set_tooltip_text(M("TP_WAVELET_LOWTHR_TOOLTIP"));
levBox->pack_start(*lowthr, Gtk::PACK_SHRINK);
wavLabels->show();
levBox->pack_start(*wavLabels);
Gtk::Box* const contrastSHVBox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
contrastSHVBox->set_spacing(2);
HSmethod->append(M("TP_WAVELET_HS1"));
HSmethod->append(M("TP_WAVELET_HS2"));
HSmethodconn = HSmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::HSmethodChanged));
const std::vector<GradientMilestone> milestones2 = {
GradientMilestone(0.0, 0.0, 0.0, 0.0),
GradientMilestone(1.0, 1.0, 1.0, 1.0)
};
hllev->setAdjusterListener(this);
hllev->setBgGradient(milestones2);
threshold->setAdjusterListener(this);
threshold->set_tooltip_text(M("TP_WAVELET_THRESHOLD_TOOLTIP"));
bllev->setAdjusterListener(this);
bllev->setBgGradient(milestones2);
threshold2->setAdjusterListener(this);
threshold2->set_tooltip_text(M("TP_WAVELET_THRESHOLD2_TOOLTIP"));
const WaveletParams default_params;
//curveEditorC->setCurveListener(this);
//curveEditorC->set_tooltip_text(M("TP_WAVELET_FINCOAR_TOOLTIP"));
//opacityShapeSH = static_cast<FlatCurveEditor*>(curveEditorC->addCurve(CT_Flat, "", nullptr, false, false));
//opacityShapeSH->setIdentityValue(0.);
//opacityShapeSH->setResetCurve(FlatCurveType(default_params.opacityCurveSH.at(0)), default_params.opacityCurveSH);
//curveEditorC->curveListComplete();
//curveEditorC->show();
contrastSHVBox->pack_start(*HSmethod);
contrastSHVBox->pack_start(*hllev);
contrastSHVBox->pack_start(*threshold);
contrastSHVBox->pack_start(*bllev);
contrastSHVBox->pack_start(*threshold2);
// contrastSHVBox->pack_start(*curveEditorC);
Gtk::Frame* const contrastSHFrame = Gtk::manage(new Gtk::Frame(M("TP_WAVELET_APPLYTO")));
contrastSHFrame->add(*contrastSHVBox);
levBox->pack_start(*contrastSHFrame);
// Chromaticity
ToolParamBlock* const chBox = Gtk::manage(new ToolParamBlock());
Gtk::Label* const labmch = Gtk::manage(new Gtk::Label(M("TP_WAVELET_CHTYPE") + ":"));
// Gtk::Box* const ctboxch = Gtk::manage(new Gtk::Box());
ctboxch->pack_start(*labmch, Gtk::PACK_SHRINK, 1);
CHmethod->append(M("TP_WAVELET_CH1"));
CHmethod->append(M("TP_WAVELET_CH2"));
CHmethod->append(M("TP_WAVELET_CH3"));
CHmethodconn = CHmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::CHmethodChanged));
ctboxch->pack_start(*CHmethod);
chBox->pack_start(*ctboxch);
Gtk::Box* const ctboxCH = Gtk::manage(new Gtk::Box());
ctboxCH->pack_start(*labmC, Gtk::PACK_SHRINK, 1);
CHSLmethod->append(M("TP_WAVELET_CHSL"));
CHSLmethod->append(M("TP_WAVELET_CHCU"));
CHSLmethodconn = CHSLmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::CHSLmethodChanged));
ctboxCH->pack_start(*CHSLmethod);
Gtk::Separator* const separatorChromaMethod = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
chBox->pack_start(*separatorChromaMethod, Gtk::PACK_SHRINK, 2);
chroma->set_tooltip_text(M("TP_WAVELET_CHRO_TOOLTIP"));
chBox->pack_start(*chroma);
chroma->setAdjusterListener(this);
satlev->setAdjusterListener(this);
satlev->setBgGradient(milestones2);
pastlev->setAdjusterListener(this);
pastlev->setBgGradient(milestones2);
chBox->pack_start(*pastlev);
chBox->pack_start(*satlev);
chro->set_tooltip_text(M("TP_WAVELET_CHR_TOOLTIP"));
chro->setAdjusterListener(this);
sigmacol->setAdjusterListener(this);
chBox->pack_start(*chro);
chBox->pack_start(*sigmacol);
Gtk::Box* const buttonchBox = Gtk::manage(new Gtk::Box());
buttonchBox->set_spacing(10);
buttonchBox->set_homogeneous(true);
neutralchPressedConn = neutralchButton->signal_pressed().connect(sigc::mem_fun(*this, &Wavelet::neutralchPressed));
chBox->pack_start(*separatorNeutral, Gtk::PACK_SHRINK, 2);
buttonchBox->pack_start(*neutralchButton);
buttonchBox->show_all_children();
chBox->pack_start(*buttonchBox, Gtk::PACK_SHRINK, 2);
for (int i = 0; i < 9; i++) {
Glib::ustring ss;
switch (i) {
case 0:
ss = Glib::ustring::compose("%1 (%2)", (i + 1), M("TP_WAVELET_FINEST"));
break;
case 8:
ss = Glib::ustring::compose("%1 (%2)", (i + 1), M("TP_WAVELET_LARGEST"));
break;
default:
ss = Glib::ustring::compose("%1", (i + 1));
}
correctionch[i] = Gtk::manage(new Adjuster(std::move(ss), -100, 100, 1, 0));
correctionch[i]->setAdjusterListener(this);
chBox->pack_start(*correctionch[i]);
}
// Toning
ToolParamBlock* const tonBox = Gtk::manage(new ToolParamBlock());
sigmaton->setAdjusterListener(this);
rangeab->setAdjusterListener(this);
protab->setAdjusterListener(this);
opaCurveEditorG->setCurveListener(this);
// const WaveletParams default_params;
opacityShapeRG = static_cast<FlatCurveEditor*>(opaCurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
opacityShapeRG->setIdentityValue(0.);
opacityShapeRG->setResetCurve(FlatCurveType(default_params.opacityCurveRG.at(0)), default_params.opacityCurveRG);
//from green to magenta
std::vector<GradientMilestone> mileston = {
GradientMilestone(0., 0., 1., 0.),
GradientMilestone(1., 1., 0., 1.)
};
opacityShapeRG->setLeftBarBgGradient(mileston);
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);
opacityShapeBY = static_cast<FlatCurveEditor*>(opacityCurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
opacityShapeBY->setIdentityValue(0.);
opacityShapeBY->setResetCurve(FlatCurveType(default_params.opacityCurveBY.at(0)), default_params.opacityCurveBY);
//from blue to yellow
mileston = {
GradientMilestone(0., 0., 0., 1.),
GradientMilestone(1., 1., 1., 0.)
};
opacityShapeBY->setLeftBarBgGradient(mileston);
opacityCurveEditorG->curveListComplete();
opacityCurveEditorG->show();
tonBox->pack_start(*opacityCurveEditorG, Gtk::PACK_SHRINK, 2);
// Denoise and Refine
ToolParamBlock* const noiseBox = Gtk::manage(new ToolParamBlock());
linkedg->set_active(false);
linkedgConn = linkedg->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::linkedgToggled));
noiseBox->pack_start(*linkedg);
level0noise->setAdjusterListener(this);
level0noise->setUpdatePolicy(RTUP_DYNAMIC);
level1noise->setAdjusterListener(this);
level1noise->setUpdatePolicy(RTUP_DYNAMIC);
level2noise->setAdjusterListener(this);
level2noise->setUpdatePolicy(RTUP_DYNAMIC);
level3noise->setAdjusterListener(this);
level3noise->setUpdatePolicy(RTUP_DYNAMIC);
leveldenoise->setAdjusterListener(this);
leveldenoise->setUpdatePolicy(RTUP_DYNAMIC);
levelsigm->setAdjusterListener(this);
levelsigm->setUpdatePolicy(RTUP_DYNAMIC);
ballum->setAdjusterListener(this);
sigm->setAdjusterListener(this);
levden->setAdjusterListener(this);
thrden->setAdjusterListener(this);
limden->setAdjusterListener(this);
CurveEditorwavnoise->setCurveListener(this);
CurveEditorwavnoiseh->setCurveListener(this);
CurveEditorwavguid->setCurveListener(this);
CurveEditorwavhue->setCurveListener(this);
quamethod->append(M("TP_WAVELET_QUACONSER"));
quamethod->append(M("TP_WAVELET_QUAAGRES"));
quamethodconn = quamethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::quamethodChanged));
// quamethod->set_tooltip_text(M("TP_WAVELET_DENQUA_TOOLTIP"));
Gtk::Label* const quaLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_DENQUA") + ":"));
quaHBox->pack_start(*quaLabel, Gtk::PACK_SHRINK, 4);
quaHBox->pack_start(*quamethod);
slimethod->append(M("TP_WAVELET_DENSLI"));
slimethod->append(M("TP_WAVELET_DENCURV"));
slimethodconn = slimethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::slimethodChanged));
// slimethod->set_tooltip_text(M("TP_WAVELET_DENSLI_TOOLTIP"));
Gtk::Label* const sliLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_DENSLILAB") + ":"));
sliHBox->pack_start(*sliLabel, Gtk::PACK_SHRINK, 4);
sliHBox->pack_start(*slimethod);
//denmethod->append(M("TP_WAVELET_DENEQUAL"));
//denmethod->append(M("TP_WAVELET_DEN14PLUS"));
//denmethod->append(M("TP_WAVELET_DEN14LOW"));
//denmethod->append(M("TP_WAVELET_DEN12PLUS"));
//denmethod->append(M("TP_WAVELET_DEN12LOW"));
//denmethodconn = denmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::denmethodChanged));
//denmethod->set_tooltip_text(M("TP_WAVELET_DENEQUAL_TOOLTIP"));
// Gtk::Box* const denHBox = Gtk::manage(new Gtk::Box());
//Gtk::Label* const denLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_DENCONTRAST") + ":"));
//denHBox->pack_start(*denLabel, Gtk::PACK_SHRINK, 4);
//denHBox->pack_start(*denmethod);
mixmethod->append(M("TP_WAVELET_MIXNOISE"));
mixmethod->append(M("TP_WAVELET_MIXMIX"));
mixmethod->append(M("TP_WAVELET_MIXMIX70"));
mixmethod->append(M("TP_WAVELET_MIXDENOISE"));
mixmethodconn = mixmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::mixmethodChanged));
mixmethod->set_tooltip_text(M("TP_WAVELET_DENMIX_TOOLTIP"));
Gtk::Label* const mixLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_MIXCONTRAST") + ":"));
mixHBox->pack_start(*mixLabel, Gtk::PACK_SHRINK, 4);
mixHBox->pack_start(*mixmethod);
wavdenoise = static_cast<FlatCurveEditor*>(CurveEditorwavnoise->addCurve(CT_Flat, "", nullptr, false, false));
wavdenoise->setIdentityValue(0.);
wavdenoise->setResetCurve(FlatCurveType(default_params.wavdenoise.at(0)), default_params.wavdenoise);
CurveEditorwavnoise->set_tooltip_text(M("TP_WAVELET_DENLOCAL_TOOLTIP"));
CurveEditorwavnoise->curveListComplete();
CurveEditorwavnoise->show();
const std::vector<GradientMilestone> milestones4 = makeWholeHueRange();
wavdenoiseh = static_cast<FlatCurveEditor*>(CurveEditorwavnoiseh->addCurve(CT_Flat, "", nullptr, false, false));
wavdenoiseh->setIdentityValue(0.);
wavdenoiseh->setResetCurve(FlatCurveType(default_params.wavdenoiseh.at(0)), default_params.wavdenoiseh);
CurveEditorwavnoiseh->set_tooltip_text(M("TP_WAVELET_DENLOCAL_TOOLTIP"));
CurveEditorwavnoiseh->curveListComplete();
CurveEditorwavnoiseh->show();
wavhue = static_cast<FlatCurveEditor*>(CurveEditorwavhue->addCurve(CT_Flat, M("TP_WAVELET_CURVEEDITOR_HH")));
// wavhue->setTooltip(M("TP_WAVELET_WAVHUE_HH_TOOLTIP"));
wavhue->setCurveColorProvider(this, 5);
CurveEditorwavhue->set_tooltip_text(M("TP_WAVELET_DENWAVHUE_TOOLTIP"));
CurveEditorwavhue->curveListComplete();
wavhue->setBottomBarBgGradient(milestones4);
wavguidf = static_cast<FlatCurveEditor*>(CurveEditorwavguid->addCurve(CT_Flat, M("TP_WAVELET_CURVEEDITOR_HH")));
// wavguidf->setTooltip(M("TP_WAVELET_WAVGUID_HH_TOOLTIP"));
wavguidf->setCurveColorProvider(this, 5);
CurveEditorwavguid->set_tooltip_text(M("TP_WAVELET_DENWAVGUID_TOOLTIP"));
CurveEditorwavguid->curveListComplete();
wavguidf->setBottomBarBgGradient(milestones4);
levelsigm->set_tooltip_text(M("TP_WAVELET_DENSIGMA_TOOLTIP"));
// levden->set_tooltip_text(M("TP_WAVELET_DENLEV_TOOLTIP"));
thrden->set_tooltip_text(M("TP_WAVELET_THRDEN_TOOLTIP"));
// limden->set_tooltip_text(M("TP_WAVELET_LIMDEN_TOOLTIP"));
noiseBox->pack_start(*ballum);
noiseBox->pack_start(*CurveEditorwavhue);
noiseBox->pack_start(*level0noise, Gtk::PACK_SHRINK, 0);
noiseBox->pack_start(*level1noise, Gtk::PACK_SHRINK, 0);
noiseBox->pack_start(*level2noise, Gtk::PACK_SHRINK, 0);
noiseBox->pack_start(*level3noise, Gtk::PACK_SHRINK, 0);
// noiseBox->pack_start(*levden);
noiseBox->pack_start(*leveldenoise, Gtk::PACK_SHRINK, 0);
noiseBox->pack_start(*thrden);
noiseBox->pack_start(*quaHBox);
noiseBox->pack_start(*sliHBox);
//noiseBox->pack_start(*denHBox);
noiseBox->pack_start(*mixHBox);
noiseBox->pack_start(*levelsigm, Gtk::PACK_SHRINK, 0);
noiseBox->pack_start(*limden);
noiseBox->pack_start(*sigm);
noiseBox->pack_start(*CurveEditorwavnoise);
// noiseBox->pack_start(*CurveEditorwavnoiseh);
balchrom->setAdjusterListener(this);
chromfi->setAdjusterListener(this);
chromco->setAdjusterListener(this);
chroFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const chroBox = Gtk::manage(new ToolParamBlock());
chroBox->pack_start(*balchrom);
chroBox->pack_start(*chromfi);
chroBox->pack_start(*chromco);
chroFrame->add(*chroBox);
noiseBox->pack_start(*chroFrame);
// noiseBox->set_tooltip_text(M("TP_WAVELET_NOISE_TOOLTIP"));
//Clarity
mergeL->setAdjusterListener(this);
mergeC->setAdjusterListener(this);
softrad->setAdjusterListener(this);
showmask->set_active(false);
showmaskConn = showmask->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::showmaskToggled));
ToolParamBlock* const clariBox = Gtk::manage(new ToolParamBlock());
// ushamethod->append(M("TP_WAVELET_USH"));
ushamethod->append(M("TP_WAVELET_SHA"));
ushamethod->append(M("TP_WAVELET_CLA"));
ushamethodconn = ushamethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::ushamethodChanged));
ushamethod->set_tooltip_text(M("TP_WAVELET_USH_TOOLTIP"));
usharpHBox->pack_start(*usharpLabel, Gtk::PACK_SHRINK, 0);
usharpHBox->pack_start(*ushamethod);
clariBox->pack_start(*usharpHBox);
clariBox->pack_start(*mergeL);
clariBox->pack_start(*mergeC);
clariBox->pack_start(*softrad);
clariBox->pack_start(*showmask);
// Edge Sharpness
ToolParamBlock* const edgBox = Gtk::manage(new ToolParamBlock());
edgval->setAdjusterListener(this);
edgBox->pack_start(*edgval);
edgeffect->setAdjusterListener(this);
edgBox->pack_start(*edgeffect);
edgeffect->set_tooltip_markup(M("TP_WAVELET_EDEFFECT_TOOLTIP"));
edgrad->setAdjusterListener(this);
edgBox->pack_start(*edgrad);
edgrad->set_tooltip_markup(M("TP_WAVELET_EDRAD_TOOLTIP"));
edgthresh->setAdjusterListener(this);
edgthresh->set_tooltip_markup(M("TP_WAVELET_EDGTHRESH_TOOLTIP"));
edgBox->pack_start(*edgthresh);
Gtk::Label* const labmedgr = Gtk::manage(new Gtk::Label(M("TP_WAVELET_MEDGREINF") + ":"));
Gtk::Box* const edbox = Gtk::manage(new Gtk::Box());
edbox->pack_start(*labmedgr, Gtk::PACK_SHRINK, 1);
Medgreinf->append(M("TP_WAVELET_RE1"));
Medgreinf->append(M("TP_WAVELET_RE2"));
Medgreinf->append(M("TP_WAVELET_RE3"));
MedgreinfConn = Medgreinf->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::MedgreinfChanged));
Medgreinf->set_tooltip_markup(M("TP_WAVELET_EDGREINF_TOOLTIP"));
edbox->pack_start(*Medgreinf);
edgBox->pack_start(*edbox);
Gtk::Separator* const separatorlc = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
edgBox->pack_start(*separatorlc, Gtk::PACK_SHRINK, 2);
Gtk::Label* const labmED = Gtk::manage(new Gtk::Label(M("TP_WAVELET_EDTYPE") + ":"));
Gtk::Box* const ctboxED = Gtk::manage(new Gtk::Box());
ctboxED->pack_start(*labmED, Gtk::PACK_SHRINK, 1);
EDmethod->append(M("TP_WAVELET_EDSL"));
EDmethod->append(M("TP_WAVELET_EDCU"));
EDmethodconn = EDmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::EDmethodChanged));
ctboxED->pack_start(*EDmethod);
// edgBox->pack_start(*ctboxED);
edgcont->setAdjusterListener(this);
edgcont->setBgGradient(milestones2);
edgcont->set_tooltip_markup(M("TP_WAVELET_EDGCONT_TOOLTIP"));
// <-- Edge Sharpness Local Contrast curve
CCWcurveEditorG->setCurveListener(this);
ccshape = static_cast<FlatCurveEditor*>(CCWcurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
ccshape->setIdentityValue(0.);
ccshape->setResetCurve(FlatCurveType(default_params.ccwcurve.at(0)), default_params.ccwcurve);
ccshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_CC_TOOLTIP"));
CCWcurveEditorG->curveListComplete();
CCWcurveEditorG->show();
// -->
edgBox->pack_start(*edgcont);
edgBox->pack_start(*CCWcurveEditorG, Gtk::PACK_SHRINK, 4);
medianlev->set_active(true);
medianlevConn = medianlev->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::medianlevToggled));
medianlev->set_tooltip_text(M("TP_WAVELET_MEDILEV_TOOLTIP"));
Gtk::Separator* const separatored1 = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
edgBox->pack_start(*separatored1, Gtk::PACK_SHRINK, 2);
Gtk::Box* const eddebox = Gtk::manage(new Gtk::Box());
edgBox->pack_start(*eddebox);
edgBox->pack_start(*medianlev);
edgedetect->setAdjusterListener(this);
edgedetect->set_tooltip_text(M("TP_WAVELET_EDGEDETECT_TOOLTIP"));
edgBox->pack_start(*edgedetect);
edgedetectthr->setAdjusterListener(this);
edgedetectthr->set_tooltip_text(M("TP_WAVELET_EDGEDETECTTHR_TOOLTIP"));
edgBox->pack_start(*edgedetectthr);
edgedetectthr2->setAdjusterListener(this);
edgBox->pack_start(*edgedetectthr2);
edgBox->pack_start(*separatoredge, Gtk::PACK_SHRINK, 2);
lipst->set_active(true);
lipstConn = lipst->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::lipstToggled));
// lipst->set_tooltip_text (M("TP_WAVELET_LIPST_TOOLTIP"));
edgBox->pack_start(*lipst);
edgesensi->setAdjusterListener(this);
edgBox->pack_start(*edgesensi);
edgeampli->setAdjusterListener(this);
edgBox->pack_start(*edgeampli);
Gtk::Box* const ctboxES = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
ctboxES->set_spacing(2);
Gtk::Box* const ctboxNP = Gtk::manage(new Gtk::Box());
ctboxNP->pack_start(*labmNP, Gtk::PACK_SHRINK, 1);
NPmethod->append(M("TP_WAVELET_NPNONE"));
NPmethod->append(M("TP_WAVELET_NPLOW"));
NPmethod->append(M("TP_WAVELET_NPHIGH"));
NPmethodconn = NPmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::NPmethodChanged));
NPmethod->set_tooltip_text(M("TP_WAVELET_NPTYPE_TOOLTIP"));
ctboxNP->pack_start(*NPmethod);
ctboxES->pack_start(*ctboxNP);
edgBox->pack_start(*ctboxES);
//Blur Wavelet
ToolParamBlock* const blBox = Gtk::manage(new ToolParamBlock());
curveEditorbl->setCurveListener(this);
blshape = static_cast<FlatCurveEditor*>(curveEditorbl->addCurve(CT_Flat, "", nullptr, false, false));
blshape->setIdentityValue(0.);
blshape->setResetCurve(FlatCurveType(default_params.blcurve.at(0)), default_params.blcurve);
blshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_BL_TOOLTIP"));
curveEditorbl->curveListComplete();
curveEditorbl->show();
blBox->pack_start(*bluwav);
bluwav->setAdjusterListener(this);
blBox->pack_start(*curveEditorbl, Gtk::PACK_SHRINK, 4);
chrwav->setAdjusterListener(this);
blBox->pack_start(*chrwav);
// Gamut
ToolParamBlock* const conBox = Gtk::manage(new ToolParamBlock());
median->set_active(true);
medianConn = median->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::medianToggled));
conBox->pack_start(*median);
hueskin->set_tooltip_markup(M("TP_WAVELET_HUESKIN_TOOLTIP"));
//from -PI to +PI (radians) convert to hsv and draw bottombar
const std::vector<GradientMilestone> milestones = {
makeHsvGm(0.0000, 0.4199f, 0.5f, 0.5f), // hsv: 0.4199 rad: -3.14
makeHsvGm(0.0540, 0.5000f, 0.5f, 0.5f), // hsv: 0.5 rad: -2.8
makeHsvGm(0.1336, 0.6000f, 0.5f, 0.5f), // hsv: 0.60 rad: -2.3
makeHsvGm(0.3567, 0.7500f, 0.5f, 0.5f), // hsv: 0.75 rad: -0.9
makeHsvGm(0.4363, 0.8560f, 0.5f, 0.5f), // hsv: 0.856 rad: -0.4
makeHsvGm(0.4841, 0.9200f, 0.5f, 0.5f), // hsv: 0.92 rad: -0.1
makeHsvGm(0.5000, 0.9300f, 0.5f, 0.5f), // hsv: 0.93 rad: 0
makeHsvGm(0.5366, 0.9600f, 0.5f, 0.5f), // hsv: 0.96 rad: 0.25
makeHsvGm(0.5955, 1.0000f, 0.5f, 0.5f), // hsv: 1. rad: 0.6
makeHsvGm(0.6911, 0.0675f, 0.5f, 0.5f), // hsv: 0.0675 rad: 1.2
makeHsvGm(0.7229, 0.0900f, 0.5f, 0.5f), // hsv: 0.09 rad: 1.4
makeHsvGm(0.7707, 0.1700f, 0.5f, 0.5f), // hsv: 0.17 rad: 1.7
makeHsvGm(0.8503, 0.2650f, 0.5f, 0.5f), // hsv: 0.265 rad: 2.1
makeHsvGm(0.8981, 0.3240f, 0.5f, 0.5f), // hsv: 0.324 rad: 2.5
makeHsvGm(1.0000, 0.4197f, 0.5f, 0.5f) // hsv: 0.419 rad: 3.14
};
hueskin->setBgGradient(milestones);
conBox->pack_start(*hueskin);
hueskin->setAdjusterListener(this);
skinprotect->setAdjusterListener(this);
conBox->pack_start(*skinprotect);
skinprotect->set_tooltip_markup(M("TP_WAVELET_SKIN_TOOLTIP"));
curveEditorGAM->setCurveListener(this);
Chshape = static_cast<FlatCurveEditor*>(curveEditorGAM->addCurve(CT_Flat, M("TP_WAVELET_CURVEEDITOR_CH")));
Chshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_CH_TOOLTIP"));
Chshape->setCurveColorProvider(this, 5);
curveEditorGAM->curveListComplete();
Chshape->setBottomBarBgGradient(milestones);
conBox->pack_start(*curveEditorGAM, Gtk::PACK_SHRINK, 4);
avoid->set_active(true);
avoidConn = avoid->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::avoidToggled));
conBox->pack_start(*avoid);
// Residual Image
ToolParamBlock* const resBox = Gtk::manage(new ToolParamBlock());
oldsh->set_active(true);
oldshConn = oldsh->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::oldshToggled));
rescon->setAdjusterListener(this);
thr->setAdjusterListener(this);
resconH->setAdjusterListener(this);
thrH->setAdjusterListener(this);
radius->setAdjusterListener(this);
// radius->hide();
shFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const shBox = Gtk::manage(new ToolParamBlock());
shBox->pack_start(*oldsh);
shBox->pack_start(*rescon, Gtk::PACK_SHRINK);
shBox->pack_start(*thr);
shBox->pack_start(*resconH, Gtk::PACK_SHRINK);
shBox->pack_start(*thrH, Gtk::PACK_SHRINK);
shBox->pack_start(*radius, Gtk::PACK_SHRINK);
shFrame->add(*shBox);
resBox->pack_start(*shFrame);
contrast->set_tooltip_text(M("TP_WAVELET_CONTRA_TOOLTIP"));
contrast->setAdjusterListener(this);
reschro->setAdjusterListener(this);
resblur->setAdjusterListener(this);
resblurc->setAdjusterListener(this);
blurFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const blurBox = Gtk::manage(new ToolParamBlock());
blurBox->pack_start(*resblur);
blurBox->pack_start(*resblurc);
blurFrame->add(*blurBox);
resblur->set_tooltip_text(M("TP_WAVELET_RESBLUR_TOOLTIP"));
resblurc->set_tooltip_text(M("TP_WAVELET_RESBLUR_TOOLTIP"));
chromaFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const chromaBox = Gtk::manage(new ToolParamBlock());
chromaBox->pack_start(*reschro);
chromaBox->pack_start(*hueskin2);
chromaBox->pack_start(*sky);
chromaFrame->add(*chromaBox);
Gtk::Label* const labmTM = Gtk::manage(new Gtk::Label(M("TP_WAVELET_TMTYPE") + ":"));
Gtk::Box* const ctboxTM = Gtk::manage(new Gtk::Box());
ctboxTM->pack_start(*labmTM, Gtk::PACK_SHRINK, 1);
// Gtk::Separator* const separatorR0 = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
// resBox->pack_start(*separatorR0, Gtk::PACK_SHRINK, 2);
TMmethod->append(M("TP_WAVELET_COMPCONT"));
TMmethod->append(M("TP_WAVELET_COMPTM"));
TMmethodconn = TMmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::TMmethodChanged));
ctboxTM->pack_start(*TMmethod);
tmrs->set_tooltip_text(M("TP_WAVELET_TMSTRENGTH_TOOLTIP"));
tmrs->setAdjusterListener(this);
gamma->set_tooltip_text(M("TP_WAVELET_COMPGAMMA_TOOLTIP"));
gamma->setAdjusterListener(this);
//edgs->set_tooltip_text(M("TP_WAVELET_TMEDGS_TOOLTIP"));
edgs->setAdjusterListener(this);
//scale->set_tooltip_text(M("TP_WAVELET_TMSCALE_TOOLTIP"));
scale->setAdjusterListener(this);
contFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const contBox = Gtk::manage(new ToolParamBlock());
contBox->pack_start(*contrast); //keep the possibility to reinstall
contBox->pack_start(*ctboxTM);
contBox->pack_start(*tmrs);
contBox->pack_start(*gamma);
contBox->pack_start(*edgs);
contBox->pack_start(*scale);
contFrame->add(*contBox);
resBox->pack_start(*contFrame);
// Gtk::Separator* const separatorR1 = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
// resBox->pack_start(*separatorR1, Gtk::PACK_SHRINK, 2);
hueskin2->set_tooltip_markup(M("TP_WAVELET_HUESKY_TOOLTIP"));
hueskin2->setBgGradient(milestones);
hueskin2->setAdjusterListener(this);
sky->set_tooltip_text(M("TP_WAVELET_SKY_TOOLTIP"));
sky->setAdjusterListener(this);
// whole hue range
const std::vector<GradientMilestone> milestones3 = makeWholeHueRange();
curveEditorRES->setCurveListener(this);
resBox->pack_start(*blurFrame);
resBox->pack_start(*chromaFrame);
hhshape = static_cast<FlatCurveEditor*>(curveEditorRES->addCurve(CT_Flat, M("TP_WAVELET_CURVEEDITOR_HH")));
hhshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_HH_TOOLTIP"));
hhshape->setCurveColorProvider(this, 5);
curveEditorRES->curveListComplete();
hhshape->setBottomBarBgGradient(milestones3);
resBox->pack_start(*curveEditorRES, Gtk::PACK_SHRINK, 4);
// Toning and Color Balance
Gtk::Separator* const separatorCB = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
Gtk::Box* const chanMixerHLBox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
Gtk::Box* const chanMixerMidBox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
Gtk::Box* const chanMixerShadowsBox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
cbenab->set_active(true);
cbenabConn = cbenab->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::cbenabToggled));
cbenab->set_tooltip_text(M("TP_WAVELET_CB_TOOLTIP"));
Gtk::Image* const iblueR = Gtk::manage(new RTImage("circle-blue-small"));
Gtk::Image* const iyelL = Gtk::manage(new RTImage("circle-yellow-small"));
Gtk::Image* const imagL = Gtk::manage(new RTImage("circle-magenta-small"));
Gtk::Image* const igreenR = Gtk::manage(new RTImage("circle-green-small"));
Gtk::Image* const iblueRm = Gtk::manage(new RTImage("circle-blue-small"));
Gtk::Image* const iyelLm = Gtk::manage(new RTImage("circle-yellow-small"));
Gtk::Image* const imagLm = Gtk::manage(new RTImage("circle-magenta-small"));
Gtk::Image* const igreenRm = Gtk::manage(new RTImage("circle-green-small"));
Gtk::Image* const iblueRh = Gtk::manage(new RTImage("circle-blue-small"));
Gtk::Image* const iyelLh = Gtk::manage(new RTImage("circle-yellow-small"));
Gtk::Image* const imagLh = Gtk::manage(new RTImage("circle-magenta-small"));
Gtk::Image* const igreenRh = Gtk::manage(new RTImage("circle-green-small"));
greenhigh = Gtk::manage(new Adjuster("", -100., 100., 1., 0., igreenRh, imagLh));
bluehigh = Gtk::manage(new Adjuster("", -100., 100., 1., 0., iblueRh, iyelLh));
greenmed = Gtk::manage(new Adjuster("", -100., 100., 1., 0., igreenRm, imagLm));
bluemed = Gtk::manage(new Adjuster("", -100., 100., 1., 0., iblueRm, iyelLm));
greenlow = Gtk::manage(new Adjuster("", -100., 100., 1., 0., igreenR, imagL));
bluelow = Gtk::manage(new Adjuster("", -100., 100., 1., 0., iblueR, iyelL));
chanMixerHLBox->pack_start(*greenhigh);
chanMixerHLBox->pack_start(*bluehigh);
chanMixerMidBox->pack_start(*greenmed);
chanMixerMidBox->pack_start(*bluemed);
chanMixerShadowsBox->pack_start(*greenlow);
chanMixerShadowsBox->pack_start(*bluelow);
greenlow->setAdjusterListener(this);
bluelow->setAdjusterListener(this);
greenmed->setAdjusterListener(this);
bluemed->setAdjusterListener(this);
greenhigh->setAdjusterListener(this);
bluehigh->setAdjusterListener(this);
resBox->pack_start(*separatorCB, Gtk::PACK_SHRINK);
chanMixerHLFrame->add(*chanMixerHLBox);
chanMixerMidFrame->add(*chanMixerMidBox);
chanMixerShadowsFrame->add(*chanMixerShadowsBox);
resBox->pack_start(*cbenab);
resBox->pack_start(*chanMixerHLFrame, Gtk::PACK_SHRINK);
resBox->pack_start(*chanMixerMidFrame, Gtk::PACK_SHRINK);
resBox->pack_start(*chanMixerShadowsFrame, Gtk::PACK_SHRINK);
Gtk::Button* const neutral = Gtk::manage(new Gtk::Button(M("TP_COLORTONING_NEUTRAL")));
neutral->set_tooltip_text(M("TP_COLORTONING_NEUTRAL_TOOLTIP"));
neutralconn = neutral->signal_pressed().connect(sigc::mem_fun(*this, &Wavelet::neutral_pressed));
neutral->show();
neutrHBox->pack_start(*neutral, Gtk::PACK_EXPAND_WIDGET);
resBox->pack_start(*neutrHBox);
// Final Touchup
// Gtk::Box* const ctboxBA = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
ctboxBA->set_spacing(2);
//Gtk::Separator *separatorfin = Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
//ctboxBA->pack_start(*separatorfin, Gtk::PACK_SHRINK, 2);
Gtk::Label* const labmBA = Gtk::manage(new Gtk::Label(M("TP_WAVELET_BATYPE") + ":"));
Gtk::Box* const ctboxFI = Gtk::manage(new Gtk::Box());
ctboxFI->pack_start(*labmBA, Gtk::PACK_SHRINK, 1);
BAmethod->append(M("TP_WAVELET_BANONE"));
BAmethod->append(M("TP_WAVELET_BASLI"));
BAmethod->append(M("TP_WAVELET_BACUR"));
BAmethodconn = BAmethod->signal_changed().connect(sigc::mem_fun(*this, &Wavelet::BAmethodChanged));
ctboxFI->pack_start(*BAmethod);
ctboxBA->pack_start(*ctboxFI);
balance->setAdjusterListener(this);
balance->set_tooltip_text(M("TP_WAVELET_BALANCE_TOOLTIP"));
softradend->setAdjusterListener(this);
strend->setAdjusterListener(this);
detend->setAdjusterListener(this);
thrend->setAdjusterListener(this);
opacityCurveEditorW->setCurveListener(this);
opacityShape = static_cast<FlatCurveEditor*>(opacityCurveEditorW->addCurve(CT_Flat, "", nullptr, false, false));
opacityShape->setIdentityValue(0.);
opacityShape->setResetCurve(FlatCurveType(default_params.opacityCurveW.at(0)), default_params.opacityCurveW);
opacityShape->setBottomBarBgGradient(milestones2);
// This will add the reset button at the end of the curveType buttons
opacityCurveEditorW->curveListComplete();
opacityCurveEditorW->show();
iter->setAdjusterListener(this);
iter->set_tooltip_text(M("TP_WAVELET_ITER_TOOLTIP"));
sigmadir->setAdjusterListener(this);
// Gtk::Separator* const separatorbalend = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
opacityCurveEditorWL->setCurveListener(this);
opacityShapeWL = static_cast<FlatCurveEditor*>(opacityCurveEditorWL->addCurve(CT_Flat, "", nullptr, false, false));
opacityShapeWL->setIdentityValue(0.);
opacityShapeWL->setResetCurve(FlatCurveType(default_params.opacityCurveWL.at(0)), default_params.opacityCurveWL);
opacityShapeWL->setTooltip(M("TP_WAVELET_OPACITYWL_TOOLTIP"));
opacityShapeWL->setBottomBarBgGradient({{0., 0., 0., 0.}, {1., 1., 1., 1.}});
sigmafin->setAdjusterListener(this);
// This will add the reset button at the end of the curveType buttons
opacityCurveEditorWL->curveListComplete();
opacityCurveEditorWL->show();
curveEditorG->setCurveListener(this);
clshape = static_cast<DiagonalCurveEditor*>(curveEditorG->addCurve(CT_Diagonal, M("TP_WAVELET_CURVEEDITOR_CL")));
clshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_CL_TOOLTIP"));
clshape->setBottomBarBgGradient(milestones2);
clshape->setLeftBarBgGradient(milestones2);
curveEditorG->curveListComplete();
tmr->set_active(true);
tmr->set_tooltip_text(M("TP_WAVELET_BALCHRO_TOOLTIP"));
tmrConn = tmr->signal_toggled().connect(sigc::mem_fun(*this, &Wavelet::tmrToggled));
fincFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const fincBox = Gtk::manage(new ToolParamBlock());
fincBox->pack_start(*opacityCurveEditorWL, Gtk::PACK_SHRINK, 2);
fincBox->pack_start(*sigmafin);
fincFrame->add(*fincBox);
dirFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const dirBox = Gtk::manage(new ToolParamBlock());
dirBox->pack_start(*ctboxBA);
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);
ToolParamBlock* const finalBox = Gtk::manage(new ToolParamBlock());
finalBox->pack_start(*dirFrame);
finalBox->pack_start(*fincFrame);
finalBox->pack_start(*curveEditorG, Gtk::PACK_SHRINK, 4);
thrend->set_tooltip_text(M("TP_WAVELET_FINTHR_TOOLTIP"));
guidFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const guidBox = Gtk::manage(new ToolParamBlock());
guidBox->pack_start(*softradend);
guidBox->pack_start(*strend);
guidBox->pack_start(*detend);
guidBox->pack_start(*thrend);
guidBox->pack_start(*CurveEditorwavguid);
guidFrame->add(*guidBox);
finalBox->pack_start(*guidFrame);
//-----------------------------
expsettings->add(*settingsBox, false);
expsettings->setLevel(2);
pack_start(*expsettings);
expcontrast->add(*levBox, false);
expcontrast->setLevel(2);
pack_start(*expcontrast);
expchroma->add(*chBox, false);
expchroma->setLevel(2);
pack_start(*expchroma);
expgamut->add(*conBox, false);
expgamut->setLevel(2);
pack_start(*expgamut);
exptoning->add(*tonBox, false);
exptoning->setLevel(2);
pack_start(*exptoning);
expnoise->add(*noiseBox, false);
expnoise->setLevel(2);
pack_start(*expnoise);
expedge->add(*edgBox, false);
expedge->setLevel(2);
pack_start(*expedge);
expbl->add(*blBox, false);
expbl->setLevel(2);
pack_start(*expbl);
expclari->add(*clariBox, false);
expclari->setLevel(2);
pack_start(*expclari);
expresid->add(*resBox, false);
expresid->setLevel(2);
pack_start(*expresid);
expfinal->add(*finalBox, false);
expfinal->setLevel(2);
pack_start(*expfinal);
}
Wavelet::~Wavelet()
{
idle_register.destroy();
delete opaCurveEditorG;
//delete curveEditorC;
delete opacityCurveEditorG;
delete CurveEditorwavnoise;
delete CurveEditorwavnoiseh;
delete CurveEditorwavguid;
delete CurveEditorwavhue;
delete curveEditorbl;
delete CCWcurveEditorG;
delete curveEditorRES;
delete curveEditorGAM;
delete curveEditorG;
delete opacityCurveEditorW;
delete opacityCurveEditorWL;
}
void Wavelet::updateGUI()
{
const int temp2 = threshold2->getValue();
const int temp = threshold->getValue();
const int maxlev = thres->getValue();
threshold2->setLimits(temp + 1, maxlev, 1, maxlev + 1);
threshold2 ->setValue(temp2);
}
void Wavelet::updateGUImaxlev()
{
const int temp4 = threshold->getValue();
const int temp3 = thres->getValue();
threshold->setLimits(1, temp3, 1, temp3);
threshold ->setValue(temp4);
}
void Wavelet::wavChanged(double nlevel)
{
if (!batchMode) {
idle_register.add(
[this, nlevel]() -> bool {
wavLabels->set_text(
Glib::ustring::compose(
M("TP_WAVELET_LEVLABEL"),
Glib::ustring::format(std::fixed, std::setprecision(0), nlevel)
)
);
return false;
}
);
}
}
// Will only reset the channel mixer
// WARNING! In mutiImage mode, and for sliders in ADD mode, this will reset the slider to 0, but not to the default value as in SET mode.
void Wavelet::neutral_pressed()
{
disableListener();
greenlow->resetValue(false);
bluelow->resetValue(false);
greenmed->resetValue(false);
bluemed->resetValue(false);
greenhigh->resetValue(false);
bluehigh->resetValue(false);
enableListener();
if (listener && getEnabled()) {
listener->panelChanged(EvWavNeutral, M("GENERAL_RESET"));
}
}
void Wavelet::setListener(ToolPanelListener *tpl)
{
ToolPanel::setListener(tpl);
labgrid->setListener(tpl);
}
void Wavelet::read(const ProcParams* pp, const ParamsEdited* pedited)
{
/*****************************************************************************************************
*
* Disable listeners and signals
*
*****************************************************************************************************/
disableListener();
Lmethodconn.block(true);
CLmethodconn.block(true);
Backmethodconn.block(true);
Tilesmethodconn.block(true);
complexmethodconn.block(true);
//denmethodconn.block(true);
mixmethodconn.block(true);
slimethodconn.block(true);
quamethodconn.block(true);
daubcoeffmethodconn.block(true);
Dirmethodconn.block(true);
CHmethodconn.block(true);
CHSLmethodconn.block(true);
EDmethodconn.block(true);
NPmethodconn.block(true);
BAmethodconn.block(true);
TMmethodconn.block(true);
HSmethodconn.block(true);
MedgreinfConn.block(true);
ushamethodconn.block(true);
cbenabConn.block(true);
enableChromaConn.block(true);
enableContrastConn.block(true);
enableEdgeConn.block(true);
enableFinalConn.block(true);
enableNoiseConn.block(true);
enableResidConn.block(true);
enableToningConn.block(true);
/*****************************************************************************************************
*
* Set the GUI reflecting the given ProcParams
*
*****************************************************************************************************/
//HSmethod->set_active (1); // Note: default values are controlled in rtengine::ProcParams::SetDefaults
if (pp->wavelet.HSmethod == "without") {
HSmethod->set_active(0);
} else if (pp->wavelet.HSmethod == "with") {
HSmethod->set_active(1);
}
//CHmethod->set_active (1);
if (pp->wavelet.CHmethod == "without") {
CHmethod->set_active(0);
} else if (pp->wavelet.CHmethod == "with") {
CHmethod->set_active(1);
} else if (pp->wavelet.CHmethod == "link") {
CHmethod->set_active(2);
}
//Medgreinf->set_active (1);
if (pp->wavelet.Medgreinf == "more") {
Medgreinf->set_active(0);
} else if (pp->wavelet.Medgreinf == "none") {
Medgreinf->set_active(1);
} else if (pp->wavelet.Medgreinf == "less") {
Medgreinf->set_active(2);
}
//ushamethod
// if (pp->wavelet.ushamethod == "none") {
// ushamethod->set_active(0);
// } else
if (pp->wavelet.ushamethod == "sharp") {
ushamethod->set_active(0);
} else if (pp->wavelet.ushamethod == "clari") {
ushamethod->set_active(1);
}
//CHSLmethod->set_active (1);
if (pp->wavelet.CHSLmethod == "SL") {
CHSLmethod->set_active(0);
} else if (pp->wavelet.CHSLmethod == "CU") {
CHSLmethod->set_active(1);
}
//EDmethod->set_active (1);
if (pp->wavelet.EDmethod == "SL") {
EDmethod->set_active(0);
} else if (pp->wavelet.EDmethod == "CU") {
EDmethod->set_active(1);
}
if (pp->wavelet.NPmethod == "none") {
NPmethod->set_active(0);
} else if (pp->wavelet.NPmethod == "low") {
NPmethod->set_active(1);
} else if (pp->wavelet.NPmethod == "high") {
NPmethod->set_active(2);
}
//BAmethod->set_active (0);
if (pp->wavelet.BAmethod == "none") {
BAmethod->set_active(0);
} else if (pp->wavelet.BAmethod == "sli") {
BAmethod->set_active(1);
} else if (pp->wavelet.BAmethod == "cur") {
BAmethod->set_active(2);
}
//TMmethod->set_active (1);
if (pp->wavelet.TMmethod == "cont") {
TMmethod->set_active(0);
} else if (pp->wavelet.TMmethod == "tm") {
TMmethod->set_active(1);
}
// else if (pp->wavelet.TMmethod=="both")
// TMmethod->set_active (2);
//Backmethod->set_active (3);
if (pp->wavelet.Backmethod == "black") {
Backmethod->set_active(0);
} else if (pp->wavelet.Backmethod == "grey") {
Backmethod->set_active(1);
} else if (pp->wavelet.Backmethod == "resid") {
Backmethod->set_active(2);
}
//CLmethod->set_active (3);
if (pp->wavelet.CLmethod == "one") {
CLmethod->set_active(0);
} else if (pp->wavelet.CLmethod == "inf") {
CLmethod->set_active(1);
} else if (pp->wavelet.CLmethod == "sup") {
CLmethod->set_active(2);
} else if (pp->wavelet.CLmethod == "all") {
CLmethod->set_active(3);
}
if (pp->wavelet.complexmethod == "normal") {
complexmethod->set_active(0);
} else if (pp->wavelet.complexmethod == "expert") {
complexmethod->set_active(1);
}
//if (pp->wavelet.denmethod == "equ") {
// denmethod->set_active(0);
//} else if (pp->wavelet.denmethod == "high") {
// denmethod->set_active(1);
//} else if (pp->wavelet.denmethod == "low") {
// denmethod->set_active(2);
//} else if (pp->wavelet.denmethod == "12high") {
// denmethod->set_active(3);
//} else if (pp->wavelet.denmethod == "12low") {
// denmethod->set_active(4);
//}
if (pp->wavelet.mixmethod == "nois") {
mixmethod->set_active(0);
} else if (pp->wavelet.mixmethod == "mix") {
mixmethod->set_active(1);
} else if (pp->wavelet.mixmethod == "mix7") {
mixmethod->set_active(2);
} else if (pp->wavelet.mixmethod == "den") {
mixmethod->set_active(3);
}
if (pp->wavelet.slimethod == "sli") {
slimethod->set_active(0);
} else if (pp->wavelet.slimethod == "cur") {
slimethod->set_active(1);
}
if (pp->wavelet.quamethod == "cons") {
quamethod->set_active(0);
} else if (pp->wavelet.quamethod == "agre") {
quamethod->set_active(1);
}
//Tilesmethod->set_active (2);
if (pp->wavelet.Tilesmethod == "full") {
Tilesmethod->set_active(0);
} else if (pp->wavelet.Tilesmethod == "big") {
Tilesmethod->set_active(1);
// } else if (pp->wavelet.Tilesmethod == "lit") {
// Tilesmethod->set_active(2);
}
//daubcoeffmethod->set_active (4);
if (pp->wavelet.daubcoeffmethod == "2_") {
daubcoeffmethod->set_active(0);
} else if (pp->wavelet.daubcoeffmethod == "4_") {
daubcoeffmethod->set_active(1);
} else if (pp->wavelet.daubcoeffmethod == "6_") {
daubcoeffmethod->set_active(2);
} else if (pp->wavelet.daubcoeffmethod == "10_") {
daubcoeffmethod->set_active(3);
} else if (pp->wavelet.daubcoeffmethod == "14_") {
daubcoeffmethod->set_active(4);
} else if (pp->wavelet.daubcoeffmethod == "20_") {
daubcoeffmethod->set_active(5);
}
//Dirmethod->set_active (3);
if (pp->wavelet.Dirmethod == "one") {
Dirmethod->set_active(0);
} else if (pp->wavelet.Dirmethod == "two") {
Dirmethod->set_active(1);
} else if (pp->wavelet.Dirmethod == "thr") {
Dirmethod->set_active(2);
} else if (pp->wavelet.Dirmethod == "all") {
Dirmethod->set_active(3);
}
int selectedLevel = pp->wavelet.Lmethod - 1;
Lmethod->set_active(selectedLevel == -1 ? 4 : selectedLevel);
ccshape->setCurve(pp->wavelet.ccwcurve);
blshape->setCurve(pp->wavelet.blcurve);
opacityShapeRG->setCurve(pp->wavelet.opacityCurveRG);
wavdenoise->setCurve(pp->wavelet.wavdenoise);
wavdenoiseh->setCurve(pp->wavelet.wavdenoiseh);
//opacityShapeSH->setCurve(pp->wavelet.opacityCurveSH);
opacityShapeBY->setCurve(pp->wavelet.opacityCurveBY);
opacityShape->setCurve(pp->wavelet.opacityCurveW);
opacityShapeWL->setCurve(pp->wavelet.opacityCurveWL);
hhshape->setCurve(pp->wavelet.hhcurve);
wavguidf->setCurve(pp->wavelet.wavguidcurve);
wavhue->setCurve(pp->wavelet.wavhuecurve);
Chshape->setCurve(pp->wavelet.Chcurve);
clshape->setCurve(pp->wavelet.wavclCurve);
expcontrast->setEnabled(pp->wavelet.expcontrast);
expchroma->setEnabled(pp->wavelet.expchroma);
expedge->setEnabled(pp->wavelet.expedge);
expbl->setEnabled(pp->wavelet.expbl);
expresid->setEnabled(pp->wavelet.expresid);
expfinal->setEnabled(pp->wavelet.expfinal);
exptoning->setEnabled(pp->wavelet.exptoning);
expnoise->setEnabled(pp->wavelet.expnoise);
expclari->setEnabled(pp->wavelet.expclari);
setEnabled(pp->wavelet.enabled);
avoidConn.block(true);
avoid->set_active(pp->wavelet.avoid);
avoidConn.block(false);
showmaskConn.block(true);
showmask->set_active(pp->wavelet.showmask);
showmaskConn.block(false);
oldshConn.block(true);
oldsh->set_active(pp->wavelet.oldsh);
oldshConn.block(false);
tmrConn.block(true);
tmr->set_active(pp->wavelet.tmr);
tmrConn.block(false);
medianConn.block(true);
median->set_active(pp->wavelet.median);
medianConn.block(false);
medianlevConn.block(true);
medianlev->set_active(pp->wavelet.medianlev);
medianlevConn.block(false);
linkedgConn.block(true);
linkedg->set_active(pp->wavelet.linkedg);
linkedgConn.block(false);
cbenabConn.block(true);
cbenab->set_active(pp->wavelet.cbenab);
cbenabConn.block(false);
lipstConn.block(true);
lipst->set_active(pp->wavelet.lipst);
lipstConn.block(false);
//edgreinfConn.block (true);
//edgreinf->set_active (pp->wavelet.edgreinf);
//edgreinfConn.block (false);
//lastedgreinf = pp->wavelet.edgreinf;
lastmedian = pp->wavelet.median;
lastmedianlev = pp->wavelet.medianlev;
lastlinkedg = pp->wavelet.linkedg;
lastcbenab = pp->wavelet.cbenab;
lastlipst = pp->wavelet.lipst;
lastavoid = pp->wavelet.avoid;
lastshowmask = pp->wavelet.showmask;
lastoldsh = pp->wavelet.oldsh;
lasttmr = pp->wavelet.tmr;
sigma->setValue(pp->wavelet.sigma);
offset->setValue(pp->wavelet.offset);
lowthr->setValue(pp->wavelet.lowthr);
rescon->setValue(pp->wavelet.rescon);
resconH->setValue(pp->wavelet.resconH);
reschro->setValue(pp->wavelet.reschro);
resblur->setValue(pp->wavelet.resblur);
resblurc->setValue(pp->wavelet.resblurc);
tmrs->setValue(pp->wavelet.tmrs);
edgs->setValue(pp->wavelet.edgs);
scale->setValue(pp->wavelet.scale);
gamma->setValue(pp->wavelet.gamma);
sup->setValue(pp->wavelet.sup);
sky->setValue(pp->wavelet.sky);
thres->setValue(pp->wavelet.thres);
chroma->setValue(pp->wavelet.chroma);
chro->setValue(pp->wavelet.chro);
contrast->setValue(pp->wavelet.contrast);
edgrad->setValue(pp->wavelet.edgrad);
edgeffect->setValue(pp->wavelet.edgeffect);
edgval->setValue(pp->wavelet.edgval);
edgthresh->setValue(pp->wavelet.edgthresh);
thr->setValue(pp->wavelet.thr);
thrH->setValue(pp->wavelet.thrH);
radius->setValue(pp->wavelet.radius);
skinprotect->setValue(pp->wavelet.skinprotect);
hueskin->setValue<int>(pp->wavelet.hueskin);
hueskin2->setValue<int>(pp->wavelet.hueskin2);
updateGUImaxlev();
threshold->setValue(pp->wavelet.threshold);
updateGUI();
threshold2->setValue(pp->wavelet.threshold2);
edgedetect->setValue(pp->wavelet.edgedetect);
edgedetectthr->setValue(pp->wavelet.edgedetectthr);
edgedetectthr2->setValue(pp->wavelet.edgedetectthr2);
edgesensi->setValue(pp->wavelet.edgesensi);
edgeampli->setValue(pp->wavelet.edgeampli);
hllev->setValue<int>(pp->wavelet.hllev);
bllev->setValue<int>(pp->wavelet.bllev);
pastlev->setValue<int>(pp->wavelet.pastlev);
satlev->setValue<int>(pp->wavelet.satlev);
edgcont->setValue<int>(pp->wavelet.edgcont);
chrwav->setValue(pp->wavelet.chrwav);
bluwav->setValue(pp->wavelet.bluwav);
greenlow->setValue(pp->wavelet.greenlow);
bluelow->setValue(pp->wavelet.bluelow);
greenmed->setValue(pp->wavelet.greenmed);
bluemed->setValue(pp->wavelet.bluemed);
greenhigh->setValue(pp->wavelet.greenhigh);
bluehigh->setValue(pp->wavelet.bluehigh);
mergeL->setValue(pp->wavelet.mergeL);
mergeC->setValue(pp->wavelet.mergeC);
softrad->setValue(pp->wavelet.softrad);
softradend->setValue(pp->wavelet.softradend);
strend->setValue(pp->wavelet.strend);
detend->setValue(pp->wavelet.detend);
thrend->setValue(pp->wavelet.thrend);
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, 0, 0, 0, 0, 0, 0, false);
sigm->setValue(pp->wavelet.sigm);
levden->setValue(pp->wavelet.levden);
thrden->setValue(pp->wavelet.thrden);
limden->setValue(pp->wavelet.limden);
ballum->setValue(pp->wavelet.ballum);
balchrom->setValue(pp->wavelet.balchrom);
chromfi->setValue(pp->wavelet.chromfi);
chromco->setValue(pp->wavelet.chromco);
level0noise->setValue<double>(pp->wavelet.level0noise);
level1noise->setValue<double>(pp->wavelet.level1noise);
level2noise->setValue<double>(pp->wavelet.level2noise);
level3noise->setValue<double>(pp->wavelet.level3noise);
leveldenoise->setValue<double>(pp->wavelet.leveldenoise);
levelsigm->setValue<double>(pp->wavelet.levelsigm);
strength->setValue(pp->wavelet.strength);
balance->setValue(pp->wavelet.balance);
iter->setValue(pp->wavelet.iter);
sigmafin->setValue(pp->wavelet.sigmafin);
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]);
}
for (int i = 0; i < 9; i++) {
correctionch[i]->setValue(pp->wavelet.ch[i]);
}
/*****************************************************************************************************
*
* Set the inconsistent state (for combobox, select the "GENERAL_UNCHANGED" entry)
*
*****************************************************************************************************/
if (pedited) {
if (!pedited->wavelet.Lmethod) {
Lmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.CLmethod) {
CLmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.Backmethod) {
Backmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.complexmethod) {
complexmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
//if (!pedited->wavelet.denmethod) {
// denmethod->set_active_text(M("GENERAL_UNCHANGED"));
//}
if (!pedited->wavelet.mixmethod) {
mixmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.slimethod) {
slimethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.quamethod) {
quamethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.Tilesmethod) {
Tilesmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.daubcoeffmethod) {
daubcoeffmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.Dirmethod) {
Dirmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.CHmethod) {
CHmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.CHSLmethod) {
CHSLmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.EDmethod) {
EDmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.NPmethod) {
NPmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.BAmethod) {
BAmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.TMmethod) {
TMmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.HSmethod) {
HSmethod->set_active_text(M("GENERAL_UNCHANGED"));
}
if (!pedited->wavelet.Medgreinf) {
Medgreinf->set_active_text(M("GENERAL_UNCHANGED"));
}
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);
blshape->setUnChanged(!pedited->wavelet.blcurve);
expcontrast->set_inconsistent(!pedited->wavelet.expcontrast);
expchroma->set_inconsistent(!pedited->wavelet.expchroma);
expedge->set_inconsistent(!pedited->wavelet.expedge);
expbl->set_inconsistent(!pedited->wavelet.expbl);
expresid->set_inconsistent(!pedited->wavelet.expresid);
expfinal->set_inconsistent(!pedited->wavelet.expfinal);
expclari->set_inconsistent(!pedited->wavelet.expclari);
exptoning->set_inconsistent(!pedited->wavelet.exptoning);
expnoise->set_inconsistent(!pedited->wavelet.expnoise);
opacityShapeRG->setCurve(pp->wavelet.opacityCurveRG);
//opacityShapeSH->setCurve(pp->wavelet.opacityCurveSH);
opacityShapeBY->setCurve(pp->wavelet.opacityCurveBY);
wavdenoise->setCurve(pp->wavelet.wavdenoise);
wavdenoiseh->setCurve(pp->wavelet.wavdenoiseh);
opacityShape->setCurve(pp->wavelet.opacityCurveW);
opacityShapeWL->setCurve(pp->wavelet.opacityCurveWL);
hhshape->setUnChanged(!pedited->wavelet.hhcurve);
wavguidf->setUnChanged(!pedited->wavelet.wavguidcurve);
wavhue->setUnChanged(!pedited->wavelet.wavhuecurve);
Chshape->setUnChanged(!pedited->wavelet.Chcurve);
clshape->setUnChanged(!pedited->wavelet.wavclCurve);
avoid->set_inconsistent(!pedited->wavelet.avoid);
showmask->set_inconsistent(!pedited->wavelet.showmask);
oldsh->set_inconsistent(!pedited->wavelet.oldsh);
tmr->set_inconsistent(!pedited->wavelet.tmr);
edgthresh->setEditedState(pedited->wavelet.edgthresh ? Edited : UnEdited);
rescon->setEditedState(pedited->wavelet.rescon ? Edited : UnEdited);
sigma->setEditedState(pedited->wavelet.sigma ? Edited : UnEdited);
offset->setEditedState(pedited->wavelet.offset ? Edited : UnEdited);
lowthr->setEditedState(pedited->wavelet.lowthr ? Edited : UnEdited);
resconH->setEditedState(pedited->wavelet.resconH ? Edited : UnEdited);
reschro->setEditedState(pedited->wavelet.reschro ? Edited : UnEdited);
resblur->setEditedState(pedited->wavelet.resblur ? Edited : UnEdited);
resblurc->setEditedState(pedited->wavelet.resblurc ? Edited : UnEdited);
tmrs->setEditedState(pedited->wavelet.tmrs ? Edited : UnEdited);
edgs->setEditedState(pedited->wavelet.edgs ? Edited : UnEdited);
scale->setEditedState(pedited->wavelet.scale ? Edited : UnEdited);
gamma->setEditedState(pedited->wavelet.gamma ? Edited : UnEdited);
sup->setEditedState(pedited->wavelet.sup ? Edited : UnEdited);
sky->setEditedState(pedited->wavelet.sky ? Edited : UnEdited);
thres->setEditedState(pedited->wavelet.thres ? Edited : UnEdited);
balance->setEditedState(pedited->wavelet.balance ? Edited : UnEdited);
iter->setEditedState(pedited->wavelet.iter ? Edited : UnEdited);
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);
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);
edgedetectthr->setEditedState(pedited->wavelet.edgedetectthr ? Edited : UnEdited);
edgedetectthr2->setEditedState(pedited->wavelet.edgedetectthr2 ? Edited : UnEdited);
edgesensi->setEditedState(pedited->wavelet.edgesensi ? Edited : UnEdited);
edgeampli->setEditedState(pedited->wavelet.edgeampli ? Edited : UnEdited);
chroma->setEditedState(pedited->wavelet.chroma ? Edited : UnEdited);
chro->setEditedState(pedited->wavelet.chro ? Edited : UnEdited);
greenlow->setEditedState(pedited->wavelet.greenlow ? Edited : UnEdited);
bluelow->setEditedState(pedited->wavelet.bluelow ? Edited : UnEdited);
greenmed->setEditedState(pedited->wavelet.greenmed ? Edited : UnEdited);
bluemed->setEditedState(pedited->wavelet.bluemed ? Edited : UnEdited);
greenhigh->setEditedState(pedited->wavelet.greenhigh ? Edited : UnEdited);
bluehigh->setEditedState(pedited->wavelet.bluehigh ? Edited : UnEdited);
mergeL->setEditedState(pedited->wavelet.mergeL ? Edited : UnEdited);
mergeC->setEditedState(pedited->wavelet.mergeC ? Edited : UnEdited);
softrad->setEditedState(pedited->wavelet.softrad ? Edited : UnEdited);
softradend->setEditedState(pedited->wavelet.softradend ? Edited : UnEdited);
strend->setEditedState(pedited->wavelet.strend ? Edited : UnEdited);
detend->setEditedState(pedited->wavelet.detend ? Edited : UnEdited);
thrend->setEditedState(pedited->wavelet.thrend ? Edited : UnEdited);
sigm->setEditedState(pedited->wavelet.sigm ? Edited : UnEdited);
levden->setEditedState(pedited->wavelet.levden ? Edited : UnEdited);
thrden->setEditedState(pedited->wavelet.thrden ? Edited : UnEdited);
limden->setEditedState(pedited->wavelet.limden ? Edited : UnEdited);
ballum->setEditedState(pedited->wavelet.ballum ? Edited : UnEdited);
balchrom->setEditedState(pedited->wavelet.balchrom ? Edited : UnEdited);
chromfi->setEditedState(pedited->wavelet.chromfi ? Edited : UnEdited);
chromco->setEditedState(pedited->wavelet.chromco ? Edited : UnEdited);
median->set_inconsistent(!pedited->wavelet.median);
medianlev->set_inconsistent(!pedited->wavelet.medianlev);
linkedg->set_inconsistent(!pedited->wavelet.linkedg);
// edgreinf->set_inconsistent (!pedited->wavelet.edgreinf);
cbenab->set_inconsistent(!pedited->wavelet.cbenab);
lipst->set_inconsistent(!pedited->wavelet.lipst);
contrast->setEditedState(pedited->wavelet.contrast ? Edited : UnEdited);
edgrad->setEditedState(pedited->wavelet.edgrad ? Edited : UnEdited);
edgeffect->setEditedState(pedited->wavelet.edgeffect ? Edited : UnEdited);
edgval->setEditedState(pedited->wavelet.edgval ? Edited : UnEdited);
thr->setEditedState(pedited->wavelet.thr ? Edited : UnEdited);
thrH->setEditedState(pedited->wavelet.thrH ? Edited : UnEdited);
radius->setEditedState(pedited->wavelet.radius ? Edited : UnEdited);
skinprotect->setEditedState(pedited->wavelet.skinprotect ? Edited : UnEdited);
hueskin->setEditedState(pedited->wavelet.hueskin ? Edited : UnEdited);
hueskin2->setEditedState(pedited->wavelet.hueskin2 ? Edited : UnEdited);
hllev->setEditedState(pedited->wavelet.hllev ? Edited : UnEdited);
bllev->setEditedState(pedited->wavelet.bllev ? Edited : UnEdited);
pastlev->setEditedState(pedited->wavelet.pastlev ? Edited : UnEdited);
satlev->setEditedState(pedited->wavelet.satlev ? Edited : UnEdited);
strength->setEditedState(pedited->wavelet.strength ? Edited : UnEdited);
edgcont->setEditedState(pedited->wavelet.edgcont ? Edited : UnEdited);
chrwav->setEditedState(pedited->wavelet.chrwav ? Edited : UnEdited);
bluwav->setEditedState(pedited->wavelet.bluwav ? Edited : UnEdited);
level0noise->setEditedState(pedited->wavelet.level0noise ? Edited : UnEdited);
level1noise->setEditedState(pedited->wavelet.level1noise ? Edited : UnEdited);
level2noise->setEditedState(pedited->wavelet.level2noise ? Edited : UnEdited);
level3noise->setEditedState(pedited->wavelet.level3noise ? Edited : UnEdited);
leveldenoise->setEditedState(pedited->wavelet.leveldenoise ? Edited : UnEdited);
levelsigm->setEditedState(pedited->wavelet.levelsigm ? Edited : UnEdited);
for (int i = 0; i < 9; i++) {
correction[i]->setEditedState(pedited->wavelet.c[i] ? Edited : UnEdited);
}
for (int i = 0; i < 9; i++) {
correctionch[i]->setEditedState(pedited->wavelet.ch[i] ? Edited : UnEdited);
}
}
/*****************************************************************************************************
*
* Update the GUI, all at once if not in Batch editing (in this case, display EVERYTHING)
*
*****************************************************************************************************/
if (!batchMode) {
int y;
y = thres->getValue();
int z;
for (z = y; z < 9; z++) {
correction[z]->hide();
}
for (z = 0; z < y; z++) {
correction[z]->show();
}
if (pp->wavelet.CHSLmethod == "SL") {
for (z = y; z < 9; z++) {
correctionch[z]->hide();
}
for (z = 0; z < y; z++) {
correctionch[z]->show();
}
}
//adjusterUpdateUI(tmrs);
HSmethodUpdateUI();
CHmethodUpdateUI();
//MedgreinfUpdateUI();
//CHSLmethodUpdateUI();
EDmethodUpdateUI();
NPmethodUpdateUI();
BAmethodUpdateUI();
TMmethodUpdateUI();
//BackmethodUpdateUI();
CLmethodUpdateUI();
lipstUpdateUI();
oldshToggled();
//TilesmethodUpdateUI();
//daubcoeffmethodUpdateUI();
//DirmethodUpdateUI();
//LmethodUpdateUI();
enabledUpdateUI();
medianlevUpdateUI();
cbenabUpdateUI();
if (z == 9) {
sup->show();
} else {
sup->hide();
}
if (complexmethod->get_active_row_number() == 0) {
updateGUIToMode(0);
convertParamToNormal();
} else {
updateGUIToMode(1);
}
}
/*****************************************************************************************************
*
* Enable listeners and signals
*
*****************************************************************************************************/
Lmethodconn.block(false);
CLmethodconn.block(false);
Backmethodconn.block(false);
Tilesmethodconn.block(false);
complexmethodconn.block(false);
//denmethodconn.block(false);
mixmethodconn.block(false);
slimethodconn.block(false);
quamethodconn.block(false);
daubcoeffmethodconn.block(false);
CHmethodconn.block(false);
CHSLmethodconn.block(false);
EDmethodconn.block(false);
NPmethodconn.block(false);
BAmethodconn.block(false);
TMmethodconn.block(false);
HSmethodconn.block(false);
Dirmethodconn.block(false);
MedgreinfConn.block(false);
ushamethodconn.block(false);
enableChromaConn.block(false);
enableContrastConn.block(false);
enableEdgeConn.block(false);
enableFinalConn.block(false);
enableNoiseConn.block(false);
enableResidConn.block(false);
enableToningConn.block(false);
enableListener();
}
void Wavelet::setEditProvider(EditDataProvider *provider)
{
ccshape->setEditProvider(provider);
blshape->setEditProvider(provider);
opacityShapeRG->setEditProvider(provider);
//opacityShapeSH->setEditProvider(provider);
opacityShapeBY->setEditProvider(provider);
wavdenoise->setEditProvider(provider);
wavdenoiseh->setEditProvider(provider);
opacityShape->setEditProvider(provider);
opacityShapeWL->setEditProvider(provider);
hhshape->setEditProvider(provider);
wavguidf->setEditProvider(provider);
wavhue->setEditProvider(provider);
Chshape->setEditProvider(provider);
clshape->setEditProvider(provider);
}
void Wavelet::autoOpenCurve()
{
ccshape->openIfNonlinear();
blshape->openIfNonlinear();
//opacityShapeRG->openIfNonlinear();
//opacityShapeBY->openIfNonlinear();
}
void Wavelet::write(ProcParams* pp, ParamsEdited* pedited)
{
pp->wavelet.enabled = getEnabled();
pp->wavelet.avoid = avoid->get_active();
pp->wavelet.showmask = showmask->get_active();
pp->wavelet.oldsh = oldsh->get_active();
pp->wavelet.tmr = tmr->get_active();
pp->wavelet.sigma = sigma->getValue();
pp->wavelet.offset = offset->getValue();
pp->wavelet.lowthr = lowthr->getValue();
pp->wavelet.rescon = rescon->getValue();
pp->wavelet.resconH = resconH->getValue();
pp->wavelet.reschro = reschro->getValue();
pp->wavelet.resblur = resblur->getValue();
pp->wavelet.resblurc = resblurc->getValue();
pp->wavelet.tmrs = tmrs->getValue();
pp->wavelet.edgs = edgs->getValue();
pp->wavelet.scale = scale->getValue();
pp->wavelet.gamma = gamma->getValue();
pp->wavelet.sup = sup->getValue();
pp->wavelet.sky = sky->getValue();
pp->wavelet.thres = thres->getValue();
pp->wavelet.chroma = chroma->getValue();
pp->wavelet.chro = chro->getValue();
pp->wavelet.median = median->get_active();
pp->wavelet.medianlev = medianlev->get_active();
pp->wavelet.linkedg = linkedg->get_active();
// pp->wavelet.edgreinf = edgreinf->get_active ();
pp->wavelet.cbenab = cbenab->get_active();
pp->wavelet.lipst = lipst->get_active();
pp->wavelet.contrast = contrast->getValue();
pp->wavelet.edgrad = edgrad->getValue();
pp->wavelet.edgeffect = edgeffect->getValue();
pp->wavelet.edgval = edgval->getValue();
pp->wavelet.edgthresh = edgthresh->getValue();
pp->wavelet.thr = thr->getValue();
pp->wavelet.thrH = thrH->getValue();
pp->wavelet.radius = radius->getValue();
pp->wavelet.hueskin = hueskin->getValue<int> ();
pp->wavelet.hueskin2 = hueskin2->getValue<int> ();
pp->wavelet.skinprotect = skinprotect->getValue();
pp->wavelet.threshold = threshold->getValue();
pp->wavelet.threshold2 = threshold2->getValue();
pp->wavelet.edgedetect = edgedetect->getValue();
pp->wavelet.edgedetectthr = edgedetectthr->getValue();
pp->wavelet.edgedetectthr2 = edgedetectthr2->getValue();
pp->wavelet.edgesensi = edgesensi->getValue();
pp->wavelet.edgeampli = edgeampli->getValue();
pp->wavelet.hllev = hllev->getValue<int> ();
pp->wavelet.bllev = bllev->getValue<int> ();
pp->wavelet.edgcont = edgcont->getValue<int> ();
pp->wavelet.chrwav = chrwav->getValue();
pp->wavelet.bluwav = bluwav->getValue();
pp->wavelet.level0noise = level0noise->getValue<double> ();
pp->wavelet.level1noise = level1noise->getValue<double> ();
pp->wavelet.level2noise = level2noise->getValue<double> ();
pp->wavelet.level3noise = level3noise->getValue<double> ();
pp->wavelet.leveldenoise = leveldenoise->getValue<double> ();
pp->wavelet.levelsigm = levelsigm->getValue<double> ();
pp->wavelet.ccwcurve = ccshape->getCurve();
pp->wavelet.blcurve = blshape->getCurve();
pp->wavelet.opacityCurveRG = opacityShapeRG->getCurve();
//pp->wavelet.opacityCurveSH = opacityShapeSH->getCurve();
pp->wavelet.opacityCurveBY = opacityShapeBY->getCurve();
pp->wavelet.wavdenoise = wavdenoise->getCurve();
pp->wavelet.wavdenoiseh = wavdenoiseh->getCurve();
pp->wavelet.opacityCurveW = opacityShape->getCurve();
pp->wavelet.opacityCurveWL = opacityShapeWL->getCurve();
pp->wavelet.hhcurve = hhshape->getCurve();
pp->wavelet.wavguidcurve = wavguidf->getCurve();
pp->wavelet.wavhuecurve = wavhue->getCurve();
pp->wavelet.Chcurve = Chshape->getCurve();
pp->wavelet.pastlev = pastlev->getValue<int> ();
pp->wavelet.satlev = satlev->getValue<int> ();
pp->wavelet.strength = (int) strength->getValue();
pp->wavelet.balance = (int) balance->getValue();
pp->wavelet.balchrom = balchrom->getValue();
pp->wavelet.sigm = sigm->getValue();
pp->wavelet.levden = levden->getValue();
pp->wavelet.thrden = thrden->getValue();
pp->wavelet.limden = limden->getValue();
pp->wavelet.ballum = ballum->getValue();
pp->wavelet.chromfi = chromfi->getValue();
pp->wavelet.chromco = chromco->getValue();
double zerox = 0.;
double zeroy = 0.;
labgrid->getParams(pp->wavelet.labgridALow, pp->wavelet.labgridBLow, pp->wavelet.labgridAHigh, pp->wavelet.labgridBHigh, zerox, zeroy, zerox, zeroy, zerox, zeroy);
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();
pp->wavelet.greenmed = greenmed->getValue();
pp->wavelet.bluemed = bluemed->getValue();
pp->wavelet.greenhigh = greenhigh->getValue();
pp->wavelet.bluehigh = bluehigh->getValue();
pp->wavelet.mergeL = mergeL->getValue();
pp->wavelet.mergeC = mergeC->getValue();
pp->wavelet.softrad = softrad->getValue();
pp->wavelet.softradend = softradend->getValue();
pp->wavelet.strend = strend->getValue();
pp->wavelet.detend = detend->getIntValue();
pp->wavelet.thrend = thrend->getValue();
pp->wavelet.expcontrast = expcontrast->getEnabled();
pp->wavelet.expchroma = expchroma->getEnabled();
pp->wavelet.expedge = expedge->getEnabled();
pp->wavelet.expbl = expbl->getEnabled();
pp->wavelet.expresid = expresid->getEnabled();
pp->wavelet.expfinal = expfinal->getEnabled();
pp->wavelet.exptoning = exptoning->getEnabled();
pp->wavelet.expnoise = expnoise->getEnabled();
pp->wavelet.expclari = expclari->getEnabled();
pp->wavelet.iter = (int) iter->getValue();
pp->wavelet.wavclCurve = clshape->getCurve();
pp->wavelet.sigmafin = sigmafin->getValue();
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();
}
for (int i = 0; i < 9; i++) {
pp->wavelet.ch[i] = (int) correctionch[i]->getValue();
}
if (pedited) {
pedited->wavelet.enabled = !get_inconsistent();
pedited->wavelet.avoid = !avoid->get_inconsistent();
pedited->wavelet.showmask = !showmask->get_inconsistent();
pedited->wavelet.oldsh = !oldsh->get_inconsistent();
pedited->wavelet.tmr = !tmr->get_inconsistent();
pedited->wavelet.median = !median->get_inconsistent();
pedited->wavelet.medianlev = !medianlev->get_inconsistent();
pedited->wavelet.linkedg = !linkedg->get_inconsistent();
pedited->wavelet.cbenab = !cbenab->get_inconsistent();
pedited->wavelet.lipst = !lipst->get_inconsistent();
pedited->wavelet.Medgreinf = Medgreinf->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.ushamethod = ushamethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.Lmethod = Lmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.CLmethod = CLmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.Backmethod = Backmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.Tilesmethod = Tilesmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.complexmethod = complexmethod->get_active_text() != M("GENERAL_UNCHANGED");
//pedited->wavelet.denmethod = denmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.mixmethod = mixmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.slimethod = slimethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.quamethod = quamethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.daubcoeffmethod = daubcoeffmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.CHmethod = CHmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.CHSLmethod = CHSLmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.EDmethod = EDmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.NPmethod = NPmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.BAmethod = BAmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.TMmethod = TMmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.HSmethod = HSmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.Dirmethod = Dirmethod->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wavelet.edgthresh = edgthresh->getEditedState();
pedited->wavelet.sigma = sigma->getEditedState();
pedited->wavelet.offset = offset->getEditedState();
pedited->wavelet.lowthr = lowthr->getEditedState();
pedited->wavelet.rescon = rescon->getEditedState();
pedited->wavelet.resconH = resconH->getEditedState();
pedited->wavelet.reschro = reschro->getEditedState();
pedited->wavelet.resblur = resblur->getEditedState();
pedited->wavelet.resblurc = resblurc->getEditedState();
pedited->wavelet.tmrs = tmrs->getEditedState();
pedited->wavelet.edgs = edgs->getEditedState();
pedited->wavelet.scale = scale->getEditedState();
pedited->wavelet.gamma = gamma->getEditedState();
pedited->wavelet.sup = sup->getEditedState();
pedited->wavelet.sky = sky->getEditedState();
pedited->wavelet.thres = thres->getEditedState();
pedited->wavelet.threshold = threshold->getEditedState();
pedited->wavelet.threshold2 = threshold2->getEditedState();
pedited->wavelet.edgedetect = edgedetect->getEditedState();
pedited->wavelet.edgedetectthr = edgedetectthr->getEditedState();
pedited->wavelet.edgedetectthr2 = edgedetectthr2->getEditedState();
pedited->wavelet.edgesensi = edgesensi->getEditedState();
pedited->wavelet.edgeampli = edgeampli->getEditedState();
pedited->wavelet.chroma = chroma->getEditedState();
pedited->wavelet.chro = chro->getEditedState();
pedited->wavelet.contrast = contrast->getEditedState();
pedited->wavelet.edgrad = edgrad->getEditedState();
pedited->wavelet.edgeffect = edgeffect->getEditedState();
pedited->wavelet.edgval = edgval->getEditedState();
pedited->wavelet.thr = thr->getEditedState();
pedited->wavelet.thrH = thrH->getEditedState();
pedited->wavelet.radius = radius->getEditedState();
pedited->wavelet.hueskin = hueskin->getEditedState();
pedited->wavelet.hueskin2 = hueskin2->getEditedState();
pedited->wavelet.skinprotect = skinprotect->getEditedState();
pedited->wavelet.hllev = hllev->getEditedState();
pedited->wavelet.ccwcurve = !ccshape->isUnChanged();
pedited->wavelet.blcurve = !blshape->isUnChanged();
pedited->wavelet.edgcont = edgcont->getEditedState();
pedited->wavelet.chrwav = chrwav->getEditedState();
pedited->wavelet.bluwav = bluwav->getEditedState();
pedited->wavelet.level0noise = level0noise->getEditedState();
pedited->wavelet.level1noise = level1noise->getEditedState();
pedited->wavelet.level2noise = level2noise->getEditedState();
pedited->wavelet.level3noise = level3noise->getEditedState();
pedited->wavelet.leveldenoise = leveldenoise->getEditedState();
pedited->wavelet.levelsigm = levelsigm->getEditedState();
pedited->wavelet.opacityCurveRG = !opacityShapeRG->isUnChanged();
//pedited->wavelet.opacityCurveSH = !opacityShapeSH->isUnChanged();
pedited->wavelet.opacityCurveBY = !opacityShapeBY->isUnChanged();
pedited->wavelet.wavdenoise = !wavdenoise->isUnChanged();
pedited->wavelet.wavdenoiseh = !wavdenoiseh->isUnChanged();
pedited->wavelet.opacityCurveW = !opacityShape->isUnChanged();
pedited->wavelet.opacityCurveWL = !opacityShapeWL->isUnChanged();
pedited->wavelet.hhcurve = !hhshape->isUnChanged();
pedited->wavelet.wavguidcurve = !wavguidf->isUnChanged();
pedited->wavelet.wavhuecurve = !wavhue->isUnChanged();
pedited->wavelet.Chcurve = !Chshape->isUnChanged();
pedited->wavelet.bllev = bllev->getEditedState();
pedited->wavelet.pastlev = pastlev->getEditedState();
pedited->wavelet.satlev = satlev->getEditedState();
pedited->wavelet.strength = strength->getEditedState();
pedited->wavelet.greenlow = greenlow->getEditedState();
pedited->wavelet.bluelow = bluelow->getEditedState();
pedited->wavelet.greenmed = greenmed->getEditedState();
pedited->wavelet.bluemed = bluemed->getEditedState();
pedited->wavelet.greenhigh = greenhigh->getEditedState();
pedited->wavelet.bluehigh = bluehigh->getEditedState();
pedited->wavelet.sigm = sigm->getEditedState();
pedited->wavelet.levden = levden->getEditedState();
pedited->wavelet.thrden = thrden->getEditedState();
pedited->wavelet.limden = limden->getEditedState();
pedited->wavelet.ballum = ballum->getEditedState();
pedited->wavelet.balchrom = balchrom->getEditedState();
pedited->wavelet.chromfi = chromfi->getEditedState();
pedited->wavelet.chromco = chromco->getEditedState();
pedited->wavelet.mergeL = mergeL->getEditedState();
pedited->wavelet.mergeC = mergeC->getEditedState();
pedited->wavelet.softrad = softrad->getEditedState();
pedited->wavelet.softradend = softradend->getEditedState();
pedited->wavelet.strend = strend->getEditedState();
pedited->wavelet.detend = detend->getEditedState();
pedited->wavelet.thrend = thrend->getEditedState();
pedited->wavelet.balance = balance->getEditedState();
pedited->wavelet.iter = iter->getEditedState();
pedited->wavelet.sigmafin = sigmafin->getEditedState();
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();
pedited->wavelet.expedge = !expedge->get_inconsistent();
pedited->wavelet.expbl = !expbl->get_inconsistent();
pedited->wavelet.expresid = !expresid->get_inconsistent();
pedited->wavelet.expfinal = !expfinal->get_inconsistent();
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();
}
for (int i = 0; i < 9; i++) {
pedited->wavelet.ch[i] = correctionch[i]->getEditedState();
}
}
if (CHmethod->get_active_row_number() == 0) {
pp->wavelet.CHmethod = "without";
} else if (CHmethod->get_active_row_number() == 1) {
pp->wavelet.CHmethod = "with";
} else if (CHmethod->get_active_row_number() == 2) {
pp->wavelet.CHmethod = "link";
}
if (Medgreinf->get_active_row_number() == 0) {
pp->wavelet.Medgreinf = "more";
} else if (Medgreinf->get_active_row_number() == 1) {
pp->wavelet.Medgreinf = "none";
} else if (Medgreinf->get_active_row_number() == 2) {
pp->wavelet.Medgreinf = "less";
}
// if (ushamethod->get_active_row_number() == 0) {
// pp->wavelet.ushamethod = "none";
// } else
if (ushamethod->get_active_row_number() == 0) {
pp->wavelet.ushamethod = "sharp";
} else if (ushamethod->get_active_row_number() == 1) {
pp->wavelet.ushamethod = "clari";
}
if (CHSLmethod->get_active_row_number() == 0) {
pp->wavelet.CHSLmethod = "SL";
} else if (CHSLmethod->get_active_row_number() == 1) {
pp->wavelet.CHSLmethod = "CU";
}
if (EDmethod->get_active_row_number() == 0) {
pp->wavelet.EDmethod = "SL";
} else if (EDmethod->get_active_row_number() == 1) {
pp->wavelet.EDmethod = "CU";
}
if (NPmethod->get_active_row_number() == 0) {
pp->wavelet.NPmethod = "none";
} else if (NPmethod->get_active_row_number() == 1) {
pp->wavelet.NPmethod = "low";
} else if (NPmethod->get_active_row_number() == 2) {
pp->wavelet.NPmethod = "high";
}
if (BAmethod->get_active_row_number() == 0) {
pp->wavelet.BAmethod = "none";
} else if (BAmethod->get_active_row_number() == 1) {
pp->wavelet.BAmethod = "sli";
} else if (BAmethod->get_active_row_number() == 2) {
pp->wavelet.BAmethod = "cur";
}
if (TMmethod->get_active_row_number() == 0) {
pp->wavelet.TMmethod = "cont";
} else if (TMmethod->get_active_row_number() == 1) {
pp->wavelet.TMmethod = "tm";
}
// else if (TMmethod->get_active_row_number()==2)
// pp->wavelet.TMmethod = "both";
if (HSmethod->get_active_row_number() == 0) {
pp->wavelet.HSmethod = "without";
} else if (HSmethod->get_active_row_number() == 1) {
pp->wavelet.HSmethod = "with";
}
if (CLmethod->get_active_row_number() == 0) {
pp->wavelet.CLmethod = "one";
} else if (CLmethod->get_active_row_number() == 1) {
pp->wavelet.CLmethod = "inf";
} else if (CLmethod->get_active_row_number() == 2) {
pp->wavelet.CLmethod = "sup";
} else if (CLmethod->get_active_row_number() == 3) {
pp->wavelet.CLmethod = "all";
}
if (Backmethod->get_active_row_number() == 0) {
pp->wavelet.Backmethod = "black";
} else if (Backmethod->get_active_row_number() == 1) {
pp->wavelet.Backmethod = "grey";
} else if (Backmethod->get_active_row_number() == 2) {
pp->wavelet.Backmethod = "resid";
}
if (Tilesmethod->get_active_row_number() == 0) {
pp->wavelet.Tilesmethod = "full";
} else if (Tilesmethod->get_active_row_number() == 1) {
pp->wavelet.Tilesmethod = "big";
// } else if (Tilesmethod->get_active_row_number() == 2) {
// pp->wavelet.Tilesmethod = "lit";
}
if (complexmethod->get_active_row_number() == 0) {
pp->wavelet.complexmethod = "normal";
} else if (complexmethod->get_active_row_number() == 1) {
pp->wavelet.complexmethod = "expert";
}
//if (denmethod->get_active_row_number() == 0) {
// pp->wavelet.denmethod = "equ";
//} else if (denmethod->get_active_row_number() == 1) {
// pp->wavelet.denmethod = "high";
//} else if (denmethod->get_active_row_number() == 2) {
// pp->wavelet.denmethod = "low";
//} else if (denmethod->get_active_row_number() == 3) {
// pp->wavelet.denmethod = "12high";
//} else if (denmethod->get_active_row_number() == 4) {
// pp->wavelet.denmethod = "12low";
//}
if (mixmethod->get_active_row_number() == 0) {
pp->wavelet.mixmethod = "nois";
} else if (mixmethod->get_active_row_number() == 1) {
pp->wavelet.mixmethod = "mix";
} else if (mixmethod->get_active_row_number() == 2) {
pp->wavelet.mixmethod = "mix7";
} else if (mixmethod->get_active_row_number() == 3) {
pp->wavelet.mixmethod = "den";
}
if (slimethod->get_active_row_number() == 0) {
pp->wavelet.slimethod = "sli";
} else if (slimethod->get_active_row_number() == 1) {
pp->wavelet.slimethod = "cur";
}
if (quamethod->get_active_row_number() == 0) {
pp->wavelet.quamethod = "cons";
} else if (quamethod->get_active_row_number() == 1) {
pp->wavelet.quamethod = "agre";
}
if (daubcoeffmethod->get_active_row_number() == 0) {
pp->wavelet.daubcoeffmethod = "2_";
} else if (daubcoeffmethod->get_active_row_number() == 1) {
pp->wavelet.daubcoeffmethod = "4_";
} else if (daubcoeffmethod->get_active_row_number() == 2) {
pp->wavelet.daubcoeffmethod = "6_";
} else if (daubcoeffmethod->get_active_row_number() == 3) {
pp->wavelet.daubcoeffmethod = "10_";
} else if (daubcoeffmethod->get_active_row_number() == 4) {
pp->wavelet.daubcoeffmethod = "14_";
} else if (daubcoeffmethod->get_active_row_number() == 5) {
pp->wavelet.daubcoeffmethod = "20_";
}
if (Dirmethod->get_active_row_number() == 0) {
pp->wavelet.Dirmethod = "one";
} else if (Dirmethod->get_active_row_number() == 1) {
pp->wavelet.Dirmethod = "two";
} else if (Dirmethod->get_active_row_number() == 2) {
pp->wavelet.Dirmethod = "thr";
} else if (Dirmethod->get_active_row_number() == 3) {
pp->wavelet.Dirmethod = "all";
}
pp->wavelet.Lmethod = Lmethod->get_active_row_number() + 1;
}
void Wavelet::curveChanged(CurveEditor* ce)
{
if (listener && getEnabled()) {
if (ce == ccshape) {
listener->panelChanged(EvWavCCCurve, M("HISTORY_CUSTOMCURVE"));
} else if (ce == blshape) {
listener->panelChanged(EvWavblshape, M("HISTORY_CUSTOMCURVE"));
} else if (ce == opacityShapeRG) {
listener->panelChanged(EvWavColor, M("HISTORY_CUSTOMCURVE"));
//} else if (ce == opacityShapeSH) {
// listener->panelChanged(EvWavlevelshc, M("HISTORY_CUSTOMCURVE"));
} else if (ce == opacityShapeBY) {
listener->panelChanged(EvWavOpac, M("HISTORY_CUSTOMCURVE"));
} else if (ce == wavdenoise) {
listener->panelChanged(EvWavdenoise, M("HISTORY_CUSTOMCURVE"));
} else if (ce == wavdenoiseh) {
listener->panelChanged(EvWavdenoiseh, M("HISTORY_CUSTOMCURVE"));
} else if (ce == opacityShape) {
listener->panelChanged(EvWavopacity, M("HISTORY_CUSTOMCURVE"));
} else if (ce == opacityShapeWL) {
listener->panelChanged(EvWavopacityWL, M("HISTORY_CUSTOMCURVE"));
} else if (ce == hhshape) {
listener->panelChanged(EvWavHHCurve, M("HISTORY_CUSTOMCURVE"));
} else if (ce == wavguidf) {
listener->panelChanged(EvWavguid, M("HISTORY_CUSTOMCURVE"));
} else if (ce == wavhue) {
listener->panelChanged(EvWavhue, M("HISTORY_CUSTOMCURVE"));
} else if (ce == Chshape) {
listener->panelChanged(EvWavCHCurve, M("HISTORY_CUSTOMCURVE"));
} else if (ce == clshape) {
listener->panelChanged(EvWavCLCurve, M("HISTORY_CUSTOMCURVE"));
}
}
}
void Wavelet::setDefaults(const ProcParams* defParams, const ParamsEdited* pedited)
{
for (int i = 0; i < 9; i++) {
correction[i]->setDefault(defParams->wavelet.c[i]);
}
for (int i = 0; i < 9; i++) {
correctionch[i]->setDefault(defParams->wavelet.ch[i]);
}
strength->setDefault(defParams->wavelet.strength);
balance->setDefault(defParams->wavelet.balance);
iter->setDefault(defParams->wavelet.iter);
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);
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);
resconH->setDefault(defParams->wavelet.resconH);
reschro->setDefault(defParams->wavelet.reschro);
resblur->setDefault(defParams->wavelet.resblur);
resblurc->setDefault(defParams->wavelet.resblurc);
tmrs->setDefault(defParams->wavelet.tmrs);
edgs->setDefault(defParams->wavelet.edgs);
scale->setDefault(defParams->wavelet.scale);
gamma->setDefault(defParams->wavelet.gamma);
sup->setDefault(defParams->wavelet.sup);
sky->setDefault(defParams->wavelet.sky);
thres->setDefault(defParams->wavelet.thres);
threshold->setDefault(defParams->wavelet.threshold);
threshold2->setDefault(defParams->wavelet.threshold2);
edgedetect->setDefault(defParams->wavelet.edgedetect);
edgedetectthr->setDefault(defParams->wavelet.edgedetectthr);
edgedetectthr2->setDefault(defParams->wavelet.edgedetectthr2);
edgesensi->setDefault(defParams->wavelet.edgesensi);
edgeampli->setDefault(defParams->wavelet.edgeampli);
chroma->setDefault(defParams->wavelet.chroma);
chro->setDefault(defParams->wavelet.chro);
contrast->setDefault(defParams->wavelet.contrast);
edgrad->setDefault(defParams->wavelet.edgrad);
edgeffect->setDefault(defParams->wavelet.edgeffect);
edgval->setDefault(defParams->wavelet.edgval);
edgthresh->setDefault(defParams->wavelet.edgthresh);
thr->setDefault(defParams->wavelet.thr);
thrH->setDefault(defParams->wavelet.thrH);
radius->setDefault(defParams->wavelet.radius);
hueskin->setDefault<int> (defParams->wavelet.hueskin);
hueskin2->setDefault<int> (defParams->wavelet.hueskin2);
hllev->setDefault<int> (defParams->wavelet.hllev);
bllev->setDefault<int> (defParams->wavelet.bllev);
pastlev->setDefault<int> (defParams->wavelet.pastlev);
satlev->setDefault<int> (defParams->wavelet.satlev);
edgcont->setDefault<int> (defParams->wavelet.edgcont);
chrwav->setDefault(defParams->wavelet.chrwav);
bluwav->setDefault(defParams->wavelet.bluwav);
level0noise->setDefault<double> (defParams->wavelet.level0noise);
level1noise->setDefault<double> (defParams->wavelet.level1noise);
level2noise->setDefault<double> (defParams->wavelet.level2noise);
level3noise->setDefault<double> (defParams->wavelet.level3noise);
leveldenoise->setDefault<double> (defParams->wavelet.leveldenoise);
levelsigm->setDefault<double> (defParams->wavelet.levelsigm);
sigm->setDefault(defParams->wavelet.sigm);
levden->setDefault(defParams->wavelet.levden);
thrden->setDefault(defParams->wavelet.thrden);
limden->setDefault(defParams->wavelet.limden);
ballum->setDefault(defParams->wavelet.ballum);
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, 0, 0, 0, 0, 0, 0);
greenlow->setDefault(defParams->wavelet.greenlow);
bluelow->setDefault(defParams->wavelet.bluelow);
greenmed->setDefault(defParams->wavelet.greenmed);
bluemed->setDefault(defParams->wavelet.bluemed);
greenhigh->setDefault(defParams->wavelet.greenhigh);
bluehigh->setDefault(defParams->wavelet.bluehigh);
mergeL->setDefault(defParams->wavelet.mergeL);
mergeC->setDefault(defParams->wavelet.mergeC);
softrad->setDefault(defParams->wavelet.softrad);
softradend->setDefault(defParams->wavelet.softradend);
strend->setDefault(defParams->wavelet.strend);
detend->setDefault(defParams->wavelet.detend);
thrend->setDefault(defParams->wavelet.thrend);
if (pedited) {
greenlow->setDefaultEditedState(pedited->wavelet.greenlow ? Edited : UnEdited);
bluelow->setDefaultEditedState(pedited->wavelet.bluelow ? Edited : UnEdited);
greenmed->setDefaultEditedState(pedited->wavelet.greenmed ? Edited : UnEdited);
bluemed->setDefaultEditedState(pedited->wavelet.bluemed ? Edited : UnEdited);
greenhigh->setDefaultEditedState(pedited->wavelet.greenhigh ? Edited : UnEdited);
bluehigh->setDefaultEditedState(pedited->wavelet.bluehigh ? Edited : UnEdited);
mergeL->setDefaultEditedState(pedited->wavelet.mergeL ? Edited : UnEdited);
mergeC->setDefaultEditedState(pedited->wavelet.mergeC ? Edited : UnEdited);
softrad->setDefaultEditedState(pedited->wavelet.softrad ? Edited : UnEdited);
softradend->setDefaultEditedState(pedited->wavelet.softradend ? Edited : UnEdited);
strend->setDefaultEditedState(pedited->wavelet.strend ? Edited : UnEdited);
detend->setDefaultEditedState(pedited->wavelet.detend ? Edited : UnEdited);
thrend->setDefaultEditedState(pedited->wavelet.thrend ? Edited : UnEdited);
sigm->setDefaultEditedState(pedited->wavelet.sigm ? Edited : UnEdited);
levden->setDefaultEditedState(pedited->wavelet.levden ? Edited : UnEdited);
thrden->setDefaultEditedState(pedited->wavelet.thrden ? Edited : UnEdited);
limden->setDefaultEditedState(pedited->wavelet.limden ? Edited : UnEdited);
ballum->setDefaultEditedState(pedited->wavelet.ballum ? Edited : UnEdited);
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);
lowthr->setDefault(defParams->wavelet.lowthr);
rescon->setDefault(defParams->wavelet.rescon);
resconH->setDefault(defParams->wavelet.resconH);
reschro->setDefault(defParams->wavelet.reschro);
resblur->setDefault(defParams->wavelet.resblur);
resblurc->setDefault(defParams->wavelet.resblurc);
tmrs->setDefault(defParams->wavelet.tmrs);
edgs->setDefault(defParams->wavelet.edgs);
scale->setDefault(defParams->wavelet.scale);
gamma->setDefault(defParams->wavelet.gamma);
sup->setDefault(defParams->wavelet.sup);
sky->setDefaultEditedState(pedited->wavelet.sky ? Edited : UnEdited);
thres->setDefaultEditedState(pedited->wavelet.thres ? Edited : UnEdited);
threshold->setDefaultEditedState(pedited->wavelet.threshold ? Edited : UnEdited);
threshold2->setDefaultEditedState(pedited->wavelet.threshold2 ? Edited : UnEdited);
edgedetect->setDefaultEditedState(pedited->wavelet.edgedetect ? Edited : UnEdited);
edgedetectthr->setDefaultEditedState(pedited->wavelet.edgedetectthr ? Edited : UnEdited);
edgedetectthr2->setDefaultEditedState(pedited->wavelet.edgedetectthr2 ? Edited : UnEdited);
edgesensi->setDefaultEditedState(pedited->wavelet.edgesensi ? Edited : UnEdited);
edgeampli->setDefaultEditedState(pedited->wavelet.edgeampli ? Edited : UnEdited);
chroma->setDefaultEditedState(pedited->wavelet.chroma ? Edited : UnEdited);
chro->setDefaultEditedState(pedited->wavelet.chro ? Edited : UnEdited);
contrast->setDefaultEditedState(pedited->wavelet.contrast ? Edited : UnEdited);
edgrad->setDefaultEditedState(pedited->wavelet.edgrad ? Edited : UnEdited);
edgeffect->setDefaultEditedState(pedited->wavelet.edgeffect ? Edited : UnEdited);
edgval->setDefaultEditedState(pedited->wavelet.edgval ? Edited : UnEdited);
edgthresh->setDefault(defParams->wavelet.edgthresh);
thr->setDefaultEditedState(pedited->wavelet.thr ? Edited : UnEdited);
thrH->setDefaultEditedState(pedited->wavelet.thrH ? Edited : UnEdited);
radius->setDefaultEditedState(pedited->wavelet.radius ? Edited : UnEdited);
skinprotect->setDefaultEditedState(pedited->wavelet.skinprotect ? Edited : UnEdited);
hueskin->setDefaultEditedState(pedited->wavelet.hueskin ? Edited : UnEdited);
hueskin2->setDefaultEditedState(pedited->wavelet.hueskin2 ? Edited : UnEdited);
hllev->setDefaultEditedState(pedited->wavelet.hllev ? Edited : UnEdited);
bllev->setDefaultEditedState(pedited->wavelet.bllev ? Edited : UnEdited);
pastlev->setDefaultEditedState(pedited->wavelet.pastlev ? Edited : UnEdited);
satlev->setDefaultEditedState(pedited->wavelet.satlev ? Edited : UnEdited);
edgcont->setDefaultEditedState(pedited->wavelet.edgcont ? Edited : UnEdited);
chrwav->setDefaultEditedState(pedited->wavelet.chrwav ? Edited : UnEdited);
bluwav->setDefaultEditedState(pedited->wavelet.bluwav ? Edited : UnEdited);
strength->setDefaultEditedState(pedited->wavelet.strength ? Edited : UnEdited);
balance->setDefaultEditedState(pedited->wavelet.balance ? Edited : UnEdited);
iter->setDefaultEditedState(pedited->wavelet.iter ? Edited : UnEdited);
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);
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);
level3noise->setDefaultEditedState(pedited->wavelet.level3noise ? Edited : UnEdited);
leveldenoise->setDefaultEditedState(pedited->wavelet.leveldenoise ? Edited : UnEdited);
levelsigm->setDefaultEditedState(pedited->wavelet.levelsigm ? Edited : UnEdited);
for (int i = 0; i < 9; i++) {
correction[i]->setDefaultEditedState(pedited->wavelet.c[i] ? Edited : UnEdited);
}
for (int i = 0; i < 9; i++) {
correctionch[i]->setDefaultEditedState(pedited->wavelet.ch[i] ? Edited : UnEdited);
}
} else {
sigma->setDefaultEditedState(Irrelevant);
offset->setDefaultEditedState(Irrelevant);
lowthr->setDefaultEditedState(Irrelevant);
rescon->setDefaultEditedState(Irrelevant);
resconH->setDefaultEditedState(Irrelevant);
reschro->setDefaultEditedState(Irrelevant);
resblur->setDefaultEditedState(Irrelevant);
resblurc->setDefaultEditedState(Irrelevant);
tmrs->setDefaultEditedState(Irrelevant);
edgs->setDefaultEditedState(Irrelevant);
scale->setDefaultEditedState(Irrelevant);
gamma->setDefaultEditedState(Irrelevant);
sup->setDefaultEditedState(Irrelevant);
sky->setDefaultEditedState(Irrelevant);
thres->setDefaultEditedState(Irrelevant);
threshold->setDefaultEditedState(Irrelevant);
threshold2->setDefaultEditedState(Irrelevant);
edgedetect->setDefaultEditedState(Irrelevant);
edgedetectthr->setDefaultEditedState(Irrelevant);
edgedetectthr2->setDefaultEditedState(Irrelevant);
edgesensi->setDefaultEditedState(Irrelevant);
edgeampli->setDefaultEditedState(Irrelevant);
chroma->setDefaultEditedState(Irrelevant);
chro->setDefaultEditedState(Irrelevant);
contrast->setDefaultEditedState(Irrelevant);
edgrad->setDefaultEditedState(Irrelevant);
edgeffect->setDefaultEditedState(Irrelevant);
edgval->setDefaultEditedState(Irrelevant);
edgthresh->setDefaultEditedState(Irrelevant);
thr->setDefaultEditedState(Irrelevant);
thrH->setDefaultEditedState(Irrelevant);
radius->setDefaultEditedState(Irrelevant);
skinprotect->setDefaultEditedState(Irrelevant);
hueskin->setDefaultEditedState(Irrelevant);
hueskin2->setDefaultEditedState(Irrelevant);
hllev->setDefaultEditedState(Irrelevant);
bllev->setDefaultEditedState(Irrelevant);
edgcont->setDefaultEditedState(Irrelevant);
chrwav->setDefaultEditedState(Irrelevant);
bluwav->setDefaultEditedState(Irrelevant);
level0noise->setDefaultEditedState(Irrelevant);
level1noise->setDefaultEditedState(Irrelevant);
level2noise->setDefaultEditedState(Irrelevant);
level3noise->setDefaultEditedState(Irrelevant);
leveldenoise->setDefaultEditedState(Irrelevant);
levelsigm->setDefaultEditedState(Irrelevant);
pastlev->setDefaultEditedState(Irrelevant);
satlev->setDefaultEditedState(Irrelevant);
strength->setDefaultEditedState(Irrelevant);
balance->setDefaultEditedState(Irrelevant);
iter->setDefaultEditedState(Irrelevant);
sigmafin->setDefaultEditedState(Irrelevant);
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);
}
for (int i = 0; i < 9; i++) {
correctionch[i]->setDefaultEditedState(Irrelevant);
}
}
}
void Wavelet::adjusterChanged(ThresholdAdjuster* a, double newBottom, double newTop)
{
if (listener && (multiImage || getEnabled())) {
if (a == level0noise) {
listener->panelChanged(EvWavlev0nois,
Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
} else if (a == level1noise) {
listener->panelChanged(EvWavlev1nois,
Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
} else if (a == level2noise) {
listener->panelChanged(EvWavlev2nois,
Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
} else if (a == level3noise) {
listener->panelChanged(EvWavlev3nois,
Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
} else if (a == leveldenoise) {
listener->panelChanged(EvWavlevdenois,
Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_DEN5THR") + ": %2"), int(newTop), int(newBottom)));
} else if (a == levelsigm) {
usleep(150);
listener->panelChanged(EvWavlevelsigm,
Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_LEVELLOW") + ": %1" + "\n" + M("TP_WAVELET_LEVELHIGH") + ": %2"), (newTop), (newBottom)));
}
}
}
void Wavelet::adjusterChanged(ThresholdAdjuster* a, double newBottomLeft, double newTopLeft, double newBottomRight, double newTopRight)
{
}
void Wavelet::adjusterChanged(ThresholdAdjuster* a, int newBottom, int newTop)
{
}
void Wavelet::adjusterChanged(ThresholdAdjuster* a, int newBottomLeft, int newTopLeft, int newBottomRight, int newTopRight)
{
}
void Wavelet::adjusterChanged2(ThresholdAdjuster* a, int newBottomL, int newTopL, int newBottomR, int newTopR)
{
if (listener && (multiImage || getEnabled())) {
if (a == hueskin) {
listener->panelChanged(EvWavHueskin, hueskin->getHistoryString());
} else if (a == hueskin2) {
listener->panelChanged(EvWavHueskin2, hueskin2->getHistoryString());
} else if (a == hllev) {
listener->panelChanged(EvWavlhl, hllev->getHistoryString());
} else if (a == bllev) {
listener->panelChanged(EvWavlbl, bllev->getHistoryString());
} else if (a == pastlev) {
listener->panelChanged(EvWavpast, pastlev->getHistoryString());
} else if (a == satlev) {
listener->panelChanged(EvWavsat, satlev->getHistoryString());
} else if (a == edgcont) {
listener->panelChanged(EvWavedgcont, edgcont->getHistoryString());
}
}
}
void Wavelet::HSmethodUpdateUI()
{
if (!batchMode) {
if (HSmethod->get_active_row_number() == 0) { //without
hllev->hide();
bllev->hide();
threshold->hide();
threshold2->hide();
//curveEditorC->hide();
} else { //with
hllev->show();
bllev->show();
threshold->show();
threshold2->show();
//curveEditorC->show();
}
}
}
void Wavelet::HSmethodChanged()
{
HSmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavHSmet, HSmethod->get_active_text());
}
}
void Wavelet::CHmethodUpdateUI()
{
if (!batchMode) {
if (CHmethod->get_active_row_number() == 0) {
CHSLmethod->show();
// sigmacol->show();
pastlev->hide();
satlev->hide();
chroma->hide();
chro->hide();
labmC->show();
separatorNeutral->hide();
neutralchButton->show();
int y = thres->getValue();
int z;
for (z = y; z < 9; z++) {
correctionch[z]->hide();
}
for (z = 0; z < y; z++) {
correctionch[z]->show();
}
} else if (CHmethod->get_active_row_number() == 1) {
CHSLmethod->show();
// sigmacol->show();
pastlev->show();
satlev->show();
chroma->show();
chro->hide();
labmC->show();
separatorNeutral->show();
neutralchButton->show();
int y = thres->getValue();
int z;
for (z = y; z < 9; z++) {
correctionch[z]->hide();
}
for (z = 0; z < y; z++) {
correctionch[z]->show();
}
} else {
chro->show();
// sigmacol->hide();
pastlev->hide();
satlev->hide();
chroma->hide();
CHSLmethod->hide();
labmC->hide();
separatorNeutral->hide();
neutralchButton->hide();
for (int i = 0; i < 9; i++) {
correctionch[i]->hide();
}
}
}
}
void Wavelet::CHmethodChanged()
{
CHmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavCHmet, CHmethod->get_active_text());
}
}
/*
void Wavelet::CHSLmethodChangedUI() {
if (!batchMode) {
if(CHSLmethod->get_active_row_number()==0 && CHmethod->get_active_row_number() != 2) {//SL
//CLVcurveEditorG->hide();
neutralchButton->show();
int y=thres->getValue();
int z;
for(z=y;z<9;z++) correctionch[z]->hide();
for(z=0;z<y;z++) correctionch[z]->show();
}
else if(CHSLmethod->get_active_row_number()==1) {//CU
//CLVcurveEditorG->show();
neutralchButton->hide();
for (int i = 0; i < 9; i++) {
correctionch[i]->hide();
}
}
}
}
*/
void Wavelet::CHSLmethodChanged()
{
/*
CHSLmethodChangedUI();
if (listener && (multiImage||enabled->get_active()) ) {
listener->panelChanged (EvWavCHSLmet, CHSLmethod->get_active_text ());
}
*/
}
void Wavelet::EDmethodUpdateUI()
{
if (!batchMode) {
if (EDmethod->get_active_row_number() == 0) { //SL
CCWcurveEditorG->hide();
edgcont->show();
} else if (EDmethod->get_active_row_number() == 1) { //CU
CCWcurveEditorG->show();
edgcont->hide();
}
}
}
void Wavelet::EDmethodChanged()
{
EDmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavEDmet, EDmethod->get_active_text());
}
}
void Wavelet::NPmethodUpdateUI()
{
if (!batchMode) {
}
}
void Wavelet::NPmethodChanged()
{
NPmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavNPmet, NPmethod->get_active_text());
}
}
void Wavelet::BAmethodUpdateUI()
{
if (!batchMode) {
if (BAmethod->get_active_row_number() == 0) { //none
balance->hide();
opacityCurveEditorW->hide();
iter->hide();
tmr->hide();
} else if (BAmethod->get_active_row_number() == 1) { //sli
opacityCurveEditorW->hide();
balance->show();
iter->show();
tmr->show();
} else if (BAmethod->get_active_row_number() == 2) { //CU
opacityCurveEditorW->show();
balance->hide();
iter->show();
tmr->show();
}
}
}
void Wavelet::BAmethodChanged()
{
BAmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavBAmet, BAmethod->get_active_text());
}
}
void Wavelet::TMmethodUpdateUI()
{
/*
if (!batchMode) {
if(TMmethod->get_active_row_number()==0 ) {//
tmr->hide();
}
else {
tmr->show();
}
}
*/
if (TMmethod->get_active_row_number() == 1) {
edgs->show();
scale->show();
} else if (TMmethod->get_active_row_number() == 0) {
edgs->hide();
scale->hide();
}
}
void Wavelet::TMmethodChanged()
{
TMmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavTMmet, TMmethod->get_active_text());
}
}
/*
void Wavelet::BackmethodUpdateUI() {
if (!batchMode) {
}
}
*/
void Wavelet::BackmethodChanged()
{
//BackmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavBackmet, Backmethod->get_active_text());
}
}
void Wavelet::CLmethodUpdateUI()
{
if (!batchMode) {
if (CLmethod->get_active_row_number() == 0) {
CLmethod->set_active(0);
Lmethod->set_sensitive(true);
Dirmethod->set_sensitive(true);
} else if (CLmethod->get_active_row_number() == 1) {
CLmethod->set_active(1);
Lmethod->set_sensitive(true);
Dirmethod->set_sensitive(true);
} else if (CLmethod->get_active_row_number() == 2) {
CLmethod->set_active(2);
Lmethod->set_sensitive(true);
Dirmethod->set_sensitive(true);
} else if (CLmethod->get_active_row_number() == 3) {
CLmethod->set_active(3);
Lmethod->set_sensitive(false);
Dirmethod->set_sensitive(false);
}
}
}
void Wavelet::CLmethodChanged()
{
CLmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavCLmet, CLmethod->get_active_text());
}
}
/*
void Wavelet::TilesmethodUpdateUI() {
if (!batchMode) {
}
}
*/
void Wavelet::ushamethodChanged()
{
if (ushamethod->get_active_row_number() == 1 && expclari->getEnabled() == true) {
Backmethod->set_active(2);
CLmethod->set_active(2);
Lmethod->set_active(6);
Lmethod->set_sensitive(true);
Dirmethod->set_sensitive(true);
Dirmethod->set_active(3);
CLmethod->set_sensitive(false);
Backmethod->set_sensitive(false);
} else if (ushamethod->get_active_row_number() == 0 && expclari->getEnabled() == true) {
Backmethod->set_active(0);
CLmethod->set_active(1);
Lmethod->set_active(2);
Dirmethod->set_active(3);
Lmethod->set_sensitive(true);
Dirmethod->set_sensitive(true);
CLmethod->set_sensitive(false);
Backmethod->set_sensitive(false);
/* } else if (ushamethod->get_active_row_number() == 0 || expclari->getEnabled() == false) {
Backmethod->set_active(1);
CLmethod->set_active(3);
Lmethod->set_active(3);
Dirmethod->set_active(3);
Lmethod->set_sensitive(false);
Dirmethod->set_sensitive(false);
*/
} else if (expclari->getEnabled() == false) {
Backmethod->set_active(1);
CLmethod->set_active(3);
Lmethod->set_active(3);
Dirmethod->set_active(3);
Lmethod->set_sensitive(false);
Dirmethod->set_sensitive(false);
CLmethod->set_sensitive(true);
Backmethod->set_sensitive(true);
}
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavushamet, ushamethod->get_active_text());
}
}
void Wavelet::convertParamToNormal()
{
const WaveletParams def_params;
disableListener();
//contrast
offset->setValue(def_params.offset);
sigma->setValue(def_params.sigma);
lowthr->setValue(def_params.lowthr);
//chroma
expchroma->setEnabled(def_params.expchroma);
sigmacol->setValue(def_params.sigmacol);
CHmethod->set_active(2);
//denoise
chromfi->setValue(def_params.chromfi);
chromco->setValue(def_params.chromco);
//denmethod->set_active(4);
mixmethod->set_active(2);
slimethod->set_active(0);
levelsigm->setValue<double>(def_params.levelsigm);
leveldenoise->setValue<double>(def_params.leveldenoise);
limden->setValue(def_params.limden);
thrden->setValue(def_params.thrden);
// quamethod->set_active(0);
sigm->setValue(def_params.sigm);
//toning
exptoning->setEnabled(def_params.exptoning);
//gamut
median->set_active(def_params.median);
avoid->set_active(def_params.avoid);
hueskin->setValue(def_params.hueskin);
skinprotect->setValue(def_params.skinprotect);
//blur
expbl->setEnabled(def_params.expbl);
//edge sharpness
lipst->set_active(def_params.lipst);
lipstUpdateUI();
edgesensi->setValue(def_params.edgesensi);
edgeampli->setValue(def_params.edgeampli);
NPmethod->set_active(0);
//resid
// oldsh->set_active(true);
radius->setValue(def_params.radius);
resblur->setValue(def_params.resblur);
resblurc->setValue(def_params.resblurc);
cbenab->set_active(false);
//final touchup
BAmethod->set_active(0);
sigmafin->setValue(def_params.sigmafin);
enableListener();
// Update GUI based on converted widget parameters:
}
void Wavelet::updateGUIToMode(int mode)
{
if(mode ==0) {
offset->hide();
sigma->hide();
lowthr->hide();
ctboxch->hide();
sigmacol->hide();
expgamut->hide();
exptoning->hide();
chroFrame->hide();
expbl->hide();
lipst->hide();
dirFrame->hide();
oldsh->hide();
radius->hide();
blurFrame->hide();
cbenab->hide();
sigmafin->hide();
//denHBox->hide();
mixHBox->hide();
sliHBox->hide();
sigm->hide();
levelsigm->hide();
CurveEditorwavnoiseh->hide();
CurveEditorwavnoise->hide();
// levden->hide();
thrden->hide();
leveldenoise->hide();
limden->hide();
} else {
offset->show();
sigma->show();
lowthr->show();
ctboxch->show();
sigmacol->show();
expgamut->show();
exptoning->show();
chroFrame->show();
expbl->show();
lipst->show();
dirFrame->show();
oldsh->hide();
radius->show();
blurFrame->show();
cbenab->show();
sigmafin->show();
//denHBox->hide();
mixHBox->show();
sigm->hide();
levelsigm->show();
limden->show();
levden->show();
sliHBox->show();
if (slimethod->get_active_row_number() == 0){
leveldenoise->show();
thrden->show();
CurveEditorwavnoiseh->hide();
CurveEditorwavnoise->hide();
} else {
thrden->hide();
leveldenoise->show();
CurveEditorwavnoiseh->show();
CurveEditorwavnoise->show();
}
disableListener();
//denmethod->set_active(4);
enableListener();
}
}
void Wavelet::complexmethodChanged()
{
if (complexmethod->get_active_row_number() == 0) {
updateGUIToMode(0);
convertParamToNormal();
} else {
updateGUIToMode(1);
}
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavcomplexmet, complexmethod->get_active_text());
}
}
//void Wavelet::denmethodChanged()
//{
//
// if (listener && (multiImage || getEnabled())) {
// listener->panelChanged(EvWavdenmethod, denmethod->get_active_text());
// }
//}
void Wavelet::mixmethodChanged()
{
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavmixmethod, mixmethod->get_active_text());
}
}
void Wavelet::slimethodChanged()
{
if (slimethod->get_active_row_number() == 0 && complexmethod->get_active_row_number() == 0) {
updateGUIToMode(0);
convertParamToNormal();
leveldenoise->show();
} else if (slimethod->get_active_row_number() == 0 && complexmethod->get_active_row_number() == 1){
updateGUIToMode(1);
leveldenoise->show();
CurveEditorwavnoiseh->hide();
CurveEditorwavnoise->hide();
} else if (slimethod->get_active_row_number() == 1 && complexmethod->get_active_row_number() == 1){
updateGUIToMode(1);
leveldenoise->show();
CurveEditorwavnoiseh->show();
CurveEditorwavnoise->show();
}
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavslimethod, slimethod->get_active_text());
}
}
void Wavelet::quamethodChanged()
{
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavquamethod, quamethod->get_active_text());
}
}
void Wavelet::TilesmethodChanged()
{
//TilesmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavTilesmet, Tilesmethod->get_active_text());
}
}
/*
void Wavelet::daubcoeffmethodUpdateUI() {
if (!batchMode) {
}}
*/
void Wavelet::daubcoeffmethodChanged()
{
//daubcoeffmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavdaubcoeffmet, daubcoeffmethod->get_active_text());
}
}
/*
void Wavelet::MedgreinfUpdateUI() {
if (!batchMode) {
}
}
*/
void Wavelet::MedgreinfChanged()
{
//MedgreinfUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavedgreinf, Medgreinf->get_active_text());
}
}
/*
void Wavelet::DirmethodUpdateUI() {
if (!batchMode) {
}
}
*/
void Wavelet::DirmethodChanged()
{
//DirmethodUpdateUI();
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavDirmeto, Dirmethod->get_active_text());
}
}
/*
void Wavelet::LmethodUpdateUI() {
if (!batchMode) {
}
}
*/
void Wavelet::LmethodChanged()
{
//LmethodUpdateUI();
if (ushamethod->get_active_row_number() == 0 && expclari->getEnabled() == true) {
if (Lmethod->get_active_row_number() > 3) {
Lmethod->set_active(3);
}
}
if (ushamethod->get_active_row_number() == 1 && expclari->getEnabled() == true) {
if (Lmethod->get_active_row_number() < 4) {
Lmethod->set_active(4);
}
}
if (listener && (multiImage || getEnabled())) {
listener->panelChanged(EvWavLmet, Lmethod->get_active_text());
}
}
void Wavelet::setBatchMode(bool batchMode)
{
Lmethod->append(M("GENERAL_UNCHANGED"));
CLmethod->append(M("GENERAL_UNCHANGED"));
Backmethod->append(M("GENERAL_UNCHANGED"));
Tilesmethod->append(M("GENERAL_UNCHANGED"));
complexmethod->append(M("GENERAL_UNCHANGED"));
//denmethod->append(M("GENERAL_UNCHANGED"));
mixmethod->append(M("GENERAL_UNCHANGED"));
slimethod->append(M("GENERAL_UNCHANGED"));
quamethod->append(M("GENERAL_UNCHANGED"));
daubcoeffmethod->append(M("GENERAL_UNCHANGED"));
CHmethod->append(M("GENERAL_UNCHANGED"));
Medgreinf->append(M("GENERAL_UNCHANGED"));
ushamethod->append(M("GENERAL_UNCHANGED"));
CHSLmethod->append(M("GENERAL_UNCHANGED"));
EDmethod->append(M("GENERAL_UNCHANGED"));
NPmethod->append(M("GENERAL_UNCHANGED"));
BAmethod->append(M("GENERAL_UNCHANGED"));
TMmethod->append(M("GENERAL_UNCHANGED"));
HSmethod->append(M("GENERAL_UNCHANGED"));
Dirmethod->append(M("GENERAL_UNCHANGED"));
CCWcurveEditorG->setBatchMode(batchMode);
opaCurveEditorG->setBatchMode(batchMode);
//curveEditorC->setBatchMode(batchMode);
opacityCurveEditorG->setBatchMode(batchMode);
CurveEditorwavnoise->setBatchMode(batchMode);
CurveEditorwavnoiseh->setBatchMode(batchMode);
CurveEditorwavguid->setBatchMode(batchMode);
CurveEditorwavhue->setBatchMode(batchMode);
opacityCurveEditorW->setBatchMode(batchMode);
opacityCurveEditorWL->setBatchMode(batchMode);
curveEditorbl->setBatchMode(batchMode);
curveEditorRES->setBatchMode(batchMode);
curveEditorGAM->setBatchMode(batchMode);
sigma->showEditedCB();
offset->showEditedCB();
lowthr->showEditedCB();
rescon->showEditedCB();
resconH->showEditedCB();
reschro->showEditedCB();
resblur->showEditedCB();
resblurc->showEditedCB();
tmrs->showEditedCB();
edgs->showEditedCB();
scale->showEditedCB();
gamma->showEditedCB();
sup->showEditedCB();
sky->showEditedCB();
thres->showEditedCB();
threshold->showEditedCB();
threshold2->showEditedCB();
edgedetect->showEditedCB();
edgedetectthr->showEditedCB();
edgedetectthr2->showEditedCB();
edgesensi->showEditedCB();
edgeampli->showEditedCB();
chroma->showEditedCB();
chro->showEditedCB();
contrast->showEditedCB();
edgrad->showEditedCB();
edgeffect->showEditedCB();
edgval->showEditedCB();
edgthresh->showEditedCB();
thr->showEditedCB();
thrH->showEditedCB();
radius->showEditedCB();
skinprotect->showEditedCB();
hueskin->showEditedCB();
hueskin2->showEditedCB();
hllev->showEditedCB();
bllev->showEditedCB();
pastlev->showEditedCB();
satlev->showEditedCB();
edgcont->showEditedCB();
chrwav->showEditedCB();
bluwav->showEditedCB();
strength->showEditedCB();
balance->showEditedCB();
iter->showEditedCB();
sigmafin->showEditedCB();
sigmaton->showEditedCB();
sigmacol->showEditedCB();
sigmadir->showEditedCB();
rangeab->showEditedCB();
protab->showEditedCB();
level0noise->showEditedCB();
level1noise->showEditedCB();
level2noise->showEditedCB();
level3noise->showEditedCB();
leveldenoise->showEditedCB();
levelsigm->showEditedCB();
ToolPanel::setBatchMode(batchMode);
for (int i = 0; i < 9; i++) {
correction[i]->showEditedCB();
}
for (int i = 0; i < 9; i++) {
correctionch[i]->showEditedCB();
}
}
void Wavelet::adjusterUpdateUI(Adjuster* a)
{
/*
if (!batchMode) {
if (a == tmrs ) {
float tm;
tm=tmrs->getValue();
if(tm==0.f) tmr->hide();
else tmr->show();
}
else if (a == gamma ) {
float tm;
tm=tmrs->getValue();
if(tm==0.f) tmr->hide();
else tmr->show();
}
}
*/
}
void Wavelet::adjusterChanged(Adjuster* a, double newval)
{
if (listener && (multiImage || getEnabled())) {
if (a == edgthresh) {
listener->panelChanged(EvWavtiles, edgthresh->getTextValue());
} else if (a == rescon) {
listener->panelChanged(EvWavrescon, rescon->getTextValue());
} else if (a == sigma) {
listener->panelChanged(EvWavsigma, sigma->getTextValue());
} else if (a == offset) {
listener->panelChanged(EvWavoffset, offset->getTextValue());
} else if (a == lowthr) {
listener->panelChanged(EvWavlowthr, lowthr->getTextValue());
} else if (a == resconH) {
listener->panelChanged(EvWavresconH, resconH->getTextValue());
} else if (a == reschro) {
listener->panelChanged(EvWavreschro, reschro->getTextValue());
} else if (a == resblur) {
listener->panelChanged(EvWavresblur, resblur->getTextValue());
} else if (a == resblurc) {
listener->panelChanged(EvWavresblurc, resblurc->getTextValue());
} else if (a == tmrs) {
adjusterUpdateUI(a);
listener->panelChanged(EvWavtmrs, tmrs->getTextValue());
if (tmrs->getValue() != 0 && TMmethod->get_active_row_number() == 1) {
edgs->show();
scale->show();
} else if (TMmethod->get_active_row_number() == 0) {
edgs->hide();
scale->hide();
}
} else if (a == gamma) {
adjusterUpdateUI(a);
listener->panelChanged(EvWavgamma, gamma->getTextValue());
} else if (a == edgs) {
adjusterUpdateUI(a);
listener->panelChanged(EvWavedgs, edgs->getTextValue());
} else if (a == scale) {
adjusterUpdateUI(a);
listener->panelChanged(EvWavscale, scale->getTextValue());
} else if (a == sky) {
listener->panelChanged(EvWavsky, sky->getTextValue());
} else if (a == sup) {
listener->panelChanged(EvWavsup, sup->getTextValue());
} else if (a == chroma) {
listener->panelChanged(EvWavchroma, chroma->getTextValue());
} else if (a == chro) {
listener->panelChanged(EvWavchro, chro->getTextValue());
} else if (a == contrast) {
listener->panelChanged(EvWavunif, contrast->getTextValue());
} else if (a == thr) {
listener->panelChanged(EvWavthr, thr->getTextValue());
} else if (a == thrH) {
listener->panelChanged(EvWavthrH, thrH->getTextValue());
} else if (a == radius) {
listener->panelChanged(EvWavradius, radius->getTextValue());
} else if (a == threshold) {
listener->panelChanged(EvWavThreshold, threshold->getTextValue());
updateGUI();
updateGUImaxlev();
} else if (a == threshold2) {
listener->panelChanged(EvWavThreshold2, threshold2->getTextValue());
} else if (a == edgedetect) {
listener->panelChanged(EvWavedgedetect, edgedetect->getTextValue());
} else if (a == edgedetectthr) {
listener->panelChanged(EvWavedgedetectthr, edgedetectthr->getTextValue());
} else if (a == edgedetectthr2) {
listener->panelChanged(EvWavedgedetectthr2, edgedetectthr2->getTextValue());
} else if (a == edgesensi) {
listener->panelChanged(EvWavedgesensi, edgesensi->getTextValue());
} else if (a == edgeampli) {
listener->panelChanged(EvWavedgeampli, edgeampli->getTextValue());
} else if (a == edgrad) {
listener->panelChanged(EvWavedgrad, edgrad->getTextValue());
} else if (a == edgeffect) {
listener->panelChanged(EvWavedgeffect, edgeffect->getTextValue());
} else if (a == edgval) {
listener->panelChanged(EvWavedgval, edgval->getTextValue());
} else if (a == thres) {
int y = thres->getValue();
int z;
for (z = y; z < 9; z++) {
correction[z]->hide();
}
for (z = 0; z < y; z++) {
correction[z]->show();
}
for (z = y; z < 9; z++) {
correctionch[z]->hide();
}
for (z = 0; z < y; z++) {
correctionch[z]->show();
}
if (z == 9) {
sup->show();
} else {
sup->hide();
}
if(z >= 8 ) {
expnoise->setEnabled(false);
expnoise->set_sensitive(false);
} else {
// expnoise->setEnabled(pp->wavelet.expnoise);
expnoise->set_sensitive(true);
}
listener->panelChanged(EvWavthres, thres->getTextValue());
updateGUImaxlev();
updateGUI();
} else if (a == skinprotect) {
listener->panelChanged(EvWavSkin, skinprotect->getTextValue());
} else if (a == strength) {
listener->panelChanged(EvWavStrength, strength->getTextValue());
} else if (a == balance) {
listener->panelChanged(EvWavbalance, balance->getTextValue());
} else if (a == iter) {
listener->panelChanged(EvWaviter, iter->getTextValue());
} else if (a == sigmafin) {
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) {
listener->panelChanged(EvWavsigmadir, sigmadir->getTextValue());
} else if (a == greenhigh) {
listener->panelChanged(EvWavgreenhigh, greenhigh->getTextValue());
} else if (a == bluehigh) {
listener->panelChanged(EvWavbluehigh, bluehigh->getTextValue());
} else if (a == ballum) {
listener->panelChanged(EvWavballum, ballum->getTextValue());
} else if (a == sigm) {
listener->panelChanged(EvWavsigm, sigm->getTextValue());
} else if (a == levden) {
listener->panelChanged(EvWavlevden, levden->getTextValue());
} else if (a == thrden) {
listener->panelChanged(EvWavthrden, thrden->getTextValue());
} else if (a == limden) {
listener->panelChanged(EvWavlimden, limden->getTextValue());
} else if (a == balchrom) {
listener->panelChanged(EvWavbalchrom, balchrom->getTextValue());
} else if (a == chromfi) {
listener->panelChanged(EvWavchromfi, chromfi->getTextValue());
} else if (a == chromco) {
listener->panelChanged(EvWavchromco, chromco->getTextValue());
} else if (a == mergeL) {
listener->panelChanged(EvWavmergeL, mergeL->getTextValue());
} else if (a == mergeC) {
listener->panelChanged(EvWavmergeC, mergeC->getTextValue());
} else if (a == softrad) {
listener->panelChanged(EvWavsoftrad, softrad->getTextValue());
} else if (a == softradend) {
listener->panelChanged(EvWavsoftradend, softradend->getTextValue());
} else if (a == strend) {
listener->panelChanged(EvWavstrend, strend->getTextValue());
} else if (a == detend) {
listener->panelChanged(EvWavdetend, detend->getTextValue());
} else if (a == thrend) {
listener->panelChanged(EvWavthrend, thrend->getTextValue());
} else if (a == greenmed) {
listener->panelChanged(EvWavgreenmed, greenmed->getTextValue());
} else if (a == bluemed) {
listener->panelChanged(EvWavbluemed, bluemed->getTextValue());
} else if (a == greenlow) {
listener->panelChanged(EvWavgreenlow, greenlow->getTextValue());
} else if (a == bluelow) {
listener->panelChanged(EvWavbluelow, bluelow->getTextValue());
} else if (a == chrwav) {
listener->panelChanged(EvWavchrwav, chrwav->getTextValue());
} else if (a == bluwav) {
listener->panelChanged(EvWavbluwav, bluwav->getTextValue());
}
if ((a == correction[0] || a == correction[1] || a == correction[2] || a == correction[3] || a == correction[4] || a == correction[5] || a == correction[6] || a == correction[7] || a == correction[8])) {
listener->panelChanged(EvWavelet,
Glib::ustring::compose("%1, %2, %3, %4, %5, %6, %7, %8, %9",
Glib::ustring::format(std::fixed, std::setprecision(0), correction[0]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[1]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[2]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[3]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[4]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[5]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[6]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[7]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correction[8]->getValue()))
);
} else if (a == correctionch[0] || a == correctionch[1] || a == correctionch[2] || a == correctionch[3] || a == correctionch[4] || a == correctionch[5] || a == correctionch[6] || a == correctionch[7] || a == correctionch[8]) {
listener->panelChanged(EvWaveletch,
Glib::ustring::compose("%1, %2, %3, %4, %5, %6, %7, %8, %9",
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[0]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[1]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[2]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[3]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[4]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[5]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[6]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[7]->getValue()),
Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[8]->getValue()))
);
}
}
}
void Wavelet::enabledUpdateUI()
{
if (!batchMode) {
int y = thres->getValue();
int z;
for (z = y; z < 9; z++) {
correction[z]->hide();
}
for (z = 0; z < y; z++) {
correction[z]->show();
}
if (z == 9) {
sup->show();
} else {
sup->hide();
}
if(z >= 8) {
expnoise->setEnabled(false);
expnoise->set_sensitive(false);
} else {
expnoise->set_sensitive(true);
}
// adjusterUpdateUI(tmrs);
}
}
void Wavelet::enabledChanged()
{
enabledUpdateUI();
if (listener) {
if (get_inconsistent()) {
listener->panelChanged(EvWavEnabled, M("GENERAL_UNCHANGED"));
} else if (getEnabled()) {
listener->panelChanged(EvWavEnabled, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavEnabled, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::medianToggled()
{
if (multiImage) {
if (median->get_inconsistent()) {
median->set_inconsistent(false);
medianConn.block(true);
median->set_active(false);
medianConn.block(false);
} else if (lastmedian) {
median->set_inconsistent(true);
}
lastmedian = median->get_active();
}
if (listener && (multiImage || getEnabled())) {
if (median->get_inconsistent()) {
listener->panelChanged(EvWavmedian, M("GENERAL_UNCHANGED"));
} else if (median->get_active()) {
listener->panelChanged(EvWavmedian, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavmedian, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::medianlevUpdateUI()
{
if (!batchMode) {
if (medianlev->get_active()) {
edgedetect->show();
lipst->show();
separatoredge->show();
edgedetectthr->show();
edgedetectthr2->show();
// edgesensi->show();
// edgeampli->show();
// NPmethod->show();
// labmNP->show();
if (lipst->get_active()) {
edgesensi->show();
edgeampli->show();
NPmethod->show();
labmNP->show();
}
else {
edgesensi->hide();
edgeampli->hide();
NPmethod->hide();
labmNP->hide();
}
} else {
edgedetect->hide();
lipst->hide();
edgedetectthr->hide();
edgedetectthr2->hide();
edgesensi->hide();
edgeampli->hide();
separatoredge->hide();
NPmethod->hide();
labmNP->hide();
}
}
}
void Wavelet::medianlevToggled()
{
if (multiImage) {
if (medianlev->get_inconsistent()) {
medianlev->set_inconsistent(false);
medianlevConn.block(true);
medianlev->set_active(false);
medianlevConn.block(false);
} else if (lastmedianlev) {
medianlev->set_inconsistent(true);
}
lastmedianlev = medianlev->get_active();
}
medianlevUpdateUI();
if (listener && (multiImage || getEnabled())) {
if (medianlev->get_inconsistent()) {
listener->panelChanged(EvWavmedianlev, M("GENERAL_UNCHANGED"));
} else if (medianlev->get_active()) {
listener->panelChanged(EvWavmedianlev, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavmedianlev, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::linkedgToggled()
{
if (multiImage) {
if (linkedg->get_inconsistent()) {
linkedg->set_inconsistent(false);
linkedgConn.block(true);
linkedg->set_active(false);
linkedgConn.block(false);
} else if (lastlinkedg) {
linkedg->set_inconsistent(true);
}
lastlinkedg = linkedg->get_active();
}
if (listener && (multiImage || getEnabled())) {
if (linkedg->get_inconsistent()) {
listener->panelChanged(EvWavlinkedg, M("GENERAL_UNCHANGED"));
} else if (linkedg->get_active()) {
listener->panelChanged(EvWavlinkedg, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavlinkedg, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::cbenabUpdateUI()
{
if (!batchMode) {
if (cbenab->get_active()) {
chanMixerHLFrame->show();
chanMixerMidFrame->show();
chanMixerShadowsFrame->show();
neutrHBox->show();
} else {
chanMixerHLFrame->hide();
chanMixerMidFrame->hide();
chanMixerShadowsFrame->hide();
neutrHBox->hide();
}
}
}
void Wavelet::cbenabToggled()
{
if (multiImage) {
if (cbenab->get_inconsistent()) {
cbenab->set_inconsistent(false);
cbenabConn.block(true);
cbenab->set_active(false);
cbenabConn.block(false);
} else if (lastcbenab) {
cbenab->set_inconsistent(true);
}
lastcbenab = cbenab->get_active();
}
cbenabUpdateUI();
if (listener && (multiImage || getEnabled())) {
if (cbenab->get_inconsistent()) {
listener->panelChanged(EvWavcbenab, M("GENERAL_UNCHANGED"));
} else if (cbenab->get_active()) {
listener->panelChanged(EvWavcbenab, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavcbenab, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::lipstUpdateUI()
{
if (!batchMode) {
if (lipst->get_active()) {
NPmethod->show();
edgesensi->show();
edgeampli->show();
labmNP->show();
} else {
NPmethod->hide();
edgesensi->hide();
edgeampli->hide();
labmNP->hide();
}
}
}
void Wavelet::lipstToggled()
{
if (multiImage) {
if (lipst->get_inconsistent()) {
lipst->set_inconsistent(false);
lipstConn.block(true);
lipst->set_active(false);
lipstConn.block(false);
} else if (lastlipst) {
lipst->set_inconsistent(true);
}
lastlipst = lipst->get_active();
}
lipstUpdateUI();
if (listener && (multiImage || getEnabled())) {
if (lipst->get_inconsistent()) {
listener->panelChanged(EvWavlipst, M("GENERAL_UNCHANGED"));
} else if (lipst->get_active()) {
listener->panelChanged(EvWavlipst, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavlipst, M("GENERAL_DISABLED"));
}
}
}
/*
void Wavelet::edgreinfToggled () {
if (batchMode) {
if (edgreinf->get_inconsistent()) {
edgreinf->set_inconsistent (false);
edgreinfConn.block (true);
edgreinf->set_active (false);
edgreinfConn.block (false);
}
else if (lastedgreinf)
edgreinf->set_inconsistent (true);
lastedgreinf = edgreinf->get_active ();
}
if (listener) {
if (enabled->get_inconsistent ())
listener->panelChanged (EvWavedgreinf, M("GENERAL_UNCHANGED"));
else if (enabled->get_active ())
listener->panelChanged (EvWavedgreinf, M("GENERAL_ENABLED"));
else
listener->panelChanged (EvWavedgreinf, M("GENERAL_DISABLED"));
}
}
*/
void Wavelet::avoidToggled()
{
if (multiImage) {
if (avoid->get_inconsistent()) {
avoid->set_inconsistent(false);
avoidConn.block(true);
avoid->set_active(false);
avoidConn.block(false);
} else if (lastavoid) {
avoid->set_inconsistent(true);
}
lastavoid = avoid->get_active();
}
if (listener && (multiImage || getEnabled())) {
if (avoid->get_inconsistent()) {
listener->panelChanged(EvWavavoid, M("GENERAL_UNCHANGED"));
} else if (avoid->get_active()) {
listener->panelChanged(EvWavavoid, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavavoid, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::showmaskToggled()
{
if (multiImage) {
if (showmask->get_inconsistent()) {
showmask->set_inconsistent(false);
showmaskConn.block(true);
showmask->set_active(false);
showmaskConn.block(false);
} else if (lastshowmask) {
showmask->set_inconsistent(true);
}
lastshowmask = showmask->get_active();
}
if (listener && (multiImage || getEnabled())) {
if (showmask->get_inconsistent()) {
listener->panelChanged(EvWavshowmask, M("GENERAL_UNCHANGED"));
} else if (showmask->get_active()) {
listener->panelChanged(EvWavshowmask, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavshowmask, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::oldshToggled()
{
if (oldsh->get_active()) {
radius->hide();
} else {
radius->show();
}
if (multiImage) {
if (oldsh->get_inconsistent()) {
oldsh->set_inconsistent(false);
oldshConn.block(true);
oldsh->set_active(false);
oldshConn.block(false);
} else if (lastoldsh) {
oldsh->set_inconsistent(true);
}
lastoldsh = oldsh->get_active();
}
if (listener && (multiImage || getEnabled())) {
if (oldsh->get_inconsistent()) {
listener->panelChanged(EvWavoldsh, M("GENERAL_UNCHANGED"));
} else if (oldsh->get_active()) {
listener->panelChanged(EvWavoldsh, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavoldsh, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::tmrToggled()
{
if (multiImage) {
if (tmr->get_inconsistent()) {
tmr->set_inconsistent(false);
tmrConn.block(true);
tmr->set_active(false);
tmrConn.block(false);
} else if (lasttmr) {
tmr->set_inconsistent(true);
}
lasttmr = tmr->get_active();
}
if (listener && (multiImage || getEnabled())) {
if (tmr->get_inconsistent()) {
listener->panelChanged(EvWavtmr, M("GENERAL_UNCHANGED"));
} else if (tmr->get_active()) {
listener->panelChanged(EvWavtmr, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWavtmr, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::colorForValue(double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller)
{
float R = 0.f, G = 0.f, B = 0.f;
if (elemType == ColorCaller::CCET_VERTICAL_BAR) {
valY = 0.5;
}
if (callerId == 1) { // ch - main curve
Color::hsv2rgb01(float(valX), float(valY), 0.5f, R, G, B);
}
/* else if (callerId == 2) { // cc - bottom bar
// float value = (1.f - 0.7f) * float(valX) + 0.7f;
float value = (1.f - 0.7f) * float(valX) + 0.7f;
// whole hue range
// Y axis / from 0.15 up to 0.75 (arbitrary values; was 0.45 before)
Color::hsv2rgb01(float(valY), float(valX), value, R, G, B);
}
*/
else if (callerId == 4) { // LH - bottom bar
Color::hsv2rgb01(float(valX), 0.5f, float(valY), R, G, B);
} else if (callerId == 5) { // HH - bottom bar
float h = float((valY - 0.5) * 0.3 + valX);
if (h > 1.0f) {
h -= 1.0f;
} else if (h < 0.0f) {
h += 1.0f;
}
Color::hsv2rgb01(h, 0.5f, 0.5f, R, G, B);
}
caller->ccRed = double(R);
caller->ccGreen = double(G);
caller->ccBlue = double(B);
}
void Wavelet::setAdjusterBehavior(bool multiplieradd, bool thresholdadd, bool threshold2add, bool thresadd, bool chroadd, bool chromaadd, bool contrastadd, bool skinadd, bool reschroadd, bool tmrsadd, bool edgsadd, bool scaleadd, bool resconadd, bool resconHadd, bool thradd, bool thrHadd, bool radiusadd, bool skyadd, bool edgradadd, bool edgvaladd, bool strengthadd, bool gammaadd, bool edgedetectadd, bool edgedetectthradd, bool edgedetectthr2add)
{
for (int i = 0; i < 9; i++) {
correction[i]->setAddMode(multiplieradd);
}
threshold->setAddMode(thresholdadd);
skinprotect->setAddMode(skinadd);
threshold2->setAddMode(threshold2add);
thres->setAddMode(thresadd);
chro->setAddMode(chroadd);
chroma->setAddMode(chromaadd);
contrast->setAddMode(contrastadd);
rescon->setAddMode(resconadd);
resconH->setAddMode(resconHadd);
reschro->setAddMode(reschroadd);
tmrs->setAddMode(tmrsadd);
edgs->setAddMode(edgsadd);
scale->setAddMode(scaleadd);
thr->setAddMode(thradd);
thrH->setAddMode(thrHadd);
radius->setAddMode(radiusadd);
sky->setAddMode(skyadd);
edgrad->setAddMode(edgradadd);
edgval->setAddMode(edgvaladd);
strength->setAddMode(strengthadd);
gamma->setAddMode(gammaadd);
edgedetect->setAddMode(edgedetectadd);
edgedetectthr->setAddMode(edgedetectthradd);
edgedetectthr2->setAddMode(edgedetectthr2add);
}
void Wavelet::neutralPressed()
{
for (int i = 0; i < 9; i++) {
correction[i]->setValue(0);
adjusterChanged(correction[i], 0);
}
sup->setValue(0);
adjusterChanged(sup, 0);
}
void Wavelet::neutralchPressed()
{
for (int i = 0; i < 9; i++) {
correctionch[i]->setValue(0);
adjusterChanged(correctionch[i], 0);
}
}
void Wavelet::contrastPlusPressed()
{
for (int i = 0; i < 9; i++) {
int inc = 1 * (9 - i);
correction[i]->setValue(correction[i]->getValue() + inc);
adjusterChanged(correction[i], correction[i]->getValue());
}
}
void Wavelet::contrastMinusPressed()
{
for (int i = 0; i < 9; i++) {
int inc = -1 * (9 - i);
correction[i]->setValue(correction[i]->getValue() + inc);
adjusterChanged(correction[i], correction[i]->getValue());
}
}
void Wavelet::foldAllButMe(GdkEventButton* event, MyExpander *expander)
{
if (event->button == 3) {
expsettings->set_expanded(expsettings == expander);
expcontrast->set_expanded(expcontrast == expander);
expchroma->set_expanded(expchroma == expander);
exptoning->set_expanded(exptoning == expander);
expnoise->set_expanded(expnoise == expander);
expedge->set_expanded(expedge == expander);
expbl->set_expanded(expbl == expander);
expgamut->set_expanded(expgamut == expander);
expresid->set_expanded(expresid == expander);
expfinal->set_expanded(expfinal == expander);
expclari->set_expanded(expclari == expander);
}
}
void Wavelet::enableToggled(MyExpander *expander)
{
if (listener) {
rtengine::ProcEvent event = NUMOFEVENTS;
if (expander == expcontrast) {
event = EvWavenacont;
} else if (expander == expchroma) {
event = EvWavenachrom;
} else if (expander == exptoning) {
event = EvWavenatoning;
} else if (expander == expnoise) {
event = EvWavenanoise;
} else if (expander == expedge) {
event = EvWavenaedge;
} else if (expander == expbl) {
event = EvWavenabl;
} else if (expander == expresid) {
event = EvWavenares;
} else if (expander == expfinal) {
event = EvWavenafin;
} else if (expander == expclari) {
if (expclari->getEnabled() == false) {
Backmethod->set_active(1);
CLmethod->set_active(3);
Lmethod->set_active(3);
Dirmethod->set_active(3);
Lmethod->set_sensitive(false);
Dirmethod->set_sensitive(false);
CLmethod->set_sensitive(true);
Backmethod->set_sensitive(true);
} else {
if (ushamethod->get_active_row_number() == 1) {
Backmethod->set_active(2);
CLmethod->set_active(2);
Lmethod->set_active(6);
Lmethod->set_sensitive(true);
Dirmethod->set_sensitive(true);
Dirmethod->set_active(3);
CLmethod->set_sensitive(false);
Backmethod->set_sensitive(false);
} else if (ushamethod->get_active_row_number() == 0) {
Backmethod->set_active(0);
CLmethod->set_active(1);
Lmethod->set_active(2);
Dirmethod->set_active(3);
Lmethod->set_sensitive(true);
Dirmethod->set_sensitive(true);
CLmethod->set_sensitive(false);
Backmethod->set_sensitive(false);
}
}
event = EvWavenaclari;
} else
// unknown expander, returning !
{
return;
}
if (expander->get_inconsistent()) {
listener->panelChanged(event, M("GENERAL_UNCHANGED"));
} else if (expander->getEnabled()) {
listener->panelChanged(event, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(event, M("GENERAL_DISABLED"));
}
}
}
void Wavelet::writeOptions(std::vector<int> &tpOpen)
{
tpOpen.push_back(expsettings->get_expanded());
tpOpen.push_back(expcontrast->get_expanded());
tpOpen.push_back(expchroma->get_expanded());
tpOpen.push_back(exptoning->get_expanded());
tpOpen.push_back(expnoise->get_expanded());
tpOpen.push_back(expedge->get_expanded());
tpOpen.push_back(expbl->get_expanded());
tpOpen.push_back(expgamut->get_expanded());
tpOpen.push_back(expresid->get_expanded());
tpOpen.push_back(expfinal->get_expanded());
tpOpen.push_back(expclari->get_expanded());
}
void Wavelet::updateToolState(const std::vector<int>& tpOpen)
{
if (tpOpen.empty()) {
expsettings->set_expanded(false);
expcontrast->set_expanded(false);
expchroma->set_expanded(false);
exptoning->set_expanded(false);
expnoise->set_expanded(false);
expedge->set_expanded(false);
expbl->set_expanded(false);
expgamut->set_expanded(false);
expresid->set_expanded(false);
expfinal->set_expanded(false);
expclari->set_expanded(false);
return;
}
if (tpOpen.size() >= 11) {
expsettings->set_expanded(tpOpen[0]);
expcontrast->set_expanded(tpOpen[1]);
expchroma->set_expanded(tpOpen[2]);
exptoning->set_expanded(tpOpen[3]);
expnoise->set_expanded(tpOpen[4]);
expedge->set_expanded(tpOpen[5]);
expbl->set_expanded(tpOpen[6]);
expgamut->set_expanded(tpOpen[7]);
expresid->set_expanded(tpOpen[8]);
expfinal->set_expanded(tpOpen[9]);
expclari->set_expanded(tpOpen[10]);
}
}
Reference in New Issue View Git Blame Copy Permalink