1474 lines
51 KiB
C++
1474 lines
51 KiB
C++
/*
|
|
* This file is part of RawTherapee.
|
|
*
|
|
* Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
|
|
*
|
|
* RawTherapee is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* RawTherapee is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with RawTherapee. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <iomanip>
|
|
#include <cmath>
|
|
|
|
#include "blackwhite.h"
|
|
|
|
#include "curveeditor.h"
|
|
#include "curveeditorgroup.h"
|
|
#include "guiutils.h"
|
|
#include "rtimage.h"
|
|
#include "options.h"
|
|
|
|
#include "../rtengine/color.h"
|
|
#include "../rtengine/procparams.h"
|
|
#include "../rtengine/utils.h"
|
|
|
|
using namespace rtengine;
|
|
using namespace rtengine::procparams;
|
|
|
|
const Glib::ustring BlackWhite::TOOL_NAME = "blackwhite";
|
|
|
|
BlackWhite::BlackWhite (): FoldableToolPanel(this, TOOL_NAME, M("TP_BWMIX_LABEL"), false, true)
|
|
{
|
|
CurveListener::setMulti(true);
|
|
|
|
nextredbw = 0.3333;
|
|
nextgreenbw = 0.3333;
|
|
nextbluebw = 0.3333;
|
|
|
|
//----------- Method combobox ------------------------------
|
|
|
|
Gtk::Box* metHBox = Gtk::manage (new Gtk::Box ());
|
|
metHBox->set_spacing (2);
|
|
Gtk::Label* metLabel = Gtk::manage (new Gtk::Label (M("TP_BWMIX_MET") + ":"));
|
|
metHBox->pack_start (*metLabel, Gtk::PACK_SHRINK);
|
|
|
|
method = Gtk::manage (new MyComboBoxText ());
|
|
method->append (M("TP_BWMIX_MET_DESAT"));
|
|
method->append (M("TP_BWMIX_MET_LUMEQUAL"));
|
|
method->append (M("TP_BWMIX_MET_CHANMIX"));
|
|
|
|
method->set_active (0);
|
|
metHBox->pack_start (*method);
|
|
pack_start (*metHBox);
|
|
methodconn = method->signal_changed().connect ( sigc::mem_fun(*this, &BlackWhite::methodChanged) );
|
|
|
|
|
|
//----------- Luminance equalizer ------------------------------
|
|
|
|
luminanceSep = Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
|
|
pack_start (*luminanceSep);
|
|
|
|
std::vector<GradientMilestone> bottomMilestones;
|
|
float R, G, B;
|
|
|
|
// -0.1 rad < Hue < 1.6 rad
|
|
for (int i = 0; i < 7; i++) {
|
|
float x = float(i) * (1.0f / 6.f);
|
|
Color::hsv2rgb01(x, 0.5f, 0.5f, R, G, B);
|
|
bottomMilestones.push_back( GradientMilestone(double(x), double(R), double(G), double(B)) );
|
|
}
|
|
|
|
luminanceCEG = new CurveEditorGroup (options.lastBWCurvesDir, M("TP_BWMIX_CHANNEL"));
|
|
luminanceCEG->setCurveListener (this);
|
|
luminanceCurve = static_cast<FlatCurveEditor*>(luminanceCEG->addCurve(CT_Flat, M("TP_BWMIX_VAL")));
|
|
luminanceCurve->setEditID(EUID_BlackWhiteLuminance, BT_SINGLEPLANE_FLOAT);
|
|
luminanceCurve->setBottomBarBgGradient(bottomMilestones);
|
|
luminanceCurve->setCurveColorProvider(this, 3);
|
|
luminanceCurve->setTooltip(M("TP_BWMIX_CURVEEDITOR_LH_TOOLTIP"));
|
|
|
|
luminanceCEG->curveListComplete();
|
|
pack_start (*luminanceCEG, Gtk::PACK_SHRINK, 4);
|
|
|
|
//----------- Auto and Reset buttons ------------------------------
|
|
|
|
mixerFrame = Gtk::manage (new Gtk::Frame (M("TP_BWMIX_MET_CHANMIX")));
|
|
mixerFrame->set_label_align(0.025, 0.5);
|
|
pack_start (*mixerFrame, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerVBox = Gtk::manage (new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
|
|
mixerVBox->set_spacing(4);
|
|
|
|
autoHBox = Gtk::manage (new Gtk::Box ());
|
|
|
|
autoch = Gtk::manage (new Gtk::ToggleButton (M("TP_BWMIX_AUTOCH")));
|
|
autoconn = autoch->signal_toggled().connect( sigc::mem_fun(*this, &BlackWhite::autoch_toggled) );
|
|
|
|
neutral = Gtk::manage (new Gtk::Button (M("TP_BWMIX_NEUTRAL")));
|
|
neutralconn = neutral->signal_pressed().connect( sigc::mem_fun(*this, &BlackWhite::neutral_pressed) );
|
|
neutral->show();
|
|
|
|
autoHBox->pack_start (*autoch);
|
|
autoHBox->pack_end (*neutral);
|
|
autoHBox->pack_end (*Gtk::manage (new Gtk::Label (" "))); //spacer
|
|
mixerVBox->pack_start (*autoHBox);
|
|
|
|
//----------- Presets combobox ------------------------------
|
|
|
|
mixerVBox->pack_start (*Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL)));
|
|
|
|
settingHBox = Gtk::manage (new Gtk::Box ());
|
|
settingHBox->set_spacing (2);
|
|
settingHBox->set_tooltip_markup (M("TP_BWMIX_SETTING_TOOLTIP"));
|
|
Gtk::Label *settingLabel = Gtk::manage (new Gtk::Label (M("TP_BWMIX_SETTING") + ":"));
|
|
|
|
settingHBox->pack_start (*settingLabel, Gtk::PACK_SHRINK);
|
|
setting = Gtk::manage (new MyComboBoxText ());
|
|
setting->append (M("TP_BWMIX_SET_NORMCONTAST"));
|
|
setting->append (M("TP_BWMIX_SET_HIGHCONTAST"));
|
|
setting->append (M("TP_BWMIX_SET_LUMINANCE"));
|
|
setting->append (M("TP_BWMIX_SET_LANDSCAPE"));
|
|
setting->append (M("TP_BWMIX_SET_PORTRAIT"));
|
|
setting->append (M("TP_BWMIX_SET_LOWSENSIT"));
|
|
setting->append (M("TP_BWMIX_SET_HIGHSENSIT"));
|
|
setting->append (M("TP_BWMIX_SET_PANCHRO"));
|
|
setting->append (M("TP_BWMIX_SET_HYPERPANCHRO"));
|
|
setting->append (M("TP_BWMIX_SET_ORTHOCHRO"));
|
|
setting->append (M("TP_BWMIX_SET_RGBABS"));
|
|
setting->append (M("TP_BWMIX_SET_RGBREL"));
|
|
setting->append (M("TP_BWMIX_SET_ROYGCBPMABS"));
|
|
setting->append (M("TP_BWMIX_SET_ROYGCBPMREL"));
|
|
setting->append (M("TP_BWMIX_SET_INFRARED"));
|
|
|
|
setting->set_active (11);
|
|
settingHBox->pack_start (*setting);
|
|
mixerVBox->pack_start (*settingHBox);
|
|
settingconn = setting->signal_changed().connect ( sigc::mem_fun(*this, &BlackWhite::settingChanged) );
|
|
|
|
RGBLabels = Gtk::manage(new Gtk::Label("---", Gtk::ALIGN_CENTER));
|
|
RGBLabels->set_tooltip_text(M("TP_BWMIX_RGBLABEL_HINT"));
|
|
mixerVBox->pack_start (*RGBLabels);
|
|
|
|
//----------- Complementary Color checkbox ------------------------------
|
|
|
|
enabledccSep = Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
|
|
mixerVBox->pack_start (*enabledccSep);
|
|
|
|
enabledcc = Gtk::manage (new Gtk::CheckButton (M("TP_BWMIX_CC_ENABLED")));
|
|
|
|
enabledcc->set_active (true);
|
|
enabledcc->set_tooltip_markup (M("TP_BWMIX_CC_TOOLTIP"));
|
|
|
|
mixerVBox->pack_start(*enabledcc, Gtk::PACK_SHRINK, 0);
|
|
enabledcc->show ();
|
|
enaccconn = enabledcc->signal_toggled().connect( sigc::mem_fun(*this, &BlackWhite::enabledcc_toggled) );
|
|
|
|
//----------- Color Filters ------------------------------
|
|
|
|
filterSep = Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
|
|
mixerVBox->pack_start (*filterSep);
|
|
|
|
filterHBox = Gtk::manage (new Gtk::Box ());
|
|
filterHBox->set_spacing (2);
|
|
filterHBox->set_tooltip_markup (M("TP_BWMIX_FILTER_TOOLTIP"));
|
|
Gtk::Label *filterLabel = Gtk::manage (new Gtk::Label (M("TP_BWMIX_FILTER") + ":"));
|
|
filterHBox->pack_start (*filterLabel, Gtk::PACK_SHRINK);
|
|
filter = Gtk::manage (new MyComboBoxText ());
|
|
filter->append (M("TP_BWMIX_FILTER_NONE"));
|
|
filter->append (M("TP_BWMIX_FILTER_RED"));
|
|
filter->append (M("TP_BWMIX_FILTER_REDYELLOW"));
|
|
filter->append (M("TP_BWMIX_FILTER_YELLOW"));
|
|
filter->append (M("TP_BWMIX_FILTER_GREENYELLOW"));
|
|
filter->append (M("TP_BWMIX_FILTER_GREEN"));
|
|
filter->append (M("TP_BWMIX_FILTER_BLUEGREEN"));
|
|
filter->append (M("TP_BWMIX_FILTER_BLUE"));
|
|
filter->append (M("TP_BWMIX_FILTER_PURPLE"));
|
|
|
|
filter->set_active (0);
|
|
filterHBox->pack_start (*filter);
|
|
mixerVBox->pack_start (*filterHBox);
|
|
filterconn = filter->signal_changed().connect ( sigc::mem_fun(*this, &BlackWhite::filterChanged) );
|
|
|
|
//----------- RGB / ROYGCBPM Mixer ------------------------------
|
|
|
|
imgIcon[0] = Gtk::manage (new RTImage ("circle-red-small.png"));
|
|
imgIcon[1] = Gtk::manage (new RTImage ("circle-orange-small.png"));
|
|
imgIcon[2] = Gtk::manage (new RTImage ("circle-yellow-small.png"));
|
|
imgIcon[3] = Gtk::manage (new RTImage ("circle-green-small.png"));
|
|
imgIcon[4] = Gtk::manage (new RTImage ("circle-cyan-small.png"));
|
|
imgIcon[5] = Gtk::manage (new RTImage ("circle-blue-small.png"));
|
|
imgIcon[6] = Gtk::manage (new RTImage ("circle-purple-small.png"));
|
|
imgIcon[7] = Gtk::manage (new RTImage ("circle-magenta-small.png"));
|
|
|
|
imgIcon[8] = Gtk::manage (new RTImage ("circle-empty-red-small.png"));
|
|
imgIcon[9] = Gtk::manage (new RTImage ("circle-empty-green-small.png"));
|
|
imgIcon[10] = Gtk::manage (new RTImage ("circle-empty-blue-small.png"));
|
|
|
|
mixerVBox->pack_start (*Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL)));
|
|
|
|
mixerRed = Gtk::manage(new Adjuster (/*M("TP_BWMIX_RED")*/"", -100, 200, 1, 33, imgIcon[0]));
|
|
|
|
mixerRed->setAdjusterListener (this);
|
|
mixerRed->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerRed->show();
|
|
mixerVBox->pack_start( *mixerRed, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerGreen = Gtk::manage(new Adjuster (/*M("TP_BWMIX_GREEN")*/"", -100, 200, 1, 33, imgIcon[3]));
|
|
|
|
mixerGreen->setAdjusterListener (this);
|
|
mixerGreen->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerGreen->show();
|
|
mixerVBox->pack_start( *mixerGreen, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerBlue = Gtk::manage(new Adjuster (/*M("TP_BWMIX_BLUE")*/"", -100, 200, 1, 33, imgIcon[5]));
|
|
|
|
mixerBlue->setAdjusterListener (this);
|
|
mixerBlue->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerBlue->show();
|
|
mixerVBox->pack_start( *mixerBlue, Gtk::PACK_SHRINK, 0);
|
|
|
|
filterSep2 = Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
|
|
mixerVBox->pack_start (*filterSep2);
|
|
|
|
algoHBox = Gtk::manage (new Gtk::Box ());
|
|
algoHBox->set_spacing (2);
|
|
algoHBox->set_tooltip_markup (M("TP_BWMIX_ALGO_TOOLTIP"));
|
|
|
|
alLabel = Gtk::manage (new Gtk::Label (M("TP_BWMIX_ALGO") + ":"));
|
|
algoHBox->pack_start (*alLabel, Gtk::PACK_SHRINK);
|
|
|
|
algo = Gtk::manage (new MyComboBoxText ());
|
|
algo->append (M("TP_BWMIX_ALGO_LI"));
|
|
algo->append (M("TP_BWMIX_ALGO_SP"));
|
|
algo->set_active (1);
|
|
algoHBox->pack_start (*algo);
|
|
mixerVBox->pack_start(*algoHBox);
|
|
algoconn = algo->signal_changed().connect ( sigc::mem_fun(*this, &BlackWhite::algoChanged) );
|
|
|
|
mixerOrange = Gtk::manage(new Adjuster (/*M("TP_BWMIX_ORANGE")*/"", -100, 200, 1, 33, imgIcon[1]));
|
|
|
|
mixerOrange->setAdjusterListener (this);
|
|
mixerOrange->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerOrange->show();
|
|
mixerVBox->pack_start( *mixerOrange, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerYellow = Gtk::manage(new Adjuster (/*M("TP_BWMIX_YELLOW")*/"", -100, 200, 1, 33, imgIcon[2]));
|
|
|
|
mixerYellow->setAdjusterListener (this);
|
|
mixerYellow->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerYellow->show();
|
|
mixerVBox->pack_start( *mixerYellow, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerCyan = Gtk::manage(new Adjuster (/*M("TP_BWMIX_CYAN")*/"", -100, 200, 1, 33, imgIcon[4]));
|
|
|
|
mixerCyan->setAdjusterListener (this);
|
|
mixerCyan->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerCyan->show();
|
|
mixerVBox->pack_start( *mixerCyan, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerPurple = Gtk::manage(new Adjuster (/*M("TP_BWMIX_PURPLE")*/"", -100, 200, 1, 33, imgIcon[6]));
|
|
|
|
mixerPurple->setAdjusterListener (this);
|
|
mixerPurple->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerPurple->show();
|
|
mixerVBox->pack_start( *mixerPurple, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerMagenta = Gtk::manage(new Adjuster (/*M("TP_BWMIX_MAGENTA")*/"", -100, 200, 1, 33, imgIcon[7]));
|
|
|
|
mixerMagenta->setAdjusterListener (this);
|
|
mixerMagenta->set_tooltip_markup (M("TP_BWMIX_RGB_TOOLTIP"));
|
|
mixerMagenta->show();
|
|
mixerVBox->pack_start( *mixerMagenta, Gtk::PACK_SHRINK, 0);
|
|
|
|
mixerFrame->add(*mixerVBox);
|
|
|
|
//----------- Gamma sliders ------------------------------
|
|
|
|
gammaFrame = Gtk::manage (new Gtk::Frame (M("TP_BWMIX_GAMMA")));
|
|
gammaFrame->set_label_align(0.025, 0.5);
|
|
pack_start (*gammaFrame, Gtk::PACK_SHRINK, 0);
|
|
|
|
Gtk::Box* gammaVBox = Gtk::manage (new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
|
|
gammaVBox->set_spacing(4);
|
|
|
|
|
|
gammaRed = Gtk::manage(new Adjuster (/*M("TP_BWMIX_GAM_RED")*/"", -100, 100, 1, 0, imgIcon[8]));
|
|
|
|
gammaRed->setAdjusterListener (this);
|
|
gammaRed->set_tooltip_markup (M("TP_BWMIX_GAM_TOOLTIP"));
|
|
gammaRed->show();
|
|
gammaVBox->pack_start( *gammaRed, Gtk::PACK_SHRINK, 0);
|
|
|
|
gammaGreen = Gtk::manage(new Adjuster (/*M("TP_BWMIX_GAM_GREEN")*/"", -100, 100, 1, 0, imgIcon[9]));
|
|
|
|
gammaGreen->setAdjusterListener (this);
|
|
gammaGreen->set_tooltip_markup (M("TP_BWMIX_GAM_TOOLTIP"));
|
|
gammaGreen->show();
|
|
gammaVBox->pack_start( *gammaGreen, Gtk::PACK_SHRINK, 0);
|
|
|
|
gammaBlue = Gtk::manage(new Adjuster (/*M("TP_BWMIX_GAM_BLUE")*/"", -100, 100, 1, 0, imgIcon[10]));
|
|
|
|
gammaBlue->setAdjusterListener (this);
|
|
gammaBlue->set_tooltip_markup (M("TP_BWMIX_GAM_TOOLTIP"));
|
|
gammaBlue->show();
|
|
gammaVBox->pack_start( *gammaBlue, Gtk::PACK_SHRINK, 0);
|
|
|
|
gammaFrame->add(*gammaVBox);
|
|
|
|
//----------- Curve 1 ------------------------------
|
|
|
|
std::vector<GradientMilestone> bottomMilestonesbw;
|
|
bottomMilestonesbw.push_back( GradientMilestone(0., 0., 0., 0.) );
|
|
bottomMilestonesbw.push_back( GradientMilestone(1., 1., 1., 1.) );
|
|
|
|
beforeCurveMode = Gtk::manage (new MyComboBoxText ());
|
|
beforeCurveMode->append (M("TP_BWMIX_TCMODE_STANDARD"));
|
|
beforeCurveMode->append (M("TP_BWMIX_TCMODE_WEIGHTEDSTD"));
|
|
beforeCurveMode->append (M("TP_BWMIX_TCMODE_FILMLIKE"));
|
|
beforeCurveMode->append (M("TP_BWMIX_TCMODE_SATANDVALBLENDING"));
|
|
beforeCurveMode->set_active (0);
|
|
|
|
beforeCurveCEG = new CurveEditorGroup (options.lastBWCurvesDir, M("TP_BWMIX_CURVEEDITOR1"));
|
|
beforeCurveCEG->setCurveListener (this);
|
|
|
|
beforeCurve = static_cast<DiagonalCurveEditor*>(beforeCurveCEG->addCurve(CT_Diagonal, "", beforeCurveMode));
|
|
beforeCurve->setEditID(EUID_BlackWhiteBeforeCurve, BT_IMAGEFLOAT);
|
|
beforeCurve->setBottomBarBgGradient(bottomMilestonesbw);
|
|
beforeCurve->setLeftBarBgGradient(bottomMilestonesbw);
|
|
beforeCurve->setTooltip(M("TP_BWMIX_CURVEEDITOR_BEFORE_TOOLTIP"));
|
|
|
|
// This will add the reset button at the end of the curveType buttons
|
|
beforeCurveCEG->curveListComplete();
|
|
|
|
pack_start( *beforeCurveCEG, Gtk::PACK_SHRINK, 2);
|
|
|
|
tcmodeconn = beforeCurveMode->signal_changed().connect( sigc::mem_fun(*this, &BlackWhite::curveMode1Changed), true );
|
|
|
|
//----------- Curve 2 ------------------------------
|
|
/*
|
|
afterCurveMode = Gtk::manage (new MyComboBoxText ());
|
|
afterCurveMode->append (M("TP_BWMIX_TCMODE_STANDARD"));
|
|
// afterCurveMode->append (M("TP_BWMIX_TCMODE_WEIGHTEDSTD"));
|
|
afterCurveMode->set_active (0);
|
|
*/
|
|
afterCurveCEG = new CurveEditorGroup (options.lastBWCurvesDir, M("TP_BWMIX_CURVEEDITOR2"));
|
|
afterCurveCEG->setCurveListener (this);
|
|
|
|
// afterCurve = static_cast<DiagonalCurveEditor*>(afterCurveCEG->addCurve(CT_Diagonal, "", afterCurveMode));
|
|
afterCurve = static_cast<DiagonalCurveEditor*>(afterCurveCEG->addCurve(CT_Diagonal, ""));
|
|
afterCurve->setEditID(EUID_BlackWhiteAfterCurve, BT_SINGLEPLANE_FLOAT);
|
|
afterCurve->setBottomBarBgGradient(bottomMilestonesbw);
|
|
afterCurve->setLeftBarBgGradient(bottomMilestonesbw);
|
|
afterCurve->setTooltip(M("TP_BWMIX_CURVEEDITOR_AFTER_TOOLTIP"));
|
|
|
|
afterCurveCEG->curveListComplete();
|
|
|
|
pack_start( *afterCurveCEG, Gtk::PACK_SHRINK, 2);
|
|
|
|
// tcmodeconn2 = afterCurveMode->signal_changed().connect( sigc::mem_fun(*this, &BlackWhite::curveMode1Changed2), true );
|
|
|
|
show_all();
|
|
|
|
disableListener();
|
|
methodChanged();
|
|
enableListener();
|
|
}
|
|
BlackWhite::~BlackWhite ()
|
|
{
|
|
idle_register.destroy();
|
|
|
|
delete luminanceCEG;
|
|
delete beforeCurveCEG;
|
|
delete afterCurveCEG;
|
|
}
|
|
|
|
void BlackWhite::BWChanged (double redbw, double greenbw, double bluebw)
|
|
{
|
|
nextredbw = redbw;
|
|
nextgreenbw = greenbw;
|
|
nextbluebw = bluebw;
|
|
|
|
idle_register.add(
|
|
[this]() -> bool
|
|
{
|
|
BWComputed_();
|
|
return false;
|
|
}
|
|
);
|
|
}
|
|
|
|
bool BlackWhite::BWComputed_ ()
|
|
{
|
|
|
|
disableListener ();
|
|
mixerRed->setValue (nextredbw);
|
|
adjusterChanged(mixerRed, mixerRed->getValue());
|
|
mixerGreen->setValue (nextgreenbw);
|
|
adjusterChanged(mixerGreen, mixerGreen->getValue());
|
|
mixerBlue->setValue (nextbluebw);
|
|
adjusterChanged(mixerBlue, mixerBlue->getValue());
|
|
autoconn.block (true);
|
|
autoch->set_active (true);
|
|
autoconn.block (false);
|
|
lastAuto = false;
|
|
nextcount++;
|
|
enableListener ();
|
|
if (listener && nextcount <= 1 ) {
|
|
// activated only 1 time, but perhaps in some cases if we want that all is update pp3, auto, sliders : nextcount <= 2 but it cost time and result is identical
|
|
listener->panelChanged (EvAutoch, M("GENERAL_ENABLED"));
|
|
}
|
|
|
|
updateRGBLabel();
|
|
|
|
return false;
|
|
}
|
|
|
|
void BlackWhite::read (const ProcParams* pp, const ParamsEdited* pedited)
|
|
{
|
|
|
|
disableListener ();
|
|
methodconn.block(true);
|
|
//autoconn.block (true);
|
|
filterconn.block(true);
|
|
settingconn.block(true);
|
|
enaccconn.block (true);
|
|
|
|
if (pedited && !pedited->blackwhite.setting) {
|
|
setting->set_active (15); // "Unchanged"
|
|
} else if (pp->blackwhite.setting == "NormalContrast") {
|
|
setting->set_active (0);
|
|
} else if (pp->blackwhite.setting == "HighContrast") {
|
|
setting->set_active (1);
|
|
} else if (pp->blackwhite.setting == "Luminance") {
|
|
setting->set_active (2);
|
|
} else if (pp->blackwhite.setting == "Landscape") {
|
|
setting->set_active (3);
|
|
} else if (pp->blackwhite.setting == "Portrait") {
|
|
setting->set_active (4);
|
|
} else if (pp->blackwhite.setting == "LowSensitivity") {
|
|
setting->set_active (5);
|
|
} else if (pp->blackwhite.setting == "HighSensitivity") {
|
|
setting->set_active (6);
|
|
} else if (pp->blackwhite.setting == "Panchromatic") {
|
|
setting->set_active (7);
|
|
} else if (pp->blackwhite.setting == "HyperPanchromatic") {
|
|
setting->set_active (8);
|
|
} else if (pp->blackwhite.setting == "Orthochromatic") {
|
|
setting->set_active (9);
|
|
} else if (pp->blackwhite.setting == "RGB-Abs") {
|
|
setting->set_active (10);
|
|
} else if (pp->blackwhite.setting == "RGB-Rel") {
|
|
setting->set_active (11);
|
|
} else if (pp->blackwhite.setting == "ROYGCBPM-Abs") {
|
|
setting->set_active (12);
|
|
} else if (pp->blackwhite.setting == "ROYGCBPM-Rel") {
|
|
setting->set_active (13);
|
|
} else if (pp->blackwhite.setting == "InfraRed") {
|
|
setting->set_active (14);
|
|
}
|
|
|
|
settingChanged();
|
|
|
|
|
|
if (pedited && !pedited->blackwhite.method) {
|
|
method->set_active (3); // "Unchanged"
|
|
} else if (pp->blackwhite.method == "Desaturation") {
|
|
method->set_active (0);
|
|
} else if (pp->blackwhite.method == "LumEqualizer") {
|
|
method->set_active (1);
|
|
} else if (pp->blackwhite.method == "ChannelMixer") {
|
|
method->set_active (2);
|
|
}
|
|
|
|
methodChanged();
|
|
|
|
|
|
if (pedited && !pedited->blackwhite.filter) {
|
|
filter->set_active (9); // "Unchanged"
|
|
} else if (pp->blackwhite.filter == "None") {
|
|
filter->set_active (0);
|
|
} else if (pp->blackwhite.filter == "Red") {
|
|
filter->set_active (1);
|
|
} else if (pp->blackwhite.filter == "Orange") {
|
|
filter->set_active (2);
|
|
} else if (pp->blackwhite.filter == "Yellow") {
|
|
filter->set_active (3);
|
|
} else if (pp->blackwhite.filter == "YellowGreen") {
|
|
filter->set_active (4);
|
|
} else if (pp->blackwhite.filter == "Green") {
|
|
filter->set_active (5);
|
|
} else if (pp->blackwhite.filter == "Cyan") {
|
|
filter->set_active (6);
|
|
} else if (pp->blackwhite.filter == "Blue") {
|
|
filter->set_active (7);
|
|
} else if (pp->blackwhite.filter == "Purple") {
|
|
filter->set_active (8);
|
|
}
|
|
|
|
filterChanged();
|
|
|
|
enabledcc->set_active (pp->blackwhite.enabledcc);
|
|
lastEnabledcc = pp->blackwhite.enabledcc;
|
|
setEnabled (pp->blackwhite.enabled);
|
|
|
|
mixerRed->setValue (pp->blackwhite.mixerRed);
|
|
mixerGreen->setValue (pp->blackwhite.mixerGreen);
|
|
mixerBlue->setValue (pp->blackwhite.mixerBlue);
|
|
gammaRed->setValue (pp->blackwhite.gammaRed);
|
|
gammaGreen->setValue (pp->blackwhite.gammaGreen);
|
|
gammaBlue->setValue (pp->blackwhite.gammaBlue);
|
|
mixerOrange->setValue (pp->blackwhite.mixerOrange);
|
|
mixerYellow->setValue (pp->blackwhite.mixerYellow);
|
|
mixerCyan->setValue (pp->blackwhite.mixerCyan);
|
|
mixerMagenta->setValue (pp->blackwhite.mixerMagenta);
|
|
mixerPurple->setValue (pp->blackwhite.mixerPurple);
|
|
luminanceCurve->setCurve (pp->blackwhite.luminanceCurve);
|
|
beforeCurve->setCurve (pp->blackwhite.beforeCurve);
|
|
beforeCurveMode->set_active(toUnderlying(pp->blackwhite.beforeCurveMode));
|
|
afterCurve->setCurve (pp->blackwhite.afterCurve);
|
|
// afterCurveMode->set_active(pp->blackwhite.afterCurveMode);
|
|
|
|
autoch->set_active (pp->blackwhite.autoc);
|
|
lastAuto = pp->blackwhite.autoc;
|
|
|
|
algoconn.block(true);
|
|
|
|
if (pedited && !pedited->blackwhite.algo) {
|
|
algo->set_active (2);
|
|
} else if (pp->blackwhite.algo == "LI") {
|
|
algo->set_active (0);
|
|
} else if (pp->blackwhite.algo == "SP") {
|
|
algo->set_active (1);
|
|
}
|
|
|
|
algoconn.block(false);
|
|
algoChanged();
|
|
|
|
|
|
if (pedited) {
|
|
luminanceCurve->setUnChanged (!pedited->blackwhite.luminanceCurve);
|
|
beforeCurve->setUnChanged (!pedited->blackwhite.beforeCurve);
|
|
afterCurve->setUnChanged (!pedited->blackwhite.afterCurve);
|
|
autoch->set_inconsistent (!pedited->blackwhite.autoc);
|
|
set_inconsistent (multiImage && !pedited->blackwhite.enabled);
|
|
enabledcc->set_inconsistent (!pedited->blackwhite.enabledcc);
|
|
mixerRed->setEditedState (pedited->blackwhite.mixerRed ? Edited : UnEdited);
|
|
mixerGreen->setEditedState (pedited->blackwhite.mixerGreen ? Edited : UnEdited);
|
|
mixerBlue->setEditedState (pedited->blackwhite.mixerBlue ? Edited : UnEdited);
|
|
gammaRed->setEditedState (pedited->blackwhite.gammaRed ? Edited : UnEdited);
|
|
gammaGreen->setEditedState (pedited->blackwhite.gammaGreen ? Edited : UnEdited);
|
|
gammaBlue->setEditedState (pedited->blackwhite.gammaBlue ? Edited : UnEdited);
|
|
mixerOrange->setEditedState (pedited->blackwhite.mixerOrange ? Edited : UnEdited);
|
|
mixerYellow->setEditedState (pedited->blackwhite.mixerYellow ? Edited : UnEdited);
|
|
mixerCyan->setEditedState (pedited->blackwhite.mixerCyan ? Edited : UnEdited);
|
|
mixerMagenta->setEditedState (pedited->blackwhite.mixerMagenta ? Edited : UnEdited);
|
|
mixerPurple->setEditedState (pedited->blackwhite.mixerPurple ? Edited : UnEdited);
|
|
|
|
if (!pedited->blackwhite.beforeCurveMode) {
|
|
beforeCurveMode->set_active(4); // "Unchanged"
|
|
}
|
|
|
|
// if (!pedited->blackwhite.afterCurveMode) {
|
|
// afterCurveMode->set_active(1); // "Unchanged"
|
|
// }
|
|
}
|
|
|
|
methodconn.block(false);
|
|
filterconn.block(false);
|
|
settingconn.block(false);
|
|
//autoconn.block (false);
|
|
enaccconn.block (false);
|
|
|
|
updateRGBLabel();
|
|
|
|
enableListener ();
|
|
}
|
|
|
|
void BlackWhite::write (ProcParams* pp, ParamsEdited* pedited)
|
|
{
|
|
pp->blackwhite.enabled = getEnabled();
|
|
pp->blackwhite.luminanceCurve = luminanceCurve->getCurve ();
|
|
pp->blackwhite.autoc = autoch->get_active();
|
|
pp->blackwhite.enabledcc = enabledcc->get_active ();
|
|
pp->blackwhite.mixerRed = mixerRed->getValue ();
|
|
pp->blackwhite.mixerGreen = mixerGreen->getValue ();
|
|
pp->blackwhite.mixerBlue = mixerBlue->getValue ();
|
|
pp->blackwhite.gammaRed = gammaRed->getValue ();
|
|
pp->blackwhite.gammaGreen = gammaGreen->getValue ();
|
|
pp->blackwhite.gammaBlue = gammaBlue->getValue ();
|
|
pp->blackwhite.mixerOrange = mixerOrange->getValue ();
|
|
pp->blackwhite.mixerYellow = mixerYellow->getValue ();
|
|
pp->blackwhite.mixerCyan = mixerCyan->getValue ();
|
|
pp->blackwhite.mixerMagenta = mixerMagenta->getValue ();
|
|
pp->blackwhite.mixerPurple = mixerPurple->getValue ();
|
|
pp->blackwhite.beforeCurve = beforeCurve->getCurve ();
|
|
pp->blackwhite.afterCurve = afterCurve->getCurve ();
|
|
|
|
int tcMode = beforeCurveMode->get_active_row_number();
|
|
|
|
if (tcMode == 0) {
|
|
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::STD_BW;
|
|
} else if (tcMode == 1) {
|
|
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::WEIGHTEDSTD_BW;
|
|
} else if (tcMode == 2) {
|
|
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::FILMLIKE_BW;
|
|
} else if (tcMode == 3) {
|
|
pp->blackwhite.beforeCurveMode = BlackWhiteParams::TcMode::SATANDVALBLENDING_BW;
|
|
}
|
|
|
|
// tcMode = afterCurveMode->get_active_row_number();
|
|
// if (tcMode == 0) pp->blackwhite.afterCurveMode = BlackWhiteParams::TCMode::STD_BW;
|
|
// else if (tcMode == 1) pp->blackwhite.afterCurveMode = BlackWhiteParams::TCMode::WEIGHTEDSTD;
|
|
|
|
if (pedited) {
|
|
pedited->blackwhite.enabled = !get_inconsistent();
|
|
pedited->blackwhite.luminanceCurve = !luminanceCurve->isUnChanged ();
|
|
pedited->blackwhite.autoc = !autoch->get_inconsistent();
|
|
pedited->blackwhite.enabledcc = !enabledcc->get_inconsistent();
|
|
pedited->blackwhite.mixerRed = mixerRed->getEditedState ();
|
|
pedited->blackwhite.mixerGreen = mixerGreen->getEditedState ();
|
|
pedited->blackwhite.mixerBlue = mixerBlue->getEditedState ();
|
|
pedited->blackwhite.gammaRed = gammaRed->getEditedState ();
|
|
pedited->blackwhite.gammaGreen = gammaGreen->getEditedState ();
|
|
pedited->blackwhite.gammaBlue = gammaBlue->getEditedState ();
|
|
pedited->blackwhite.filter = filter->get_active_text() != M("GENERAL_UNCHANGED");
|
|
pedited->blackwhite.setting = setting->get_active_text() != M("GENERAL_UNCHANGED");
|
|
pedited->blackwhite.method = method->get_active_text() != M("GENERAL_UNCHANGED");
|
|
pedited->blackwhite.mixerOrange = mixerOrange->getEditedState ();
|
|
pedited->blackwhite.mixerYellow = mixerYellow->getEditedState ();
|
|
pedited->blackwhite.mixerCyan = mixerCyan->getEditedState ();
|
|
pedited->blackwhite.mixerMagenta = mixerMagenta->getEditedState ();
|
|
pedited->blackwhite.mixerPurple = mixerPurple->getEditedState ();
|
|
pedited->blackwhite.beforeCurve = !beforeCurve->isUnChanged ();
|
|
pedited->blackwhite.beforeCurveMode = beforeCurveMode->get_active_row_number() != 4;
|
|
pedited->blackwhite.afterCurve = !afterCurve->isUnChanged ();
|
|
pedited->blackwhite.algo = algo->get_active_text() != M("GENERAL_UNCHANGED");
|
|
|
|
// pedited->blackwhite.afterCurveMode = afterCurveMode->get_active_row_number() != 1;
|
|
}
|
|
|
|
if (method->get_active_row_number() == 0) {
|
|
pp->blackwhite.method = "Desaturation";
|
|
} else if (method->get_active_row_number() == 1) {
|
|
pp->blackwhite.method = "LumEqualizer";
|
|
} else if (method->get_active_row_number() == 2) {
|
|
pp->blackwhite.method = "ChannelMixer";
|
|
}
|
|
|
|
if (algo->get_active_row_number() == 0) {
|
|
pp->blackwhite.algo = "LI";
|
|
} else if (algo->get_active_row_number() == 1) {
|
|
pp->blackwhite.algo = "SP";
|
|
}
|
|
|
|
pp->blackwhite.setting = getSettingString();
|
|
pp->blackwhite.filter = getFilterString();
|
|
}
|
|
|
|
void BlackWhite::algoChanged ()
|
|
{
|
|
if (listener && (multiImage || getEnabled()) ) {
|
|
listener->panelChanged (EvBWMethodalg, algo->get_active_text ());
|
|
}
|
|
}
|
|
|
|
void BlackWhite::curveChanged (CurveEditor* ce)
|
|
{
|
|
if (listener) {
|
|
if (ce == beforeCurve) {
|
|
listener->panelChanged (EvBWBeforeCurve, M("HISTORY_CUSTOMCURVE"));
|
|
}
|
|
|
|
if (ce == afterCurve) {
|
|
listener->panelChanged (EvBWAfterCurve, M("HISTORY_CUSTOMCURVE"));
|
|
}
|
|
|
|
if (ce == luminanceCurve) {
|
|
listener->panelChanged (EvBWLuminanceEqual, M("HISTORY_CUSTOMCURVE"));
|
|
}
|
|
}
|
|
}
|
|
|
|
void BlackWhite::curveMode1Changed ()
|
|
{
|
|
if (listener) {
|
|
Glib::signal_idle().connect (sigc::mem_fun(*this, &BlackWhite::curveMode1Changed_));
|
|
}
|
|
}
|
|
bool BlackWhite::curveMode1Changed_ ()
|
|
{
|
|
if (listener) {
|
|
listener->panelChanged (EvBWBeforeCurveMode, escapeHtmlChars(beforeCurveMode->get_active_text()));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
/*
|
|
void BlackWhite::curveMode1Changed2 () {
|
|
if (listener) Glib::signal_idle().connect (sigc::mem_fun(*this, &BlackWhite::curveMode1Changed2_));
|
|
}
|
|
bool BlackWhite::curveMode1Changed2_ () {
|
|
if (listener) listener->panelChanged (EvBWAfterCurveMode, escapeHtmlChars(afterCurveMode->get_active_text()));
|
|
return false;
|
|
}
|
|
*/
|
|
void BlackWhite::colorForValue (double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller* caller)
|
|
{
|
|
|
|
float r, g, b;
|
|
|
|
if (elemType == ColorCaller::CCET_VERTICAL_BAR) {
|
|
valY = 0.5f;
|
|
}
|
|
|
|
if (callerId == 1) { // Hue = f(Hue)
|
|
|
|
float h = float((valY - 0.5) * 2. + valX);
|
|
|
|
if (h > 1.0f) {
|
|
h -= 1.0f;
|
|
} else if (h < 0.0f) {
|
|
h += 1.0f;
|
|
}
|
|
|
|
Color::hsv2rgb01(h, 0.5f, 0.5f, r, g, b);
|
|
caller->ccRed = double(r);
|
|
caller->ccGreen = double(g);
|
|
caller->ccBlue = double(b);
|
|
} else if (callerId == 2) { // Saturation = f(Hue)
|
|
Color::hsv2rgb01(float(valX), float(valY), 0.5f, r, g, b);
|
|
caller->ccRed = double(r);
|
|
caller->ccGreen = double(g);
|
|
caller->ccBlue = double(b);
|
|
} else if (callerId == 3) { // Value = f(Hue)
|
|
Color::hsv2rgb01(float(valX), 0.5f, float(valY), r, g, b);
|
|
caller->ccRed = double(r);
|
|
caller->ccGreen = double(g);
|
|
caller->ccBlue = double(b);
|
|
} else {
|
|
printf("Error: no curve displayed!\n");
|
|
}
|
|
}
|
|
|
|
|
|
void BlackWhite::settingChanged ()
|
|
{
|
|
|
|
if ( setting->get_active_row_number() == 10 || setting->get_active_row_number() == 11 ) {
|
|
// RGB Channel Mixer
|
|
showMixer(3);
|
|
hideEnabledCC();
|
|
showFilter();
|
|
} else if ( setting->get_active_row_number() == 12 || setting->get_active_row_number() == 13 ) {
|
|
// ROYGCBPM Channel Mixer
|
|
showMixer(7);
|
|
showEnabledCC();
|
|
showFilter();
|
|
} else if ( setting->get_active_row_number() == 14 ) {
|
|
// Infrared
|
|
filter->set_active (0);
|
|
showMixer(3, false);
|
|
hideEnabledCC();
|
|
hideFilter();
|
|
} else {
|
|
// RGB Presets
|
|
showMixer(3, false);
|
|
hideEnabledCC();
|
|
showFilter();
|
|
}
|
|
|
|
// Checking "listener" to avoid "autoch" getting toggled off because it has to change the sliders when toggling on
|
|
if (listener) {
|
|
if (multiImage && autoch->get_inconsistent()) {
|
|
autoch->set_inconsistent (false);
|
|
}
|
|
|
|
autoconn.block(true);
|
|
autoch->set_active (false);
|
|
autoconn.block(false);
|
|
lastAuto = false;
|
|
}
|
|
|
|
updateRGBLabel();
|
|
|
|
if (listener && (multiImage || getEnabled())) {
|
|
listener->panelChanged (EvBWsetting, setting->get_active_text ());
|
|
}
|
|
}
|
|
|
|
|
|
void BlackWhite::filterChanged ()
|
|
{
|
|
// Checking "listener" to avoid "autoch" getting toggled off because it has to change the sliders when toggling on
|
|
if (listener) {
|
|
if (multiImage && autoch->get_inconsistent()) {
|
|
autoch->set_inconsistent (false);
|
|
}
|
|
|
|
autoconn.block(true);
|
|
autoch->set_active (false);
|
|
autoconn.block(false);
|
|
lastAuto = false;
|
|
}
|
|
|
|
updateRGBLabel();
|
|
|
|
if (listener && (multiImage || getEnabled())) {
|
|
listener->panelChanged (EvBWfilter, filter->get_active_text ());
|
|
}
|
|
}
|
|
|
|
void BlackWhite::methodChanged ()
|
|
{
|
|
if(method->get_active_row_number() == 2) {
|
|
// Channel Mixer
|
|
hideLuminance();
|
|
|
|
if(setting->get_active_row_number() == 10 || setting->get_active_row_number() == 11) {
|
|
hideEnabledCC();
|
|
showMixer(3);
|
|
} else if(setting->get_active_row_number() == 12 || setting->get_active_row_number() == 13) {
|
|
showEnabledCC();
|
|
showMixer(7);
|
|
} else {
|
|
hideEnabledCC();
|
|
showMixer(3, false);
|
|
}
|
|
|
|
beforeCurveCEG->show();
|
|
afterCurveCEG->show();
|
|
|
|
bool wasEnabled = disableListener();
|
|
settingChanged();
|
|
|
|
if (wasEnabled) {
|
|
enableListener();
|
|
}
|
|
} else if(method->get_active_row_number() == 1) {
|
|
// Luminance Equalizer
|
|
showLuminance();
|
|
hideMixer();
|
|
beforeCurveCEG->show();
|
|
afterCurveCEG->show();
|
|
} else if(method->get_active_row_number() == 0) {
|
|
// Desaturation
|
|
hideLuminance();
|
|
hideMixer();
|
|
beforeCurveCEG->show();
|
|
afterCurveCEG->show();
|
|
}
|
|
|
|
if (listener && (multiImage || getEnabled())) {
|
|
listener->panelChanged (EvBWmethod, method->get_active_text ());
|
|
}
|
|
}
|
|
|
|
void BlackWhite::enabledChanged ()
|
|
{
|
|
if (listener) {
|
|
if (get_inconsistent()) {
|
|
listener->panelChanged (EvBWChmixEnabled, M("GENERAL_UNCHANGED"));
|
|
} else if (getEnabled()) {
|
|
listener->panelChanged (EvBWChmixEnabled, M("GENERAL_ENABLED"));
|
|
} else {
|
|
listener->panelChanged (EvBWChmixEnabled, M("GENERAL_DISABLED"));
|
|
}
|
|
}
|
|
}
|
|
|
|
void BlackWhite::neutral_pressed ()
|
|
{
|
|
// This method deselects auto chmixer and sets "neutral" values to params
|
|
disableListener();
|
|
|
|
if (multiImage && autoch->get_inconsistent()) {
|
|
autoch->set_inconsistent (false);
|
|
}
|
|
|
|
autoconn.block(true);
|
|
autoch->set_active (false);
|
|
autoconn.block(false);
|
|
lastAuto = false;
|
|
|
|
int activeSetting = setting->get_active_row_number();
|
|
|
|
if (activeSetting < 10 || activeSetting > 13) {
|
|
setting->set_active (11);
|
|
}
|
|
|
|
filter->set_active (0);
|
|
mixerRed->resetValue(false);
|
|
mixerGreen->resetValue(false);
|
|
mixerBlue->resetValue(false);
|
|
mixerOrange->resetValue(false);
|
|
mixerYellow->resetValue(false);
|
|
mixerMagenta->resetValue(false);
|
|
mixerPurple->resetValue(false);
|
|
mixerCyan->resetValue(false);
|
|
|
|
enableListener();
|
|
|
|
updateRGBLabel();
|
|
|
|
nextcount = 0;
|
|
if(listener) {
|
|
listener->panelChanged (EvNeutralBW, M("GENERAL_RESET"));
|
|
}
|
|
}
|
|
|
|
void BlackWhite::enabledcc_toggled ()
|
|
{
|
|
|
|
// toggling off the Complementary Colors does switch off the Auto button
|
|
if (multiImage) {
|
|
// multiple image editing (batch)
|
|
if (enabledcc->get_inconsistent()) {
|
|
enabledcc->set_inconsistent (false); // set consistent
|
|
enaccconn.block (true);
|
|
enabledcc->set_active (false); // ... and deactivated
|
|
enaccconn.block (false);
|
|
} else if (lastEnabledcc) {
|
|
enabledcc->set_inconsistent (true);
|
|
}
|
|
|
|
lastEnabledcc = enabledcc->get_active ();
|
|
}
|
|
|
|
if (multiImage && autoch->get_inconsistent()) {
|
|
autoch->set_inconsistent (false);
|
|
}
|
|
|
|
autoconn.block(true);
|
|
autoch->set_active (false);
|
|
autoconn.block(false);
|
|
lastAuto = false;
|
|
|
|
updateRGBLabel();
|
|
|
|
if (listener) {
|
|
if (enabledcc->get_inconsistent()) {
|
|
listener->panelChanged (EvBWChmixEnabledLm, M("GENERAL_UNCHANGED"));
|
|
} else if (enabledcc->get_active ()) {
|
|
listener->panelChanged (EvBWChmixEnabledLm, M("GENERAL_ENABLED"));
|
|
} else {
|
|
listener->panelChanged (EvBWChmixEnabledLm, M("GENERAL_DISABLED"));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void BlackWhite::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited)
|
|
{
|
|
|
|
mixerRed->setDefault (defParams->blackwhite.mixerRed);
|
|
mixerGreen->setDefault (defParams->blackwhite.mixerGreen);
|
|
mixerBlue->setDefault (defParams->blackwhite.mixerBlue);
|
|
gammaRed->setDefault (defParams->blackwhite.gammaRed);
|
|
gammaGreen->setDefault (defParams->blackwhite.gammaGreen);
|
|
gammaBlue->setDefault (defParams->blackwhite.gammaBlue);
|
|
mixerOrange->setDefault (defParams->blackwhite.mixerOrange);
|
|
mixerYellow->setDefault (defParams->blackwhite.mixerYellow);
|
|
mixerCyan->setDefault (defParams->blackwhite.mixerCyan);
|
|
mixerMagenta->setDefault (defParams->blackwhite.mixerMagenta);
|
|
mixerPurple->setDefault (defParams->blackwhite.mixerPurple);
|
|
|
|
if (pedited) {
|
|
mixerRed->setDefaultEditedState (pedited->blackwhite.mixerRed ? Edited : UnEdited);
|
|
mixerGreen->setDefaultEditedState (pedited->blackwhite.mixerGreen ? Edited : UnEdited);
|
|
mixerBlue->setDefaultEditedState (pedited->blackwhite.mixerBlue ? Edited : UnEdited);
|
|
gammaRed->setDefaultEditedState (pedited->blackwhite.gammaRed ? Edited : UnEdited);
|
|
gammaGreen->setDefaultEditedState (pedited->blackwhite.gammaGreen ? Edited : UnEdited);
|
|
gammaBlue->setDefaultEditedState (pedited->blackwhite.gammaBlue ? Edited : UnEdited);
|
|
mixerOrange->setDefaultEditedState (pedited->blackwhite.mixerOrange ? Edited : UnEdited);
|
|
mixerYellow->setDefaultEditedState (pedited->blackwhite.mixerYellow ? Edited : UnEdited);
|
|
mixerCyan->setDefaultEditedState (pedited->blackwhite.mixerCyan ? Edited : UnEdited);
|
|
mixerMagenta->setDefaultEditedState (pedited->blackwhite.mixerMagenta ? Edited : UnEdited);
|
|
mixerPurple->setDefaultEditedState (pedited->blackwhite.mixerPurple ? Edited : UnEdited);
|
|
} else {
|
|
mixerRed->setDefaultEditedState (Irrelevant);
|
|
mixerGreen->setDefaultEditedState (Irrelevant);
|
|
mixerBlue->setDefaultEditedState (Irrelevant);
|
|
gammaRed->setDefaultEditedState (Irrelevant);
|
|
gammaGreen->setDefaultEditedState (Irrelevant);
|
|
gammaBlue->setDefaultEditedState (Irrelevant);
|
|
mixerOrange->setDefaultEditedState (Irrelevant);
|
|
mixerYellow->setDefaultEditedState (Irrelevant);
|
|
mixerCyan->setDefaultEditedState (Irrelevant);
|
|
mixerMagenta->setDefaultEditedState (Irrelevant);
|
|
mixerPurple->setDefaultEditedState (Irrelevant);
|
|
}
|
|
}
|
|
|
|
void BlackWhite::autoch_toggled ()
|
|
{
|
|
|
|
if (batchMode) {
|
|
if (multiImage) {
|
|
if (autoch->get_inconsistent()) {
|
|
autoch->set_inconsistent (false);
|
|
autoconn.block (true);
|
|
autoch->set_active (false);
|
|
autoconn.block (false);
|
|
} else if (lastAuto) {
|
|
autoch->set_inconsistent (true);
|
|
}
|
|
}
|
|
|
|
lastAuto = autoch->get_active ();
|
|
|
|
mixerRed->setEditedState (UnEdited);
|
|
mixerGreen->setEditedState (UnEdited);
|
|
mixerBlue->setEditedState (UnEdited);
|
|
mixerOrange->setEditedState (UnEdited);
|
|
mixerYellow->setEditedState (UnEdited);
|
|
mixerPurple->setEditedState (UnEdited);
|
|
mixerMagenta->setEditedState (UnEdited);
|
|
mixerCyan->setEditedState (UnEdited);
|
|
|
|
bool wasEnabled = disableListener();
|
|
|
|
if (mixerRed->getAddMode()) {
|
|
mixerRed->resetValue(true);
|
|
}
|
|
|
|
if (mixerGreen->getAddMode()) {
|
|
mixerGreen->resetValue(true);
|
|
}
|
|
|
|
if (mixerBlue->getAddMode()) {
|
|
mixerBlue->resetValue(true);
|
|
}
|
|
|
|
if (mixerOrange->getAddMode()) {
|
|
mixerOrange->resetValue(true);
|
|
}
|
|
|
|
if (mixerYellow->getAddMode()) {
|
|
mixerYellow->resetValue(true);
|
|
}
|
|
|
|
if (mixerMagenta->getAddMode()) {
|
|
mixerMagenta->resetValue(true);
|
|
}
|
|
|
|
if (mixerPurple->getAddMode()) {
|
|
mixerPurple->resetValue(true);
|
|
}
|
|
|
|
if (mixerCyan->getAddMode()) {
|
|
mixerCyan->resetValue(true);
|
|
}
|
|
|
|
setting->set_active (11);
|
|
filter->set_active (0);
|
|
|
|
if (wasEnabled) {
|
|
enableListener();
|
|
}
|
|
|
|
if (listener) {
|
|
if (autoch->get_inconsistent()) {
|
|
listener->panelChanged (EvAutoch, M("GENERAL_UNCHANGED"));
|
|
} else if (autoch->get_active ()) {
|
|
listener->panelChanged (EvAutoch, M("GENERAL_ENABLED"));
|
|
} else {
|
|
listener->panelChanged (EvAutoch, M("GENERAL_DISABLED"));
|
|
}
|
|
}
|
|
} else {
|
|
if (autoch->get_active()) {
|
|
bool wasEnabled = disableListener();
|
|
mixerRed->resetValue(false);
|
|
mixerGreen->resetValue(false);
|
|
mixerBlue->resetValue(false);
|
|
mixerOrange->resetValue(false);
|
|
mixerYellow->resetValue(false);
|
|
mixerMagenta->resetValue(false);
|
|
mixerPurple->resetValue(false);
|
|
mixerCyan->resetValue(false);
|
|
setting->set_active (11);
|
|
filter->set_active (0);
|
|
|
|
if (wasEnabled) {
|
|
enableListener();
|
|
}
|
|
|
|
updateRGBLabel();
|
|
|
|
if (listener) {
|
|
listener->panelChanged (EvAutoch, M("GENERAL_ENABLED"));
|
|
}
|
|
} else {
|
|
if (listener) {
|
|
listener->panelChanged (EvAutoch, M("GENERAL_DISABLED"));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void BlackWhite::adjusterChanged(Adjuster* a, double newval)
|
|
{
|
|
// Checking "listener" to avoid "autoch" getting toggled off because it has to change the sliders when toggling on
|
|
if (listener && (a == mixerRed || a == mixerGreen || a == mixerBlue || a == mixerOrange || a == mixerYellow || a == mixerMagenta || a == mixerPurple || a == mixerCyan) ) {
|
|
if (multiImage && autoch->get_inconsistent()) {
|
|
autoch->set_inconsistent (false);
|
|
}
|
|
|
|
nextcount = 0;
|
|
autoconn.block(true);
|
|
autoch->set_active (false);
|
|
autoconn.block(false);
|
|
lastAuto = false;
|
|
}
|
|
|
|
if (a == mixerRed || a == mixerGreen || a == mixerBlue
|
|
|| a == mixerOrange || a == mixerYellow || a == mixerCyan
|
|
|| a == mixerMagenta || a == mixerPurple)
|
|
|
|
{
|
|
updateRGBLabel();
|
|
}
|
|
|
|
if (listener && (multiImage || getEnabled())) {
|
|
Glib::ustring value = a->getTextValue();
|
|
|
|
if (a == mixerRed) {
|
|
listener->panelChanged (EvBWred, value );
|
|
} else if (a == mixerGreen) {
|
|
listener->panelChanged (EvBWgreen, value );
|
|
} else if (a == mixerBlue) {
|
|
listener->panelChanged (EvBWblue, value );
|
|
} else if (a == gammaGreen) {
|
|
listener->panelChanged (EvBWgreengam, value );
|
|
} else if (a == gammaBlue) {
|
|
listener->panelChanged (EvBWbluegam, value );
|
|
} else if (a == gammaRed) {
|
|
listener->panelChanged (EvBWredgam, value );
|
|
} else if (a == mixerOrange) {
|
|
listener->panelChanged (EvBWoran, value );
|
|
} else if (a == mixerYellow) {
|
|
listener->panelChanged (EvBWyell, value );
|
|
} else if (a == mixerCyan) {
|
|
listener->panelChanged (EvBWcyan, value );
|
|
} else if (a == mixerMagenta) {
|
|
listener->panelChanged (EvBWmag, value );
|
|
} else if (a == mixerPurple) {
|
|
listener->panelChanged (EvBWpur, value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void BlackWhite::updateRGBLabel ()
|
|
{
|
|
if (!batchMode) {
|
|
float kcorrec = 1.f;
|
|
float r, g, b;
|
|
|
|
if (autoch->get_active()) {
|
|
r = nextredbw;
|
|
g = nextgreenbw;
|
|
b = nextbluebw;
|
|
} else {
|
|
r = mixerRed->getValue();
|
|
g = mixerGreen->getValue();
|
|
b = mixerBlue->getValue();
|
|
}
|
|
|
|
double mixR, mixG, mixB;
|
|
float filcor;
|
|
Glib::ustring sSetting = getSettingString();
|
|
Color::computeBWMixerConstants(sSetting, getFilterString(), getalgoString(), filcor, r, g, b,
|
|
mixerOrange->getValue(), mixerYellow->getValue(), mixerCyan->getValue(), mixerPurple->getValue(), mixerMagenta->getValue(),
|
|
autoch->get_active(), enabledcc->get_active(), kcorrec, mixR, mixG, mixB);
|
|
|
|
if( filcor != 1.f) {
|
|
r = kcorrec * r / (r + g + b);
|
|
g = kcorrec * g / (r + g + b);
|
|
b = kcorrec * b / (r + g + b);
|
|
}
|
|
|
|
RGBLabels->set_text(
|
|
Glib::ustring::compose(M("TP_BWMIX_RGBLABEL"),
|
|
Glib::ustring::format(std::fixed, std::setprecision(1), r * 100.f),
|
|
Glib::ustring::format(std::fixed, std::setprecision(1), g * 100.f),
|
|
Glib::ustring::format(std::fixed, std::setprecision(1), b * 100.f),
|
|
Glib::ustring::format(std::fixed, std::setprecision(0), ceil(kcorrec * 100.f/*(r+g+b)*100.)*/)))
|
|
);
|
|
|
|
// We have to update the RGB sliders too if preset values has been chosen
|
|
if (sSetting != "RGB-Abs" && sSetting != "RGB-Rel" && sSetting != "ROYGCBPM-Abs" && sSetting != "ROYGCBPM-Rel") {
|
|
mixerRed->setValue(mixR);
|
|
mixerGreen->setValue(mixG);
|
|
mixerBlue->setValue(mixB);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BlackWhite::setBatchMode (bool batchMode)
|
|
{
|
|
removeIfThere (autoHBox, autoch, false);
|
|
autoch = Gtk::manage (new Gtk::CheckButton (M("TP_BWMIX_AUTOCH")));
|
|
autoconn = autoch->signal_toggled().connect( sigc::mem_fun(*this, &BlackWhite::autoch_toggled) );
|
|
autoHBox->pack_start (*autoch);
|
|
|
|
removeIfThere (mixerVBox, RGBLabels, false);
|
|
delete RGBLabels;
|
|
RGBLabels = nullptr;
|
|
|
|
ToolPanel::setBatchMode (batchMode);
|
|
mixerRed->showEditedCB ();
|
|
mixerOrange->showEditedCB ();
|
|
mixerYellow->showEditedCB ();
|
|
mixerGreen->showEditedCB ();
|
|
mixerCyan->showEditedCB ();
|
|
mixerBlue->showEditedCB ();
|
|
mixerMagenta->showEditedCB ();
|
|
mixerPurple->showEditedCB ();
|
|
gammaRed->showEditedCB ();
|
|
gammaGreen->showEditedCB ();
|
|
gammaBlue->showEditedCB ();
|
|
method->append (M("GENERAL_UNCHANGED"));
|
|
filter->append (M("GENERAL_UNCHANGED"));
|
|
setting->append (M("GENERAL_UNCHANGED"));
|
|
luminanceCEG->setBatchMode (batchMode);
|
|
beforeCurveCEG->setBatchMode (batchMode);
|
|
beforeCurveCEG->show();
|
|
beforeCurveMode->append (M("GENERAL_UNCHANGED"));
|
|
afterCurveCEG->setBatchMode (batchMode);
|
|
afterCurveCEG->show();
|
|
// afterCurveMode->append (M("GENERAL_UNCHANGED"));
|
|
algo->append (M("GENERAL_UNCHANGED"));
|
|
|
|
showLuminance();
|
|
showFilter();
|
|
showEnabledCC();
|
|
showGamma();
|
|
showMixer(7);
|
|
}
|
|
|
|
void BlackWhite::autoOpenCurve ()
|
|
{
|
|
luminanceCurve->openIfNonlinear();
|
|
beforeCurve->openIfNonlinear();
|
|
afterCurve->openIfNonlinear();
|
|
}
|
|
void BlackWhite::setEditProvider (EditDataProvider *provider)
|
|
{
|
|
luminanceCurve->setEditProvider(provider);
|
|
beforeCurve->setEditProvider(provider);
|
|
afterCurve->setEditProvider(provider);
|
|
}
|
|
|
|
void BlackWhite::setAdjusterBehavior (bool bwadd, bool bwgadd)
|
|
{
|
|
|
|
mixerRed->setAddMode(bwadd);
|
|
mixerOrange->setAddMode(bwadd);
|
|
mixerYellow->setAddMode(bwadd);
|
|
mixerGreen->setAddMode(bwadd);
|
|
mixerCyan->setAddMode(bwadd);
|
|
mixerBlue->setAddMode(bwadd);
|
|
mixerMagenta->setAddMode(bwadd);
|
|
mixerPurple->setAddMode(bwadd);
|
|
|
|
gammaRed->setAddMode(bwgadd);
|
|
gammaGreen->setAddMode(bwgadd);
|
|
gammaBlue->setAddMode(bwgadd);
|
|
}
|
|
|
|
void BlackWhite::trimValues (rtengine::procparams::ProcParams* pp)
|
|
{
|
|
|
|
mixerRed->trimValue (pp->blackwhite.mixerRed);
|
|
mixerGreen->trimValue (pp->blackwhite.mixerGreen);
|
|
mixerBlue->trimValue (pp->blackwhite.mixerBlue);
|
|
gammaRed->trimValue (pp->blackwhite.gammaRed);
|
|
gammaGreen->trimValue (pp->blackwhite.gammaGreen);
|
|
gammaBlue->trimValue (pp->blackwhite.gammaBlue);
|
|
mixerOrange->trimValue (pp->blackwhite.mixerOrange);
|
|
mixerYellow->trimValue (pp->blackwhite.mixerYellow);
|
|
mixerCyan->trimValue (pp->blackwhite.mixerCyan);
|
|
mixerMagenta->trimValue (pp->blackwhite.mixerMagenta);
|
|
mixerPurple->trimValue (pp->blackwhite.mixerPurple);
|
|
}
|
|
|
|
void BlackWhite::showLuminance()
|
|
{
|
|
luminanceCEG->show();
|
|
luminanceSep->show();
|
|
}
|
|
|
|
void BlackWhite::hideLuminance()
|
|
{
|
|
if (!batchMode) {
|
|
luminanceCEG->hide();
|
|
luminanceSep->hide();
|
|
}
|
|
}
|
|
|
|
void BlackWhite::showFilter()
|
|
{
|
|
filterHBox->show();
|
|
filterSep->show();
|
|
}
|
|
|
|
void BlackWhite::hideFilter()
|
|
{
|
|
if (!batchMode) {
|
|
filterHBox->hide();
|
|
filterSep->hide();
|
|
}
|
|
}
|
|
|
|
void BlackWhite::showEnabledCC()
|
|
{
|
|
enabledcc->show();
|
|
enabledccSep->show();
|
|
}
|
|
|
|
void BlackWhite::hideEnabledCC()
|
|
{
|
|
if (!batchMode) {
|
|
enabledcc->hide();
|
|
enabledccSep->hide();
|
|
}
|
|
}
|
|
|
|
void BlackWhite::showMixer(int nChannels, bool RGBIsSensitive)
|
|
{
|
|
if (!batchMode) {
|
|
RGBLabels->show();
|
|
}
|
|
|
|
if (!batchMode && nChannels == 3) {
|
|
mixerRed->show();
|
|
mixerRed->set_sensitive (RGBIsSensitive);
|
|
mixerGreen->show();
|
|
mixerGreen->set_sensitive (RGBIsSensitive);
|
|
mixerBlue->show();
|
|
mixerBlue->set_sensitive (RGBIsSensitive);
|
|
filterSep2->hide();
|
|
algo->hide();
|
|
alLabel->hide();
|
|
mixerOrange->hide();
|
|
mixerYellow->hide();
|
|
mixerCyan->hide();
|
|
mixerMagenta->hide();
|
|
mixerPurple->hide();
|
|
} else {
|
|
mixerRed->show();
|
|
mixerRed->set_sensitive (true);
|
|
mixerGreen->show();
|
|
mixerGreen->set_sensitive (true);
|
|
mixerBlue->show();
|
|
mixerBlue->set_sensitive (true);
|
|
filterSep2->show();
|
|
mixerOrange->show();
|
|
algo->show();
|
|
alLabel->show();
|
|
mixerYellow->show();
|
|
mixerCyan->show();
|
|
mixerMagenta->show();
|
|
mixerPurple->show();
|
|
}
|
|
|
|
mixerFrame->show();
|
|
}
|
|
|
|
void BlackWhite::hideMixer()
|
|
{
|
|
if (!batchMode) {
|
|
mixerFrame->hide();
|
|
}
|
|
}
|
|
|
|
void BlackWhite::showGamma()
|
|
{
|
|
gammaFrame->show();
|
|
}
|
|
|
|
void BlackWhite::hideGamma()
|
|
{
|
|
if (!batchMode) {
|
|
gammaFrame->hide();
|
|
}
|
|
}
|
|
|
|
Glib::ustring BlackWhite::getalgoString()
|
|
{
|
|
Glib::ustring retVal;
|
|
|
|
if (algo->get_active_row_number() == 0) {
|
|
retVal = "LI";
|
|
} else if (algo->get_active_row_number() == 1) {
|
|
retVal = "SP";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
Glib::ustring BlackWhite::getSettingString()
|
|
{
|
|
Glib::ustring retVal;
|
|
|
|
if (setting->get_active_row_number() == 0) {
|
|
retVal = "NormalContrast";
|
|
} else if (setting->get_active_row_number() == 1) {
|
|
retVal = "HighContrast";
|
|
} else if (setting->get_active_row_number() == 2) {
|
|
retVal = "Luminance";
|
|
} else if (setting->get_active_row_number() == 3) {
|
|
retVal = "Landscape";
|
|
} else if (setting->get_active_row_number() == 4) {
|
|
retVal = "Portrait";
|
|
} else if (setting->get_active_row_number() == 5) {
|
|
retVal = "LowSensitivity";
|
|
} else if (setting->get_active_row_number() == 6) {
|
|
retVal = "HighSensitivity";
|
|
} else if (setting->get_active_row_number() == 7) {
|
|
retVal = "Panchromatic";
|
|
} else if (setting->get_active_row_number() == 8) {
|
|
retVal = "HyperPanchromatic";
|
|
} else if (setting->get_active_row_number() == 9) {
|
|
retVal = "Orthochromatic";
|
|
} else if (setting->get_active_row_number() == 10) {
|
|
retVal = "RGB-Abs";
|
|
} else if (setting->get_active_row_number() == 11) {
|
|
retVal = "RGB-Rel";
|
|
} else if (setting->get_active_row_number() == 12) {
|
|
retVal = "ROYGCBPM-Abs";
|
|
} else if (setting->get_active_row_number() == 13) {
|
|
retVal = "ROYGCBPM-Rel";
|
|
} else if (setting->get_active_row_number() == 14) {
|
|
retVal = "InfraRed";
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
Glib::ustring BlackWhite::getFilterString()
|
|
{
|
|
Glib::ustring retVal;
|
|
|
|
if (filter->get_active_row_number() == 0) {
|
|
retVal = "None";
|
|
} else if (filter->get_active_row_number() == 1) {
|
|
retVal = "Red";
|
|
} else if (filter->get_active_row_number() == 2) {
|
|
retVal = "Orange";
|
|
} else if (filter->get_active_row_number() == 3) {
|
|
retVal = "Yellow";
|
|
} else if (filter->get_active_row_number() == 4) {
|
|
retVal = "YellowGreen";
|
|
} else if (filter->get_active_row_number() == 5) {
|
|
retVal = "Green";
|
|
} else if (filter->get_active_row_number() == 6) {
|
|
retVal = "Cyan";
|
|
} else if (filter->get_active_row_number() == 7) {
|
|
retVal = "Blue";
|
|
} else if (filter->get_active_row_number() == 8) {
|
|
retVal = "Purple";
|
|
}
|
|
|
|
return retVal;
|
|
}
|