1 /*
2 * This file is part of RawTherapee.
3 *
4 * RawTherapee is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * RawTherapee is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with RawTherapee. If not, see <https://www.gnu.org/licenses/>.
16 *
17 * 2014 Jacques Desmis <jdesmis@gmail.com>
18 */
19
20 #include "wavelet.h"
21 #include <cmath>
22
23 #include "curveeditor.h"
24 #include "curveeditorgroup.h"
25 #include "editcallbacks.h"
26 #include "guiutils.h"
27 #include "rtimage.h"
28 #include "options.h"
29 #include "../rtengine/color.h"
30
31 using namespace rtengine;
32 using namespace rtengine::procparams;
33
34 namespace
35 {
36
makeHsvGm(double position,float h,float s,float v)37 GradientMilestone makeHsvGm(double position, float h, float s, float v)
38 {
39 float r;
40 float g;
41 float b;
42 Color::hsv2rgb01(h, s, v, r, g, b);
43 return GradientMilestone(position, r, g, b);
44 }
45
makeWholeHueRange()46 std::vector<GradientMilestone> makeWholeHueRange()
47 {
48 std::vector<GradientMilestone> res;
49 res.reserve(7);
50
51 for (int i = 0; i < 7; ++i) {
52 const float x = static_cast<float>(i) / 6.0f;
53 res.push_back(makeHsvGm(x, x, 0.5f, 0.5f));
54 }
55
56 return res;
57 }
58
59 }
60
Wavelet()61 Wavelet::Wavelet() :
62 FoldableToolPanel(this, "wavelet", M("TP_WAVELET_LABEL"), true, true),
63 curveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_CONTEDIT"))),
64 CCWcurveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_CCURVE"))),
65 curveEditorRES(new CurveEditorGroup(options.lastWaveletCurvesDir)),
66 curveEditorGAM(new CurveEditorGroup(options.lastWaveletCurvesDir)),
67 separatorNeutral(Gtk::manage(new Gtk::HSeparator())),
68 separatoredge(Gtk::manage(new Gtk::HSeparator())),
69 opaCurveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_COLORT"))),
70 opacityCurveEditorG(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_OPACITY"))),
71 opacityCurveEditorW(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_OPACITYW"))),
72 opacityCurveEditorWL(new CurveEditorGroup(options.lastWaveletCurvesDir, M("TP_WAVELET_OPACITYWL"))),
73 median(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_MEDI")))),
74 medianlev(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_MEDILEV")))),
75 linkedg(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_LINKEDG")))),
76 cbenab(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_CBENAB")))),
77 lipst(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_LIPST")))),
78 avoid(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_AVOID")))),
79 tmr(Gtk::manage(new Gtk::CheckButton(M("TP_WAVELET_BALCHRO")))),
80 neutralchButton(Gtk::manage(new Gtk::Button(M("TP_WAVELET_NEUTRAL")))),
81 rescon(Gtk::manage(new Adjuster(M("TP_WAVELET_RESCON"), -100, 100, 1, 0))),
82 resconH(Gtk::manage(new Adjuster(M("TP_WAVELET_RESCONH"), -100, 100, 1, 0))),
83 reschro(Gtk::manage(new Adjuster(M("TP_WAVELET_RESCHRO"), -100, 100, 1, 0))),
84 tmrs(Gtk::manage(new Adjuster(M("TP_WAVELET_TMSTRENGTH"), -1.0, 2.0, 0.01, 0.0))),
85 gamma(Gtk::manage(new Adjuster(M("TP_WAVELET_COMPGAMMA"), 0.4, 2.0, 0.01, 1.0))),
86 sup(Gtk::manage(new Adjuster(M("TP_WAVELET_SUPE"), -100, 350, 1, 0))),
87 sky(Gtk::manage(new Adjuster(M("TP_WAVELET_SKY"), -100., 100.0, 1., 0.))),
88 thres(Gtk::manage(new Adjuster(M("TP_WAVELET_LEVELS"), 4, 9, 1, 7))),//3
89 chroma(Gtk::manage(new Adjuster(M("TP_WAVELET_CHRO"), 1, 9, 1, 5))),
90 chro(Gtk::manage(new Adjuster(M("TP_WAVELET_CHR"), 0., 100., 1., 0.))),
91 contrast(Gtk::manage(new Adjuster(M("TP_WAVELET_CONTRA"), -100, 100, 1, 0))),
92 thr(Gtk::manage(new Adjuster(M("TP_WAVELET_THR"), 0, 100, 1, 35))),
93 thrH(Gtk::manage(new Adjuster(M("TP_WAVELET_THRH"), 0, 100, 1, 65))),
94 skinprotect(Gtk::manage( new Adjuster(M("TP_WAVELET_SKIN"), -100, 100, 1, 0.) )),
95 edgrad(Gtk::manage( new Adjuster(M("TP_WAVELET_EDRAD"), 0, 100, 1, 15) )),
96 edgval(Gtk::manage( new Adjuster(M("TP_WAVELET_EDVAL"), 0, 100, 1, 0) )),
97 edgthresh(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGTHRESH"), -50, 100, 1, 10 ))),
98 strength(Gtk::manage(new Adjuster(M("TP_WAVELET_STRENGTH"), 0, 100, 1, 100))),
99 balance(Gtk::manage(new Adjuster(M("TP_WAVELET_BALANCE"), -30, 100, 1, 0))),
100 iter(Gtk::manage(new Adjuster(M("TP_WAVELET_ITER"), -3, 3, 1, 0))),
101 hueskin(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_HUESKIN"), -314., 314., -5., 25., 170., 120., 0, false))),
102 hueskin2(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_HUESKY"), -314., 314., -260., -250, -130., -140., 0, false))),
103 hllev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_HIGHLIGHT"), 0., 100., 50., 75., 100., 98., 0, false))),
104 bllev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_LOWLIGHT"), 0., 100., 0., 2., 50., 25., 0, false))),
105 pastlev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_PASTEL"), 0., 70., 0., 2., 30., 20., 0, false))),
106 satlev(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_SAT"), 0., 130., 30., 45., 130., 100., 0, false))),
107 edgcont(Gtk::manage(new ThresholdAdjuster(M("TP_WAVELET_EDGCONT"), 0., 100., 0, 10, 75, 40, 0., false))),
108 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))),
109 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))),
110 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))),
111 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))),
112 threshold(Gtk::manage(new Adjuster(M("TP_WAVELET_THRESHOLD"), 1, 9, 1, 5))),
113 threshold2(Gtk::manage(new Adjuster(M("TP_WAVELET_THRESHOLD2"), 1, 9, 1, 4))),
114 edgedetect(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEDETECT"), 0, 100, 1, 90))),
115 edgedetectthr(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEDETECTTHR"), 0, 100, 1, 20))),
116 edgedetectthr2(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEDETECTTHR2"), -10, 100, 1, 0))),
117 edgesensi(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGESENSI"), 0, 100, 1, 60))),
118 edgeampli(Gtk::manage(new Adjuster(M("TP_WAVELET_EDGEAMPLI"), 0, 100, 1, 10))),
119 Lmethod(Gtk::manage(new MyComboBoxText())),
120 CHmethod(Gtk::manage(new MyComboBoxText())),
121 CHSLmethod(Gtk::manage(new MyComboBoxText())),
122 EDmethod(Gtk::manage(new MyComboBoxText())),
123 BAmethod(Gtk::manage(new MyComboBoxText())),
124 NPmethod(Gtk::manage(new MyComboBoxText())),
125 TMmethod(Gtk::manage(new MyComboBoxText())),
126 HSmethod(Gtk::manage(new MyComboBoxText())),
127 CLmethod(Gtk::manage(new MyComboBoxText())),
128 Backmethod(Gtk::manage(new MyComboBoxText())),
129 Tilesmethod(Gtk::manage(new MyComboBoxText())),
130 daubcoeffmethod(Gtk::manage(new MyComboBoxText())),
131 Dirmethod(Gtk::manage(new MyComboBoxText())),
132 Medgreinf(Gtk::manage(new MyComboBoxText())),
133 chanMixerHLFrame(Gtk::manage(new Gtk::Frame(M("TP_COLORTONING_HIGHLIGHT")))),
134 chanMixerMidFrame(Gtk::manage(new Gtk::Frame(M("TP_COLORTONING_MIDTONES")))),
135 chanMixerShadowsFrame(Gtk::manage(new Gtk::Frame(M("TP_COLORTONING_SHADOWS")))),
136 wavLabels(Gtk::manage(new Gtk::Label("---", Gtk::ALIGN_CENTER))),
137 labmC(Gtk::manage(new Gtk::Label(M("TP_WAVELET_CTYPE") + ":"))),
138 labmNP(Gtk::manage(new Gtk::Label(M("TP_WAVELET_NPTYPE") + ":"))),
139 expchroma(Gtk::manage(new MyExpander(true, M("TP_WAVELET_LEVCH")))),
140 expcontrast(Gtk::manage(new MyExpander(true, M("TP_WAVELET_LEVF")))),
141 expedge(Gtk::manage(new MyExpander(true, M("TP_WAVELET_EDGE")))),
142 expfinal(Gtk::manage(new MyExpander(true, M("TP_WAVELET_FINAL")))),
143 expgamut(Gtk::manage(new MyExpander(false, M("TP_WAVELET_CONTR")))),
144 expnoise(Gtk::manage(new MyExpander(true, M("TP_WAVELET_NOISE")))),
145 expresid(Gtk::manage(new MyExpander(true, M("TP_WAVELET_RESID")))),
146 expsettings(Gtk::manage(new MyExpander(false, M("TP_WAVELET_SETTINGS")))),
147 exptoning(Gtk::manage(new MyExpander(true, M("TP_WAVELET_TON")))),
148 neutrHBox(Gtk::manage(new Gtk::HBox()))
149 {
150 CurveListener::setMulti(true);
151
152 expsettings->signal_button_release_event().connect_notify( sigc::bind( sigc::mem_fun(this, &Wavelet::foldAllButMe), expsettings) );
153
154 expcontrast->signal_button_release_event().connect_notify( sigc::bind( sigc::mem_fun(this, &Wavelet::foldAllButMe), expcontrast) );
155 enableContrastConn = expcontrast->signal_enabled_toggled().connect ( sigc::bind( sigc::mem_fun(this, &Wavelet::enableToggled), expcontrast) );
156
157 expchroma->signal_button_release_event().connect_notify( sigc::bind ( sigc::mem_fun(this, &Wavelet::foldAllButMe), expchroma) );
158 enableChromaConn = expchroma->signal_enabled_toggled().connect ( sigc::bind( sigc::mem_fun(this, &Wavelet::enableToggled), expchroma) );
159
160 exptoning->signal_button_release_event().connect_notify( sigc::bind ( sigc::mem_fun(this, &Wavelet::foldAllButMe), exptoning) );
161 enableToningConn = exptoning->signal_enabled_toggled().connect ( sigc::bind( sigc::mem_fun(this, &Wavelet::enableToggled), exptoning) );
162
163 expnoise->signal_button_release_event().connect_notify( sigc::bind ( sigc::mem_fun(this, &Wavelet::foldAllButMe), expnoise) );
164 enableNoiseConn = expnoise->signal_enabled_toggled().connect ( sigc::bind( sigc::mem_fun(this, &Wavelet::enableToggled), expnoise) );
165
166 expedge->signal_button_release_event().connect_notify( sigc::bind ( sigc::mem_fun(this, &Wavelet::foldAllButMe), expedge) );
167 enableEdgeConn = expedge->signal_enabled_toggled().connect ( sigc::bind( sigc::mem_fun(this, &Wavelet::enableToggled), expedge) );
168
169 expgamut->signal_button_release_event().connect_notify( sigc::bind ( sigc::mem_fun(this, &Wavelet::foldAllButMe), expgamut) );
170
171 expresid->signal_button_release_event().connect_notify( sigc::bind ( sigc::mem_fun(this, &Wavelet::foldAllButMe), expresid) );
172 enableResidConn = expresid->signal_enabled_toggled().connect ( sigc::bind( sigc::mem_fun(this, &Wavelet::enableToggled), expresid) );
173
174 expfinal->signal_button_release_event().connect_notify( sigc::bind ( sigc::mem_fun(this, &Wavelet::foldAllButMe), expfinal) );
175 enableFinalConn = expfinal->signal_enabled_toggled().connect ( sigc::bind( sigc::mem_fun(this, &Wavelet::enableToggled), expfinal) );
176
177 // Wavelet Settings
178 ToolParamBlock* const settingsBox = Gtk::manage (new ToolParamBlock());
179
180 strength->setAdjusterListener (this);
181
182 thres->set_tooltip_text (M("TP_WAVELET_LEVELS_TOOLTIP"));
183 thres->setAdjusterListener (this);
184
185 Tilesmethod->append (M("TP_WAVELET_TILESFULL"));
186 Tilesmethod->append (M("TP_WAVELET_TILESBIG"));
187 Tilesmethod->append (M("TP_WAVELET_TILESLIT"));
188 Tilesmethodconn = Tilesmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::TilesmethodChanged) );
189 Tilesmethod->set_tooltip_text (M("TP_WAVELET_TILES_TOOLTIP"));
190 Gtk::HBox* const tilesizeHBox = Gtk::manage(new Gtk::HBox());
191 Gtk::Label* const tilesizeLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_TILESIZE") + ":"));
192 tilesizeHBox->pack_start(*tilesizeLabel, Gtk::PACK_SHRINK, 4);
193 tilesizeHBox->pack_start(*Tilesmethod);
194
195 daubcoeffmethod->set_sensitive(true);
196 daubcoeffmethod->append (M("TP_WAVELET_DAUB2"));
197 daubcoeffmethod->append (M("TP_WAVELET_DAUB4"));
198 daubcoeffmethod->append (M("TP_WAVELET_DAUB6"));
199 daubcoeffmethod->append (M("TP_WAVELET_DAUB10"));
200 daubcoeffmethod->append (M("TP_WAVELET_DAUB14"));
201 daubcoeffmethodconn = daubcoeffmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::daubcoeffmethodChanged) );
202 daubcoeffmethod->set_tooltip_text (M("TP_WAVELET_DAUB_TOOLTIP"));
203 Gtk::Label* const daubcoeffLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_DAUB") + ":"));
204 Gtk::HBox* const daubcoeffHBox = Gtk::manage(new Gtk::HBox());
205 daubcoeffHBox->pack_start(*daubcoeffLabel, Gtk::PACK_SHRINK, 4);
206 daubcoeffHBox->pack_start(*daubcoeffmethod);
207
208 Backmethod->append (M("TP_WAVELET_B0"));
209 Backmethod->append (M("TP_WAVELET_B1"));
210 Backmethod->append (M("TP_WAVELET_B2"));
211 Backmethodconn = Backmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::BackmethodChanged) );
212 Gtk::HBox* const backgroundHBox = Gtk::manage(new Gtk::HBox());
213 Gtk::Label* const backgroundLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_BACKGROUND") + ":"));
214 backgroundHBox->pack_start(*backgroundLabel, Gtk::PACK_SHRINK, 4);
215 backgroundHBox->pack_start(*Backmethod);
216
217 CLmethod->append (M("TP_WAVELET_LEVDIR_ONE"));
218 CLmethod->append (M("TP_WAVELET_LEVDIR_INF"));
219 CLmethod->append (M("TP_WAVELET_LEVDIR_SUP"));
220 CLmethod->append (M("TP_WAVELET_LEVDIR_ALL"));
221 CLmethodconn = CLmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::CLmethodChanged) );
222 Gtk::HBox* const levdirMainHBox = Gtk::manage(new Gtk::HBox());
223 Gtk::Label* const levdirMainLabel = Gtk::manage(new Gtk::Label(M("TP_WAVELET_PROC") + ":"));
224 levdirMainHBox->pack_start(*levdirMainLabel, Gtk::PACK_SHRINK, 4);
225 levdirMainHBox->pack_start(*CLmethod); //same
226
227 Lmethod->set_sensitive(false);
228 Lmethod->set_sensitive(false);
229 Lmethod->append (M("TP_WAVELET_1"));
230 Lmethod->append (M("TP_WAVELET_2"));
231 Lmethod->append (M("TP_WAVELET_3"));
232 Lmethod->append (M("TP_WAVELET_4"));
233 Lmethod->append (M("TP_WAVELET_5"));
234 Lmethod->append (M("TP_WAVELET_6"));
235 Lmethod->append (M("TP_WAVELET_7"));
236 Lmethod->append (M("TP_WAVELET_8"));
237 Lmethod->append (M("TP_WAVELET_9"));
238 Lmethod->append (M("TP_WAVELET_SUPE"));
239 Lmethod->append (M("TP_WAVELET_RESID"));
240 Lmethod->set_active(0);
241 Dirmethod->set_sensitive(false);
242 Dirmethod->append (M("TP_WAVELET_DONE"));
243 Dirmethod->append (M("TP_WAVELET_DTWO"));
244 Dirmethod->append (M("TP_WAVELET_DTHR"));
245 Dirmethod->append (M("TP_WAVELET_DALL"));
246 Lmethodconn = Lmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::LmethodChanged) );
247 Dirmethodconn = Dirmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::DirmethodChanged) );
248 Gtk::HBox* const levdirSubHBox = Gtk::manage(new Gtk::HBox());
249 levdirSubHBox->pack_start(*Lmethod);
250 levdirSubHBox->pack_start(*Dirmethod, Gtk::PACK_EXPAND_WIDGET, 2); // same, but 2 not 4?
251
252 settingsBox->pack_start(*strength);
253 settingsBox->pack_start(*thres);
254 settingsBox->pack_start(*tilesizeHBox);
255 settingsBox->pack_start(*daubcoeffHBox);
256 settingsBox->pack_start(*backgroundHBox);
257 settingsBox->pack_start(*levdirMainHBox);
258 settingsBox->pack_start(*levdirSubHBox);
259
260 // Contrast
261 ToolParamBlock* const levBox = Gtk::manage (new ToolParamBlock());
262
263 Gtk::HBox* const buttonBox = Gtk::manage (new Gtk::HBox(true, 10));
264 levBox->pack_start(*buttonBox, Gtk::PACK_SHRINK, 2);
265
266 Gtk::Button* const contrastMinusButton = Gtk::manage (new Gtk::Button(M("TP_WAVELET_CONTRAST_MINUS")));
267 buttonBox->pack_start(*contrastMinusButton);
268 contrastMinusPressedConn = contrastMinusButton->signal_pressed().connect( sigc::mem_fun(*this, &Wavelet::contrastMinusPressed));
269
270 Gtk::Button* const neutralButton = Gtk::manage (new Gtk::Button(M("TP_WAVELET_NEUTRAL")));
271 buttonBox->pack_start(*neutralButton);
272 neutralPressedConn = neutralButton->signal_pressed().connect( sigc::mem_fun(*this, &Wavelet::neutralPressed));
273
274 Gtk::Button* const contrastPlusButton = Gtk::manage (new Gtk::Button(M("TP_WAVELET_CONTRAST_PLUS")));
275 buttonBox->pack_start(*contrastPlusButton);
276 contrastPlusPressedConn = contrastPlusButton->signal_pressed().connect( sigc::mem_fun(*this, &Wavelet::contrastPlusPressed));
277
278 buttonBox->show_all_children();
279
280 for(int i = 0; i < 9; i++) {
281 Glib::ustring ss;
282
283 switch( i ) {
284 case 0:
285 ss = Glib::ustring::compose( "%1 (%2)", (i + 1), M("TP_WAVELET_FINEST"));
286 break;
287
288 case 8:
289 ss = Glib::ustring::compose( "%1 (%2)", (i + 1), M("TP_WAVELET_LARGEST"));
290 break;
291
292 default:
293 ss = Glib::ustring::compose( "%1", (i + 1));
294 }
295
296 correction[i] = Gtk::manage(new Adjuster(std::move(ss), -100, 350, 1, 0));
297 correction[i]->setAdjusterListener(this);
298 levBox->pack_start(*correction[i]);
299 }
300
301 levBox->pack_start(*sup);
302 sup->setAdjusterListener (this);
303 wavLabels->show();
304 levBox->pack_start (*wavLabels);
305
306 Gtk::VBox* const contrastSHVBox = Gtk::manage(new Gtk::VBox);
307 contrastSHVBox->set_spacing(2);
308
309 HSmethod->append (M("TP_WAVELET_HS1"));
310 HSmethod->append (M("TP_WAVELET_HS2"));
311 HSmethodconn = HSmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::HSmethodChanged) );
312
313 const std::vector<GradientMilestone> milestones2 = {
314 GradientMilestone(0.0, 0.0, 0.0, 0.0),
315 GradientMilestone(1.0, 1.0, 1.0, 1.0)
316 };
317
318 hllev->setAdjusterListener (this);
319 hllev->setBgGradient(milestones2);
320
321 threshold->setAdjusterListener (this);
322 threshold->set_tooltip_text (M("TP_WAVELET_THRESHOLD_TOOLTIP"));
323
324 bllev->setAdjusterListener (this);
325 bllev->setBgGradient(milestones2);
326
327 threshold2->setAdjusterListener (this);
328 threshold2->set_tooltip_text (M("TP_WAVELET_THRESHOLD2_TOOLTIP"));
329
330 contrastSHVBox->pack_start(*HSmethod);
331 contrastSHVBox->pack_start(*hllev);
332 contrastSHVBox->pack_start(*threshold);
333 contrastSHVBox->pack_start(*bllev);
334 contrastSHVBox->pack_start(*threshold2);
335 Gtk::Frame* const contrastSHFrame = Gtk::manage(new Gtk::Frame(M("TP_WAVELET_APPLYTO")));
336 contrastSHFrame->add(*contrastSHVBox);
337 levBox->pack_start(*contrastSHFrame);
338
339 // Chromaticity
340 ToolParamBlock* const chBox = Gtk::manage (new ToolParamBlock());
341
342 Gtk::Label* const labmch = Gtk::manage(new Gtk::Label(M("TP_WAVELET_CHTYPE") + ":"));
343 Gtk::HBox* const ctboxch = Gtk::manage(new Gtk::HBox());
344 ctboxch->pack_start (*labmch, Gtk::PACK_SHRINK, 1);
345
346 CHmethod->append (M("TP_WAVELET_CH1"));
347 CHmethod->append (M("TP_WAVELET_CH2"));
348 CHmethod->append (M("TP_WAVELET_CH3"));
349 CHmethodconn = CHmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::CHmethodChanged) );
350 ctboxch->pack_start(*CHmethod);
351 chBox->pack_start(*ctboxch);
352
353 Gtk::HBox* const ctboxCH = Gtk::manage(new Gtk::HBox());
354 ctboxCH->pack_start (*labmC, Gtk::PACK_SHRINK, 1);
355
356 CHSLmethod->append (M("TP_WAVELET_CHSL"));
357 CHSLmethod->append (M("TP_WAVELET_CHCU"));
358 CHSLmethodconn = CHSLmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::CHSLmethodChanged) );
359 ctboxCH->pack_start(*CHSLmethod);
360
361 Gtk::HSeparator* const separatorChromaMethod = Gtk::manage (new Gtk::HSeparator());
362 chBox->pack_start(*separatorChromaMethod, Gtk::PACK_SHRINK, 2);
363
364 chroma->set_tooltip_text (M("TP_WAVELET_CHRO_TOOLTIP"));
365 chBox->pack_start(*chroma);
366 chroma->setAdjusterListener (this);
367
368 satlev->setAdjusterListener (this);
369 satlev->setBgGradient(milestones2);
370
371 pastlev->setAdjusterListener (this);
372 pastlev->setBgGradient(milestones2);
373
374 chBox->pack_start(*pastlev);
375 chBox->pack_start(*satlev);
376
377 chro->set_tooltip_text (M("TP_WAVELET_CHR_TOOLTIP"));
378 chBox->pack_start(*chro);
379 chro->setAdjusterListener (this);
380
381 Gtk::HBox* const buttonchBox = Gtk::manage (new Gtk::HBox(true, 10));
382 neutralchPressedConn = neutralchButton->signal_pressed().connect( sigc::mem_fun(*this, &Wavelet::neutralchPressed));
383 chBox->pack_start(*separatorNeutral, Gtk::PACK_SHRINK, 2);
384 buttonchBox->pack_start(*neutralchButton);
385 buttonchBox->show_all_children();
386 chBox->pack_start(*buttonchBox, Gtk::PACK_SHRINK, 2);
387
388 for(int i = 0; i < 9; i++) {
389 Glib::ustring ss;
390
391 switch( i ) {
392 case 0:
393 ss = Glib::ustring::compose( "%1 (%2)", (i + 1), M("TP_WAVELET_FINEST"));
394 break;
395
396 case 8:
397 ss = Glib::ustring::compose( "%1 (%2)", (i + 1), M("TP_WAVELET_LARGEST"));
398 break;
399
400 default:
401 ss = Glib::ustring::compose( "%1", (i + 1));
402 }
403
404 correctionch[i] = Gtk::manage(new Adjuster(std::move(ss), -100, 100, 1, 0));
405 correctionch[i]->setAdjusterListener(this);
406 chBox->pack_start(*correctionch[i]);
407 }
408
409 // Toning
410 ToolParamBlock* const tonBox = Gtk::manage (new ToolParamBlock());
411
412 opaCurveEditorG->setCurveListener (this);
413
414 const WaveletParams default_params;
415
416 opacityShapeRG = static_cast<FlatCurveEditor*>(opaCurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
417 opacityShapeRG->setIdentityValue(0.);
418 opacityShapeRG->setResetCurve(FlatCurveType(default_params.opacityCurveRG.at(0)), default_params.opacityCurveRG);
419
420 opaCurveEditorG->curveListComplete();
421 opaCurveEditorG->show();
422
423 tonBox->pack_start( *opaCurveEditorG, Gtk::PACK_SHRINK, 2);
424
425 opacityCurveEditorG->setCurveListener (this);
426
427 opacityShapeBY = static_cast<FlatCurveEditor*>(opacityCurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
428 opacityShapeBY->setIdentityValue(0.);
429 opacityShapeBY->setResetCurve(FlatCurveType(default_params.opacityCurveBY.at(0)), default_params.opacityCurveBY);
430
431 opacityCurveEditorG->curveListComplete();
432 opacityCurveEditorG->show();
433
434 tonBox->pack_start( *opacityCurveEditorG, Gtk::PACK_SHRINK, 2);
435
436 // Denoise and Refine
437 ToolParamBlock* const noiseBox = Gtk::manage (new ToolParamBlock());
438
439 linkedg->set_active (true);
440 linkedgConn = linkedg->signal_toggled().connect( sigc::mem_fun(*this, &Wavelet::linkedgToggled) );
441 noiseBox->pack_start(*linkedg);
442
443 level0noise->setAdjusterListener (this);
444 level0noise->setUpdatePolicy(RTUP_DYNAMIC);
445
446 level1noise->setAdjusterListener (this);
447 level1noise->setUpdatePolicy(RTUP_DYNAMIC);
448
449 level2noise->setAdjusterListener (this);
450 level2noise->setUpdatePolicy(RTUP_DYNAMIC);
451
452 level3noise->setAdjusterListener (this);
453 level3noise->setUpdatePolicy(RTUP_DYNAMIC);
454
455 noiseBox->pack_start( *level0noise, Gtk::PACK_SHRINK, 0);
456 noiseBox->pack_start( *level1noise, Gtk::PACK_SHRINK, 0);
457 noiseBox->pack_start( *level2noise, Gtk::PACK_SHRINK, 0);
458 noiseBox->pack_start( *level3noise, Gtk::PACK_SHRINK, 0);
459
460 // Edge Sharpness
461 ToolParamBlock* const edgBox = Gtk::manage (new ToolParamBlock());
462
463 edgval->setAdjusterListener(this);
464 edgBox->pack_start(*edgval);
465
466 edgrad->setAdjusterListener(this);
467 edgBox->pack_start(*edgrad);
468 edgrad->set_tooltip_markup (M("TP_WAVELET_EDRAD_TOOLTIP"));
469
470 edgthresh->setAdjusterListener (this);
471 edgthresh->set_tooltip_markup (M("TP_WAVELET_EDGTHRESH_TOOLTIP"));
472 edgBox->pack_start (*edgthresh);
473
474 Gtk::Label* const labmedgr = Gtk::manage(new Gtk::Label(M("TP_WAVELET_MEDGREINF") + ":"));
475 Gtk::HBox* const edbox = Gtk::manage(new Gtk::HBox());
476 edbox->pack_start (*labmedgr, Gtk::PACK_SHRINK, 1);
477
478 Medgreinf->append (M("TP_WAVELET_RE1"));
479 Medgreinf->append (M("TP_WAVELET_RE2"));
480 Medgreinf->append (M("TP_WAVELET_RE3"));
481 MedgreinfConn = Medgreinf->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::MedgreinfChanged) );
482 Medgreinf->set_tooltip_markup (M("TP_WAVELET_EDGREINF_TOOLTIP"));
483 edbox->pack_start(*Medgreinf);
484 edgBox->pack_start(*edbox);
485
486 Gtk::HSeparator* const separatorlc = Gtk::manage (new Gtk::HSeparator());
487 edgBox->pack_start(*separatorlc, Gtk::PACK_SHRINK, 2);
488
489 Gtk::Label* const labmED = Gtk::manage(new Gtk::Label(M("TP_WAVELET_EDTYPE") + ":"));
490 Gtk::HBox* const ctboxED = Gtk::manage(new Gtk::HBox());
491 ctboxED->pack_start (*labmED, Gtk::PACK_SHRINK, 1);
492
493 EDmethod->append (M("TP_WAVELET_EDSL"));
494 EDmethod->append (M("TP_WAVELET_EDCU"));
495 EDmethodconn = EDmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::EDmethodChanged) );
496 ctboxED->pack_start(*EDmethod);
497 edgBox->pack_start (*ctboxED);
498
499 edgcont->setAdjusterListener (this);
500 edgcont->setBgGradient(milestones2);
501 edgcont->set_tooltip_markup (M("TP_WAVELET_EDGCONT_TOOLTIP"));
502
503 // <-- Edge Sharpness Local Contrast curve
504 CCWcurveEditorG->setCurveListener (this);
505
506 ccshape = static_cast<FlatCurveEditor*>(CCWcurveEditorG->addCurve(CT_Flat, "", nullptr, false, false));
507
508 ccshape->setIdentityValue(0.);
509 ccshape->setResetCurve(FlatCurveType(default_params.ccwcurve.at(0)), default_params.ccwcurve);
510 ccshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_CC_TOOLTIP"));
511
512 CCWcurveEditorG->curveListComplete();
513 CCWcurveEditorG->show();
514 // -->
515
516 edgBox->pack_start (*edgcont);
517 edgBox->pack_start(*CCWcurveEditorG, Gtk::PACK_SHRINK, 4);
518
519 medianlev->set_active (true);
520 medianlevConn = medianlev->signal_toggled().connect( sigc::mem_fun(*this, &Wavelet::medianlevToggled) );
521 medianlev->set_tooltip_text (M("TP_WAVELET_MEDILEV_TOOLTIP"));
522
523 Gtk::HSeparator* const separatored1 = Gtk::manage (new Gtk::HSeparator());
524 edgBox->pack_start(*separatored1, Gtk::PACK_SHRINK, 2);
525
526 Gtk::HBox* const eddebox = Gtk::manage(new Gtk::HBox());
527 edgBox->pack_start (*eddebox);
528 edgBox->pack_start(*medianlev);
529
530 edgedetect->setAdjusterListener (this);
531 edgedetect->set_tooltip_text (M("TP_WAVELET_EDGEDETECT_TOOLTIP"));
532 edgBox->pack_start(*edgedetect);
533
534 edgedetectthr->setAdjusterListener (this);
535 edgedetectthr->set_tooltip_text (M("TP_WAVELET_EDGEDETECTTHR_TOOLTIP"));
536 edgBox->pack_start(*edgedetectthr);
537
538 edgedetectthr2->setAdjusterListener (this);
539 edgBox->pack_start(*edgedetectthr2);
540
541 edgBox->pack_start(*separatoredge, Gtk::PACK_SHRINK, 2);
542
543 lipst->set_active (true);
544 lipstConn = lipst->signal_toggled().connect( sigc::mem_fun(*this, &Wavelet::lipstToggled) );
545 // lipst->set_tooltip_text (M("TP_WAVELET_LIPST_TOOLTIP"));
546 edgBox->pack_start(*lipst);
547
548 edgesensi->setAdjusterListener (this);
549 edgBox->pack_start(*edgesensi);
550
551 edgeampli->setAdjusterListener (this);
552 edgBox->pack_start(*edgeampli);
553
554 Gtk::VBox* const ctboxES = Gtk::manage (new Gtk::VBox());
555
556 ctboxES->set_spacing(2);
557
558 Gtk::HBox* const ctboxNP = Gtk::manage(new Gtk::HBox());
559 ctboxNP->pack_start (*labmNP, Gtk::PACK_SHRINK, 1);
560
561 NPmethod->append (M("TP_WAVELET_NPNONE"));
562 NPmethod->append (M("TP_WAVELET_NPLOW"));
563 NPmethod->append (M("TP_WAVELET_NPHIGH"));
564 NPmethodconn = NPmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::NPmethodChanged) );
565 NPmethod->set_tooltip_text (M("TP_WAVELET_NPTYPE_TOOLTIP"));
566
567 ctboxNP->pack_start(*NPmethod);
568 ctboxES->pack_start(*ctboxNP);
569
570 edgBox->pack_start(*ctboxES);
571
572 // Gamut
573 ToolParamBlock* const conBox = Gtk::manage (new ToolParamBlock());
574
575 median->set_active (true);
576 medianConn = median->signal_toggled().connect( sigc::mem_fun(*this, &Wavelet::medianToggled) );
577 conBox->pack_start(*median);
578
579 hueskin->set_tooltip_markup (M("TP_WAVELET_HUESKIN_TOOLTIP"));
580
581 //from -PI to +PI (radians) convert to hsv and draw bottombar
582 const std::vector<GradientMilestone> milestones = {
583 makeHsvGm(0.0000, 0.4199f, 0.5f, 0.5f), // hsv: 0.4199 rad: -3.14
584 makeHsvGm(0.0540, 0.5000f, 0.5f, 0.5f), // hsv: 0.5 rad: -2.8
585 makeHsvGm(0.1336, 0.6000f, 0.5f, 0.5f), // hsv: 0.60 rad: -2.3
586 makeHsvGm(0.3567, 0.7500f, 0.5f, 0.5f), // hsv: 0.75 rad: -0.9
587 makeHsvGm(0.4363, 0.8560f, 0.5f, 0.5f), // hsv: 0.856 rad: -0.4
588 makeHsvGm(0.4841, 0.9200f, 0.5f, 0.5f), // hsv: 0.92 rad: -0.1
589 makeHsvGm(0.5000, 0.9300f, 0.5f, 0.5f), // hsv: 0.93 rad: 0
590 makeHsvGm(0.5366, 0.9600f, 0.5f, 0.5f), // hsv: 0.96 rad: 0.25
591 makeHsvGm(0.5955, 1.0000f, 0.5f, 0.5f), // hsv: 1. rad: 0.6
592 makeHsvGm(0.6911, 0.0675f, 0.5f, 0.5f), // hsv: 0.0675 rad: 1.2
593 makeHsvGm(0.7229, 0.0900f, 0.5f, 0.5f), // hsv: 0.09 rad: 1.4
594 makeHsvGm(0.7707, 0.1700f, 0.5f, 0.5f), // hsv: 0.17 rad: 1.7
595 makeHsvGm(0.8503, 0.2650f, 0.5f, 0.5f), // hsv: 0.265 rad: 2.1
596 makeHsvGm(0.8981, 0.3240f, 0.5f, 0.5f), // hsv: 0.324 rad: 2.5
597 makeHsvGm(1.0000, 0.4197f, 0.5f, 0.5f) // hsv: 0.419 rad: 3.14
598 };
599
600 hueskin->setBgGradient(milestones);
601 conBox->pack_start(*hueskin);
602 hueskin->setAdjusterListener (this);
603
604 skinprotect->setAdjusterListener(this);
605 conBox->pack_start(*skinprotect);
606 skinprotect->set_tooltip_markup (M("TP_WAVELET_SKIN_TOOLTIP"));
607
608 curveEditorGAM->setCurveListener (this);
609
610 Chshape = static_cast<FlatCurveEditor*>(curveEditorGAM->addCurve(CT_Flat, M("TP_WAVELET_CURVEEDITOR_CH")));
611 Chshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_CH_TOOLTIP"));
612 Chshape->setCurveColorProvider(this, 5);
613 curveEditorGAM->curveListComplete();
614 Chshape->setBottomBarBgGradient(milestones);
615
616 conBox->pack_start (*curveEditorGAM, Gtk::PACK_SHRINK, 4);
617
618 avoid->set_active (true);
619 avoidConn = avoid->signal_toggled().connect( sigc::mem_fun(*this, &Wavelet::avoidToggled) );
620 conBox->pack_start(*avoid);
621
622 // Residual Image
623 ToolParamBlock* const resBox = Gtk::manage (new ToolParamBlock());
624
625 rescon->setAdjusterListener (this);
626 resBox->pack_start(*rescon, Gtk::PACK_SHRINK);
627
628 resBox->pack_start(*thr);
629 thr->setAdjusterListener (this);
630
631 resconH->setAdjusterListener (this);
632 resBox->pack_start(*resconH, Gtk::PACK_SHRINK);
633
634 thrH->setAdjusterListener (this);
635 resBox->pack_start(*thrH, Gtk::PACK_SHRINK);
636
637 contrast->set_tooltip_text (M("TP_WAVELET_CONTRA_TOOLTIP"));
638 contrast->setAdjusterListener (this);
639 resBox->pack_start(*contrast); //keep the possibility to reinstall
640
641 reschro->setAdjusterListener (this);
642 resBox->pack_start(*reschro);
643
644
645 Gtk::Label* const labmTM = Gtk::manage(new Gtk::Label(M("TP_WAVELET_TMTYPE") + ":"));
646 Gtk::HBox* const ctboxTM = Gtk::manage(new Gtk::HBox());
647 ctboxTM->pack_start (*labmTM, Gtk::PACK_SHRINK, 1);
648
649 Gtk::HSeparator* const separatorR0 = Gtk::manage (new Gtk::HSeparator());
650 resBox->pack_start(*separatorR0, Gtk::PACK_SHRINK, 2);
651
652 TMmethod->append (M("TP_WAVELET_COMPCONT"));
653 TMmethod->append (M("TP_WAVELET_COMPTM"));
654 TMmethodconn = TMmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::TMmethodChanged) );
655 ctboxTM->pack_start(*TMmethod);
656 resBox->pack_start (*ctboxTM);
657
658 tmrs->set_tooltip_text (M("TP_WAVELET_TMSTRENGTH_TOOLTIP"));
659
660 resBox->pack_start(*tmrs);
661 tmrs->setAdjusterListener (this);
662
663 gamma->set_tooltip_text (M("TP_WAVELET_COMPGAMMA_TOOLTIP"));
664 resBox->pack_start(*gamma);
665 gamma->setAdjusterListener (this);
666
667 Gtk::HSeparator* const separatorR1 = Gtk::manage (new Gtk::HSeparator());
668 resBox->pack_start(*separatorR1, Gtk::PACK_SHRINK, 2);
669
670 hueskin2->set_tooltip_markup (M("TP_WAVELET_HUESKY_TOOLTIP"));
671 hueskin2->setBgGradient(milestones);
672 resBox->pack_start(*hueskin2);
673 hueskin2->setAdjusterListener (this);
674
675 sky->set_tooltip_text (M("TP_WAVELET_SKY_TOOLTIP"));
676 sky->setAdjusterListener (this);
677
678 resBox->pack_start(*sky);
679
680 // whole hue range
681 const std::vector<GradientMilestone> milestones3 = makeWholeHueRange();
682
683 curveEditorRES->setCurveListener (this);
684
685 hhshape = static_cast<FlatCurveEditor*>(curveEditorRES->addCurve(CT_Flat, M("TP_WAVELET_CURVEEDITOR_HH")));
686 hhshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_HH_TOOLTIP"));
687 hhshape->setCurveColorProvider(this, 5);
688 curveEditorRES->curveListComplete();
689 hhshape->setBottomBarBgGradient(milestones3);
690
691 resBox->pack_start (*curveEditorRES, Gtk::PACK_SHRINK, 4);
692
693 // Toning and Color Balance
694 Gtk::HSeparator* const separatorCB = Gtk::manage (new Gtk::HSeparator());
695
696 Gtk::VBox* const chanMixerHLBox = Gtk::manage (new Gtk::VBox());
697 Gtk::VBox* const chanMixerMidBox = Gtk::manage (new Gtk::VBox());
698 Gtk::VBox* const chanMixerShadowsBox = Gtk::manage (new Gtk::VBox());
699
700 cbenab->set_active (true);
701 cbenabConn = cbenab->signal_toggled().connect( sigc::mem_fun(*this, &Wavelet::cbenabToggled) );
702 cbenab->set_tooltip_text (M("TP_WAVELET_CB_TOOLTIP"));
703
704 Gtk::Image* const iblueR = Gtk::manage (new RTImage ("circle-blue-small.png"));
705 Gtk::Image* const iyelL = Gtk::manage (new RTImage ("circle-yellow-small.png"));
706 Gtk::Image* const imagL = Gtk::manage (new RTImage ("circle-magenta-small.png"));
707 Gtk::Image* const igreenR = Gtk::manage (new RTImage ("circle-green-small.png"));
708
709 Gtk::Image* const iblueRm = Gtk::manage (new RTImage ("circle-blue-small.png"));
710 Gtk::Image* const iyelLm = Gtk::manage (new RTImage ("circle-yellow-small.png"));
711 Gtk::Image* const imagLm = Gtk::manage (new RTImage ("circle-magenta-small.png"));
712 Gtk::Image* const igreenRm = Gtk::manage (new RTImage ("circle-green-small.png"));
713
714 Gtk::Image* const iblueRh = Gtk::manage (new RTImage ("circle-blue-small.png"));
715 Gtk::Image* const iyelLh = Gtk::manage (new RTImage ("circle-yellow-small.png"));
716 Gtk::Image* const imagLh = Gtk::manage (new RTImage ("circle-magenta-small.png"));
717 Gtk::Image* const igreenRh = Gtk::manage (new RTImage ("circle-green-small.png"));
718
719 greenhigh = Gtk::manage (new Adjuster ("", -100., 100., 1., 0., igreenRh, imagLh));
720 bluehigh = Gtk::manage (new Adjuster ("", -100., 100., 1., 0., iblueRh, iyelLh));
721 greenmed = Gtk::manage (new Adjuster ("", -100., 100., 1., 0., igreenRm, imagLm));
722 bluemed = Gtk::manage (new Adjuster ("", -100., 100., 1., 0. , iblueRm , iyelLm));
723 greenlow = Gtk::manage (new Adjuster ("", -100., 100., 1., 0., igreenR, imagL));
724 bluelow = Gtk::manage (new Adjuster ("", -100., 100., 1., 0., iblueR , iyelL));
725
726 chanMixerHLBox->pack_start (*greenhigh);
727 chanMixerHLBox->pack_start (*bluehigh);
728 chanMixerMidBox->pack_start (*greenmed);
729 chanMixerMidBox->pack_start (*bluemed);
730 chanMixerShadowsBox->pack_start (*greenlow);
731 chanMixerShadowsBox->pack_start (*bluelow);
732
733 greenlow->setAdjusterListener (this);
734 bluelow->setAdjusterListener (this);
735 greenmed->setAdjusterListener (this);
736 bluemed->setAdjusterListener (this);
737 greenhigh->setAdjusterListener (this);
738 bluehigh->setAdjusterListener (this);
739
740 resBox->pack_start(*separatorCB, Gtk::PACK_SHRINK);
741
742 chanMixerHLFrame->add(*chanMixerHLBox);
743 chanMixerMidFrame->add(*chanMixerMidBox);
744 chanMixerShadowsFrame->add(*chanMixerShadowsBox);
745 resBox->pack_start(*cbenab);
746
747 resBox->pack_start(*chanMixerHLFrame, Gtk::PACK_SHRINK);
748 resBox->pack_start(*chanMixerMidFrame, Gtk::PACK_SHRINK);
749 resBox->pack_start(*chanMixerShadowsFrame, Gtk::PACK_SHRINK);
750
751 //RTImage *resetImg = Gtk::manage (new RTImage ("undo-small.png", "redo-small.png"));
752 //neutral->set_image(*resetImg);
753 Gtk::Button* const neutral = Gtk::manage(new Gtk::Button(M("TP_COLORTONING_NEUTRAL")));
754 neutral->set_tooltip_text (M("TP_COLORTONING_NEUTRAL_TIP"));
755 neutralconn = neutral->signal_pressed().connect( sigc::mem_fun(*this, &Wavelet::neutral_pressed) );
756 neutral->show();
757 neutrHBox->pack_start (*neutral, Gtk::PACK_EXPAND_WIDGET);
758
759 resBox->pack_start (*neutrHBox);
760
761 // Final Touchup
762 Gtk::VBox* const ctboxBA = Gtk::manage (new Gtk::VBox());
763
764 ctboxBA->set_spacing(2);
765
766 //Gtk::HSeparator *separatorfin = Gtk::manage (new Gtk::HSeparator());
767 //ctboxBA->pack_start(*separatorfin, Gtk::PACK_SHRINK, 2);
768 Gtk::Label* const labmBA = Gtk::manage(new Gtk::Label(M("TP_WAVELET_BATYPE") + ":"));
769 Gtk::HBox* const ctboxFI = Gtk::manage(new Gtk::HBox());
770 ctboxFI->pack_start (*labmBA, Gtk::PACK_SHRINK, 1);
771
772 BAmethod->append (M("TP_WAVELET_BANONE"));
773 BAmethod->append (M("TP_WAVELET_BASLI"));
774 BAmethod->append (M("TP_WAVELET_BACUR"));
775 BAmethodconn = BAmethod->signal_changed().connect ( sigc::mem_fun(*this, &Wavelet::BAmethodChanged) );
776 ctboxFI->pack_start(*BAmethod);
777 ctboxBA->pack_start(*ctboxFI);
778
779 balance->setAdjusterListener (this);
780 balance->set_tooltip_text (M("TP_WAVELET_BALANCE_TOOLTIP"));
781
782 opacityCurveEditorW->setCurveListener (this);
783
784 opacityShape = static_cast<FlatCurveEditor*>(opacityCurveEditorW->addCurve(CT_Flat, "", nullptr, false, false));
785 opacityShape->setIdentityValue(0.);
786 opacityShape->setResetCurve(FlatCurveType(default_params.opacityCurveW.at(0)), default_params.opacityCurveW);
787 opacityShape->setBottomBarBgGradient(milestones2);
788
789 // This will add the reset button at the end of the curveType buttons
790 opacityCurveEditorW->curveListComplete();
791 opacityCurveEditorW->show();
792
793 iter->setAdjusterListener (this);
794 iter->set_tooltip_text (M("TP_WAVELET_ITER_TOOLTIP"));
795
796 Gtk::HSeparator* const separatorbalend = Gtk::manage (new Gtk::HSeparator());
797
798 opacityCurveEditorWL->setCurveListener (this);
799
800 opacityShapeWL = static_cast<FlatCurveEditor*>(opacityCurveEditorWL->addCurve(CT_Flat, "", nullptr, false, false));
801 opacityShapeWL->setIdentityValue(0.);
802 opacityShapeWL->setResetCurve(FlatCurveType(default_params.opacityCurveWL.at(0)), default_params.opacityCurveWL);
803 opacityShapeWL->setTooltip(M("TP_WAVELET_OPACITYWL_TOOLTIP"));
804
805 // This will add the reset button at the end of the curveType buttons
806 opacityCurveEditorWL->curveListComplete();
807 opacityCurveEditorWL->show();
808
809 curveEditorG->setCurveListener (this);
810
811 clshape = static_cast<DiagonalCurveEditor*>(curveEditorG->addCurve(CT_Diagonal, M("TP_WAVELET_CURVEEDITOR_CL")));
812 clshape->setTooltip(M("TP_WAVELET_CURVEEDITOR_CL_TOOLTIP"));
813 clshape->setBottomBarBgGradient(milestones2);
814 clshape->setLeftBarBgGradient(milestones2);
815
816 curveEditorG->curveListComplete();
817
818 tmr->set_active (true);
819 tmr->set_tooltip_text (M("TP_WAVELET_BALCHRO_TOOLTIP"));
820 tmrConn = tmr->signal_toggled().connect( sigc::mem_fun(*this, &Wavelet::tmrToggled) );
821
822 ToolParamBlock* const finalBox = Gtk::manage (new ToolParamBlock());
823
824 finalBox->pack_start (*ctboxBA);
825 finalBox->pack_start(*balance);
826
827 finalBox->pack_start( *opacityCurveEditorW, Gtk::PACK_SHRINK, 2);
828
829 finalBox->pack_start(*iter);
830
831 finalBox->pack_start(*tmr);
832 finalBox->pack_start(*separatorbalend, Gtk::PACK_SHRINK, 2);
833 finalBox->pack_start( *opacityCurveEditorWL, Gtk::PACK_SHRINK, 2);
834
835 finalBox->pack_start (*curveEditorG, Gtk::PACK_SHRINK, 4);
836
837 //-----------------------------
838
839 expsettings->add(*settingsBox, false);
840 expsettings->setLevel(2);
841 pack_start (*expsettings);
842
843 expcontrast->add(*levBox, false);
844 expcontrast->setLevel(2);
845 pack_start (*expcontrast);
846
847 expchroma->add(*chBox, false);
848 expchroma->setLevel(2);
849 pack_start (*expchroma);
850
851 exptoning->add(*tonBox, false);
852 exptoning->setLevel(2);
853 pack_start (*exptoning);
854
855 expnoise->add(*noiseBox, false);
856 expnoise->setLevel(2);
857 pack_start (*expnoise);
858
859 expedge->add(*edgBox, false);
860 expedge->setLevel(2);
861 pack_start (*expedge);
862
863 expgamut->add(*conBox, false);
864 expgamut->setLevel(2);
865 pack_start (*expgamut);
866
867 expresid->add(*resBox, false);
868 expresid->setLevel(2);
869 pack_start(*expresid);
870
871 expfinal->add(*finalBox, false);
872 expfinal->setLevel(2);
873 pack_start(*expfinal);
874 }
875
~Wavelet()876 Wavelet::~Wavelet ()
877 {
878 idle_register.destroy();
879
880 delete opaCurveEditorG;
881 delete opacityCurveEditorG;
882 delete CCWcurveEditorG;
883 delete curveEditorRES;
884 delete curveEditorGAM;
885 delete curveEditorG;
886 delete opacityCurveEditorW;
887 delete opacityCurveEditorWL;
888
889 }
890
wavChanged(double nlevel)891 void Wavelet::wavChanged (double nlevel)
892 {
893 if (!batchMode) {
894 idle_register.add(
895 [this, nlevel]() -> bool
896 {
897 wavLabels->set_text(
898 Glib::ustring::compose(
899 M("TP_WAVELET_LEVLABEL"),
900 Glib::ustring::format(std::fixed, std::setprecision(0), nlevel)
901 )
902 );
903 return false;
904 }
905 );
906 }
907 }
908
909 // Will only reset the channel mixer
910 // 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.
neutral_pressed()911 void Wavelet::neutral_pressed ()
912 {
913 disableListener();
914 greenlow->resetValue(false);
915 bluelow->resetValue(false);
916 greenmed->resetValue(false);
917 bluemed->resetValue(false);
918 greenhigh->resetValue(false);
919 bluehigh->resetValue(false);
920
921 enableListener();
922
923 if (listener && getEnabled()) {
924 listener->panelChanged (EvWavNeutral, M("GENERAL_RESET"));
925 }
926 }
927
read(const ProcParams * pp,const ParamsEdited * pedited)928 void Wavelet::read (const ProcParams* pp, const ParamsEdited* pedited)
929 {
930
931 /*****************************************************************************************************
932 *
933 * Disable listeners and signals
934 *
935 *****************************************************************************************************/
936
937 disableListener ();
938 Lmethodconn.block(true);
939 CLmethodconn.block(true);
940 Backmethodconn.block(true);
941 Tilesmethodconn.block(true);
942 daubcoeffmethodconn.block(true);
943 Dirmethodconn.block(true);
944 CHmethodconn.block(true);
945 CHSLmethodconn.block(true);
946 EDmethodconn.block(true);
947 NPmethodconn.block(true);
948 BAmethodconn.block(true);
949 TMmethodconn.block(true);
950 HSmethodconn.block(true);
951 MedgreinfConn.block(true);
952 cbenabConn.block(true);
953 enableChromaConn.block(true);
954 enableContrastConn.block(true);
955 enableEdgeConn.block(true);
956 enableFinalConn.block(true);
957 enableNoiseConn.block(true);
958 enableResidConn.block(true);
959 enableToningConn.block(true);
960
961 /*****************************************************************************************************
962 *
963 * Set the GUI reflecting the given ProcParams
964 *
965 *****************************************************************************************************/
966
967 //HSmethod->set_active (1); // Note: default values are controlled in rtengine::ProcParams::SetDefaults
968 if (pp->wavelet.HSmethod == "without") {
969 HSmethod->set_active (0);
970 } else if (pp->wavelet.HSmethod == "with") {
971 HSmethod->set_active (1);
972 }
973
974 //CHmethod->set_active (1);
975 if (pp->wavelet.CHmethod == "without") {
976 CHmethod->set_active (0);
977 } else if (pp->wavelet.CHmethod == "with") {
978 CHmethod->set_active (1);
979 } else if (pp->wavelet.CHmethod == "link") {
980 CHmethod->set_active (2);
981 }
982
983 //Medgreinf->set_active (1);
984 if (pp->wavelet.Medgreinf == "more") {
985 Medgreinf->set_active (0);
986 } else if (pp->wavelet.Medgreinf == "none") {
987 Medgreinf->set_active (1);
988 } else if (pp->wavelet.Medgreinf == "less") {
989 Medgreinf->set_active (2);
990 }
991
992 //CHSLmethod->set_active (1);
993 if (pp->wavelet.CHSLmethod == "SL") {
994 CHSLmethod->set_active (0);
995 } else if (pp->wavelet.CHSLmethod == "CU") {
996 CHSLmethod->set_active (1);
997 }
998
999 //EDmethod->set_active (1);
1000 if (pp->wavelet.EDmethod == "SL") {
1001 EDmethod->set_active (0);
1002 } else if (pp->wavelet.EDmethod == "CU") {
1003 EDmethod->set_active (1);
1004 }
1005
1006 if (pp->wavelet.NPmethod == "none") {
1007 NPmethod->set_active (0);
1008 } else if (pp->wavelet.NPmethod == "low") {
1009 NPmethod->set_active (1);
1010 } else if (pp->wavelet.NPmethod == "high") {
1011 NPmethod->set_active (2);
1012 }
1013
1014 //BAmethod->set_active (0);
1015 if (pp->wavelet.BAmethod == "none") {
1016 BAmethod->set_active (0);
1017 } else if (pp->wavelet.BAmethod == "sli") {
1018 BAmethod->set_active (1);
1019 } else if (pp->wavelet.BAmethod == "cur") {
1020 BAmethod->set_active (2);
1021 }
1022
1023 //TMmethod->set_active (1);
1024 if (pp->wavelet.TMmethod == "cont") {
1025 TMmethod->set_active (0);
1026 } else if (pp->wavelet.TMmethod == "tm") {
1027 TMmethod->set_active (1);
1028 }
1029
1030 // else if (pp->wavelet.TMmethod=="both")
1031 // TMmethod->set_active (2);
1032
1033 //Backmethod->set_active (3);
1034 if (pp->wavelet.Backmethod == "black") {
1035 Backmethod->set_active (0);
1036 } else if (pp->wavelet.Backmethod == "grey") {
1037 Backmethod->set_active (1);
1038 } else if (pp->wavelet.Backmethod == "resid") {
1039 Backmethod->set_active (2);
1040 }
1041
1042 //CLmethod->set_active (3);
1043 if (pp->wavelet.CLmethod == "one") {
1044 CLmethod->set_active (0);
1045 } else if (pp->wavelet.CLmethod == "inf") {
1046 CLmethod->set_active (1);
1047 } else if (pp->wavelet.CLmethod == "sup") {
1048 CLmethod->set_active (2);
1049 } else if (pp->wavelet.CLmethod == "all") {
1050 CLmethod->set_active (3);
1051 }
1052
1053 //Tilesmethod->set_active (2);
1054 if (pp->wavelet.Tilesmethod == "full") {
1055 Tilesmethod->set_active (0);
1056 } else if (pp->wavelet.Tilesmethod == "big") {
1057 Tilesmethod->set_active (1);
1058 } else if (pp->wavelet.Tilesmethod == "lit") {
1059 Tilesmethod->set_active (2);
1060 }
1061
1062 //daubcoeffmethod->set_active (4);
1063 if (pp->wavelet.daubcoeffmethod == "2_") {
1064 daubcoeffmethod->set_active (0);
1065 } else if (pp->wavelet.daubcoeffmethod == "4_") {
1066 daubcoeffmethod->set_active (1);
1067 } else if (pp->wavelet.daubcoeffmethod == "6_") {
1068 daubcoeffmethod->set_active (2);
1069 } else if (pp->wavelet.daubcoeffmethod == "10_") {
1070 daubcoeffmethod->set_active (3);
1071 } else if (pp->wavelet.daubcoeffmethod == "14_") {
1072 daubcoeffmethod->set_active (4);
1073 }
1074
1075 //Dirmethod->set_active (3);
1076 if (pp->wavelet.Dirmethod == "one") {
1077 Dirmethod->set_active (0);
1078 } else if (pp->wavelet.Dirmethod == "two") {
1079 Dirmethod->set_active (1);
1080 } else if (pp->wavelet.Dirmethod == "thr") {
1081 Dirmethod->set_active (2);
1082 } else if (pp->wavelet.Dirmethod == "all") {
1083 Dirmethod->set_active (3);
1084 }
1085
1086 int selectedLevel = pp->wavelet.Lmethod - 1;
1087 Lmethod->set_active (selectedLevel == -1 ? 4 : selectedLevel);
1088
1089 ccshape->setCurve (pp->wavelet.ccwcurve);
1090 opacityShapeRG->setCurve (pp->wavelet.opacityCurveRG);
1091 opacityShapeBY->setCurve (pp->wavelet.opacityCurveBY);
1092 opacityShape->setCurve (pp->wavelet.opacityCurveW);
1093 opacityShapeWL->setCurve (pp->wavelet.opacityCurveWL);
1094 hhshape->setCurve (pp->wavelet.hhcurve);
1095 Chshape->setCurve (pp->wavelet.Chcurve);
1096 clshape->setCurve (pp->wavelet.wavclCurve);
1097 expcontrast->setEnabled (pp->wavelet.expcontrast);
1098 expchroma->setEnabled (pp->wavelet.expchroma);
1099 expedge->setEnabled (pp->wavelet.expedge);
1100 expresid->setEnabled (pp->wavelet.expresid);
1101 expfinal->setEnabled (pp->wavelet.expfinal);
1102 exptoning->setEnabled (pp->wavelet.exptoning);
1103 expnoise->setEnabled (pp->wavelet.expnoise);
1104
1105 setEnabled(pp->wavelet.enabled);
1106 avoidConn.block (true);
1107 avoid->set_active (pp->wavelet.avoid);
1108 avoidConn.block (false);
1109 tmrConn.block (true);
1110 tmr->set_active (pp->wavelet.tmr);
1111 tmrConn.block (false);
1112 medianConn.block (true);
1113 median->set_active (pp->wavelet.median);
1114 medianConn.block (false);
1115 medianlevConn.block (true);
1116 medianlev->set_active (pp->wavelet.medianlev);
1117 medianlevConn.block (false);
1118 linkedgConn.block (true);
1119 linkedg->set_active (pp->wavelet.linkedg);
1120 linkedgConn.block (false);
1121 cbenabConn.block (true);
1122 cbenab->set_active (pp->wavelet.cbenab);
1123 cbenabConn.block (false);
1124
1125 lipstConn.block (true);
1126 lipst->set_active (pp->wavelet.lipst);
1127 lipstConn.block (false);
1128 //edgreinfConn.block (true);
1129 //edgreinf->set_active (pp->wavelet.edgreinf);
1130 //edgreinfConn.block (false);
1131 //lastedgreinf = pp->wavelet.edgreinf;
1132 lastmedian = pp->wavelet.median;
1133 lastmedianlev = pp->wavelet.medianlev;
1134 lastlinkedg = pp->wavelet.linkedg;
1135 lastcbenab = pp->wavelet.cbenab;
1136 lastlipst = pp->wavelet.lipst;
1137 lastavoid = pp->wavelet.avoid;
1138 lasttmr = pp->wavelet.tmr;
1139 rescon->setValue (pp->wavelet.rescon);
1140 resconH->setValue (pp->wavelet.resconH);
1141 reschro->setValue (pp->wavelet.reschro);
1142 tmrs->setValue (pp->wavelet.tmrs);
1143 gamma->setValue (pp->wavelet.gamma);
1144 sup->setValue (pp->wavelet.sup);
1145 sky->setValue (pp->wavelet.sky);
1146 thres->setValue (pp->wavelet.thres);
1147 chroma->setValue (pp->wavelet.chroma);
1148 chro->setValue (pp->wavelet.chro);
1149 contrast->setValue (pp->wavelet.contrast);
1150 edgrad->setValue (pp->wavelet.edgrad);
1151 edgval->setValue (pp->wavelet.edgval);
1152 edgthresh->setValue (pp->wavelet.edgthresh);
1153 thr->setValue (pp->wavelet.thr);
1154 thrH->setValue (pp->wavelet.thrH);
1155 skinprotect->setValue(pp->wavelet.skinprotect);
1156 hueskin->setValue<int>(pp->wavelet.hueskin);
1157 hueskin2->setValue<int>(pp->wavelet.hueskin2);
1158 threshold->setValue(pp->wavelet.threshold);
1159 threshold2->setValue(pp->wavelet.threshold2);
1160 edgedetect->setValue(pp->wavelet.edgedetect);
1161 edgedetectthr->setValue(pp->wavelet.edgedetectthr);
1162 edgedetectthr2->setValue(pp->wavelet.edgedetectthr2);
1163 edgesensi->setValue(pp->wavelet.edgesensi);
1164 edgeampli->setValue(pp->wavelet.edgeampli);
1165 hllev->setValue<int>(pp->wavelet.hllev);
1166 bllev->setValue<int>(pp->wavelet.bllev);
1167 pastlev->setValue<int>(pp->wavelet.pastlev);
1168 satlev->setValue<int>(pp->wavelet.satlev);
1169 edgcont->setValue<int>(pp->wavelet.edgcont);
1170
1171 greenlow->setValue (pp->wavelet.greenlow);
1172 bluelow->setValue (pp->wavelet.bluelow);
1173 greenmed->setValue (pp->wavelet.greenmed);
1174 bluemed->setValue (pp->wavelet.bluemed);
1175 greenhigh->setValue (pp->wavelet.greenhigh);
1176 bluehigh->setValue (pp->wavelet.bluehigh);
1177
1178 level0noise->setValue<double>(pp->wavelet.level0noise);
1179 level1noise->setValue<double>(pp->wavelet.level1noise);
1180 level2noise->setValue<double>(pp->wavelet.level2noise);
1181 level3noise->setValue<double>(pp->wavelet.level3noise);
1182 strength->setValue(pp->wavelet.strength);
1183 balance->setValue(pp->wavelet.balance);
1184 iter->setValue(pp->wavelet.iter);
1185
1186 for (int i = 0; i < 9; i++) {
1187 correction[i]->setValue(pp->wavelet.c[i]);
1188 }
1189
1190 for (int i = 0; i < 9; i++) {
1191 correctionch[i]->setValue(pp->wavelet.ch[i]);
1192 }
1193
1194 /*****************************************************************************************************
1195 *
1196 * Set the inconsistent state (for combobox, select the "GENERAL_UNCHANGED" entry)
1197 *
1198 *****************************************************************************************************/
1199
1200 if (pedited) {
1201 if (!pedited->wavelet.Lmethod) {
1202 Lmethod->set_active_text(M("GENERAL_UNCHANGED"));
1203 }
1204
1205 if (!pedited->wavelet.CLmethod) {
1206 CLmethod->set_active_text(M("GENERAL_UNCHANGED"));
1207 }
1208
1209 if (!pedited->wavelet.Backmethod) {
1210 Backmethod->set_active_text(M("GENERAL_UNCHANGED"));
1211 }
1212
1213 if (!pedited->wavelet.Tilesmethod) {
1214 Tilesmethod->set_active_text(M("GENERAL_UNCHANGED"));
1215 }
1216
1217 if (!pedited->wavelet.daubcoeffmethod) {
1218 daubcoeffmethod->set_active_text(M("GENERAL_UNCHANGED"));
1219 }
1220
1221 if (!pedited->wavelet.Dirmethod) {
1222 Dirmethod->set_active_text(M("GENERAL_UNCHANGED"));
1223 }
1224
1225 if (!pedited->wavelet.CHmethod) {
1226 CHmethod->set_active_text(M("GENERAL_UNCHANGED"));
1227 }
1228
1229 if (!pedited->wavelet.CHSLmethod) {
1230 CHSLmethod->set_active_text(M("GENERAL_UNCHANGED"));
1231 }
1232
1233 if (!pedited->wavelet.EDmethod) {
1234 EDmethod->set_active_text(M("GENERAL_UNCHANGED"));
1235 }
1236
1237 if (!pedited->wavelet.NPmethod) {
1238 NPmethod->set_active_text(M("GENERAL_UNCHANGED"));
1239 }
1240
1241 if (!pedited->wavelet.BAmethod) {
1242 BAmethod->set_active_text(M("GENERAL_UNCHANGED"));
1243 }
1244
1245 if (!pedited->wavelet.TMmethod) {
1246 TMmethod->set_active_text(M("GENERAL_UNCHANGED"));
1247 }
1248
1249 if (!pedited->wavelet.HSmethod) {
1250 HSmethod->set_active_text(M("GENERAL_UNCHANGED"));
1251 }
1252
1253 if (!pedited->wavelet.Medgreinf) {
1254 Medgreinf->set_active_text(M("GENERAL_UNCHANGED"));
1255 }
1256
1257 set_inconsistent (multiImage && !pedited->wavelet.enabled);
1258 ccshape->setUnChanged (!pedited->wavelet.ccwcurve);
1259 expcontrast->set_inconsistent (!pedited->wavelet.expcontrast);
1260 expchroma->set_inconsistent (!pedited->wavelet.expchroma);
1261 expedge->set_inconsistent (!pedited->wavelet.expedge);
1262 expresid->set_inconsistent (!pedited->wavelet.expresid);
1263 expfinal->set_inconsistent (!pedited->wavelet.expfinal);
1264 exptoning->set_inconsistent (!pedited->wavelet.exptoning);
1265 expnoise->set_inconsistent (!pedited->wavelet.expnoise);
1266 opacityShapeRG->setCurve (pp->wavelet.opacityCurveRG);
1267 opacityShapeBY->setCurve (pp->wavelet.opacityCurveBY);
1268 opacityShape->setCurve (pp->wavelet.opacityCurveW);
1269 opacityShapeWL->setCurve (pp->wavelet.opacityCurveWL);
1270 hhshape->setUnChanged (!pedited->wavelet.hhcurve);
1271 Chshape->setUnChanged (!pedited->wavelet.Chcurve);
1272 clshape->setUnChanged (!pedited->wavelet.wavclCurve);
1273 avoid->set_inconsistent (!pedited->wavelet.avoid);
1274 tmr->set_inconsistent (!pedited->wavelet.tmr);
1275 edgthresh->setEditedState (pedited->wavelet.edgthresh ? Edited : UnEdited);
1276 rescon->setEditedState (pedited->wavelet.rescon ? Edited : UnEdited);
1277 resconH->setEditedState (pedited->wavelet.resconH ? Edited : UnEdited);
1278 reschro->setEditedState (pedited->wavelet.reschro ? Edited : UnEdited);
1279 tmrs->setEditedState (pedited->wavelet.tmrs ? Edited : UnEdited);
1280 gamma->setEditedState (pedited->wavelet.gamma ? Edited : UnEdited);
1281 sup->setEditedState (pedited->wavelet.sup ? Edited : UnEdited);
1282 sky->setEditedState (pedited->wavelet.sky ? Edited : UnEdited);
1283 thres->setEditedState (pedited->wavelet.thres ? Edited : UnEdited);
1284 balance->setEditedState (pedited->wavelet.balance ? Edited : UnEdited);
1285 iter->setEditedState (pedited->wavelet.iter ? Edited : UnEdited);
1286 threshold->setEditedState (pedited->wavelet.threshold ? Edited : UnEdited);
1287 threshold2->setEditedState (pedited->wavelet.threshold2 ? Edited : UnEdited);
1288 edgedetect->setEditedState (pedited->wavelet.edgedetect ? Edited : UnEdited);
1289 edgedetectthr->setEditedState (pedited->wavelet.edgedetectthr ? Edited : UnEdited);
1290 edgedetectthr2->setEditedState (pedited->wavelet.edgedetectthr2 ? Edited : UnEdited);
1291 edgesensi->setEditedState (pedited->wavelet.edgesensi ? Edited : UnEdited);
1292 edgeampli->setEditedState (pedited->wavelet.edgeampli ? Edited : UnEdited);
1293 chroma->setEditedState (pedited->wavelet.chroma ? Edited : UnEdited);
1294 chro->setEditedState (pedited->wavelet.chro ? Edited : UnEdited);
1295
1296 greenlow->setEditedState (pedited->wavelet.greenlow ? Edited : UnEdited);
1297 bluelow->setEditedState (pedited->wavelet.bluelow ? Edited : UnEdited);
1298 greenmed->setEditedState (pedited->wavelet.greenmed ? Edited : UnEdited);
1299 bluemed->setEditedState (pedited->wavelet.bluemed ? Edited : UnEdited);
1300 greenhigh->setEditedState (pedited->wavelet.greenhigh ? Edited : UnEdited);
1301 bluehigh->setEditedState (pedited->wavelet.bluehigh ? Edited : UnEdited);
1302
1303 median->set_inconsistent (!pedited->wavelet.median);
1304 medianlev->set_inconsistent (!pedited->wavelet.medianlev);
1305 linkedg->set_inconsistent (!pedited->wavelet.linkedg);
1306 // edgreinf->set_inconsistent (!pedited->wavelet.edgreinf);
1307 cbenab->set_inconsistent (!pedited->wavelet.cbenab);
1308 lipst->set_inconsistent (!pedited->wavelet.lipst);
1309 contrast->setEditedState (pedited->wavelet.contrast ? Edited : UnEdited);
1310 edgrad->setEditedState (pedited->wavelet.edgrad ? Edited : UnEdited);
1311 edgval->setEditedState (pedited->wavelet.edgval ? Edited : UnEdited);
1312 thr->setEditedState (pedited->wavelet.thr ? Edited : UnEdited);
1313 thrH->setEditedState (pedited->wavelet.thrH ? Edited : UnEdited);
1314 skinprotect->setEditedState (pedited->wavelet.skinprotect ? Edited : UnEdited);
1315 hueskin->setEditedState (pedited->wavelet.hueskin ? Edited : UnEdited);
1316 hueskin2->setEditedState (pedited->wavelet.hueskin2 ? Edited : UnEdited);
1317 hllev->setEditedState (pedited->wavelet.hllev ? Edited : UnEdited);
1318 bllev->setEditedState (pedited->wavelet.bllev ? Edited : UnEdited);
1319 pastlev->setEditedState (pedited->wavelet.pastlev ? Edited : UnEdited);
1320 satlev->setEditedState (pedited->wavelet.satlev ? Edited : UnEdited);
1321 strength->setEditedState(pedited->wavelet.strength ? Edited : UnEdited);
1322 edgcont->setEditedState (pedited->wavelet.edgcont ? Edited : UnEdited);
1323 level0noise->setEditedState (pedited->wavelet.level0noise ? Edited : UnEdited);
1324 level1noise->setEditedState (pedited->wavelet.level1noise ? Edited : UnEdited);
1325 level2noise->setEditedState (pedited->wavelet.level2noise ? Edited : UnEdited);
1326 level3noise->setEditedState (pedited->wavelet.level3noise ? Edited : UnEdited);
1327
1328 for(int i = 0; i < 9; i++) {
1329 correction[i]->setEditedState (pedited->wavelet.c[i] ? Edited : UnEdited);
1330 }
1331
1332 for(int i = 0; i < 9; i++) {
1333 correctionch[i]->setEditedState (pedited->wavelet.ch[i] ? Edited : UnEdited);
1334 }
1335 }
1336
1337 /*****************************************************************************************************
1338 *
1339 * Update the GUI, all at once if not in Batch editing (in this case, display EVERYTHING)
1340 *
1341 *****************************************************************************************************/
1342
1343 if (!batchMode) {
1344 int y;
1345 y = thres->getValue();
1346 int z;
1347
1348 for(z = y; z < 9; z++) {
1349 correction[z]->hide();
1350 }
1351
1352 for(z = 0; z < y; z++) {
1353 correction[z]->show();
1354 }
1355
1356 if (pp->wavelet.CHSLmethod == "SL") {
1357 for(z = y; z < 9; z++) {
1358 correctionch[z]->hide();
1359 }
1360
1361 for(z = 0; z < y; z++) {
1362 correctionch[z]->show();
1363 }
1364 }
1365
1366 //adjusterUpdateUI(tmrs);
1367 HSmethodUpdateUI();
1368 CHmethodUpdateUI();
1369 //MedgreinfUpdateUI();
1370 //CHSLmethodUpdateUI();
1371 EDmethodUpdateUI();
1372 NPmethodUpdateUI();
1373 BAmethodUpdateUI();
1374 TMmethodUpdateUI();
1375 //BackmethodUpdateUI();
1376 CLmethodUpdateUI();
1377 lipstUpdateUI ();
1378 //TilesmethodUpdateUI();
1379 //daubcoeffmethodUpdateUI();
1380 //DirmethodUpdateUI();
1381 //LmethodUpdateUI();
1382 enabledUpdateUI ();
1383 medianlevUpdateUI ();
1384 cbenabUpdateUI ();
1385
1386 if(z == 9) {
1387 sup->show();
1388 } else {
1389 sup->hide();
1390 }
1391 }
1392
1393 /*****************************************************************************************************
1394 *
1395 * Enable listeners and signals
1396 *
1397 *****************************************************************************************************/
1398
1399 Lmethodconn.block(false);
1400 CLmethodconn.block(false);
1401 Backmethodconn.block(false);
1402 Tilesmethodconn.block(false);
1403 daubcoeffmethodconn.block(false);
1404 CHmethodconn.block(false);
1405 CHSLmethodconn.block(false);
1406 EDmethodconn.block(false);
1407 NPmethodconn.block(false);
1408 BAmethodconn.block(false);
1409 TMmethodconn.block(false);
1410 HSmethodconn.block(false);
1411 Dirmethodconn.block(false);
1412 MedgreinfConn.block(false);
1413 enableChromaConn.block(false);
1414 enableContrastConn.block(false);
1415 enableEdgeConn.block(false);
1416 enableFinalConn.block(false);
1417 enableNoiseConn.block(false);
1418 enableResidConn.block(false);
1419 enableToningConn.block(false);
1420
1421 enableListener ();
1422 }
1423
setEditProvider(EditDataProvider * provider)1424 void Wavelet::setEditProvider (EditDataProvider *provider)
1425 {
1426 ccshape->setEditProvider(provider);
1427 opacityShapeRG->setEditProvider(provider);
1428 opacityShapeBY->setEditProvider(provider);
1429 opacityShape->setEditProvider(provider);
1430 opacityShapeWL->setEditProvider(provider);
1431 hhshape->setEditProvider(provider);
1432 Chshape->setEditProvider(provider);
1433 clshape->setEditProvider(provider);
1434 }
1435
autoOpenCurve()1436 void Wavelet::autoOpenCurve ()
1437 {
1438 ccshape->openIfNonlinear();
1439 //opacityShapeRG->openIfNonlinear();
1440 //opacityShapeBY->openIfNonlinear();
1441 }
1442
write(ProcParams * pp,ParamsEdited * pedited)1443 void Wavelet::write (ProcParams* pp, ParamsEdited* pedited)
1444 {
1445
1446 pp->wavelet.enabled = getEnabled();
1447 pp->wavelet.avoid = avoid->get_active ();
1448 pp->wavelet.tmr = tmr->get_active ();
1449 pp->wavelet.rescon = rescon->getValue();
1450 pp->wavelet.resconH = resconH->getValue();
1451 pp->wavelet.reschro = reschro->getValue();
1452 pp->wavelet.tmrs = tmrs->getValue();
1453 pp->wavelet.gamma = gamma->getValue();
1454 pp->wavelet.sup = sup->getValue();
1455 pp->wavelet.sky = sky->getValue();
1456 pp->wavelet.thres = thres->getValue();
1457 pp->wavelet.chroma = chroma->getValue();
1458 pp->wavelet.chro = chro->getValue();
1459 pp->wavelet.median = median->get_active ();
1460 pp->wavelet.medianlev = medianlev->get_active ();
1461 pp->wavelet.linkedg = linkedg->get_active ();
1462 // pp->wavelet.edgreinf = edgreinf->get_active ();
1463 pp->wavelet.cbenab = cbenab->get_active ();
1464 pp->wavelet.lipst = lipst->get_active ();
1465 pp->wavelet.contrast = contrast->getValue();
1466 pp->wavelet.edgrad = edgrad->getValue();
1467 pp->wavelet.edgval = edgval->getValue();
1468 pp->wavelet.edgthresh = edgthresh->getValue();
1469 pp->wavelet.thr = thr->getValue();
1470 pp->wavelet.thrH = thrH->getValue();
1471 pp->wavelet.hueskin = hueskin->getValue<int> ();
1472 pp->wavelet.hueskin2 = hueskin2->getValue<int> ();
1473 pp->wavelet.skinprotect = skinprotect->getValue();
1474 pp->wavelet.threshold = threshold->getValue();
1475 pp->wavelet.threshold2 = threshold2->getValue();
1476 pp->wavelet.edgedetect = edgedetect->getValue();
1477 pp->wavelet.edgedetectthr = edgedetectthr->getValue();
1478 pp->wavelet.edgedetectthr2 = edgedetectthr2->getValue();
1479 pp->wavelet.edgesensi = edgesensi->getValue();
1480 pp->wavelet.edgeampli = edgeampli->getValue();
1481 pp->wavelet.hllev = hllev->getValue<int> ();
1482 pp->wavelet.bllev = bllev->getValue<int> ();
1483 pp->wavelet.edgcont = edgcont->getValue<int> ();
1484 pp->wavelet.level0noise = level0noise->getValue<double> ();
1485 pp->wavelet.level1noise = level1noise->getValue<double> ();
1486 pp->wavelet.level2noise = level2noise->getValue<double> ();
1487 pp->wavelet.level3noise = level3noise->getValue<double> ();
1488 pp->wavelet.ccwcurve = ccshape->getCurve ();
1489 pp->wavelet.opacityCurveRG = opacityShapeRG->getCurve ();
1490 pp->wavelet.opacityCurveBY = opacityShapeBY->getCurve ();
1491 pp->wavelet.opacityCurveW = opacityShape->getCurve ();
1492 pp->wavelet.opacityCurveWL = opacityShapeWL->getCurve ();
1493 pp->wavelet.hhcurve = hhshape->getCurve ();
1494 pp->wavelet.Chcurve = Chshape->getCurve ();
1495 pp->wavelet.pastlev = pastlev->getValue<int> ();
1496 pp->wavelet.satlev = satlev->getValue<int> ();
1497 pp->wavelet.strength = (int) strength->getValue();
1498 pp->wavelet.balance = (int) balance->getValue();
1499
1500 pp->wavelet.greenlow = greenlow->getValue ();
1501 pp->wavelet.bluelow = bluelow->getValue ();
1502 pp->wavelet.greenmed = greenmed->getValue ();
1503 pp->wavelet.bluemed = bluemed->getValue ();
1504 pp->wavelet.greenhigh = greenhigh->getValue ();
1505 pp->wavelet.bluehigh = bluehigh->getValue ();
1506 pp->wavelet.expcontrast = expcontrast->getEnabled();
1507 pp->wavelet.expchroma = expchroma->getEnabled();
1508 pp->wavelet.expedge = expedge->getEnabled();
1509 pp->wavelet.expresid = expresid->getEnabled();
1510 pp->wavelet.expfinal = expfinal->getEnabled();
1511 pp->wavelet.exptoning = exptoning->getEnabled();
1512 pp->wavelet.expnoise = expnoise->getEnabled();
1513
1514 pp->wavelet.iter = (int) iter->getValue();
1515 pp->wavelet.wavclCurve = clshape->getCurve ();
1516
1517 for (int i = 0; i < 9; i++) {
1518 pp->wavelet.c[i] = (int) correction[i]->getValue();
1519 }
1520
1521 for (int i = 0; i < 9; i++) {
1522 pp->wavelet.ch[i] = (int) correctionch[i]->getValue();
1523 }
1524
1525 if (pedited) {
1526 pedited->wavelet.enabled = !get_inconsistent();
1527 pedited->wavelet.avoid = !avoid->get_inconsistent();
1528 pedited->wavelet.tmr = !tmr->get_inconsistent();
1529 pedited->wavelet.median = !median->get_inconsistent();
1530 pedited->wavelet.medianlev = !medianlev->get_inconsistent();
1531 pedited->wavelet.linkedg = !linkedg->get_inconsistent();
1532 pedited->wavelet.cbenab = !cbenab->get_inconsistent();
1533 pedited->wavelet.lipst = !lipst->get_inconsistent();
1534 pedited->wavelet.Medgreinf = Medgreinf->get_active_text() != M("GENERAL_UNCHANGED");
1535 pedited->wavelet.Lmethod = Lmethod->get_active_text() != M("GENERAL_UNCHANGED");
1536 pedited->wavelet.CLmethod = CLmethod->get_active_text() != M("GENERAL_UNCHANGED");
1537 pedited->wavelet.Backmethod = Backmethod->get_active_text() != M("GENERAL_UNCHANGED");
1538 pedited->wavelet.Tilesmethod = Tilesmethod->get_active_text() != M("GENERAL_UNCHANGED");
1539 pedited->wavelet.daubcoeffmethod = daubcoeffmethod->get_active_text() != M("GENERAL_UNCHANGED");
1540 pedited->wavelet.CHmethod = CHmethod->get_active_text() != M("GENERAL_UNCHANGED");
1541 pedited->wavelet.CHSLmethod = CHSLmethod->get_active_text() != M("GENERAL_UNCHANGED");
1542 pedited->wavelet.EDmethod = EDmethod->get_active_text() != M("GENERAL_UNCHANGED");
1543 pedited->wavelet.NPmethod = NPmethod->get_active_text() != M("GENERAL_UNCHANGED");
1544 pedited->wavelet.BAmethod = BAmethod->get_active_text() != M("GENERAL_UNCHANGED");
1545 pedited->wavelet.TMmethod = TMmethod->get_active_text() != M("GENERAL_UNCHANGED");
1546 pedited->wavelet.HSmethod = HSmethod->get_active_text() != M("GENERAL_UNCHANGED");
1547 pedited->wavelet.Dirmethod = Dirmethod->get_active_text() != M("GENERAL_UNCHANGED");
1548 pedited->wavelet.edgthresh = edgthresh->getEditedState();
1549 pedited->wavelet.rescon = rescon->getEditedState();
1550 pedited->wavelet.resconH = resconH->getEditedState();
1551 pedited->wavelet.reschro = reschro->getEditedState();
1552 pedited->wavelet.tmrs = tmrs->getEditedState();
1553 pedited->wavelet.gamma = gamma->getEditedState();
1554 pedited->wavelet.sup = sup->getEditedState();
1555 pedited->wavelet.sky = sky->getEditedState();
1556 pedited->wavelet.thres = thres->getEditedState();
1557 pedited->wavelet.threshold = threshold->getEditedState();
1558 pedited->wavelet.threshold2 = threshold2->getEditedState();
1559 pedited->wavelet.edgedetect = edgedetect->getEditedState();
1560 pedited->wavelet.edgedetectthr = edgedetectthr->getEditedState();
1561 pedited->wavelet.edgedetectthr2 = edgedetectthr2->getEditedState();
1562 pedited->wavelet.edgesensi = edgesensi->getEditedState();
1563 pedited->wavelet.edgeampli = edgeampli->getEditedState();
1564 pedited->wavelet.chroma = chroma->getEditedState();
1565 pedited->wavelet.chro = chro->getEditedState();
1566 pedited->wavelet.contrast = contrast->getEditedState();
1567 pedited->wavelet.edgrad = edgrad->getEditedState();
1568 pedited->wavelet.edgval = edgval->getEditedState();
1569 pedited->wavelet.thr = thr->getEditedState();
1570 pedited->wavelet.thrH = thrH->getEditedState();
1571 pedited->wavelet.hueskin = hueskin->getEditedState ();
1572 pedited->wavelet.hueskin2 = hueskin2->getEditedState ();
1573 pedited->wavelet.skinprotect = skinprotect->getEditedState();
1574 pedited->wavelet.hllev = hllev->getEditedState ();
1575 pedited->wavelet.ccwcurve = !ccshape->isUnChanged ();
1576 pedited->wavelet.edgcont = edgcont->getEditedState ();
1577 pedited->wavelet.level0noise = level0noise->getEditedState ();
1578 pedited->wavelet.level1noise = level1noise->getEditedState ();
1579 pedited->wavelet.level2noise = level2noise->getEditedState ();
1580 pedited->wavelet.level3noise = level3noise->getEditedState ();
1581 pedited->wavelet.opacityCurveRG = !opacityShapeRG->isUnChanged ();
1582 pedited->wavelet.opacityCurveBY = !opacityShapeBY->isUnChanged ();
1583 pedited->wavelet.opacityCurveW = !opacityShape->isUnChanged ();
1584 pedited->wavelet.opacityCurveWL = !opacityShapeWL->isUnChanged ();
1585 pedited->wavelet.hhcurve = !hhshape->isUnChanged ();
1586 pedited->wavelet.Chcurve = !Chshape->isUnChanged ();
1587 pedited->wavelet.bllev = bllev->getEditedState ();
1588 pedited->wavelet.pastlev = pastlev->getEditedState ();
1589 pedited->wavelet.satlev = satlev->getEditedState ();
1590 pedited->wavelet.strength = strength->getEditedState ();
1591 pedited->wavelet.greenlow = greenlow->getEditedState ();
1592 pedited->wavelet.bluelow = bluelow->getEditedState ();
1593 pedited->wavelet.greenmed = greenmed->getEditedState ();
1594 pedited->wavelet.bluemed = bluemed->getEditedState ();
1595 pedited->wavelet.greenhigh = greenhigh->getEditedState ();
1596 pedited->wavelet.bluehigh = bluehigh->getEditedState ();
1597 pedited->wavelet.balance = balance->getEditedState ();
1598 pedited->wavelet.iter = iter->getEditedState ();
1599 pedited->wavelet.wavclCurve = !clshape->isUnChanged ();
1600 pedited->wavelet.expcontrast = !expcontrast->get_inconsistent();
1601 pedited->wavelet.expchroma = !expchroma->get_inconsistent();
1602 pedited->wavelet.expedge = !expedge->get_inconsistent();
1603 pedited->wavelet.expresid = !expresid->get_inconsistent();
1604 pedited->wavelet.expfinal = !expfinal->get_inconsistent();
1605 pedited->wavelet.exptoning = !exptoning->get_inconsistent();
1606 pedited->wavelet.expnoise = !expnoise->get_inconsistent();
1607
1608 for(int i = 0; i < 9; i++) {
1609 pedited->wavelet.c[i] = correction[i]->getEditedState();
1610 }
1611
1612 for(int i = 0; i < 9; i++) {
1613 pedited->wavelet.ch[i] = correctionch[i]->getEditedState();
1614 }
1615
1616 }
1617
1618 if (CHmethod->get_active_row_number() == 0) {
1619 pp->wavelet.CHmethod = "without";
1620 } else if (CHmethod->get_active_row_number() == 1) {
1621 pp->wavelet.CHmethod = "with";
1622 } else if (CHmethod->get_active_row_number() == 2) {
1623 pp->wavelet.CHmethod = "link";
1624 }
1625
1626 if (Medgreinf->get_active_row_number() == 0) {
1627 pp->wavelet.Medgreinf = "more";
1628 } else if (Medgreinf->get_active_row_number() == 1) {
1629 pp->wavelet.Medgreinf = "none";
1630 } else if (Medgreinf->get_active_row_number() == 2) {
1631 pp->wavelet.Medgreinf = "less";
1632 }
1633
1634 if (CHSLmethod->get_active_row_number() == 0) {
1635 pp->wavelet.CHSLmethod = "SL";
1636 } else if (CHSLmethod->get_active_row_number() == 1) {
1637 pp->wavelet.CHSLmethod = "CU";
1638 }
1639
1640 if (EDmethod->get_active_row_number() == 0) {
1641 pp->wavelet.EDmethod = "SL";
1642 } else if (EDmethod->get_active_row_number() == 1) {
1643 pp->wavelet.EDmethod = "CU";
1644 }
1645
1646 if (NPmethod->get_active_row_number() == 0) {
1647 pp->wavelet.NPmethod = "none";
1648 } else if (NPmethod->get_active_row_number() == 1) {
1649 pp->wavelet.NPmethod = "low";
1650 } else if (NPmethod->get_active_row_number() == 2) {
1651 pp->wavelet.NPmethod = "high";
1652 }
1653
1654 if (BAmethod->get_active_row_number() == 0) {
1655 pp->wavelet.BAmethod = "none";
1656 } else if (BAmethod->get_active_row_number() == 1) {
1657 pp->wavelet.BAmethod = "sli";
1658 } else if (BAmethod->get_active_row_number() == 2) {
1659 pp->wavelet.BAmethod = "cur";
1660 }
1661
1662 if (TMmethod->get_active_row_number() == 0) {
1663 pp->wavelet.TMmethod = "cont";
1664 } else if (TMmethod->get_active_row_number() == 1) {
1665 pp->wavelet.TMmethod = "tm";
1666 }
1667
1668 // else if (TMmethod->get_active_row_number()==2)
1669 // pp->wavelet.TMmethod = "both";
1670
1671 if (HSmethod->get_active_row_number() == 0) {
1672 pp->wavelet.HSmethod = "without";
1673 } else if (HSmethod->get_active_row_number() == 1) {
1674 pp->wavelet.HSmethod = "with";
1675 }
1676
1677 if (CLmethod->get_active_row_number() == 0) {
1678 pp->wavelet.CLmethod = "one";
1679 } else if (CLmethod->get_active_row_number() == 1) {
1680 pp->wavelet.CLmethod = "inf";
1681 } else if (CLmethod->get_active_row_number() == 2) {
1682 pp->wavelet.CLmethod = "sup";
1683 } else if (CLmethod->get_active_row_number() == 3) {
1684 pp->wavelet.CLmethod = "all";
1685 }
1686
1687 if (Backmethod->get_active_row_number() == 0) {
1688 pp->wavelet.Backmethod = "black";
1689 } else if (Backmethod->get_active_row_number() == 1) {
1690 pp->wavelet.Backmethod = "grey";
1691 } else if (Backmethod->get_active_row_number() == 2) {
1692 pp->wavelet.Backmethod = "resid";
1693 }
1694
1695 if (Tilesmethod->get_active_row_number() == 0) {
1696 pp->wavelet.Tilesmethod = "full";
1697 } else if (Tilesmethod->get_active_row_number() == 1) {
1698 pp->wavelet.Tilesmethod = "big";
1699 } else if (Tilesmethod->get_active_row_number() == 2) {
1700 pp->wavelet.Tilesmethod = "lit";
1701 }
1702
1703 if (daubcoeffmethod->get_active_row_number() == 0) {
1704 pp->wavelet.daubcoeffmethod = "2_";
1705 } else if (daubcoeffmethod->get_active_row_number() == 1) {
1706 pp->wavelet.daubcoeffmethod = "4_";
1707 } else if (daubcoeffmethod->get_active_row_number() == 2) {
1708 pp->wavelet.daubcoeffmethod = "6_";
1709 } else if (daubcoeffmethod->get_active_row_number() == 3) {
1710 pp->wavelet.daubcoeffmethod = "10_";
1711 } else if (daubcoeffmethod->get_active_row_number() == 4) {
1712 pp->wavelet.daubcoeffmethod = "14_";
1713 }
1714
1715 if (Dirmethod->get_active_row_number() == 0) {
1716 pp->wavelet.Dirmethod = "one";
1717 } else if (Dirmethod->get_active_row_number() == 1) {
1718 pp->wavelet.Dirmethod = "two";
1719 } else if (Dirmethod->get_active_row_number() == 2) {
1720 pp->wavelet.Dirmethod = "thr";
1721 } else if (Dirmethod->get_active_row_number() == 3) {
1722 pp->wavelet.Dirmethod = "all";
1723 }
1724
1725 pp->wavelet.Lmethod = Lmethod->get_active_row_number() + 1;
1726 }
1727
curveChanged(CurveEditor * ce)1728 void Wavelet::curveChanged (CurveEditor* ce)
1729 {
1730
1731 if (listener && getEnabled()) {
1732 if (ce == ccshape) {
1733 listener->panelChanged (EvWavCCCurve, M("HISTORY_CUSTOMCURVE"));
1734 } else if (ce == opacityShapeRG) {
1735 listener->panelChanged (EvWavColor, M("HISTORY_CUSTOMCURVE"));
1736 } else if (ce == opacityShapeBY) {
1737 listener->panelChanged (EvWavOpac, M("HISTORY_CUSTOMCURVE"));
1738 } else if (ce == opacityShape) {
1739 listener->panelChanged (EvWavopacity, M("HISTORY_CUSTOMCURVE"));
1740 } else if (ce == opacityShapeWL) {
1741 listener->panelChanged (EvWavopacityWL, M("HISTORY_CUSTOMCURVE"));
1742 } else if (ce == hhshape) {
1743 listener->panelChanged (EvWavHHCurve, M("HISTORY_CUSTOMCURVE"));
1744 } else if (ce == Chshape) {
1745 listener->panelChanged (EvWavCHCurve, M("HISTORY_CUSTOMCURVE"));
1746 } else if (ce == clshape) {
1747 listener->panelChanged (EvWavCLCurve, M("HISTORY_CUSTOMCURVE"));
1748 }
1749 }
1750 }
1751
setDefaults(const ProcParams * defParams,const ParamsEdited * pedited)1752 void Wavelet::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited)
1753 {
1754
1755 for (int i = 0; i < 9; i++) {
1756 correction[i]->setDefault(defParams->wavelet.c[i]);
1757 }
1758
1759 for (int i = 0; i < 9; i++) {
1760 correctionch[i]->setDefault(defParams->wavelet.ch[i]);
1761 }
1762
1763 strength->setDefault(defParams->wavelet.strength );
1764 balance->setDefault(defParams->wavelet.balance );
1765 iter->setDefault(defParams->wavelet.iter );
1766 rescon->setDefault (defParams->wavelet.rescon);
1767 resconH->setDefault (defParams->wavelet.resconH);
1768 reschro->setDefault (defParams->wavelet.reschro);
1769 tmrs->setDefault (defParams->wavelet.tmrs);
1770 gamma->setDefault (defParams->wavelet.gamma);
1771 sup->setDefault (defParams->wavelet.sup);
1772 sky->setDefault (defParams->wavelet.sky);
1773 thres->setDefault (defParams->wavelet.thres);
1774 threshold->setDefault (defParams->wavelet.threshold);
1775 threshold2->setDefault (defParams->wavelet.threshold2);
1776 edgedetect->setDefault (defParams->wavelet.edgedetect);
1777 edgedetectthr->setDefault (defParams->wavelet.edgedetectthr);
1778 edgedetectthr2->setDefault (defParams->wavelet.edgedetectthr2);
1779 edgesensi->setDefault (defParams->wavelet.edgesensi);
1780 edgeampli->setDefault (defParams->wavelet.edgeampli);
1781 chroma->setDefault (defParams->wavelet.chroma);
1782 chro->setDefault (defParams->wavelet.chro);
1783 contrast->setDefault (defParams->wavelet.contrast);
1784 edgrad->setDefault (defParams->wavelet.edgrad);
1785 edgval->setDefault (defParams->wavelet.edgval);
1786 edgthresh->setDefault (defParams->wavelet.edgthresh);
1787 thr->setDefault (defParams->wavelet.thr);
1788 thrH->setDefault (defParams->wavelet.thrH);
1789 hueskin->setDefault<int> (defParams->wavelet.hueskin);
1790 hueskin2->setDefault<int> (defParams->wavelet.hueskin2);
1791 hllev->setDefault<int> (defParams->wavelet.hllev);
1792 bllev->setDefault<int> (defParams->wavelet.bllev);
1793 pastlev->setDefault<int> (defParams->wavelet.pastlev);
1794 satlev->setDefault<int> (defParams->wavelet.satlev);
1795 edgcont->setDefault<int> (defParams->wavelet.edgcont);
1796 level0noise->setDefault<double> (defParams->wavelet.level0noise);
1797 level1noise->setDefault<double> (defParams->wavelet.level1noise);
1798 level2noise->setDefault<double> (defParams->wavelet.level2noise);
1799 level3noise->setDefault<double> (defParams->wavelet.level3noise);
1800
1801 greenlow->setDefault (defParams->wavelet.greenlow);
1802 bluelow->setDefault (defParams->wavelet.bluelow);
1803 greenmed->setDefault (defParams->wavelet.greenmed);
1804 bluemed->setDefault (defParams->wavelet.bluemed);
1805 greenhigh->setDefault (defParams->wavelet.greenhigh);
1806 bluehigh->setDefault (defParams->wavelet.bluehigh);
1807
1808 if (pedited) {
1809 greenlow->setDefaultEditedState (pedited->wavelet.greenlow ? Edited : UnEdited);
1810 bluelow->setDefaultEditedState (pedited->wavelet.bluelow ? Edited : UnEdited);
1811 greenmed->setDefaultEditedState (pedited->wavelet.greenmed ? Edited : UnEdited);
1812 bluemed->setDefaultEditedState (pedited->wavelet.bluemed ? Edited : UnEdited);
1813 greenhigh->setDefaultEditedState (pedited->wavelet.greenhigh ? Edited : UnEdited);
1814 bluehigh->setDefaultEditedState (pedited->wavelet.bluehigh ? Edited : UnEdited);
1815
1816 rescon->setDefault (defParams->wavelet.rescon);
1817 resconH->setDefault (defParams->wavelet.resconH);
1818 reschro->setDefault (defParams->wavelet.reschro);
1819 tmrs->setDefault (defParams->wavelet.tmrs);
1820 gamma->setDefault (defParams->wavelet.gamma);
1821 sup->setDefault (defParams->wavelet.sup);
1822 sky->setDefaultEditedState(pedited->wavelet.sky ? Edited : UnEdited);
1823 thres->setDefaultEditedState(pedited->wavelet.thres ? Edited : UnEdited);
1824 threshold->setDefaultEditedState(pedited->wavelet.threshold ? Edited : UnEdited);
1825 threshold2->setDefaultEditedState(pedited->wavelet.threshold2 ? Edited : UnEdited);
1826 edgedetect->setDefaultEditedState(pedited->wavelet.edgedetect ? Edited : UnEdited);
1827 edgedetectthr->setDefaultEditedState(pedited->wavelet.edgedetectthr ? Edited : UnEdited);
1828 edgedetectthr2->setDefaultEditedState(pedited->wavelet.edgedetectthr2 ? Edited : UnEdited);
1829 edgesensi->setDefaultEditedState(pedited->wavelet.edgesensi ? Edited : UnEdited);
1830 edgeampli->setDefaultEditedState(pedited->wavelet.edgeampli ? Edited : UnEdited);
1831 chroma->setDefaultEditedState(pedited->wavelet.chroma ? Edited : UnEdited);
1832 chro->setDefaultEditedState(pedited->wavelet.chro ? Edited : UnEdited);
1833 contrast->setDefaultEditedState(pedited->wavelet.contrast ? Edited : UnEdited);
1834 edgrad->setDefaultEditedState(pedited->wavelet.edgrad ? Edited : UnEdited);
1835 edgval->setDefaultEditedState(pedited->wavelet.edgval ? Edited : UnEdited);
1836 edgthresh->setDefault (defParams->wavelet.edgthresh);
1837 thr->setDefaultEditedState(pedited->wavelet.thr ? Edited : UnEdited);
1838 thrH->setDefaultEditedState(pedited->wavelet.thrH ? Edited : UnEdited);
1839 skinprotect->setDefaultEditedState(pedited->wavelet.skinprotect ? Edited : UnEdited);
1840 hueskin->setDefaultEditedState(pedited->wavelet.hueskin ? Edited : UnEdited);
1841 hueskin2->setDefaultEditedState(pedited->wavelet.hueskin2 ? Edited : UnEdited);
1842 hllev->setDefaultEditedState(pedited->wavelet.hllev ? Edited : UnEdited);
1843 bllev->setDefaultEditedState(pedited->wavelet.bllev ? Edited : UnEdited);
1844 pastlev->setDefaultEditedState(pedited->wavelet.pastlev ? Edited : UnEdited);
1845 satlev->setDefaultEditedState(pedited->wavelet.satlev ? Edited : UnEdited);
1846 edgcont->setDefaultEditedState(pedited->wavelet.edgcont ? Edited : UnEdited);
1847 strength->setDefaultEditedState(pedited->wavelet.strength ? Edited : UnEdited);
1848 balance->setDefaultEditedState(pedited->wavelet.balance ? Edited : UnEdited);
1849 iter->setDefaultEditedState(pedited->wavelet.iter ? Edited : UnEdited);
1850 level0noise->setDefaultEditedState(pedited->wavelet.level0noise ? Edited : UnEdited);
1851 level1noise->setDefaultEditedState(pedited->wavelet.level1noise ? Edited : UnEdited);
1852 level2noise->setDefaultEditedState(pedited->wavelet.level2noise ? Edited : UnEdited);
1853 level3noise->setDefaultEditedState(pedited->wavelet.level3noise ? Edited : UnEdited);
1854
1855 for (int i = 0; i < 9; i++) {
1856 correction[i]->setDefaultEditedState(pedited->wavelet.c[i] ? Edited : UnEdited);
1857 }
1858
1859 for (int i = 0; i < 9; i++) {
1860 correctionch[i]->setDefaultEditedState(pedited->wavelet.ch[i] ? Edited : UnEdited);
1861 }
1862 } else {
1863 rescon->setDefaultEditedState(Irrelevant);
1864 resconH->setDefaultEditedState(Irrelevant);
1865 reschro->setDefaultEditedState(Irrelevant);
1866 tmrs->setDefaultEditedState(Irrelevant);
1867 gamma->setDefaultEditedState(Irrelevant);
1868 sup->setDefaultEditedState(Irrelevant);
1869 sky->setDefaultEditedState(Irrelevant);
1870 thres->setDefaultEditedState(Irrelevant);
1871 threshold->setDefaultEditedState(Irrelevant);
1872 threshold2->setDefaultEditedState(Irrelevant);
1873 edgedetect->setDefaultEditedState(Irrelevant);
1874 edgedetectthr->setDefaultEditedState(Irrelevant);
1875 edgedetectthr2->setDefaultEditedState(Irrelevant);
1876 edgesensi->setDefaultEditedState(Irrelevant);
1877 edgeampli->setDefaultEditedState(Irrelevant);
1878 chroma->setDefaultEditedState(Irrelevant);
1879 chro->setDefaultEditedState(Irrelevant);
1880 contrast->setDefaultEditedState(Irrelevant);
1881 edgrad->setDefaultEditedState(Irrelevant);
1882 edgval->setDefaultEditedState(Irrelevant);
1883 edgthresh->setDefaultEditedState(Irrelevant);
1884 thr->setDefaultEditedState(Irrelevant);
1885 thrH->setDefaultEditedState(Irrelevant);
1886 skinprotect->setDefaultEditedState(Irrelevant);
1887 hueskin->setDefaultEditedState (Irrelevant);
1888 hueskin2->setDefaultEditedState (Irrelevant);
1889 hllev->setDefaultEditedState (Irrelevant);
1890 bllev->setDefaultEditedState (Irrelevant);
1891 edgcont->setDefaultEditedState (Irrelevant);
1892 level0noise->setDefaultEditedState (Irrelevant);
1893 level1noise->setDefaultEditedState (Irrelevant);
1894 level2noise->setDefaultEditedState (Irrelevant);
1895 level3noise->setDefaultEditedState (Irrelevant);
1896 pastlev->setDefaultEditedState (Irrelevant);
1897 satlev->setDefaultEditedState (Irrelevant);
1898 strength->setDefaultEditedState (Irrelevant);
1899 balance->setDefaultEditedState (Irrelevant);
1900 iter->setDefaultEditedState (Irrelevant);
1901
1902 for (int i = 0; i < 9; i++) {
1903 correction[i]->setDefaultEditedState(Irrelevant);
1904 }
1905
1906 for (int i = 0; i < 9; i++) {
1907 correctionch[i]->setDefaultEditedState(Irrelevant);
1908 }
1909 }
1910 }
1911
adjusterChanged(ThresholdAdjuster * a,double newBottom,double newTop)1912 void Wavelet::adjusterChanged(ThresholdAdjuster* a, double newBottom, double newTop)
1913 {
1914 if (listener && (multiImage || getEnabled()) ) {
1915 if(a == level0noise) {
1916 listener->panelChanged (EvWavlev0nois,
1917 Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
1918 } else if(a == level1noise) {
1919 listener->panelChanged (EvWavlev1nois,
1920 Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
1921 } else if(a == level2noise) {
1922 listener->panelChanged (EvWavlev2nois,
1923 Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
1924 } else if(a == level3noise) {
1925 listener->panelChanged (EvWavlev3nois,
1926 Glib::ustring::compose(Glib::ustring(M("TP_WAVELET_NOIS") + ": %1" + "\n" + M("TP_WAVELET_STREN") + ": %2"), int(newTop), int(newBottom)));
1927 }
1928
1929 }
1930 }
1931
adjusterChanged(ThresholdAdjuster * a,double newBottomLeft,double newTopLeft,double newBottomRight,double newTopRight)1932 void Wavelet::adjusterChanged(ThresholdAdjuster* a, double newBottomLeft, double newTopLeft, double newBottomRight, double newTopRight)
1933 {
1934 }
1935
adjusterChanged(ThresholdAdjuster * a,int newBottom,int newTop)1936 void Wavelet::adjusterChanged(ThresholdAdjuster* a, int newBottom, int newTop)
1937 {
1938 }
1939
adjusterChanged(ThresholdAdjuster * a,int newBottomLeft,int newTopLeft,int newBottomRight,int newTopRight)1940 void Wavelet::adjusterChanged(ThresholdAdjuster* a, int newBottomLeft, int newTopLeft, int newBottomRight, int newTopRight)
1941 {
1942 }
1943
adjusterChanged2(ThresholdAdjuster * a,int newBottomL,int newTopL,int newBottomR,int newTopR)1944 void Wavelet::adjusterChanged2(ThresholdAdjuster* a, int newBottomL, int newTopL, int newBottomR, int newTopR)
1945 {
1946 if (listener && (multiImage || getEnabled()) ) {
1947 if(a == hueskin) {
1948 listener->panelChanged (EvWavHueskin, hueskin->getHistoryString());
1949 } else if(a == hueskin2) {
1950 listener->panelChanged (EvWavHueskin2, hueskin2->getHistoryString());
1951 } else if(a == hllev) {
1952 listener->panelChanged (EvWavlhl, hllev->getHistoryString());
1953 } else if(a == bllev) {
1954 listener->panelChanged (EvWavlbl, bllev->getHistoryString());
1955 } else if(a == pastlev) {
1956 listener->panelChanged (EvWavpast, pastlev->getHistoryString());
1957 } else if(a == satlev) {
1958 listener->panelChanged (EvWavsat, satlev->getHistoryString());
1959 } else if(a == edgcont) {
1960 listener->panelChanged (EvWavedgcont, edgcont->getHistoryString());
1961 }
1962 }
1963 }
1964
HSmethodUpdateUI()1965 void Wavelet::HSmethodUpdateUI()
1966 {
1967 if (!batchMode) {
1968 if(HSmethod->get_active_row_number() == 0) { //without
1969 hllev->hide();
1970 bllev->hide();
1971 threshold->hide();
1972 threshold2->hide();
1973 } else { //with
1974 hllev->show();
1975 bllev->show();
1976 threshold->show();
1977 threshold2->show();
1978 }
1979 }
1980 }
1981
HSmethodChanged()1982 void Wavelet::HSmethodChanged()
1983 {
1984 HSmethodUpdateUI();
1985
1986 if (listener && (multiImage || getEnabled()) ) {
1987 listener->panelChanged (EvWavHSmet, HSmethod->get_active_text ());
1988 }
1989 }
1990
CHmethodUpdateUI()1991 void Wavelet::CHmethodUpdateUI()
1992 {
1993 if (!batchMode) {
1994 if(CHmethod->get_active_row_number() == 0) {
1995 CHSLmethod->show();
1996 pastlev->hide();
1997 satlev->hide();
1998 chroma->hide();
1999 chro->hide();
2000 labmC->show();
2001 separatorNeutral->hide();
2002 neutralchButton->show();
2003 int y = thres->getValue();
2004 int z;
2005
2006 for(z = y; z < 9; z++) {
2007 correctionch[z]->hide();
2008 }
2009
2010 for(z = 0; z < y; z++) {
2011 correctionch[z]->show();
2012 }
2013 } else if(CHmethod->get_active_row_number() == 1) {
2014 CHSLmethod->show();
2015 pastlev->show();
2016 satlev->show();
2017 chroma->show();
2018 chro->hide();
2019 labmC->show();
2020 separatorNeutral->show();
2021 neutralchButton->show();
2022 int y = thres->getValue();
2023 int z;
2024
2025 for(z = y; z < 9; z++) {
2026 correctionch[z]->hide();
2027 }
2028
2029 for(z = 0; z < y; z++) {
2030 correctionch[z]->show();
2031 }
2032 } else {
2033 chro->show();
2034 pastlev->hide();
2035 satlev->hide();
2036 chroma->hide();
2037 CHSLmethod->hide();
2038 labmC->hide();
2039 separatorNeutral->hide();
2040 neutralchButton->hide();
2041
2042 for (int i = 0; i < 9; i++) {
2043 correctionch[i]->hide();
2044 }
2045 }
2046 }
2047 }
2048
CHmethodChanged()2049 void Wavelet::CHmethodChanged()
2050 {
2051 CHmethodUpdateUI();
2052
2053 if (listener && (multiImage || getEnabled()) ) {
2054 listener->panelChanged (EvWavCHmet, CHmethod->get_active_text ());
2055 }
2056 }
2057
2058 /*
2059 void Wavelet::CHSLmethodChangedUI() {
2060 if (!batchMode) {
2061 if(CHSLmethod->get_active_row_number()==0 && CHmethod->get_active_row_number() != 2) {//SL
2062 //CLVcurveEditorG->hide();
2063 neutralchButton->show();
2064 int y=thres->getValue();
2065 int z;
2066 for(z=y;z<9;z++) correctionch[z]->hide();
2067 for(z=0;z<y;z++) correctionch[z]->show();
2068 }
2069 else if(CHSLmethod->get_active_row_number()==1) {//CU
2070 //CLVcurveEditorG->show();
2071 neutralchButton->hide();
2072 for (int i = 0; i < 9; i++) {
2073 correctionch[i]->hide();
2074 }
2075 }
2076 }
2077 }
2078 */
2079
CHSLmethodChanged()2080 void Wavelet::CHSLmethodChanged()
2081 {
2082 /*
2083 CHSLmethodChangedUI();
2084 if (listener && (multiImage||enabled->get_active()) ) {
2085 listener->panelChanged (EvWavCHSLmet, CHSLmethod->get_active_text ());
2086 }
2087 */
2088 }
2089
EDmethodUpdateUI()2090 void Wavelet::EDmethodUpdateUI()
2091 {
2092 if (!batchMode) {
2093 if(EDmethod->get_active_row_number() == 0 ) { //SL
2094 CCWcurveEditorG->hide();
2095 edgcont->show();
2096 } else if(EDmethod->get_active_row_number() == 1) { //CU
2097 CCWcurveEditorG->show();
2098 edgcont->hide();
2099 }
2100 }
2101 }
EDmethodChanged()2102 void Wavelet::EDmethodChanged()
2103 {
2104 EDmethodUpdateUI();
2105
2106 if (listener && (multiImage || getEnabled()) ) {
2107 listener->panelChanged (EvWavEDmet, EDmethod->get_active_text ());
2108 }
2109 }
2110
NPmethodUpdateUI()2111 void Wavelet::NPmethodUpdateUI()
2112 {
2113 if (!batchMode) {
2114
2115 }
2116 }
NPmethodChanged()2117 void Wavelet::NPmethodChanged()
2118 {
2119 NPmethodUpdateUI();
2120
2121 if (listener && (multiImage || getEnabled()) ) {
2122 listener->panelChanged (EvWavNPmet, NPmethod->get_active_text ());
2123 }
2124 }
2125
2126
2127
BAmethodUpdateUI()2128 void Wavelet::BAmethodUpdateUI()
2129 {
2130 if (!batchMode) {
2131 if(BAmethod->get_active_row_number() == 0 ) { //none
2132 balance->hide();
2133 opacityCurveEditorW->hide();
2134 iter->hide();
2135
2136 } else if(BAmethod->get_active_row_number() == 1) { //sli
2137 opacityCurveEditorW->hide();
2138 balance->show();
2139 iter->show();
2140 } else if(BAmethod->get_active_row_number() == 2) { //CU
2141 opacityCurveEditorW->show();
2142 balance->hide();
2143 iter->show();
2144 }
2145 }
2146 }
BAmethodChanged()2147 void Wavelet::BAmethodChanged()
2148 {
2149 BAmethodUpdateUI();
2150
2151 if (listener && (multiImage || getEnabled()) ) {
2152 listener->panelChanged (EvWavBAmet, BAmethod->get_active_text ());
2153 }
2154 }
2155
2156
TMmethodUpdateUI()2157 void Wavelet::TMmethodUpdateUI()
2158 {
2159 /*
2160 if (!batchMode) {
2161 if(TMmethod->get_active_row_number()==0 ) {//
2162 tmr->hide();
2163 }
2164 else {
2165 tmr->show();
2166 }
2167 }
2168 */
2169 }
2170
TMmethodChanged()2171 void Wavelet::TMmethodChanged()
2172 {
2173 TMmethodUpdateUI();
2174
2175 if (listener && (multiImage || getEnabled()) ) {
2176 listener->panelChanged (EvWavTMmet, TMmethod->get_active_text ());
2177 }
2178 }
2179
2180 /*
2181 void Wavelet::BackmethodUpdateUI() {
2182 if (!batchMode) {
2183 }
2184 }
2185 */
2186
BackmethodChanged()2187 void Wavelet::BackmethodChanged()
2188 {
2189 //BackmethodUpdateUI();
2190 if (listener && (multiImage || getEnabled()) ) {
2191 listener->panelChanged (EvWavBackmet, Backmethod->get_active_text ());
2192 }
2193 }
2194
CLmethodUpdateUI()2195 void Wavelet::CLmethodUpdateUI()
2196 {
2197 if (!batchMode) {
2198 if (CLmethod->get_active_row_number() == 0) {
2199 CLmethod->set_active (0);
2200 Lmethod->set_sensitive(true);
2201 Dirmethod->set_sensitive(true);
2202 } else if (CLmethod->get_active_row_number() == 1) {
2203 CLmethod->set_active (1);
2204 Lmethod->set_sensitive(true);
2205 Dirmethod->set_sensitive(true);
2206 } else if (CLmethod->get_active_row_number() == 2) {
2207 CLmethod->set_active (2);
2208 Lmethod->set_sensitive(true);
2209 Dirmethod->set_sensitive(true);
2210 } else if (CLmethod->get_active_row_number() == 3) {
2211 CLmethod->set_active (3);
2212 Lmethod->set_sensitive(false);
2213 Dirmethod->set_sensitive(false);
2214 }
2215 }
2216 }
2217
CLmethodChanged()2218 void Wavelet::CLmethodChanged()
2219 {
2220 CLmethodUpdateUI();
2221
2222 if (listener && (multiImage || getEnabled()) ) {
2223 listener->panelChanged (EvWavCLmet, CLmethod->get_active_text ());
2224 }
2225 }
2226
2227 /*
2228 void Wavelet::TilesmethodUpdateUI() {
2229 if (!batchMode) {
2230 }
2231 }
2232 */
2233
TilesmethodChanged()2234 void Wavelet::TilesmethodChanged()
2235 {
2236 //TilesmethodUpdateUI();
2237 if (listener && (multiImage || getEnabled()) ) {
2238 listener->panelChanged (EvWavTilesmet, Tilesmethod->get_active_text ());
2239 }
2240 }
2241
2242 /*
2243 void Wavelet::daubcoeffmethodUpdateUI() {
2244 if (!batchMode) {
2245 }}
2246 */
daubcoeffmethodChanged()2247 void Wavelet::daubcoeffmethodChanged()
2248 {
2249 //daubcoeffmethodUpdateUI();
2250 if (listener && (multiImage || getEnabled()) ) {
2251 listener->panelChanged (EvWavdaubcoeffmet, daubcoeffmethod->get_active_text ());
2252 }
2253 }
2254
2255 /*
2256 void Wavelet::MedgreinfUpdateUI() {
2257 if (!batchMode) {
2258 }
2259 }
2260 */
MedgreinfChanged()2261 void Wavelet::MedgreinfChanged()
2262 {
2263 //MedgreinfUpdateUI();
2264 if (listener && (multiImage || getEnabled()) ) {
2265 listener->panelChanged (EvWavedgreinf, Medgreinf->get_active_text ());
2266 }
2267 }
2268
2269 /*
2270 void Wavelet::DirmethodUpdateUI() {
2271 if (!batchMode) {
2272 }
2273 }
2274 */
DirmethodChanged()2275 void Wavelet::DirmethodChanged()
2276 {
2277 //DirmethodUpdateUI();
2278 if (listener && (multiImage || getEnabled()) ) {
2279 listener->panelChanged (EvWavDirmeto, Dirmethod->get_active_text ());
2280 }
2281 }
2282
2283 /*
2284 void Wavelet::LmethodUpdateUI() {
2285 if (!batchMode) {
2286 }
2287 }
2288 */
LmethodChanged()2289 void Wavelet::LmethodChanged()
2290 {
2291 //LmethodUpdateUI();
2292 if (listener && (multiImage || getEnabled()) ) {
2293 listener->panelChanged (EvWavLmet, Lmethod->get_active_text ());
2294 }
2295 }
2296
setBatchMode(bool batchMode)2297 void Wavelet::setBatchMode (bool batchMode)
2298 {
2299 Lmethod->append (M("GENERAL_UNCHANGED"));
2300 CLmethod->append (M("GENERAL_UNCHANGED"));
2301 Backmethod->append (M("GENERAL_UNCHANGED"));
2302 Tilesmethod->append (M("GENERAL_UNCHANGED"));
2303 daubcoeffmethod->append (M("GENERAL_UNCHANGED"));
2304 CHmethod->append (M("GENERAL_UNCHANGED"));
2305 Medgreinf->append (M("GENERAL_UNCHANGED"));
2306 CHSLmethod->append (M("GENERAL_UNCHANGED"));
2307 EDmethod->append (M("GENERAL_UNCHANGED"));
2308 NPmethod->append (M("GENERAL_UNCHANGED"));
2309 BAmethod->append (M("GENERAL_UNCHANGED"));
2310 TMmethod->append (M("GENERAL_UNCHANGED"));
2311 HSmethod->append (M("GENERAL_UNCHANGED"));
2312 Dirmethod->append (M("GENERAL_UNCHANGED"));
2313 CCWcurveEditorG->setBatchMode (batchMode);
2314 opaCurveEditorG->setBatchMode (batchMode);
2315 opacityCurveEditorG->setBatchMode (batchMode);
2316 opacityCurveEditorW->setBatchMode (batchMode);
2317 opacityCurveEditorWL->setBatchMode (batchMode);
2318 curveEditorRES->setBatchMode (batchMode);
2319 curveEditorGAM->setBatchMode (batchMode);
2320 rescon->showEditedCB ();
2321 resconH->showEditedCB ();
2322 reschro->showEditedCB ();
2323 tmrs->showEditedCB ();
2324 gamma->showEditedCB ();
2325 sup->showEditedCB ();
2326 sky->showEditedCB ();
2327 thres->showEditedCB ();
2328 threshold->showEditedCB ();
2329 threshold2->showEditedCB ();
2330 edgedetect->showEditedCB ();
2331 edgedetectthr->showEditedCB ();
2332 edgedetectthr2->showEditedCB ();
2333 edgesensi->showEditedCB ();
2334 edgeampli->showEditedCB ();
2335 chroma->showEditedCB ();
2336 chro->showEditedCB ();
2337 contrast->showEditedCB ();
2338 edgrad->showEditedCB ();
2339 edgval->showEditedCB ();
2340 edgthresh->showEditedCB ();
2341 thr->showEditedCB ();
2342 thrH->showEditedCB ();
2343 skinprotect->showEditedCB();
2344 hueskin->showEditedCB ();
2345 hueskin2->showEditedCB ();
2346 hllev->showEditedCB ();
2347 bllev->showEditedCB ();
2348 pastlev->showEditedCB ();
2349 satlev->showEditedCB ();
2350 edgcont->showEditedCB ();
2351 strength->showEditedCB ();
2352 balance->showEditedCB ();
2353 iter->showEditedCB ();
2354 level0noise->showEditedCB ();
2355 level1noise->showEditedCB ();
2356 level2noise->showEditedCB ();
2357 level3noise->showEditedCB ();
2358
2359 ToolPanel::setBatchMode (batchMode);
2360
2361 for (int i = 0; i < 9; i++) {
2362 correction[i]->showEditedCB();
2363 }
2364
2365 for (int i = 0; i < 9; i++) {
2366 correctionch[i]->showEditedCB();
2367 }
2368 }
2369
adjusterUpdateUI(Adjuster * a)2370 void Wavelet::adjusterUpdateUI (Adjuster* a)
2371 {
2372 /*
2373 if (!batchMode) {
2374 if (a == tmrs ) {
2375 float tm;
2376 tm=tmrs->getValue();
2377 if(tm==0.f) tmr->hide();
2378 else tmr->show();
2379 }
2380 else if (a == gamma ) {
2381 float tm;
2382 tm=tmrs->getValue();
2383 if(tm==0.f) tmr->hide();
2384 else tmr->show();
2385 );
2386 }
2387 }
2388 */
2389 }
2390
adjusterChanged(Adjuster * a,double newval)2391 void Wavelet::adjusterChanged(Adjuster* a, double newval)
2392 {
2393 if (listener && (multiImage || getEnabled()) ) {
2394 if (a == edgthresh) {
2395 listener->panelChanged (EvWavtiles, edgthresh->getTextValue());
2396 } else if (a == rescon ) {
2397 listener->panelChanged (EvWavrescon, rescon->getTextValue());
2398 } else if (a == resconH ) {
2399 listener->panelChanged (EvWavresconH, resconH->getTextValue());
2400 } else if (a == reschro ) {
2401 listener->panelChanged (EvWavreschro, reschro->getTextValue());
2402 } else if (a == tmrs ) {
2403 adjusterUpdateUI(a);
2404 listener->panelChanged (EvWavtmrs, tmrs->getTextValue());
2405 } else if (a == gamma ) {
2406 adjusterUpdateUI(a);
2407 listener->panelChanged (EvWavgamma, gamma->getTextValue());
2408 } else if (a == sky ) {
2409 listener->panelChanged (EvWavsky, sky->getTextValue());
2410 } else if (a == sup ) {
2411 listener->panelChanged (EvWavsup, sup->getTextValue());
2412 } else if (a == chroma ) {
2413 listener->panelChanged (EvWavchroma, chroma->getTextValue());
2414 } else if (a == chro ) {
2415 listener->panelChanged (EvWavchro, chro->getTextValue());
2416 } else if (a == contrast ) {
2417 listener->panelChanged (EvWavunif, contrast->getTextValue());
2418 } else if (a == thr ) {
2419 listener->panelChanged (EvWavthr, thr->getTextValue());
2420 } else if (a == thrH ) {
2421 listener->panelChanged (EvWavthrH, thrH->getTextValue());
2422 } else if (a == threshold ) {
2423 listener->panelChanged (EvWavThreshold, threshold->getTextValue());
2424 } else if (a == threshold2 ) {
2425 listener->panelChanged (EvWavThreshold2, threshold2->getTextValue());
2426 } else if (a == edgedetect ) {
2427 listener->panelChanged (EvWavedgedetect, edgedetect->getTextValue());
2428 } else if (a == edgedetectthr ) {
2429 listener->panelChanged (EvWavedgedetectthr, edgedetectthr->getTextValue());
2430 } else if (a == edgedetectthr2 ) {
2431 listener->panelChanged (EvWavedgedetectthr2, edgedetectthr2->getTextValue());
2432 } else if (a == edgesensi ) {
2433 listener->panelChanged (EvWavedgesensi, edgesensi->getTextValue());
2434 } else if (a == edgeampli ) {
2435 listener->panelChanged (EvWavedgeampli, edgeampli->getTextValue());
2436 } else if (a == edgrad ) {
2437 listener->panelChanged (EvWavedgrad, edgrad->getTextValue());
2438 } else if (a == edgval ) {
2439 listener->panelChanged (EvWavedgval, edgval->getTextValue());
2440 } else if (a == thres ) {
2441 int y = thres->getValue();
2442 int z;
2443
2444 for(z = y; z < 9; z++) {
2445 correction[z]->hide();
2446 }
2447
2448 for(z = 0; z < y; z++) {
2449 correction[z]->show();
2450 }
2451
2452 for(z = y; z < 9; z++) {
2453 correctionch[z]->hide();
2454 }
2455
2456 for(z = 0; z < y; z++) {
2457 correctionch[z]->show();
2458 }
2459
2460 if(z == 9) {
2461 sup->show();
2462 } else {
2463 sup->hide();
2464 }
2465
2466 listener->panelChanged (EvWavthres, thres->getTextValue());
2467 } else if (a == skinprotect) {
2468 listener->panelChanged (EvWavSkin, skinprotect->getTextValue());
2469 } else if (a == strength) {
2470 listener->panelChanged (EvWavStrength, strength->getTextValue());
2471 } else if (a == balance) {
2472 listener->panelChanged (EvWavbalance, balance->getTextValue());
2473 } else if (a == iter) {
2474 listener->panelChanged (EvWaviter, iter->getTextValue());
2475 } else if (a == greenhigh ) {
2476 listener->panelChanged (EvWavgreenhigh, greenhigh->getTextValue());
2477 } else if (a == bluehigh ) {
2478 listener->panelChanged (EvWavbluehigh, bluehigh->getTextValue());
2479 } else if (a == greenmed ) {
2480 listener->panelChanged (EvWavgreenmed, greenmed->getTextValue());
2481 } else if (a == bluemed ) {
2482 listener->panelChanged (EvWavbluemed, bluemed->getTextValue());
2483 } else if (a == greenlow ) {
2484 listener->panelChanged (EvWavgreenlow, greenlow->getTextValue());
2485 } else if (a == bluelow ) {
2486 listener->panelChanged (EvWavbluelow, bluelow->getTextValue());
2487 }
2488
2489 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])) {
2490 listener->panelChanged (EvWavelet,
2491 Glib::ustring::compose("%1, %2, %3, %4, %5, %6, %7, %8, %9",
2492 Glib::ustring::format(std::fixed, std::setprecision(0), correction[0]->getValue()),
2493 Glib::ustring::format(std::fixed, std::setprecision(0), correction[1]->getValue()),
2494 Glib::ustring::format(std::fixed, std::setprecision(0), correction[2]->getValue()),
2495 Glib::ustring::format(std::fixed, std::setprecision(0), correction[3]->getValue()),
2496 Glib::ustring::format(std::fixed, std::setprecision(0), correction[4]->getValue()),
2497 Glib::ustring::format(std::fixed, std::setprecision(0), correction[5]->getValue()),
2498 Glib::ustring::format(std::fixed, std::setprecision(0), correction[6]->getValue()),
2499 Glib::ustring::format(std::fixed, std::setprecision(0), correction[7]->getValue()),
2500 Glib::ustring::format(std::fixed, std::setprecision(0), correction[8]->getValue()))
2501 );
2502 } 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] ) {
2503 listener->panelChanged (EvWaveletch,
2504 Glib::ustring::compose("%1, %2, %3, %4, %5, %6, %7, %8, %9",
2505 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[0]->getValue()),
2506 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[1]->getValue()),
2507 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[2]->getValue()),
2508 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[3]->getValue()),
2509 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[4]->getValue()),
2510 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[5]->getValue()),
2511 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[6]->getValue()),
2512 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[7]->getValue()),
2513 Glib::ustring::format(std::fixed, std::setprecision(0), correctionch[8]->getValue()))
2514 );
2515 }
2516 }
2517 }
2518
enabledUpdateUI()2519 void Wavelet::enabledUpdateUI ()
2520 {
2521 if (!batchMode) {
2522 int y = thres->getValue();
2523 int z;
2524
2525 for(z = y; z < 9; z++) {
2526 correction[z]->hide();
2527 }
2528
2529 for(z = 0; z < y; z++) {
2530 correction[z]->show();
2531 }
2532
2533 if(z == 9) {
2534 sup->show();
2535 } else {
2536 sup->hide();
2537 }
2538
2539 // adjusterUpdateUI(tmrs);
2540 }
2541 }
2542
enabledChanged()2543 void Wavelet::enabledChanged ()
2544 {
2545 enabledUpdateUI();
2546
2547 if (listener) {
2548 if (get_inconsistent()) {
2549 listener->panelChanged (EvWavEnabled, M("GENERAL_UNCHANGED"));
2550 } else if (getEnabled()) {
2551 listener->panelChanged (EvWavEnabled, M("GENERAL_ENABLED"));
2552 } else {
2553 listener->panelChanged (EvWavEnabled, M("GENERAL_DISABLED"));
2554 }
2555 }
2556 }
2557
medianToggled()2558 void Wavelet::medianToggled ()
2559 {
2560
2561 if (multiImage) {
2562 if (median->get_inconsistent()) {
2563 median->set_inconsistent (false);
2564 medianConn.block (true);
2565 median->set_active (false);
2566 medianConn.block (false);
2567 } else if (lastmedian) {
2568 median->set_inconsistent (true);
2569 }
2570
2571 lastmedian = median->get_active ();
2572 }
2573
2574 if (listener && (multiImage || getEnabled ())) {
2575 if (median->get_inconsistent()) {
2576 listener->panelChanged (EvWavmedian, M("GENERAL_UNCHANGED"));
2577 } else if (median->get_active ()) {
2578 listener->panelChanged (EvWavmedian, M("GENERAL_ENABLED"));
2579 } else {
2580 listener->panelChanged (EvWavmedian, M("GENERAL_DISABLED"));
2581 }
2582 }
2583 }
2584
medianlevUpdateUI()2585 void Wavelet::medianlevUpdateUI ()
2586 {
2587 if (!batchMode) {
2588 if (medianlev->get_active ()) {
2589 edgedetect->show();
2590 lipst->show();
2591 separatoredge->show();
2592
2593 edgedetectthr->show();
2594 edgedetectthr2->show();
2595
2596 // edgesensi->show();
2597 // edgeampli->show();
2598 // NPmethod->show();
2599 // labmNP->show();
2600 if (lipst->get_active ()) {
2601 edgesensi->show();
2602 edgeampli->show();
2603 NPmethod->show();
2604 labmNP->show();
2605 }
2606
2607 else {
2608 edgesensi->hide();
2609 edgeampli->hide();
2610 NPmethod->hide();
2611 labmNP->hide();
2612 }
2613 } else {
2614 edgedetect->hide();
2615 lipst->hide();
2616 edgedetectthr->hide();
2617 edgedetectthr2->hide();
2618 edgesensi->hide();
2619 edgeampli->hide();
2620 separatoredge->hide();
2621 NPmethod->hide();
2622 labmNP->hide();
2623
2624 }
2625 }
2626 }
2627
medianlevToggled()2628 void Wavelet::medianlevToggled ()
2629 {
2630
2631 if (multiImage) {
2632 if (medianlev->get_inconsistent()) {
2633 medianlev->set_inconsistent (false);
2634 medianlevConn.block (true);
2635 medianlev->set_active (false);
2636 medianlevConn.block (false);
2637 } else if (lastmedianlev) {
2638 medianlev->set_inconsistent (true);
2639 }
2640
2641 lastmedianlev = medianlev->get_active ();
2642 }
2643
2644 medianlevUpdateUI();
2645
2646 if (listener && (multiImage || getEnabled ())) {
2647 if (medianlev->get_inconsistent()) {
2648 listener->panelChanged (EvWavmedianlev, M("GENERAL_UNCHANGED"));
2649 } else if (medianlev->get_active () ) {
2650 listener->panelChanged (EvWavmedianlev, M("GENERAL_ENABLED"));
2651 } else {
2652 listener->panelChanged (EvWavmedianlev, M("GENERAL_DISABLED"));
2653 }
2654 }
2655 }
2656
linkedgToggled()2657 void Wavelet::linkedgToggled ()
2658 {
2659
2660 if (multiImage) {
2661 if (linkedg->get_inconsistent()) {
2662 linkedg->set_inconsistent (false);
2663 linkedgConn.block (true);
2664 linkedg->set_active (false);
2665 linkedgConn.block (false);
2666 } else if (lastlinkedg) {
2667 linkedg->set_inconsistent (true);
2668 }
2669
2670 lastlinkedg = linkedg->get_active ();
2671 }
2672
2673 if (listener && (multiImage || getEnabled ())) {
2674 if (linkedg->get_inconsistent()) {
2675 listener->panelChanged (EvWavlinkedg, M("GENERAL_UNCHANGED"));
2676 } else if (linkedg->get_active () ) {
2677 listener->panelChanged (EvWavlinkedg, M("GENERAL_ENABLED"));
2678 } else {
2679 listener->panelChanged (EvWavlinkedg, M("GENERAL_DISABLED"));
2680 }
2681 }
2682 }
2683
cbenabUpdateUI()2684 void Wavelet::cbenabUpdateUI ()
2685 {
2686 if (!batchMode) {
2687 if(cbenab->get_active ()) {
2688 chanMixerHLFrame->show();
2689 chanMixerMidFrame->show();
2690 chanMixerShadowsFrame->show();
2691 neutrHBox->show();
2692 } else {
2693 chanMixerHLFrame->hide();
2694 chanMixerMidFrame->hide();
2695 chanMixerShadowsFrame->hide();
2696 neutrHBox->hide();
2697 }
2698 }
2699 }
2700
cbenabToggled()2701 void Wavelet::cbenabToggled ()
2702 {
2703 if (multiImage) {
2704 if (cbenab->get_inconsistent()) {
2705 cbenab->set_inconsistent (false);
2706 cbenabConn.block (true);
2707 cbenab->set_active (false);
2708 cbenabConn.block (false);
2709 } else if (lastcbenab) {
2710 cbenab->set_inconsistent (true);
2711 }
2712
2713 lastcbenab = cbenab->get_active ();
2714 }
2715
2716 cbenabUpdateUI();
2717
2718 if (listener && (multiImage || getEnabled ())) {
2719 if (cbenab->get_inconsistent() ) {
2720 listener->panelChanged (EvWavcbenab, M("GENERAL_UNCHANGED"));
2721 } else if (cbenab->get_active () ) {
2722 listener->panelChanged (EvWavcbenab, M("GENERAL_ENABLED"));
2723 } else {
2724 listener->panelChanged (EvWavcbenab, M("GENERAL_DISABLED"));
2725 }
2726 }
2727 }
2728
2729
2730
lipstUpdateUI()2731 void Wavelet::lipstUpdateUI ()
2732 {
2733 if (!batchMode) {
2734 if (lipst->get_active ()) {
2735 NPmethod->show();
2736 edgesensi->show();
2737 edgeampli->show();
2738 labmNP->show();
2739 } else {
2740 NPmethod->hide();
2741 edgesensi->hide();
2742 edgeampli->hide();
2743 labmNP->hide();
2744
2745 }
2746 }
2747 }
2748
2749
lipstToggled()2750 void Wavelet::lipstToggled ()
2751 {
2752
2753 if (multiImage) {
2754 if (lipst->get_inconsistent()) {
2755 lipst->set_inconsistent (false);
2756 lipstConn.block (true);
2757 lipst->set_active (false);
2758 lipstConn.block (false);
2759 } else if (lastlipst) {
2760 lipst->set_inconsistent (true);
2761 }
2762
2763 lastlipst = lipst->get_active ();
2764 }
2765
2766 lipstUpdateUI();
2767
2768 if (listener && (multiImage || getEnabled ())) {
2769 if (lipst->get_inconsistent()) {
2770 listener->panelChanged (EvWavlipst, M("GENERAL_UNCHANGED"));
2771 } else if (lipst->get_active ()) {
2772 listener->panelChanged (EvWavlipst, M("GENERAL_ENABLED"));
2773 } else {
2774 listener->panelChanged (EvWavlipst, M("GENERAL_DISABLED"));
2775 }
2776 }
2777 }
2778
2779 /*
2780 void Wavelet::edgreinfToggled () {
2781
2782 if (batchMode) {
2783 if (edgreinf->get_inconsistent()) {
2784 edgreinf->set_inconsistent (false);
2785 edgreinfConn.block (true);
2786 edgreinf->set_active (false);
2787 edgreinfConn.block (false);
2788 }
2789 else if (lastedgreinf)
2790 edgreinf->set_inconsistent (true);
2791
2792 lastedgreinf = edgreinf->get_active ();
2793 }
2794
2795 if (listener) {
2796 if (enabled->get_inconsistent ())
2797 listener->panelChanged (EvWavedgreinf, M("GENERAL_UNCHANGED"));
2798 else if (enabled->get_active ())
2799 listener->panelChanged (EvWavedgreinf, M("GENERAL_ENABLED"));
2800 else
2801 listener->panelChanged (EvWavedgreinf, M("GENERAL_DISABLED"));
2802 }
2803 }
2804 */
avoidToggled()2805 void Wavelet::avoidToggled ()
2806 {
2807
2808 if (multiImage) {
2809 if (avoid->get_inconsistent()) {
2810 avoid->set_inconsistent (false);
2811 avoidConn.block (true);
2812 avoid->set_active (false);
2813 avoidConn.block (false);
2814 } else if (lastavoid) {
2815 avoid->set_inconsistent (true);
2816 }
2817
2818 lastavoid = avoid->get_active ();
2819 }
2820
2821 if (listener && (multiImage || getEnabled ())) {
2822 if (avoid->get_inconsistent()) {
2823 listener->panelChanged (EvWavavoid, M("GENERAL_UNCHANGED"));
2824 } else if (avoid->get_active ()) {
2825 listener->panelChanged (EvWavavoid, M("GENERAL_ENABLED"));
2826 } else {
2827 listener->panelChanged (EvWavavoid, M("GENERAL_DISABLED"));
2828 }
2829 }
2830 }
2831
tmrToggled()2832 void Wavelet::tmrToggled ()
2833 {
2834
2835 if (multiImage) {
2836 if (tmr->get_inconsistent()) {
2837 tmr->set_inconsistent (false);
2838 tmrConn.block (true);
2839 tmr->set_active (false);
2840 tmrConn.block (false);
2841 } else if (lasttmr) {
2842 tmr->set_inconsistent (true);
2843 }
2844
2845 lasttmr = tmr->get_active ();
2846 }
2847
2848 if (listener && (multiImage || getEnabled ())) {
2849 if (tmr->get_inconsistent()) {
2850 listener->panelChanged (EvWavtmr, M("GENERAL_UNCHANGED"));
2851 } else if (tmr->get_active ()) {
2852 listener->panelChanged (EvWavtmr, M("GENERAL_ENABLED"));
2853 } else {
2854 listener->panelChanged (EvWavtmr, M("GENERAL_DISABLED"));
2855 }
2856 }
2857 }
2858
2859
colorForValue(double valX,double valY,enum ColorCaller::ElemType elemType,int callerId,ColorCaller * caller)2860 void Wavelet::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller *caller)
2861 {
2862
2863 float R = 0.f, G = 0.f, B = 0.f;
2864
2865 if (elemType == ColorCaller::CCET_VERTICAL_BAR) {
2866 valY = 0.5;
2867 }
2868
2869 if (callerId == 1) { // ch - main curve
2870
2871 Color::hsv2rgb01(float(valX), float(valY), 0.5f, R, G, B);
2872 }
2873 /* else if (callerId == 2) { // cc - bottom bar
2874
2875 // float value = (1.f - 0.7f) * float(valX) + 0.7f;
2876 float value = (1.f - 0.7f) * float(valX) + 0.7f;
2877 // whole hue range
2878 // Y axis / from 0.15 up to 0.75 (arbitrary values; was 0.45 before)
2879 Color::hsv2rgb01(float(valY), float(valX), value, R, G, B);
2880 }
2881 */
2882 else if (callerId == 4) { // LH - bottom bar
2883 Color::hsv2rgb01(float(valX), 0.5f, float(valY), R, G, B);
2884 } else if (callerId == 5) { // HH - bottom bar
2885 float h = float((valY - 0.5) * 0.3 + valX);
2886
2887 if (h > 1.0f) {
2888 h -= 1.0f;
2889 } else if (h < 0.0f) {
2890 h += 1.0f;
2891 }
2892
2893 Color::hsv2rgb01(h, 0.5f, 0.5f, R, G, B);
2894 }
2895
2896 caller->ccRed = double(R);
2897 caller->ccGreen = double(G);
2898 caller->ccBlue = double(B);
2899 }
setAdjusterBehavior(bool multiplieradd,bool thresholdadd,bool threshold2add,bool thresadd,bool chroadd,bool chromaadd,bool contrastadd,bool skinadd,bool reschroadd,bool tmrsadd,bool resconadd,bool resconHadd,bool thradd,bool thrHadd,bool skyadd,bool edgradadd,bool edgvaladd,bool strengthadd,bool gammaadd,bool edgedetectadd,bool edgedetectthradd,bool edgedetectthr2add)2900 void Wavelet::setAdjusterBehavior (bool multiplieradd, bool thresholdadd, bool threshold2add, bool thresadd, bool chroadd, bool chromaadd, bool contrastadd, bool skinadd, bool reschroadd, bool tmrsadd, bool resconadd, bool resconHadd, bool thradd, bool thrHadd, bool skyadd, bool edgradadd, bool edgvaladd, bool strengthadd, bool gammaadd, bool edgedetectadd, bool edgedetectthradd , bool edgedetectthr2add)
2901 {
2902
2903 for (int i = 0; i < 9; i++) {
2904 correction[i]->setAddMode(multiplieradd);
2905 }
2906
2907 threshold->setAddMode(thresholdadd);
2908 skinprotect->setAddMode(skinadd);
2909 threshold2->setAddMode(threshold2add);
2910 thres->setAddMode(thresadd);
2911 chro->setAddMode(chroadd);
2912 chroma->setAddMode(chromaadd);
2913 contrast->setAddMode(contrastadd);
2914 rescon->setAddMode(resconadd);
2915 resconH->setAddMode(resconHadd);
2916 reschro->setAddMode(reschroadd);
2917 tmrs->setAddMode(tmrsadd);
2918 thr->setAddMode(thradd);
2919 thrH->setAddMode(thrHadd);
2920 sky->setAddMode(skyadd);
2921 edgrad->setAddMode(edgradadd);
2922 edgval->setAddMode(edgvaladd);
2923 strength->setAddMode(strengthadd);
2924 gamma->setAddMode(gammaadd);
2925 edgedetect->setAddMode(edgedetectadd);
2926 edgedetectthr->setAddMode(edgedetectthradd);
2927 edgedetectthr2->setAddMode(edgedetectthr2add);
2928 }
2929
2930
neutralPressed()2931 void Wavelet::neutralPressed ()
2932 {
2933 for (int i = 0; i < 9; i++) {
2934 correction[i]->setValue(0);
2935 adjusterChanged(correction[i], 0);
2936 }
2937 }
2938
neutralchPressed()2939 void Wavelet::neutralchPressed ()
2940 {
2941
2942 for (int i = 0; i < 9; i++) {
2943 correctionch[i]->setValue(0);
2944 adjusterChanged(correctionch[i], 0);
2945 }
2946 }
2947
2948
contrastPlusPressed()2949 void Wavelet::contrastPlusPressed ()
2950 {
2951
2952 for (int i = 0; i < 9; i++) {
2953 int inc = 1 * (9 - i);
2954 correction[i]->setValue(correction[i]->getValue() + inc);
2955 adjusterChanged(correction[i], correction[i]->getValue());
2956 }
2957 }
2958
2959
contrastMinusPressed()2960 void Wavelet::contrastMinusPressed ()
2961 {
2962
2963 for (int i = 0; i < 9; i++) {
2964 int inc = -1 * (9 - i);
2965 correction[i]->setValue(correction[i]->getValue() + inc);
2966 adjusterChanged(correction[i], correction[i]->getValue());
2967 }
2968 }
2969
foldAllButMe(GdkEventButton * event,MyExpander * expander)2970 void Wavelet::foldAllButMe (GdkEventButton* event, MyExpander *expander)
2971 {
2972 if (event->button == 3) {
2973 expsettings->set_expanded(expsettings == expander);
2974 expcontrast->set_expanded(expcontrast == expander);
2975 expchroma->set_expanded(expchroma == expander);
2976 exptoning->set_expanded(exptoning == expander);
2977 expnoise->set_expanded(expnoise == expander);
2978 expedge->set_expanded(expedge == expander);
2979 expgamut->set_expanded(expgamut == expander);
2980 expresid->set_expanded(expresid == expander);
2981 expfinal->set_expanded(expfinal == expander);
2982 }
2983 }
2984
enableToggled(MyExpander * expander)2985 void Wavelet::enableToggled(MyExpander *expander)
2986 {
2987 if (listener) {
2988 rtengine::ProcEvent event = NUMOFEVENTS;
2989
2990 if (expander == expcontrast) {
2991 event = EvWavenacont;
2992 } else if (expander == expchroma) {
2993 event = EvWavenachrom;
2994 } else if (expander == exptoning) {
2995 event = EvWavenatoning;
2996 } else if (expander == expnoise) {
2997 event = EvWavenanoise;
2998 } else if (expander == expedge) {
2999 event = EvWavenaedge;
3000 } else if (expander == expresid) {
3001 event = EvWavenares;
3002 } else if (expander == expfinal) {
3003 event = EvWavenafin;
3004 } else
3005 // unknown expander, returning !
3006 {
3007 return;
3008 }
3009
3010 if (expander->get_inconsistent()) {
3011 listener->panelChanged (event, M("GENERAL_UNCHANGED"));
3012 } else if (expander->getEnabled()) {
3013 listener->panelChanged (event, M("GENERAL_ENABLED"));
3014 } else {
3015 listener->panelChanged (event, M("GENERAL_DISABLED"));
3016 }
3017 }
3018 }
3019
writeOptions(std::vector<int> & tpOpen)3020 void Wavelet::writeOptions(std::vector<int> &tpOpen)
3021 {
3022 tpOpen.push_back (expsettings->get_expanded ());
3023 tpOpen.push_back (expcontrast->get_expanded ());
3024 tpOpen.push_back (expchroma->get_expanded ());
3025 tpOpen.push_back (exptoning->get_expanded ());
3026 tpOpen.push_back (expnoise->get_expanded ());
3027 tpOpen.push_back (expedge->get_expanded ());
3028 tpOpen.push_back (expgamut->get_expanded ());
3029 tpOpen.push_back (expresid->get_expanded ());
3030 tpOpen.push_back (expfinal->get_expanded ());
3031 }
3032
updateToolState(std::vector<int> & tpOpen)3033 void Wavelet::updateToolState(std::vector<int> &tpOpen)
3034 {
3035 if(tpOpen.size() >= 9) {
3036 expsettings->set_expanded(tpOpen.at(0));
3037 expcontrast->set_expanded(tpOpen.at(1));
3038 expchroma->set_expanded(tpOpen.at(2));
3039 exptoning->set_expanded(tpOpen.at(3));
3040 expnoise->set_expanded(tpOpen.at(4));
3041 expedge->set_expanded(tpOpen.at(5));
3042 expgamut->set_expanded(tpOpen.at(6));
3043 expresid->set_expanded(tpOpen.at(7));
3044 expfinal->set_expanded(tpOpen.at(8));
3045 }
3046 }
3047
3048