diff --git a/rtengine/rawimagesource.cc b/rtengine/rawimagesource.cc index d84c0436a..ed0fac707 100644 --- a/rtengine/rawimagesource.cc +++ b/rtengine/rawimagesource.cc @@ -4992,13 +4992,14 @@ BENCHFUN array2D& Y = red; // red will be overridden anyway => we can use its buffer to store Y array2D& Cb = green; // green will be overridden anyway => we can use its buffer to store Cb array2D& Cr = blue; // blue will be overridden anyway => we can use its buffer to store Cr - const float gamma = sharpeningParams.gamma; StopWatch Stop1("rgb2Y"); +#ifdef _OPENMP #pragma omp parallel for +#endif for (int i = 0; i < H; ++i) { Color::RGB2L(red[i], green[i], blue[i], L[i], xyz_rgb, W); - Color::RGB2YCbCr(red[i], green[i], blue[i], Y[i], Cb[i], Cr[i], gamma, W); + Color::RGB2YCbCr(red[i], green[i], blue[i], Y[i], Cb[i], Cr[i], sharpeningParams.gamma, W); } // calculate contrast based blend factors to reduce sharpening in regions with low contrast JaggedArray blend(W, H); @@ -5011,9 +5012,11 @@ BENCHFUN ImProcFunctions ipf(&dummy); ipf.deconvsharpening(Y, tmp, blend, W, H, sharpeningParams, 1.0); StopWatch Stop2("Y2RGB"); +#ifdef _OPENMP #pragma omp parallel for +#endif for (int i = 0; i < H; ++i) { - Color::YCbCr2RGB(Y[i], Cb[i], Cr[i], red[i], green[i], blue[i], gamma, W); + Color::YCbCr2RGB(Y[i], Cb[i], Cr[i], red[i], green[i], blue[i], sharpeningParams.gamma, W); } Stop2.stop(); } diff --git a/rtgui/batchtoolpanelcoord.cc b/rtgui/batchtoolpanelcoord.cc index 1a0eaeb28..62867996e 100644 --- a/rtgui/batchtoolpanelcoord.cc +++ b/rtgui/batchtoolpanelcoord.cc @@ -152,6 +152,7 @@ void BatchToolPanelCoordinator::initSession () cacorrection->setAdjusterBehavior (false); sharpening->setAdjusterBehavior (false, false, false, false, false, false, false); prsharpening->setAdjusterBehavior (false, false, false, false, false, false, false); + pdSharpening->setAdjusterBehavior (false, false, false, false); sharpenEdge->setAdjusterBehavior (false, false); sharpenMicro->setAdjusterBehavior (false, false, false); epd->setAdjusterBehavior (false, false, false, false, false); diff --git a/rtgui/pdsharpening.cc b/rtgui/pdsharpening.cc index 43b32ce7e..1151684e7 100644 --- a/rtgui/pdsharpening.cc +++ b/rtgui/pdsharpening.cc @@ -1,7 +1,7 @@ /* * This file is part of RawTherapee. * - * Copyright (c) 2004-2010 Gabor Horvath + * Copyright (c) 2019 Ingo Weyrich (heckflosse67@gmx.de) * * RawTherapee is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -15,7 +15,8 @@ * * You should have received a copy of the GNU General Public License * along with RawTherapee. If not, see . - */ +*/ + #include #include "eventmapper.h" #include "pdsharpening.h" @@ -25,7 +26,7 @@ using namespace rtengine; using namespace rtengine::procparams; -PdSharpening::PdSharpening () : FoldableToolPanel(this, "pdsharpening", M("TP_PDSHARPENING_LABEL"), false, true) +PdSharpening::PdSharpening() : FoldableToolPanel(this, "pdsharpening", M("TP_PDSHARPENING_LABEL"), false, true) { auto m = ProcEventMapper::getInstance(); @@ -35,177 +36,164 @@ PdSharpening::PdSharpening () : FoldableToolPanel(this, "pdsharpening", M("TP_PD EvPdShrDIterations = m->newEvent(DEMOSAIC, "HISTORY_MSG_PDSHARPEN_ITERATIONS"); EvPdShrAutoContrast = m->newEvent(DEMOSAIC, "HISTORY_MSG_PDSHARPEN_AUTO_CONTRAST"); - Gtk::HBox* hb = Gtk::manage (new Gtk::HBox ()); - hb->show (); - contrast = Gtk::manage(new Adjuster (M("TP_SHARPENING_CONTRAST"), 0, 200, 1, 10)); - contrast->setAdjusterListener (this); + Gtk::HBox* hb = Gtk::manage(new Gtk::HBox()); + hb->show(); + contrast = Gtk::manage(new Adjuster(M("TP_SHARPENING_CONTRAST"), 0, 200, 1, 10)); + contrast->setAdjusterListener(this); contrast->addAutoButton(M("TP_RAW_DUALDEMOSAICAUTOCONTRAST_TOOLTIP")); contrast->setAutoValue(true); pack_start(*contrast); contrast->show(); - pack_start (*hb); + pack_start(*hb); - rld = new Gtk::VBox (); - gamma = Gtk::manage (new Adjuster (M("TP_SHARPENING_GAMMA"), 0.5, 3.0, 0.05, 1.35)); - dradius = Gtk::manage (new Adjuster (M("TP_SHARPENING_EDRADIUS"), 0.4, 2.5, 0.01, 0.75)); - diter = Gtk::manage (new Adjuster (M("TP_SHARPENING_RLD_ITERATIONS"), 5, 100, 1, 30)); - rld->pack_start (*gamma); - rld->pack_start (*dradius); - rld->pack_start (*diter); + Gtk::VBox* rld = Gtk::manage(new Gtk::VBox()); + gamma = Gtk::manage(new Adjuster(M("TP_SHARPENING_GAMMA"), 0.5, 3.0, 0.05, 1.35)); + dradius = Gtk::manage(new Adjuster(M("TP_SHARPENING_EDRADIUS"), 0.4, 2.5, 0.01, 0.75)); + diter = Gtk::manage(new Adjuster(M("TP_SHARPENING_RLD_ITERATIONS"), 5, 100, 1, 30)); + rld->pack_start(*gamma); + rld->pack_start(*dradius); + rld->pack_start(*diter); gamma->show(); - dradius->show (); - diter->show (); - rld->show (); + dradius->show(); + diter->show(); + rld->show(); pack_start(*rld); - dradius->setAdjusterListener (this); - gamma->setAdjusterListener (this); - diter->setAdjusterListener (this); + dradius->setAdjusterListener(this); + gamma->setAdjusterListener(this); + diter->setAdjusterListener(this); - if (contrast->delay < options.adjusterMaxDelay) { - contrast->delay = options.adjusterMaxDelay; - } - if (dradius->delay < options.adjusterMaxDelay) { - dradius->delay = options.adjusterMaxDelay; - } - if (gamma->delay < options.adjusterMaxDelay) { - gamma->delay = options.adjusterMaxDelay; - } - if (diter->delay < options.adjusterMaxDelay) { - diter->delay = options.adjusterMaxDelay; - } - - rld->reference(); + contrast->delay = std::max(contrast->delay, options.adjusterMaxDelay); + dradius->delay = std::max(dradius->delay, options.adjusterMaxDelay); + gamma->delay = std::max(gamma->delay, options.adjusterMaxDelay); + diter->delay = std::max(diter->delay, options.adjusterMaxDelay); } -PdSharpening::~PdSharpening () +PdSharpening::~PdSharpening() { idle_register.destroy(); - delete rld; } -void PdSharpening::read (const ProcParams* pp, const ParamsEdited* pedited) +void PdSharpening::read(const ProcParams* pp, const ParamsEdited* pedited) { - disableListener (); + disableListener(); if (pedited) { - contrast->setEditedState (pedited->pdsharpening.contrast ? Edited : UnEdited); - contrast->setAutoInconsistent (multiImage && !pedited->pdsharpening.autoContrast); - gamma->setEditedState (pedited->pdsharpening.gamma ? Edited : UnEdited); - dradius->setEditedState (pedited->pdsharpening.deconvradius ? Edited : UnEdited); - diter->setEditedState (pedited->pdsharpening.deconviter ? Edited : UnEdited); + contrast->setEditedState(pedited->pdsharpening.contrast ? Edited : UnEdited); + contrast->setAutoInconsistent(multiImage && !pedited->pdsharpening.autoContrast); + gamma->setEditedState(pedited->pdsharpening.gamma ? Edited : UnEdited); + dradius->setEditedState(pedited->pdsharpening.deconvradius ? Edited : UnEdited); + diter->setEditedState(pedited->pdsharpening.deconviter ? Edited : UnEdited); - set_inconsistent (multiImage && !pedited->pdsharpening.enabled); + set_inconsistent(multiImage && !pedited->pdsharpening.enabled); } setEnabled(pp->pdsharpening.enabled); - contrast->setValue (pp->pdsharpening.contrast); - contrast->setAutoValue (pp->pdsharpening.autoContrast); - gamma->setValue (pp->pdsharpening.gamma); - dradius->setValue (pp->pdsharpening.deconvradius); - diter->setValue (pp->pdsharpening.deconviter); + contrast->setValue(pp->pdsharpening.contrast); + contrast->setAutoValue(pp->pdsharpening.autoContrast); + gamma->setValue(pp->pdsharpening.gamma); + dradius->setValue(pp->pdsharpening.deconvradius); + diter->setValue(pp->pdsharpening.deconviter); lastAutoContrast = pp->pdsharpening.autoContrast; - enableListener (); + enableListener(); } -void PdSharpening::write (ProcParams* pp, ParamsEdited* pedited) +void PdSharpening::write(ProcParams* pp, ParamsEdited* pedited) { - pp->pdsharpening.contrast = contrast->getValue (); + pp->pdsharpening.contrast = contrast->getValue(); pp->pdsharpening.autoContrast = contrast->getAutoValue(); - pp->pdsharpening.enabled = getEnabled (); - pp->pdsharpening.gamma = gamma->getValue (); - pp->pdsharpening.deconvradius = dradius->getValue (); - pp->pdsharpening.deconviter = (int)diter->getValue (); + pp->pdsharpening.enabled = getEnabled(); + pp->pdsharpening.gamma = gamma->getValue(); + pp->pdsharpening.deconvradius = dradius->getValue(); + pp->pdsharpening.deconviter =(int)diter->getValue(); if (pedited) { - pedited->pdsharpening.contrast = contrast->getEditedState (); - pedited->pdsharpening.autoContrast = !contrast->getAutoInconsistent (); - pedited->pdsharpening.gamma = gamma->getEditedState (); - pedited->pdsharpening.deconvradius = dradius->getEditedState (); - pedited->pdsharpening.deconviter = diter->getEditedState (); - pedited->pdsharpening.enabled = !get_inconsistent(); + pedited->pdsharpening.contrast = contrast->getEditedState(); + pedited->pdsharpening.autoContrast = !contrast->getAutoInconsistent(); + pedited->pdsharpening.gamma = gamma->getEditedState(); + pedited->pdsharpening.deconvradius = dradius->getEditedState(); + pedited->pdsharpening.deconviter = diter->getEditedState(); + pedited->pdsharpening.enabled = !get_inconsistent(); } } -void PdSharpening::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited) +void PdSharpening::setDefaults(const ProcParams* defParams, const ParamsEdited* pedited) { - contrast->setDefault (defParams->pdsharpening.contrast); - gamma->setDefault (defParams->pdsharpening.gamma); - dradius->setDefault (defParams->pdsharpening.deconvradius); - diter->setDefault (defParams->pdsharpening.deconviter); + contrast->setDefault(defParams->pdsharpening.contrast); + gamma->setDefault(defParams->pdsharpening.gamma); + dradius->setDefault(defParams->pdsharpening.deconvradius); + diter->setDefault(defParams->pdsharpening.deconviter); if (pedited) { - contrast->setDefaultEditedState (pedited->pdsharpening.contrast ? Edited : UnEdited); - gamma->setDefaultEditedState (pedited->pdsharpening.gamma ? Edited : UnEdited); - dradius->setDefaultEditedState (pedited->pdsharpening.deconvradius ? Edited : UnEdited); - diter->setDefaultEditedState (pedited->pdsharpening.deconviter ? Edited : UnEdited); + contrast->setDefaultEditedState(pedited->pdsharpening.contrast ? Edited : UnEdited); + gamma->setDefaultEditedState(pedited->pdsharpening.gamma ? Edited : UnEdited); + dradius->setDefaultEditedState(pedited->pdsharpening.deconvradius ? Edited : UnEdited); + diter->setDefaultEditedState(pedited->pdsharpening.deconviter ? Edited : UnEdited); } else { - contrast->setDefaultEditedState (Irrelevant); - gamma->setDefaultEditedState (Irrelevant); - dradius->setDefaultEditedState (Irrelevant); - diter->setDefaultEditedState (Irrelevant); + contrast->setDefaultEditedState(Irrelevant); + gamma->setDefaultEditedState(Irrelevant); + dradius->setDefaultEditedState(Irrelevant); + diter->setDefaultEditedState(Irrelevant); } } -void PdSharpening::adjusterChanged (Adjuster* a, double newval) +void PdSharpening::adjusterChanged(Adjuster* a, double newval) { - if (listener && (multiImage || getEnabled()) ) { + if (listener && (multiImage || getEnabled())) { Glib::ustring costr; if (a == gamma || a == dradius) { - costr = Glib::ustring::format (std::setw(3), std::fixed, std::setprecision(2), a->getValue()); + costr = Glib::ustring::format(std::setw(3), std::fixed, std::setprecision(2), a->getValue()); } else { - costr = Glib::ustring::format ((int)a->getValue()); + costr = Glib::ustring::format((int)a->getValue()); } if (a == contrast) { - listener->panelChanged (EvPdShrContrast, costr); + listener->panelChanged(EvPdShrContrast, costr); } else if (a == gamma) { - listener->panelChanged (EvPdSharpenGamma, costr); + listener->panelChanged(EvPdSharpenGamma, costr); } else if (a == dradius) { - listener->panelChanged (EvPdShrDRadius, costr); + listener->panelChanged(EvPdShrDRadius, costr); } else if (a == diter) { - listener->panelChanged (EvPdShrDIterations, costr); + listener->panelChanged(EvPdShrDIterations, costr); } } } -void PdSharpening::enabledChanged () +void PdSharpening::enabledChanged() { if (listener) { if (get_inconsistent()) { - listener->panelChanged (EvPdShrEnabled, M("GENERAL_UNCHANGED")); + listener->panelChanged(EvPdShrEnabled, M("GENERAL_UNCHANGED")); } else if (getEnabled()) { - listener->panelChanged (EvPdShrEnabled, M("GENERAL_ENABLED")); + listener->panelChanged(EvPdShrEnabled, M("GENERAL_ENABLED")); } else { - listener->panelChanged (EvPdShrEnabled, M("GENERAL_DISABLED")); + listener->panelChanged(EvPdShrEnabled, M("GENERAL_DISABLED")); } } } -void PdSharpening::setBatchMode (bool batchMode) +void PdSharpening::setBatchMode(bool batchMode) { - ToolPanel::setBatchMode (batchMode); + ToolPanel::setBatchMode(batchMode); -// pack_start (*rld); - - contrast->showEditedCB (); - gamma->showEditedCB (); - dradius->showEditedCB (); - diter->showEditedCB (); + contrast->showEditedCB(); + gamma->showEditedCB(); + dradius->showEditedCB(); + diter->showEditedCB(); } -void PdSharpening::setAdjusterBehavior (bool contrastadd, bool gammaadd, bool radiusadd, bool amountadd, bool dampingadd, bool iteradd, bool edgetoladd, bool haloctrladd) +void PdSharpening::setAdjusterBehavior(bool contrastadd, bool gammaadd, bool radiusadd, bool iteradd) { contrast->setAddMode(contrastadd); @@ -214,7 +202,7 @@ void PdSharpening::setAdjusterBehavior (bool contrastadd, bool gammaadd, bool ra diter->setAddMode(iteradd); } -void PdSharpening::trimValues (rtengine::procparams::ProcParams* pp) +void PdSharpening::trimValues(rtengine::procparams::ProcParams* pp) { contrast->trimValue(pp->pdsharpening.contrast); @@ -223,7 +211,7 @@ void PdSharpening::trimValues (rtengine::procparams::ProcParams* pp) diter->trimValue(pp->pdsharpening.deconviter); } -void PdSharpening::autoContrastChanged (double autoContrast) +void PdSharpening::autoContrastChanged(double autoContrast) { idle_register.add( [this, autoContrast]() -> bool @@ -240,25 +228,22 @@ void PdSharpening::adjusterAutoToggled(Adjuster* a, bool newval) { if (multiImage) { if (contrast->getAutoInconsistent()) { - contrast->setAutoInconsistent (false); - contrast->setAutoValue (false); + contrast->setAutoInconsistent(false); + contrast->setAutoValue(false); } else if (lastAutoContrast) { - contrast->setAutoInconsistent (true); + contrast->setAutoInconsistent(true); } lastAutoContrast = contrast->getAutoValue(); } if (listener) { - - if (a == contrast) { - if (contrast->getAutoInconsistent()) { - listener->panelChanged (EvPdShrAutoContrast, M ("GENERAL_UNCHANGED")); - } else if (contrast->getAutoValue()) { - listener->panelChanged (EvPdShrAutoContrast, M ("GENERAL_ENABLED")); - } else { - listener->panelChanged (EvPdShrAutoContrast, M ("GENERAL_DISABLED")); - } + if (contrast->getAutoInconsistent()) { + listener->panelChanged(EvPdShrAutoContrast, M("GENERAL_UNCHANGED")); + } else if (contrast->getAutoValue()) { + listener->panelChanged(EvPdShrAutoContrast, M("GENERAL_ENABLED")); + } else { + listener->panelChanged(EvPdShrAutoContrast, M("GENERAL_DISABLED")); } } } diff --git a/rtgui/pdsharpening.h b/rtgui/pdsharpening.h index af09a9b6b..b2f7b6e57 100644 --- a/rtgui/pdsharpening.h +++ b/rtgui/pdsharpening.h @@ -15,14 +15,13 @@ * * You should have received a copy of the GNU General Public License * along with RawTherapee. If not, see . - */ +*/ #pragma once -#include #include "adjuster.h" #include "toolpanel.h" -class PdSharpening : public ToolParamBlock, public AdjusterListener, public FoldableToolPanel, public rtengine::AutoContrastListener +class PdSharpening final : public ToolParamBlock, public AdjusterListener, public FoldableToolPanel, public rtengine::AutoContrastListener { protected: @@ -30,7 +29,7 @@ protected: Adjuster* gamma; Adjuster* dradius; Adjuster* diter; - Gtk::VBox* rld; + bool lastAutoContrast; rtengine::ProcEvent EvPdShrContrast; rtengine::ProcEvent EvPdShrDRadius; @@ -44,17 +43,17 @@ public: PdSharpening (); ~PdSharpening () override; - void read (const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited = nullptr) override; - void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited = nullptr) override; - void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override; - void setBatchMode (bool batchMode) override; + void read (const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited = nullptr) override; + void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited = nullptr) override; + void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited = nullptr) override; + void setBatchMode (bool batchMode) override; void adjusterAutoToggled (Adjuster* a, bool newval) override; void adjusterChanged (Adjuster* a, double newval) override; - void enabledChanged () override; + void enabledChanged () override; void autoContrastChanged (double autoContrast) override; - void setAdjusterBehavior (bool contrastadd, bool gammaadd, bool radiusadd, bool amountadd, bool dampingadd, bool iteradd, bool edgetoladd, bool haloctrladd); - void trimValues (rtengine::procparams::ProcParams* pp) override; + void setAdjusterBehavior (bool contrastadd, bool gammaadd, bool radiusadd, bool iteradds); + void trimValues (rtengine::procparams::ProcParams* pp) override; };