liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge with ef386222219c7d420954431bdbcf252e8a487d1c

Browse Source
This commit is contained in:
Hombre
2014-02-19 14:09:22 +01:00
parent 8d70ca0f41
commit ee040bc8cd
94 changed files with 1433 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
rtgui/dirpyrequalizer.cc
View File

@@ -26,6 +26,21 @@ DirPyrEqualizer::DirPyrEqualizer () : Gtk::VBox(), FoldableToolPanel(this) {
set_border_width(4);
std::vector<GradientMilestone> milestones;
float r, g, b;
Color::hsv2rgb01(0.7500, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0. , r, g, b) ); // hsv: 0.75 rad: -0.9
Color::hsv2rgb01(0.8560, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.1470, r, g, b) ); // hsv: 0.856 rad: -0.4
Color::hsv2rgb01(0.9200, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.2353, r, g, b) ); // hsv: 0.92 rad: -0.1
Color::hsv2rgb01(0.9300, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.2647, r, g, b) ); // hsv: 0.93 rad: 0
Color::hsv2rgb01(0.9600, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.3380, r, g, b) ); // hsv: 0.96 rad: 0.25
Color::hsv2rgb01(1.0000, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.4412, r, g, b) ); // hsv: 1. rad: 0.6
Color::hsv2rgb01(0.0675, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.6176, r, g, b) ); // hsv: 0.0675 rad: 1.2
Color::hsv2rgb01(0.0900, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.6764, r, g, b) ); // hsv: 0.09 rad: 1.4
Color::hsv2rgb01(0.1700, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.7647, r, g, b) ); // hsv: 0.17 rad: 1.7
Color::hsv2rgb01(0.2650, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(0.8824, r, g, b) ); // hsv: 0.265 rad: 2.1
Color::hsv2rgb01(0.3240, 0.5, 0.5, r, g, b); milestones.push_back( GradientMilestone(1. , r, g, b) ); // hsv: 0.324 rad: 2.5
enabled = Gtk::manage (new Gtk::CheckButton (M("GENERAL_ENABLED")));
enabled->set_active (true);
pack_start(*enabled);
@@ -73,8 +88,45 @@ DirPyrEqualizer::DirPyrEqualizer () : Gtk::VBox(), FoldableToolPanel(this) {
threshold->setAdjusterListener(this);
pack_start(*threshold);
show_all_children ();
Gtk::HSeparator *separator4 = Gtk::manage (new Gtk::HSeparator());
pack_start(*separator4, Gtk::PACK_SHRINK, 2);
/*
algoHBox = Gtk::manage (new Gtk::HBox ());
algoHBox->set_border_width (0);
algoHBox->set_spacing (2);
algoHBox->set_tooltip_markup (M("TP_DIRPYREQUALIZER_ALGO_TOOLTIP"));
*/
// alLabel = Gtk::manage (new Gtk::Label (M("TP_DIRPYREQUALIZER_ALGO")+":"));
// algoHBox->pack_start (*alLabel, Gtk::PACK_SHRINK);
/*
algo = Gtk::manage (new MyComboBoxText ());
algo->append_text (M("TP_DIRPYREQUALIZER_ALGO_FI"));
algo->append_text (M("TP_DIRPYREQUALIZER_ALGO_LA"));
algo->set_active (1);
// algoHBox->pack_start (*algo);
// pack_start(*algoHBox);
algoconn = algo->signal_changed().connect ( sigc::mem_fun(*this, &DirPyrEqualizer::algoChanged) );
*/
skinprotect = Gtk::manage ( new Adjuster (M("TP_DIRPYREQUALIZER_SKIN"), -100, 100, 1, 0.) );
skinprotect->setAdjusterListener(this);
pack_start(*skinprotect);
skinprotect->set_tooltip_markup (M("TP_DIRPYREQUALIZER_SKIN_TOOLTIP"));
hueskin = Gtk::manage (new ThresholdAdjuster (M("TP_DIRPYREQUALIZER_HUESKIN"), -40., 210., -5., 25., 170., 120., 0, false)); //default (b_l 0, t_l 30, b_r 170, t_r 120);
hueskin->set_tooltip_markup (M("TP_DIRPYREQUALIZER_HUESKIN_TOOLTIP"));
hueskin->setBgGradient(milestones);
pack_start(*hueskin);
gamutlab = Gtk::manage (new Gtk::CheckButton (M("TP_DIRPYREQUALIZER_GAMUT")));
gamutlab->set_active (true);
pack_start(*gamutlab);
gamutlabConn = gamutlab->signal_toggled().connect( sigc::mem_fun(*this, &DirPyrEqualizer::gamutlabToggled) );
gamutlab->set_tooltip_markup (M("TP_DIRPYREQUALIZER_TOOLTIP"));
hueskin->setAdjusterListener (this);
show_all_children ();
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
}
@@ -89,22 +141,42 @@ void DirPyrEqualizer::read (const ProcParams* pp, const ParamsEdited* pedited) {
if (pedited) {
enabled->set_inconsistent (!pedited->dirpyrequalizer.enabled);
gamutlab->set_inconsistent (!pedited->dirpyrequalizer.gamutlab);
for(int i = 0; i < 5; i++) {
multiplier[i]->setEditedState (pedited->dirpyrequalizer.mult[i] ? Edited : UnEdited);
}
threshold->setEditedState (pedited->dirpyrequalizer.threshold ? Edited : UnEdited);
skinprotect->setEditedState (pedited->dirpyrequalizer.skinprotect ? Edited : UnEdited);
hueskin->setEditedState (pedited->dirpyrequalizer.hueskin ? Edited : UnEdited);
}
enaConn.block (true);
enabled->set_active (pp->dirpyrequalizer.enabled);
enaConn.block (false);
lastEnabled = pp->dirpyrequalizer.enabled;
/*
algoconn.block(true);
if (pedited && !pedited->dirpyrequalizer.algo)
algo->set_active (2);
else if (pp->dirpyrequalizer.algo=="FI")
algo->set_active (0);
else if (pp->dirpyrequalizer.algo=="LA")
algo->set_active (1);
algoconn.block(false);
algoChanged();
*/
gamutlabConn.block (true);
gamutlab->set_active (pp->dirpyrequalizer.gamutlab);
gamutlabConn.block (false);
lastgamutlab = pp->dirpyrequalizer.gamutlab;
for (int i = 0; i < 5; i++) {
multiplier[i]->setValue(pp->dirpyrequalizer.mult[i]);
}
threshold->setValue(pp->dirpyrequalizer.threshold);
skinprotect->setValue(pp->dirpyrequalizer.skinprotect);
hueskin->setValue<int>(pp->dirpyrequalizer.hueskin);
enableListener ();
}
@@ -112,44 +184,72 @@ void DirPyrEqualizer::read (const ProcParams* pp, const ParamsEdited* pedited) {
void DirPyrEqualizer::write (ProcParams* pp, ParamsEdited* pedited) {
pp->dirpyrequalizer.enabled = enabled->get_active ();
pp->dirpyrequalizer.gamutlab = gamutlab->get_active ();
pp->dirpyrequalizer.hueskin = hueskin->getValue<int> ();
for (int i = 0; i < 5; i++) {
pp->dirpyrequalizer.mult[i] = multiplier[i]->getValue();
}
pp->dirpyrequalizer.threshold = threshold->getValue();
pp->dirpyrequalizer.skinprotect = skinprotect->getValue();
if (pedited) {
pedited->dirpyrequalizer.enabled = !enabled->get_inconsistent();
pedited->dirpyrequalizer.hueskin = hueskin->getEditedState ();
for(int i = 0; i < 5; i++) {
pedited->dirpyrequalizer.mult[i] = multiplier[i]->getEditedState();
}
pedited->dirpyrequalizer.threshold = threshold->getEditedState();
pedited->dirpyrequalizer.skinprotect = skinprotect->getEditedState();
// pedited->dirpyrequalizer.algo = algo->get_active_text()!=M("GENERAL_UNCHANGED");
}
/* if (algo->get_active_row_number()==0)
pp->dirpyrequalizer.algo = "FI";
else if (algo->get_active_row_number()==1)
pp->dirpyrequalizer.algo = "LA";
*/
}
/*
void DirPyrEqualizer::algoChanged () {
if (listener && (multiImage||enabled->get_active()) ) {
listener->panelChanged (EvDirPyrEqualizeralg, algo->get_active_text ());}
}
*/
void DirPyrEqualizer::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited) {
for (int i = 0; i < 5; i++) {
multiplier[i]->setDefault(defParams->dirpyrequalizer.mult[i]);
}
threshold->setDefault(defParams->dirpyrequalizer.threshold);
hueskin->setDefault<int> (defParams->dirpyrequalizer.hueskin);
if (pedited) {
for (int i = 0; i < 5; i++) {
multiplier[i]->setDefaultEditedState(pedited->dirpyrequalizer.mult[i] ? Edited : UnEdited);
}
threshold->setDefaultEditedState(pedited->dirpyrequalizer.threshold ? Edited : UnEdited);
skinprotect->setDefaultEditedState(pedited->dirpyrequalizer.skinprotect ? Edited : UnEdited);
hueskin->setDefaultEditedState (pedited->dirpyrequalizer.hueskin ? Edited : UnEdited);
}
else {
for (int i = 0; i < 5; i++) {
multiplier[i]->setDefaultEditedState(Irrelevant);
}
threshold->setDefaultEditedState(Irrelevant);
skinprotect->setDefaultEditedState(Irrelevant);
hueskin->setDefaultEditedState (Irrelevant);
}
}
void DirPyrEqualizer::adjusterChanged (ThresholdAdjuster* a, int newBottomLeft, int newTopLeft, int newBottomRight, int newTopRight) {
if (listener && (multiImage||enabled->get_active()) ) {
listener->panelChanged (EvDirPyrEqualizerHueskin, hueskin->getHistoryString());
}
}
void DirPyrEqualizer::setBatchMode (bool batchMode) {
ToolPanel::setBatchMode (batchMode);
@@ -158,6 +258,9 @@ void DirPyrEqualizer::setBatchMode (bool batchMode) {
multiplier[i]->showEditedCB();
}
threshold->showEditedCB();
skinprotect->showEditedCB();
hueskin->showEditedCB ();
// algo->append_text (M("GENERAL_UNCHANGED"));
}
void DirPyrEqualizer::adjusterChanged (Adjuster* a, double newval) {
@@ -169,6 +272,12 @@ void DirPyrEqualizer::adjusterChanged (Adjuster* a, double newval) {
Glib::ustring::format(std::fixed, std::setprecision(2), threshold->getValue()))
);
}
else if (a == skinprotect) {
listener->panelChanged (EvDirPyrEqualizerSkin,
Glib::ustring::compose("%1",
Glib::ustring::format(std::fixed, std::setprecision(2), skinprotect->getValue()))
);
}
else {
listener->panelChanged (EvDirPyrEqualizer,
Glib::ustring::compose("%1, %2, %3, %4, %5",
@@ -179,7 +288,7 @@ void DirPyrEqualizer::adjusterChanged (Adjuster* a, double newval) {
Glib::ustring::format(std::fixed, std::setprecision(2), multiplier[4]->getValue()))
);
}
}
}
}
void DirPyrEqualizer::enabledToggled () {
@@ -205,6 +314,28 @@ void DirPyrEqualizer::enabledToggled () {
}
}
void DirPyrEqualizer::gamutlabToggled () {
if (batchMode) {
if (gamutlab->get_inconsistent()) {
gamutlab->set_inconsistent (false);
gamutlabConn.block (true);
gamutlab->set_active (false);
gamutlabConn.block (false);
}
else if (lastgamutlab)
gamutlab->set_inconsistent (true);
lastgamutlab = gamutlab->get_active ();
}
if (listener) {
if (gamutlab->get_active ())
listener->panelChanged (EvDirPyrEqlgamutlab, M("GENERAL_ENABLED"));
else
listener->panelChanged (EvDirPyrEqlgamutlab, M("GENERAL_DISABLED"));
}
}
void DirPyrEqualizer::lumaneutralPressed () {
@@ -234,11 +365,12 @@ void DirPyrEqualizer::lumacontrastMinusPressed () {
}
}
void DirPyrEqualizer::setAdjusterBehavior (bool multiplieradd, bool thresholdadd) {
void DirPyrEqualizer::setAdjusterBehavior (bool multiplieradd, bool thresholdadd, bool skinadd) {
for (int i=0; i<5; i++)
multiplier[i]->setAddMode(multiplieradd);
threshold->setAddMode(thresholdadd);
skinprotect->setAddMode(skinadd);
}
void DirPyrEqualizer::trimValues (rtengine::procparams::ProcParams* pp) {
@@ -246,4 +378,5 @@ void DirPyrEqualizer::trimValues (rtengine::procparams::ProcParams* pp) {
for (int i=0; i<5; i++)
multiplier[i]->trimValue(pp->dirpyrequalizer.mult[i]);
threshold->trimValue(pp->dirpyrequalizer.threshold);
skinprotect->trimValue(pp->dirpyrequalizer.skinprotect);
}