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

Merge branch 'dev' into new-shadows-highlights

Browse Source
This commit is contained in:
heckflosse
2018-04-26 15:10:58 +02:00
parent c45ec6f16e 5374afe6a7
commit 63f3b2f86f
88 changed files with 1518 additions and 2541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

377
rtgui/bayerprocess.cc
View File

@@ -130,11 +130,6 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
pixelShiftShowMotionMaskOnly->set_tooltip_text (M("TP_RAW_PIXELSHIFTSHOWMOTIONMASKONLY_TOOLTIP"));
pixelShiftFrame->pack_start(*pixelShiftShowMotionMaskOnly);
#ifdef PIXELSHIFTDEV
pixelShiftAutomatic = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTADAPTIVE"), multiImage));
pixelShiftAutomatic->setCheckBoxListener (this);
pixelShiftOptions->pack_start(*pixelShiftAutomatic);
#endif
pixelShiftGreen = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTGREEN"), multiImage));
pixelShiftGreen->setCheckBoxListener (this);
pixelShiftOptions->pack_start(*pixelShiftGreen);
@@ -194,139 +189,11 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
pixelShiftOptions->pack_start(*pixelShiftMedian);
#ifdef PIXELSHIFTDEV
pixelShiftMedian3 = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTMEDIAN3"), multiImage));
pixelShiftMedian3->setCheckBoxListener (this);
pixelShiftMedian3->set_tooltip_text (M("TP_RAW_PIXELSHIFTMEDIAN3_TOOLTIP"));
pixelShiftOptions->pack_start(*pixelShiftMedian3);
pixelShiftNonGreenCross2 = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTNONGREENCROSS2"), multiImage));
pixelShiftNonGreenCross2->setCheckBoxListener (this);
pixelShiftOptions->pack_start(*pixelShiftNonGreenCross2);
pixelShiftNonGreenAmaze = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTNONGREENAMAZE"), multiImage));
pixelShiftNonGreenAmaze->setCheckBoxListener (this);
pixelShiftOptions->pack_start(*pixelShiftNonGreenAmaze);
pixelShiftNonGreenHorizontal = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTNONGREENHORIZONTAL"), multiImage));
pixelShiftNonGreenHorizontal->setCheckBoxListener (this);
pixelShiftOptions->pack_start(*pixelShiftNonGreenHorizontal);
pixelShiftNonGreenVertical = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTNONGREENVERTICAL"), multiImage));
pixelShiftNonGreenVertical->setCheckBoxListener (this);
pixelShiftOptions->pack_start(*pixelShiftNonGreenVertical);
pixelShiftExp0 = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTEXP0"), multiImage));
pixelShiftExp0->setCheckBoxListener (this);
pixelShiftOptions->pack_start(*pixelShiftExp0);
#endif
pixelShiftLmmse = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTLMMSE"), multiImage));
pixelShiftLmmse->setCheckBoxListener (this);
pixelShiftLmmse->set_tooltip_text (M("TP_RAW_PIXELSHIFTLMMSE_TOOLTIP"));
pixelShiftOptions->pack_start(*pixelShiftLmmse);
// pixelShiftOneGreen = Gtk::manage (new CheckBox(M("TP_RAW_PIXELSHIFTONEGREEN"), multiImage));
// pixelShiftOneGreen->setCheckBoxListener (this);
// pixelShiftOneGreen->set_tooltip_text (M("TP_RAW_PIXELSHIFTONEGREEN_TOOLTIP"));
// pixelShiftOptions->pack_start(*pixelShiftOneGreen);
#ifdef PIXELSHIFTDEV
pixelShiftMotion = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTMOTION"), 0, 100, 1, 70));
pixelShiftMotion->setAdjusterListener (this);
pixelShiftMotion->set_tooltip_text (M("TP_RAW_PIXELSHIFTMOTION_TOOLTIP"));
if (pixelShiftMotion->delay < options.adjusterMaxDelay) {
pixelShiftMotion->delay = options.adjusterMaxDelay;
}
pixelShiftMotion->show();
pixelShiftOptions->pack_start(*pixelShiftMotion);
Gtk::HBox* hb2 = Gtk::manage (new Gtk::HBox ());
hb2->pack_start (*Gtk::manage (new Gtk::Label ( M("TP_RAW_PIXELSHIFTMOTIONCORRECTION") + ": ")), Gtk::PACK_SHRINK, 0);
pixelShiftMotionCorrection = Gtk::manage (new MyComboBoxText ());
pixelShiftMotionCorrection->append("1x1");
pixelShiftMotionCorrection->append("1x2");
pixelShiftMotionCorrection->append("3x3");
pixelShiftMotionCorrection->append("5x5");
pixelShiftMotionCorrection->append("7x7");
pixelShiftMotionCorrection->append("3x3 new");
pixelShiftMotionCorrection->set_active(0);
pixelShiftMotionCorrection->show();
hb2->pack_start(*pixelShiftMotionCorrection);
pixelShiftOptions->pack_start(*hb2);
pixelShiftStddevFactorGreen = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTSTDDEVFACTORGREEN"), 2, 8, 0.1, 5));
pixelShiftStddevFactorGreen->setAdjusterListener (this);
if (pixelShiftStddevFactorGreen->delay < options.adjusterMaxDelay) {
pixelShiftStddevFactorGreen->delay = options.adjusterMaxDelay;
}
pixelShiftStddevFactorGreen->show();
pixelShiftOptions->pack_start(*pixelShiftStddevFactorGreen);
pixelShiftStddevFactorRed = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTSTDDEVFACTORRED"), 1, 8, 0.1, 5));
pixelShiftStddevFactorRed->setAdjusterListener (this);
if (pixelShiftStddevFactorRed->delay < options.adjusterMaxDelay) {
pixelShiftStddevFactorRed->delay = options.adjusterMaxDelay;
}
pixelShiftStddevFactorRed->show();
pixelShiftOptions->pack_start(*pixelShiftStddevFactorRed);
pixelShiftStddevFactorBlue = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTSTDDEVFACTORBLUE"), 1, 8, 0.1, 5));
pixelShiftStddevFactorBlue->setAdjusterListener (this);
if (pixelShiftStddevFactorBlue->delay < options.adjusterMaxDelay) {
pixelShiftStddevFactorBlue->delay = options.adjusterMaxDelay;
}
pixelShiftStddevFactorBlue->show();
pixelShiftOptions->pack_start(*pixelShiftStddevFactorBlue);
#endif
#ifdef PIXELSHIFTDEV
pixelShiftNreadIso = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTNREADISO"), -2.0, 2.0, 0.05, 0.0));
pixelShiftNreadIso->setAdjusterListener (this);
if (pixelShiftNreadIso->delay < options.adjusterMaxDelay) {
pixelShiftNreadIso->delay = options.adjusterMaxDelay;
}
pixelShiftNreadIso->show();
pixelShiftOptions->pack_start(*pixelShiftNreadIso);
pixelShiftPrnu = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTPRNU"), 0.3, 2.0, 0.1, 1.0));
pixelShiftPrnu->setAdjusterListener (this);
if (pixelShiftPrnu->delay < options.adjusterMaxDelay) {
pixelShiftPrnu->delay = options.adjusterMaxDelay;
}
pixelShiftPrnu->show();
pixelShiftOptions->pack_start(*pixelShiftPrnu);
pixelShiftSum = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTMASKTHRESHOLD"), 1.0, 8.0, 0.1, 3.0));
pixelShiftSum->setAdjusterListener (this);
if (pixelShiftSum->delay < options.adjusterMaxDelay) {
pixelShiftSum->delay = options.adjusterMaxDelay;
}
pixelShiftSum->show();
pixelShiftOptions->pack_start(*pixelShiftSum);
pixelShiftRedBlueWeight = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTREDBLUEWEIGHT"), 0.1, 1.0, 0.1, 0.7));
pixelShiftRedBlueWeight->setAdjusterListener (this);
if (pixelShiftRedBlueWeight->delay < options.adjusterMaxDelay) {
pixelShiftRedBlueWeight->delay = options.adjusterMaxDelay;
}
pixelShiftRedBlueWeight->show();
pixelShiftOptions->pack_start(*pixelShiftRedBlueWeight);
#endif
pixelShiftFrame->pack_start(*pixelShiftOptions);
pixelShiftOptions->hide();
@@ -336,9 +203,6 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
method->connect(method->signal_changed().connect( sigc::mem_fun(*this, &BayerProcess::methodChanged) ));
imageNumber->connect(imageNumber->signal_changed().connect( sigc::mem_fun(*this, &BayerProcess::imageNumberChanged) ));
pixelShiftMotionMethod->connect(pixelShiftMotionMethod->signal_changed().connect( sigc::mem_fun(*this, &BayerProcess::pixelShiftMotionMethodChanged) ));
#ifdef PIXELSHIFTDEV
pixelShiftMotionCorrection->connect(pixelShiftMotionCorrection->signal_changed().connect( sigc::mem_fun(*this, &BayerProcess::psMotionCorrectionChanged) ));
#endif
}
@@ -348,9 +212,6 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
method->block (true);
imageNumber->block (true);
//allEnhconn.block (true);
#ifdef PIXELSHIFTDEV
pixelShiftMotionCorrection->block (true);
#endif
method->set_active(std::numeric_limits<int>::max());
imageNumber->set_active(pp->raw.bayersensor.imageNum);
@@ -381,7 +242,6 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
}
pixelShiftSmooth->setValue (pp->raw.bayersensor.pixelShiftSmoothFactor);
pixelShiftLmmse->setValue (pp->raw.bayersensor.pixelShiftLmmse);
// pixelShiftOneGreen->setValue (pp->raw.bayersensor.pixelShiftOneGreen);
pixelShiftEqualBright->setValue (pp->raw.bayersensor.pixelShiftEqualBright);
pixelShiftEqualBrightChannel->set_sensitive (pp->raw.bayersensor.pixelShiftEqualBright);
pixelShiftEqualBrightChannel->setValue (pp->raw.bayersensor.pixelShiftEqualBrightChannel);
@@ -394,32 +254,6 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
if (!batchMode) {
pixelShiftSigma->set_sensitive (pp->raw.bayersensor.pixelShiftBlur);
}
#ifdef PIXELSHIFTDEV
pixelShiftStddevFactorGreen->setValue (pp->raw.bayersensor.pixelShiftStddevFactorGreen);
pixelShiftStddevFactorRed->setValue (pp->raw.bayersensor.pixelShiftStddevFactorRed);
pixelShiftStddevFactorBlue->setValue (pp->raw.bayersensor.pixelShiftStddevFactorBlue);
pixelShiftSum->setValue (pp->raw.bayersensor.pixelShiftSum);
pixelShiftMedian3->setValue (pp->raw.bayersensor.pixelShiftMedian3);
if (!batchMode) {
pixelShiftMedian3->set_sensitive (pixelShiftMedian->getValue() != CheckValue::off);
}
pixelShiftAutomatic->setValue (pp->raw.bayersensor.pixelShiftAutomatic);
pixelShiftNonGreenHorizontal->setValue (pp->raw.bayersensor.pixelShiftNonGreenHorizontal);
pixelShiftNonGreenVertical->setValue (pp->raw.bayersensor.pixelShiftNonGreenVertical);
pixelShiftExp0->setValue (pp->raw.bayersensor.pixelShiftExp0);
pixelShiftNonGreenCross2->setValue (pp->raw.bayersensor.pixelShiftNonGreenCross2);
pixelShiftNonGreenAmaze->setValue (pp->raw.bayersensor.pixelShiftNonGreenAmaze);
pixelShiftMotion->setValue (pp->raw.bayersensor.pixelShiftMotion);
pixelShiftMotionCorrection->set_active ((int)pp->raw.bayersensor.pixelShiftMotionCorrection);
if (!batchMode) {
pixelShiftHoleFill->set_sensitive (pixelShiftAutomatic->getValue () != CheckValue::off && pixelShiftMotionCorrection->get_active_row_number() == 5);
pixelShiftBlur->set_sensitive(pixelShiftAutomatic->getValue () != CheckValue::off && pixelShiftMotionCorrection->get_active_row_number() == 5);
pixelShiftSmooth->set_sensitive(pixelShiftAutomatic->getValue () != CheckValue::off && pixelShiftMotionCorrection->get_active_row_number() == 5 && pixelShiftBlur->getValue() != CheckValue::off);
}
pixelShiftNreadIso->setValue (pp->raw.bayersensor.pixelShiftNreadIso);
pixelShiftPrnu->setValue (pp->raw.bayersensor.pixelShiftPrnu);
pixelShiftRedBlueWeight->setValue (pp->raw.bayersensor.pixelShiftRedBlueWeight);
#endif
if(pedited) {
ccSteps->setEditedState (pedited->raw.bayersensor.ccSteps ? Edited : UnEdited);
@@ -433,30 +267,12 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
pixelShiftBlur->setEdited (pedited->raw.bayersensor.pixelShiftBlur);
pixelShiftSmooth->setEditedState ( pedited->raw.bayersensor.pixelShiftSmooth ? Edited : UnEdited);
pixelShiftLmmse->setEdited (pedited->raw.bayersensor.pixelShiftLmmse);
// pixelShiftOneGreen->setEdited (pedited->raw.bayersensor.pixelShiftOneGreen);
pixelShiftEqualBright->setEdited (pedited->raw.bayersensor.pixelShiftEqualBright);
pixelShiftEqualBrightChannel->setEdited (pedited->raw.bayersensor.pixelShiftEqualBrightChannel);
pixelShiftNonGreenCross->setEdited (pedited->raw.bayersensor.pixelShiftNonGreenCross);
lmmseIterations->setEditedState ( pedited->raw.bayersensor.lmmseIterations ? Edited : UnEdited);
pixelShiftEperIso->setEditedState ( pedited->raw.bayersensor.pixelShiftEperIso ? Edited : UnEdited);
pixelShiftSigma->setEditedState ( pedited->raw.bayersensor.pixelShiftSigma ? Edited : UnEdited);
#ifdef PIXELSHIFTDEV
pixelShiftNreadIso->setEditedState ( pedited->raw.bayersensor.pixelShiftNreadIso ? Edited : UnEdited);
pixelShiftPrnu->setEditedState ( pedited->raw.bayersensor.pixelShiftPrnu ? Edited : UnEdited);
pixelShiftStddevFactorGreen->setEditedState ( pedited->raw.bayersensor.pixelShiftStddevFactorGreen ? Edited : UnEdited);
pixelShiftStddevFactorRed->setEditedState ( pedited->raw.bayersensor.pixelShiftStddevFactorRed ? Edited : UnEdited);
pixelShiftStddevFactorBlue->setEditedState ( pedited->raw.bayersensor.pixelShiftStddevFactorBlue ? Edited : UnEdited);
pixelShiftSum->setEditedState ( pedited->raw.bayersensor.pixelShiftSum ? Edited : UnEdited);
pixelShiftAutomatic->setEdited (pedited->raw.bayersensor.pixelShiftAutomatic);
pixelShiftNonGreenHorizontal->setEdited (pedited->raw.bayersensor.pixelShiftNonGreenHorizontal);
pixelShiftNonGreenVertical->setEdited (pedited->raw.bayersensor.pixelShiftNonGreenVertical);
pixelShiftMedian3->setEdited (pedited->raw.bayersensor.pixelShiftMedian3);
pixelShiftExp0->setEdited (pedited->raw.bayersensor.pixelShiftExp0);
pixelShiftNonGreenCross2->setEdited (pedited->raw.bayersensor.pixelShiftNonGreenCross2);
pixelShiftNonGreenAmaze->setEdited (pedited->raw.bayersensor.pixelShiftNonGreenAmaze);
pixelShiftMotion->setEditedState ( pedited->raw.bayersensor.pixelShiftMotion ? Edited : UnEdited);
pixelShiftRedBlueWeight->setEditedState ( pedited->raw.bayersensor.pixelShiftRedBlueWeight ? Edited : UnEdited);
#endif
if(!pedited->raw.bayersensor.method) {
method->set_active(std::numeric_limits<int>::max()); // No name
@@ -464,11 +280,6 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
if(!pedited->raw.bayersensor.imageNum) {
imageNumber->set_active_text(M("GENERAL_UNCHANGED"));
}
#ifdef PIXELSHIFTDEV
if(!pedited->raw.bayersensor.pixelShiftMotionCorrection) {
pixelShiftMotionCorrection->set_active_text(M("GENERAL_UNCHANGED"));
}
#endif
if(!pedited->raw.bayersensor.pixelShiftMotionCorrectionMethod) {
pixelShiftMotionMethod->set_active_text(M("GENERAL_UNCHANGED"));
}
@@ -511,9 +322,6 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
//lastALLen = pp->raw.bayersensor.all_enhance;
method->block (false);
#ifdef PIXELSHIFTDEV
pixelShiftMotionCorrection->block (false);
#endif
imageNumber->block (false);
//allEnhconn.block (false);
@@ -538,28 +346,9 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
pp->raw.bayersensor.pixelShiftBlur = pixelShiftBlur->getLastActive ();
pp->raw.bayersensor.pixelShiftSmoothFactor = pixelShiftSmooth->getValue();
pp->raw.bayersensor.pixelShiftLmmse = pixelShiftLmmse->getLastActive ();
// pp->raw.bayersensor.pixelShiftOneGreen = pixelShiftOneGreen->getLastActive ();
pp->raw.bayersensor.pixelShiftEqualBright = pixelShiftEqualBright->getLastActive ();
pp->raw.bayersensor.pixelShiftEqualBrightChannel = pixelShiftEqualBrightChannel->getLastActive ();
pp->raw.bayersensor.pixelShiftNonGreenCross = pixelShiftNonGreenCross->getLastActive ();
#ifdef PIXELSHIFTDEV
pp->raw.bayersensor.pixelShiftStddevFactorGreen = pixelShiftStddevFactorGreen->getValue();
pp->raw.bayersensor.pixelShiftStddevFactorRed = pixelShiftStddevFactorRed->getValue();
pp->raw.bayersensor.pixelShiftStddevFactorBlue = pixelShiftStddevFactorBlue->getValue();
pp->raw.bayersensor.pixelShiftSum = pixelShiftSum->getValue();
pp->raw.bayersensor.pixelShiftMedian3 = pixelShiftMedian3->getLastActive ();
pp->raw.bayersensor.pixelShiftMotion = pixelShiftMotion->getIntValue();
pp->raw.bayersensor.pixelShiftMotionCorrection = (RAWParams::BayerSensor::ePSMotionCorrection)pixelShiftMotionCorrection->get_active_row_number();
pp->raw.bayersensor.pixelShiftAutomatic = pixelShiftAutomatic->getLastActive ();
pp->raw.bayersensor.pixelShiftNonGreenHorizontal = pixelShiftNonGreenHorizontal->getLastActive ();
pp->raw.bayersensor.pixelShiftNonGreenVertical = pixelShiftNonGreenVertical->getLastActive ();
pp->raw.bayersensor.pixelShiftExp0 = pixelShiftExp0->getLastActive ();
pp->raw.bayersensor.pixelShiftNonGreenCross2 = pixelShiftNonGreenCross2->getLastActive ();
pp->raw.bayersensor.pixelShiftNonGreenAmaze = pixelShiftNonGreenAmaze->getLastActive ();
pp->raw.bayersensor.pixelShiftNreadIso = pixelShiftNreadIso->getValue();
pp->raw.bayersensor.pixelShiftPrnu = pixelShiftPrnu->getValue();
pp->raw.bayersensor.pixelShiftRedBlueWeight = pixelShiftRedBlueWeight->getValue();
#endif
int currentRow = method->get_active_row_number();
if( currentRow >= 0 && currentRow < std::numeric_limits<int>::max()) {
@@ -591,28 +380,9 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
pedited->raw.bayersensor.pixelShiftBlur = !pixelShiftBlur->get_inconsistent();
pedited->raw.bayersensor.pixelShiftSmooth = pixelShiftSmooth->getEditedState();
pedited->raw.bayersensor.pixelShiftLmmse = !pixelShiftLmmse->get_inconsistent();
// pedited->raw.bayersensor.pixelShiftOneGreen = !pixelShiftOneGreen->get_inconsistent();
pedited->raw.bayersensor.pixelShiftEqualBright = !pixelShiftEqualBright->get_inconsistent();
pedited->raw.bayersensor.pixelShiftEqualBrightChannel = !pixelShiftEqualBrightChannel->get_inconsistent();
pedited->raw.bayersensor.pixelShiftNonGreenCross = !pixelShiftNonGreenCross->get_inconsistent();
#ifdef PIXELSHIFTDEV
pedited->raw.bayersensor.pixelShiftStddevFactorGreen = pixelShiftStddevFactorGreen->getEditedState ();
pedited->raw.bayersensor.pixelShiftStddevFactorRed = pixelShiftStddevFactorRed->getEditedState ();
pedited->raw.bayersensor.pixelShiftStddevFactorBlue = pixelShiftStddevFactorBlue->getEditedState ();
pedited->raw.bayersensor.pixelShiftSum = pixelShiftSum->getEditedState ();
pedited->raw.bayersensor.pixelShiftMedian3 = !pixelShiftMedian3->get_inconsistent();
pedited->raw.bayersensor.pixelShiftMotion = pixelShiftMotion->getEditedState ();
pedited->raw.bayersensor.pixelShiftMotionCorrection = pixelShiftMotionCorrection->get_active_text() != M("GENERAL_UNCHANGED");
pedited->raw.bayersensor.pixelShiftAutomatic = !pixelShiftAutomatic->get_inconsistent();
pedited->raw.bayersensor.pixelShiftNonGreenHorizontal = !pixelShiftNonGreenHorizontal->get_inconsistent();
pedited->raw.bayersensor.pixelShiftNonGreenVertical = !pixelShiftNonGreenVertical->get_inconsistent();
pedited->raw.bayersensor.pixelShiftExp0 = !pixelShiftExp0->get_inconsistent();
pedited->raw.bayersensor.pixelShiftNonGreenCross2 = !pixelShiftNonGreenCross2->get_inconsistent();
pedited->raw.bayersensor.pixelShiftNonGreenAmaze = !pixelShiftNonGreenAmaze->get_inconsistent();
pedited->raw.bayersensor.pixelShiftNreadIso = pixelShiftNreadIso->getEditedState ();
pedited->raw.bayersensor.pixelShiftPrnu = pixelShiftPrnu->getEditedState ();
pedited->raw.bayersensor.pixelShiftRedBlueWeight = pixelShiftRedBlueWeight->getEditedState ();
#endif
}
}
@@ -620,10 +390,6 @@ void BayerProcess::setBatchMode(bool batchMode)
{
method->append (M("GENERAL_UNCHANGED"));
method->set_active(std::numeric_limits<int>::max()); // No name
#ifdef PIXELSHIFTDEV
pixelShiftMotionCorrection->append (M("GENERAL_UNCHANGED"));
pixelShiftMotionCorrection->set_active_text (M("GENERAL_UNCHANGED"));
#endif
pixelShiftMotionMethod->append (M("GENERAL_UNCHANGED"));
pixelShiftMotionMethod->set_active_text (M("GENERAL_UNCHANGED"));
imageNumber->append (M("GENERAL_UNCHANGED"));
@@ -632,16 +398,6 @@ void BayerProcess::setBatchMode(bool batchMode)
ccSteps->showEditedCB ();
dcbIterations->showEditedCB ();
lmmseIterations->showEditedCB ();
#ifdef PIXELSHIFTDEV
pixelShiftMotion->showEditedCB ();
pixelShiftSum->showEditedCB ();
pixelShiftStddevFactorGreen->showEditedCB ();
pixelShiftStddevFactorRed->showEditedCB ();
pixelShiftStddevFactorBlue->showEditedCB ();
pixelShiftNreadIso->showEditedCB ();
pixelShiftPrnu->showEditedCB ();
pixelShiftRedBlueWeight->showEditedCB ();
#endif
pixelShiftEperIso->showEditedCB ();
pixelShiftSigma->showEditedCB ();
}
@@ -650,16 +406,6 @@ void BayerProcess::setDefaults(const rtengine::procparams::ProcParams* defParams
{
dcbIterations->setDefault( defParams->raw.bayersensor.dcb_iterations);
lmmseIterations->setDefault( defParams->raw.bayersensor.lmmse_iterations);
#ifdef PIXELSHIFTDEV
pixelShiftMotion->setDefault( defParams->raw.bayersensor.pixelShiftMotion);
pixelShiftSum->setDefault( defParams->raw.bayersensor.pixelShiftSum);
pixelShiftStddevFactorGreen->setDefault( defParams->raw.bayersensor.pixelShiftStddevFactorGreen);
pixelShiftStddevFactorRed->setDefault( defParams->raw.bayersensor.pixelShiftStddevFactorRed);
pixelShiftStddevFactorBlue->setDefault( defParams->raw.bayersensor.pixelShiftStddevFactorBlue);
pixelShiftNreadIso->setDefault( defParams->raw.bayersensor.pixelShiftNreadIso);
pixelShiftPrnu->setDefault( defParams->raw.bayersensor.pixelShiftPrnu);
pixelShiftRedBlueWeight->setDefault( defParams->raw.bayersensor.pixelShiftRedBlueWeight);
#endif
pixelShiftEperIso->setDefault( defParams->raw.bayersensor.pixelShiftEperIso);
pixelShiftSigma->setDefault( defParams->raw.bayersensor.pixelShiftSigma);
ccSteps->setDefault (defParams->raw.bayersensor.ccSteps);
@@ -667,32 +413,12 @@ void BayerProcess::setDefaults(const rtengine::procparams::ProcParams* defParams
if (pedited) {
dcbIterations->setDefaultEditedState( pedited->raw.bayersensor.dcbIterations ? Edited : UnEdited);
lmmseIterations->setDefaultEditedState( pedited->raw.bayersensor.lmmseIterations ? Edited : UnEdited);
#ifdef PIXELSHIFTDEV
pixelShiftMotion->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftMotion ? Edited : UnEdited);
pixelShiftSum->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftSum ? Edited : UnEdited);
pixelShiftStddevFactorGreen->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftStddevFactorGreen ? Edited : UnEdited);
pixelShiftStddevFactorRed->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftStddevFactorRed ? Edited : UnEdited);
pixelShiftStddevFactorBlue->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftStddevFactorBlue ? Edited : UnEdited);
pixelShiftNreadIso->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftNreadIso ? Edited : UnEdited);
pixelShiftPrnu->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftPrnu ? Edited : UnEdited);
pixelShiftRedBlueWeight->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftRedBlueWeight ? Edited : UnEdited);
#endif
pixelShiftEperIso->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftEperIso ? Edited : UnEdited);
pixelShiftSigma->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftSigma ? Edited : UnEdited);
ccSteps->setDefaultEditedState(pedited->raw.bayersensor.ccSteps ? Edited : UnEdited);
} else {
dcbIterations->setDefaultEditedState( Irrelevant );
lmmseIterations->setDefaultEditedState( Irrelevant );
#ifdef PIXELSHIFTDEV
pixelShiftMotion->setDefaultEditedState( Irrelevant );
pixelShiftSum->setDefaultEditedState( Irrelevant );
pixelShiftStddevFactorGreen->setDefaultEditedState( Irrelevant );
pixelShiftStddevFactorRed->setDefaultEditedState( Irrelevant );
pixelShiftStddevFactorBlue->setDefaultEditedState( Irrelevant );
pixelShiftNreadIso->setDefaultEditedState( Irrelevant );
pixelShiftPrnu->setDefaultEditedState( Irrelevant );
pixelShiftRedBlueWeight->setDefaultEditedState( Irrelevant );
#endif
pixelShiftEperIso->setDefaultEditedState( Irrelevant );
pixelShiftSigma->setDefaultEditedState( Irrelevant );
ccSteps->setDefaultEditedState(Irrelevant );
@@ -708,24 +434,6 @@ void BayerProcess::adjusterChanged (Adjuster* a, double newval)
listener->panelChanged (EvDemosaicFalseColorIter, a->getTextValue() );
} else if (a == lmmseIterations) {
listener->panelChanged (EvDemosaicLMMSEIter, a->getTextValue() );
#ifdef PIXELSHIFTDEV
} else if (a == pixelShiftMotion) {
listener->panelChanged (EvPixelShiftMotion, a->getTextValue() );
} else if (a == pixelShiftSum) {
listener->panelChanged (EvPixelShiftSum, a->getTextValue() );
} else if (a == pixelShiftStddevFactorGreen) {
listener->panelChanged (EvPixelShiftStddevFactorGreen, a->getTextValue() );
} else if (a == pixelShiftStddevFactorRed) {
listener->panelChanged (EvPixelShiftStddevFactorRed, a->getTextValue() );
} else if (a == pixelShiftStddevFactorBlue) {
listener->panelChanged (EvPixelShiftStddevFactorBlue, a->getTextValue() );
} else if (a == pixelShiftNreadIso) {
listener->panelChanged (EvPixelShiftNreadIso, a->getTextValue() );
} else if (a == pixelShiftPrnu) {
listener->panelChanged (EvPixelShiftPrnu, a->getTextValue() );
} else if (a == pixelShiftRedBlueWeight) {
listener->panelChanged (EvPixelShiftRedBlueWeight, a->getTextValue() );
#endif
} else if (a == pixelShiftEperIso) {
listener->panelChanged (EvPixelShiftEperIso, a->getTextValue() );
} else if (a == pixelShiftSigma) {
@@ -736,27 +444,6 @@ void BayerProcess::adjusterChanged (Adjuster* a, double newval)
}
}
#ifdef PIXELSHIFTDEV
void BayerProcess::psMotionCorrectionChanged ()
{
if (!batchMode) {
if(pixelShiftMotionCorrection->get_active_row_number() == 5) {
pixelShiftBlur->set_sensitive(true);
pixelShiftHoleFill->set_sensitive(true);
pixelShiftSmooth->set_sensitive(pixelShiftBlur->getValue() != CheckValue::off);
} else {
pixelShiftBlur->set_sensitive(false);
pixelShiftHoleFill->set_sensitive(false);
pixelShiftSmooth->set_sensitive(false);
}
}
if (listener) {
listener->panelChanged (EvPixelShiftMotionCorrection, pixelShiftMotionCorrection->get_active_text());
}
}
#endif
void BayerProcess::methodChanged ()
{
const int curSelection = method->get_active_row_number();
@@ -834,11 +521,6 @@ void BayerProcess::checkBoxToggled (CheckBox* c, CheckValue newval)
listener->panelChanged (EvPixelShiftHoleFill, pixelShiftHoleFill->getValueAsStr ());
}
} else if (c == pixelShiftMedian) {
#ifdef PIXELSHIFTDEV
if (!batchMode) {
pixelShiftMedian3->set_sensitive(newval != CheckValue::off);
}
#endif
if (listener) {
listener->panelChanged (EvPixelShiftMedian, pixelShiftMedian->getValueAsStr ());
}
@@ -858,10 +540,6 @@ void BayerProcess::checkBoxToggled (CheckBox* c, CheckValue newval)
if (listener) {
listener->panelChanged (EvPixelShiftLmmse, pixelShiftLmmse->getValueAsStr ());
}
// } else if (c == pixelShiftOneGreen) {
// if (listener) {
// listener->panelChanged (EvPixelShiftOneGreen, pixelShiftOneGreen->getValueAsStr ());
// }
} else if (c == pixelShiftEqualBright) {
if (!batchMode) {
pixelShiftEqualBrightChannel->set_sensitive(newval != CheckValue::off);
@@ -878,61 +556,6 @@ void BayerProcess::checkBoxToggled (CheckBox* c, CheckValue newval)
listener->panelChanged (EvPixelShiftNonGreenCross, pixelShiftNonGreenCross->getValueAsStr ());
}
}
#ifdef PIXELSHIFTDEV
else if (c == pixelShiftAutomatic) {
if (!batchMode) {
pixelShiftMotion->set_sensitive(newval != CheckValue::off);
pixelShiftEperIso->set_sensitive(newval != CheckValue::off);
pixelShiftNreadIso->set_sensitive(newval != CheckValue::off);
pixelShiftPrnu->set_sensitive(newval != CheckValue::off);
pixelShiftSigma->set_sensitive(newval != CheckValue::off);
pixelShiftSum->set_sensitive(newval != CheckValue::off);
pixelShiftRedBlueWeight->set_sensitive(newval != CheckValue::off);
pixelShiftStddevFactorGreen->set_sensitive(newval != CheckValue::off);
pixelShiftStddevFactorRed->set_sensitive(newval != CheckValue::off);
pixelShiftStddevFactorBlue->set_sensitive(newval != CheckValue::off);
pixelShiftNonGreenHorizontal->set_sensitive(newval != CheckValue::off);
pixelShiftNonGreenVertical->set_sensitive(newval != CheckValue::off);
pixelShiftHoleFill->set_sensitive(newval != CheckValue::off && pixelShiftMotionCorrection->get_active_row_number() == 5);
pixelShiftMedian3->set_sensitive(newval != CheckValue::off && pixelShiftMedian->getValue () != CheckValue::off);
pixelShiftGreen->set_sensitive(newval != CheckValue::off);
pixelShiftBlur->set_sensitive(newval != CheckValue::off && pixelShiftMotionCorrection->get_active_row_number() == 5);
pixelShiftSmooth->set_sensitive(newval != CheckValue::off && pixelShiftMotionCorrection->get_active_row_number() == 5 && pixelShiftBlur->getValue () != CheckValue::off);
pixelShiftExp0->set_sensitive(newval != CheckValue::off);
pixelShiftNonGreenCross->set_sensitive(newval != CheckValue::off);
pixelShiftNonGreenCross2->set_sensitive(newval != CheckValue::off);
pixelShiftNonGreenAmaze->set_sensitive(newval != CheckValue::off);
}
if (listener) {
listener->panelChanged (EvPixelShiftAutomatic, pixelShiftAutomatic->getValueAsStr ());
}
} else if (c == pixelShiftNonGreenHorizontal) {
if (listener) {
listener->panelChanged (EvPixelShiftNonGreenHorizontal, pixelShiftNonGreenHorizontal->getValueAsStr ());
}
} else if (c == pixelShiftNonGreenVertical) {
if (listener) {
listener->panelChanged (EvPixelShiftNonGreenVertical, pixelShiftNonGreenVertical->getValueAsStr ());
}
} else if (c == pixelShiftMedian3) {
if (listener) {
listener->panelChanged (EvPixelShiftMedian3, pixelShiftMedian3->getValueAsStr ());
}
} else if (c == pixelShiftExp0) {
if (listener) {
listener->panelChanged (EvPixelShiftExp0, pixelShiftExp0->getValueAsStr ());
}
} else if (c == pixelShiftNonGreenCross2) {
if (listener) {
listener->panelChanged (EvPixelShiftGreenAmaze, pixelShiftNonGreenCross2->getValueAsStr ());
}
} else if (c == pixelShiftNonGreenAmaze) {
if (listener) {
listener->panelChanged (EvPixelShiftNonGreenAmaze, pixelShiftNonGreenAmaze->getValueAsStr ());
}
}
#endif
}
void BayerProcess::pixelShiftMotionMethodChanged ()

22
rtgui/bayerprocess.h
View File

@@ -49,31 +49,12 @@ protected:
CheckBox* pixelShiftBlur;
CheckBox* pixelShiftHoleFill;
CheckBox* pixelShiftMedian;
// CheckBox* pixelShiftOneGreen;
CheckBox* pixelShiftLmmse;
CheckBox* pixelShiftEqualBright;
CheckBox* pixelShiftEqualBrightChannel;
Adjuster* pixelShiftSmooth;
Adjuster* pixelShiftEperIso;
Adjuster* pixelShiftSigma;
#ifdef PIXELSHIFTDEV
Adjuster* pixelShiftSum;
Adjuster* pixelShiftMotion;
MyComboBoxText* pixelShiftMotionCorrection;
CheckBox* pixelShiftAutomatic;
CheckBox* pixelShiftNonGreenHorizontal;
CheckBox* pixelShiftNonGreenVertical;
CheckBox* pixelShiftNonGreenCross2;
CheckBox* pixelShiftNonGreenAmaze;
CheckBox* pixelShiftExp0;
CheckBox* pixelShiftMedian3;
Adjuster* pixelShiftStddevFactorGreen;
Adjuster* pixelShiftStddevFactorRed;
Adjuster* pixelShiftStddevFactorBlue;
Adjuster* pixelShiftNreadIso;
Adjuster* pixelShiftPrnu;
Adjuster* pixelShiftRedBlueWeight;
#endif
int oldMethod;
IdleRegister idle_register;
@@ -92,9 +73,6 @@ public:
void checkBoxToggled (CheckBox* c, CheckValue newval);
void pixelShiftMotionMethodChanged();
void FrameCountChanged(int n, int frameNum);
#ifdef PIXELSHIFTDEV
void psMotionCorrectionChanged ();
#endif
};
#endif

3
rtgui/cacheimagedata.h
View File

@@ -108,8 +108,9 @@ public:
std::string getModel (unsigned int frame = 0) const { return camModel; }
std::string getLens (unsigned int frame = 0) const { return lens; }
std::string getOrientation (unsigned int frame = 0) const { return ""; } // TODO
bool getPixelShift (unsigned int frame = 0) const { return isPixelShift; }
bool getPixelShift () const { return isPixelShift; }
bool getHDR (unsigned int frame = 0) const { return isHDR; }
std::string getImageType (unsigned int frame) const { return isPixelShift ? "PS" : isHDR ? "HDR" : "STD"; }
rtengine::IIOSampleFormat getSampleFormat (unsigned int frame = 0) const { return sampleFormat; }
};
#endif

25
rtgui/dynamicprofilepanel.cc
View File

@@ -41,6 +41,7 @@ DynamicProfilePanel::EditDialog::EditDialog (const Glib::ustring &title, Gtk::Wi
add_optional (M ("EXIFFILTER_CAMERA"), has_camera_, camera_);
add_optional (M ("EXIFFILTER_LENS"), has_lens_, lens_);
add_optional (M ("EXIFFILTER_IMAGETYPE"), has_imagetype_, imagetype_);
add_range (M ("EXIFFILTER_ISO"), iso_min_, iso_max_);
add_range (M ("EXIFFILTER_APERTURE"), fnumber_min_, fnumber_max_);
@@ -81,6 +82,9 @@ void DynamicProfilePanel::EditDialog::set_rule (
has_lens_->set_active (rule.lens.enabled);
lens_->set_text (rule.lens.value);
has_imagetype_->set_active (rule.imagetype.enabled);
imagetype_->set_text (rule.imagetype.value);
profilepath_->updateProfileList();
if (!profilepath_->setActiveRowFromFullPath (rule.profilepath)) {
@@ -112,6 +116,9 @@ DynamicProfileRule DynamicProfilePanel::EditDialog::get_rule()
ret.lens.enabled = has_lens_->get_active();
ret.lens.value = lens_->get_text();
ret.imagetype.enabled = has_imagetype_->get_active();
ret.imagetype.value = imagetype_->get_text();
ret.profilepath = profilepath_->getFullPathFromActiveRow();
return ret;
@@ -254,6 +261,16 @@ DynamicProfilePanel::DynamicProfilePanel():
*this, &DynamicProfilePanel::render_lens));
}
cell = Gtk::manage (new Gtk::CellRendererText());
cols_count = treeview_.append_column (M ("EXIFFILTER_IMAGETYPE"), *cell);
col = treeview_.get_column (cols_count - 1);
if (col) {
col->set_cell_data_func (
*cell, sigc::mem_fun (
*this, &DynamicProfilePanel::render_imagetype));
}
cell = Gtk::manage (new Gtk::CellRendererText());
cols_count = treeview_.append_column (M ("EXIFFILTER_ISO"), *cell);
col = treeview_.get_column (cols_count - 1);
@@ -323,6 +340,7 @@ void DynamicProfilePanel::update_rule (Gtk::TreeModel::Row row,
row[columns_.expcomp] = rule.expcomp;
row[columns_.camera] = rule.camera;
row[columns_.lens] = rule.lens;
row[columns_.imagetype] = rule.imagetype;
row[columns_.profilepath] = rule.profilepath;
}
@@ -346,6 +364,7 @@ DynamicProfileRule DynamicProfilePanel::to_rule (Gtk::TreeModel::Row row,
ret.camera = row[columns_.camera];
ret.lens = row[columns_.lens];
ret.profilepath = row[columns_.profilepath];
ret.imagetype = row[columns_.imagetype];
return ret;
}
@@ -456,6 +475,12 @@ void DynamicProfilePanel::render_lens (
RENDER_OPTIONAL_ (lens);
}
void DynamicProfilePanel::render_imagetype (
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
{
RENDER_OPTIONAL_ (imagetype);
}
#undef RENDER_OPTIONAL_
void DynamicProfilePanel::on_button_up()

6
rtgui/dynamicprofilepanel.h
View File

@@ -54,6 +54,7 @@ private:
add (camera);
add (lens);
add (profilepath);
add (imagetype);
}
Gtk::TreeModelColumn<DynamicProfileRule::Range<int>> iso;
@@ -63,6 +64,7 @@ private:
Gtk::TreeModelColumn<DynamicProfileRule::Range<double>> expcomp;
Gtk::TreeModelColumn<DynamicProfileRule::Optional> camera;
Gtk::TreeModelColumn<DynamicProfileRule::Optional> lens;
Gtk::TreeModelColumn<DynamicProfileRule::Optional> imagetype;
Gtk::TreeModelColumn<Glib::ustring> profilepath;
};
@@ -74,6 +76,7 @@ private:
void render_expcomp (Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter);
void render_camera (Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter);
void render_lens (Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter);
void render_imagetype (Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter);
void render_profilepath (Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter);
class EditDialog: public Gtk::Dialog
@@ -109,6 +112,9 @@ private:
Gtk::CheckButton *has_lens_;
Gtk::Entry *lens_;
Gtk::CheckButton *has_imagetype_;
Gtk::Entry *imagetype_;
ProfileStoreComboBox *profilepath_;
};

107
rtgui/paramsedited.cc
View File

@@ -400,37 +400,20 @@ void ParamsEdited::set (bool v)
raw.bayersensor.dcbEnhance = v;
//raw.bayersensor.allEnhance = v;
raw.bayersensor.lmmseIterations = v;
raw.bayersensor.pixelShiftMotion = v;
raw.bayersensor.pixelShiftMotionCorrection = v;
raw.bayersensor.pixelShiftMotionCorrectionMethod = v;
raw.bayersensor.pixelShiftStddevFactorGreen = v;
raw.bayersensor.pixelShiftStddevFactorRed = v;
raw.bayersensor.pixelShiftStddevFactorBlue = v;
raw.bayersensor.pixelShiftEperIso = v;
raw.bayersensor.pixelShiftNreadIso = v;
raw.bayersensor.pixelShiftPrnu = v;
raw.bayersensor.pixelShiftSigma = v;
raw.bayersensor.pixelShiftSum = v;
raw.bayersensor.pixelShiftRedBlueWeight = v;
raw.bayersensor.pixelShiftShowMotion = v;
raw.bayersensor.pixelShiftShowMotionMaskOnly = v;
raw.bayersensor.pixelShiftAutomatic = v;
raw.bayersensor.pixelShiftNonGreenHorizontal = v;
raw.bayersensor.pixelShiftNonGreenVertical = v;
raw.bayersensor.pixelShiftHoleFill = v;
raw.bayersensor.pixelShiftMedian = v;
raw.bayersensor.pixelShiftMedian3 = v;
raw.bayersensor.pixelShiftGreen = v;
raw.bayersensor.pixelShiftBlur = v;
raw.bayersensor.pixelShiftSmooth = v;
raw.bayersensor.pixelShiftExp0 = v;
raw.bayersensor.pixelShiftLmmse = v;
raw.bayersensor.pixelShiftOneGreen = v;
raw.bayersensor.pixelShiftEqualBright = v;
raw.bayersensor.pixelShiftEqualBrightChannel = v;
raw.bayersensor.pixelShiftNonGreenCross = v;
raw.bayersensor.pixelShiftNonGreenCross2 = v;
raw.bayersensor.pixelShiftNonGreenAmaze = v;
raw.bayersensor.greenEq = v;
raw.bayersensor.linenoise = v;
raw.bayersensor.linenoiseDirection = v;
@@ -963,37 +946,20 @@ void ParamsEdited::initFrom (const std::vector<rtengine::procparams::ProcParams>
raw.bayersensor.dcbEnhance = raw.bayersensor.dcbEnhance && p.raw.bayersensor.dcb_enhance == other.raw.bayersensor.dcb_enhance;
//raw.bayersensor.allEnhance = raw.bayersensor.allEnhance && p.raw.bayersensor.all_enhance == other.raw.bayersensor.all_enhance;
raw.bayersensor.lmmseIterations = raw.bayersensor.lmmseIterations && p.raw.bayersensor.lmmse_iterations == other.raw.bayersensor.lmmse_iterations;
raw.bayersensor.pixelShiftMotion = raw.bayersensor.pixelShiftMotion && p.raw.bayersensor.pixelShiftMotion == other.raw.bayersensor.pixelShiftMotion;
raw.bayersensor.pixelShiftMotionCorrection = raw.bayersensor.pixelShiftMotionCorrection && p.raw.bayersensor.pixelShiftMotionCorrection == other.raw.bayersensor.pixelShiftMotionCorrection;
raw.bayersensor.pixelShiftMotionCorrectionMethod = raw.bayersensor.pixelShiftMotionCorrectionMethod && p.raw.bayersensor.pixelShiftMotionCorrectionMethod == other.raw.bayersensor.pixelShiftMotionCorrectionMethod;
raw.bayersensor.pixelShiftStddevFactorGreen = raw.bayersensor.pixelShiftStddevFactorGreen && p.raw.bayersensor.pixelShiftStddevFactorGreen == other.raw.bayersensor.pixelShiftStddevFactorGreen;
raw.bayersensor.pixelShiftStddevFactorRed = raw.bayersensor.pixelShiftStddevFactorRed && p.raw.bayersensor.pixelShiftStddevFactorRed == other.raw.bayersensor.pixelShiftStddevFactorRed;
raw.bayersensor.pixelShiftStddevFactorBlue = raw.bayersensor.pixelShiftStddevFactorBlue && p.raw.bayersensor.pixelShiftStddevFactorBlue == other.raw.bayersensor.pixelShiftStddevFactorBlue;
raw.bayersensor.pixelShiftEperIso = raw.bayersensor.pixelShiftEperIso && p.raw.bayersensor.pixelShiftEperIso == other.raw.bayersensor.pixelShiftEperIso;
raw.bayersensor.pixelShiftNreadIso = raw.bayersensor.pixelShiftNreadIso && p.raw.bayersensor.pixelShiftNreadIso == other.raw.bayersensor.pixelShiftNreadIso;
raw.bayersensor.pixelShiftPrnu = raw.bayersensor.pixelShiftPrnu && p.raw.bayersensor.pixelShiftPrnu == other.raw.bayersensor.pixelShiftPrnu;
raw.bayersensor.pixelShiftSigma = raw.bayersensor.pixelShiftSigma && p.raw.bayersensor.pixelShiftSigma == other.raw.bayersensor.pixelShiftSigma;
raw.bayersensor.pixelShiftSum = raw.bayersensor.pixelShiftSum && p.raw.bayersensor.pixelShiftSum == other.raw.bayersensor.pixelShiftSum;
raw.bayersensor.pixelShiftRedBlueWeight = raw.bayersensor.pixelShiftRedBlueWeight && p.raw.bayersensor.pixelShiftRedBlueWeight == other.raw.bayersensor.pixelShiftRedBlueWeight;
raw.bayersensor.pixelShiftShowMotion = raw.bayersensor.pixelShiftShowMotion && p.raw.bayersensor.pixelShiftShowMotion == other.raw.bayersensor.pixelShiftShowMotion;
raw.bayersensor.pixelShiftShowMotionMaskOnly = raw.bayersensor.pixelShiftShowMotionMaskOnly && p.raw.bayersensor.pixelShiftShowMotionMaskOnly == other.raw.bayersensor.pixelShiftShowMotionMaskOnly;
raw.bayersensor.pixelShiftAutomatic = raw.bayersensor.pixelShiftAutomatic && p.raw.bayersensor.pixelShiftAutomatic == other.raw.bayersensor.pixelShiftAutomatic;
raw.bayersensor.pixelShiftNonGreenHorizontal = raw.bayersensor.pixelShiftNonGreenHorizontal && p.raw.bayersensor.pixelShiftNonGreenHorizontal == other.raw.bayersensor.pixelShiftNonGreenHorizontal;
raw.bayersensor.pixelShiftNonGreenVertical = raw.bayersensor.pixelShiftNonGreenVertical && p.raw.bayersensor.pixelShiftNonGreenVertical == other.raw.bayersensor.pixelShiftNonGreenVertical;
raw.bayersensor.pixelShiftHoleFill = raw.bayersensor.pixelShiftHoleFill && p.raw.bayersensor.pixelShiftHoleFill == other.raw.bayersensor.pixelShiftHoleFill;
raw.bayersensor.pixelShiftMedian = raw.bayersensor.pixelShiftMedian && p.raw.bayersensor.pixelShiftMedian == other.raw.bayersensor.pixelShiftMedian;
raw.bayersensor.pixelShiftMedian3 = raw.bayersensor.pixelShiftMedian3 && p.raw.bayersensor.pixelShiftMedian3 == other.raw.bayersensor.pixelShiftMedian3;
raw.bayersensor.pixelShiftGreen = raw.bayersensor.pixelShiftGreen && p.raw.bayersensor.pixelShiftGreen == other.raw.bayersensor.pixelShiftGreen;
raw.bayersensor.pixelShiftBlur = raw.bayersensor.pixelShiftBlur && p.raw.bayersensor.pixelShiftBlur == other.raw.bayersensor.pixelShiftBlur;
raw.bayersensor.pixelShiftSmooth = raw.bayersensor.pixelShiftSmooth && p.raw.bayersensor.pixelShiftSmoothFactor == other.raw.bayersensor.pixelShiftSmoothFactor;
raw.bayersensor.pixelShiftExp0 = raw.bayersensor.pixelShiftExp0 && p.raw.bayersensor.pixelShiftExp0 == other.raw.bayersensor.pixelShiftExp0;
raw.bayersensor.pixelShiftLmmse = raw.bayersensor.pixelShiftLmmse && p.raw.bayersensor.pixelShiftLmmse == other.raw.bayersensor.pixelShiftLmmse;
raw.bayersensor.pixelShiftOneGreen = raw.bayersensor.pixelShiftOneGreen && p.raw.bayersensor.pixelShiftOneGreen == other.raw.bayersensor.pixelShiftOneGreen;
raw.bayersensor.pixelShiftEqualBright = raw.bayersensor.pixelShiftEqualBright && p.raw.bayersensor.pixelShiftEqualBright == other.raw.bayersensor.pixelShiftEqualBright;
raw.bayersensor.pixelShiftEqualBrightChannel = raw.bayersensor.pixelShiftEqualBrightChannel && p.raw.bayersensor.pixelShiftEqualBrightChannel == other.raw.bayersensor.pixelShiftEqualBrightChannel;
raw.bayersensor.pixelShiftNonGreenCross = raw.bayersensor.pixelShiftNonGreenCross && p.raw.bayersensor.pixelShiftNonGreenCross == other.raw.bayersensor.pixelShiftNonGreenCross;
raw.bayersensor.pixelShiftNonGreenCross2 = raw.bayersensor.pixelShiftNonGreenCross2 && p.raw.bayersensor.pixelShiftNonGreenCross2 == other.raw.bayersensor.pixelShiftNonGreenCross2;
raw.bayersensor.pixelShiftNonGreenAmaze = raw.bayersensor.pixelShiftNonGreenAmaze && p.raw.bayersensor.pixelShiftNonGreenAmaze == other.raw.bayersensor.pixelShiftNonGreenAmaze;
raw.bayersensor.greenEq = raw.bayersensor.greenEq && p.raw.bayersensor.greenthresh == other.raw.bayersensor.greenthresh;
raw.bayersensor.linenoise = raw.bayersensor.linenoise && p.raw.bayersensor.linenoise == other.raw.bayersensor.linenoise;
raw.bayersensor.linenoiseDirection = raw.bayersensor.linenoiseDirection && p.raw.bayersensor.linenoiseDirection == other.raw.bayersensor.linenoiseDirection;
@@ -2512,54 +2478,18 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.bayersensor.lmmse_iterations = mods.raw.bayersensor.lmmse_iterations;
}
if (raw.bayersensor.pixelShiftMotion) {
toEdit.raw.bayersensor.pixelShiftMotion = mods.raw.bayersensor.pixelShiftMotion;
}
if (raw.bayersensor.pixelShiftMotionCorrection) {
toEdit.raw.bayersensor.pixelShiftMotionCorrection = mods.raw.bayersensor.pixelShiftMotionCorrection;
}
if (raw.bayersensor.pixelShiftMotionCorrectionMethod) {
toEdit.raw.bayersensor.pixelShiftMotionCorrectionMethod = mods.raw.bayersensor.pixelShiftMotionCorrectionMethod;
}
if (raw.bayersensor.pixelShiftStddevFactorGreen) {
toEdit.raw.bayersensor.pixelShiftStddevFactorGreen = mods.raw.bayersensor.pixelShiftStddevFactorGreen;
}
if (raw.bayersensor.pixelShiftStddevFactorRed) {
toEdit.raw.bayersensor.pixelShiftStddevFactorRed = mods.raw.bayersensor.pixelShiftStddevFactorRed;
}
if (raw.bayersensor.pixelShiftStddevFactorBlue) {
toEdit.raw.bayersensor.pixelShiftStddevFactorBlue = mods.raw.bayersensor.pixelShiftStddevFactorBlue;
}
if (raw.bayersensor.pixelShiftEperIso) {
toEdit.raw.bayersensor.pixelShiftEperIso = mods.raw.bayersensor.pixelShiftEperIso;
}
if (raw.bayersensor.pixelShiftNreadIso) {
toEdit.raw.bayersensor.pixelShiftNreadIso = mods.raw.bayersensor.pixelShiftNreadIso;
}
if (raw.bayersensor.pixelShiftPrnu) {
toEdit.raw.bayersensor.pixelShiftPrnu = mods.raw.bayersensor.pixelShiftPrnu;
}
if (raw.bayersensor.pixelShiftSigma) {
toEdit.raw.bayersensor.pixelShiftSigma = mods.raw.bayersensor.pixelShiftSigma;
}
if (raw.bayersensor.pixelShiftSum) {
toEdit.raw.bayersensor.pixelShiftSum = mods.raw.bayersensor.pixelShiftSum;
}
if (raw.bayersensor.pixelShiftRedBlueWeight) {
toEdit.raw.bayersensor.pixelShiftRedBlueWeight = mods.raw.bayersensor.pixelShiftRedBlueWeight;
}
if (raw.bayersensor.pixelShiftShowMotion) {
toEdit.raw.bayersensor.pixelShiftShowMotion = mods.raw.bayersensor.pixelShiftShowMotion;
}
@@ -2568,18 +2498,6 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.bayersensor.pixelShiftShowMotionMaskOnly = mods.raw.bayersensor.pixelShiftShowMotionMaskOnly;
}
if (raw.bayersensor.pixelShiftAutomatic) {
toEdit.raw.bayersensor.pixelShiftAutomatic = mods.raw.bayersensor.pixelShiftAutomatic;
}
if (raw.bayersensor.pixelShiftNonGreenHorizontal) {
toEdit.raw.bayersensor.pixelShiftNonGreenHorizontal = mods.raw.bayersensor.pixelShiftNonGreenHorizontal;
}
if (raw.bayersensor.pixelShiftNonGreenVertical) {
toEdit.raw.bayersensor.pixelShiftNonGreenVertical = mods.raw.bayersensor.pixelShiftNonGreenVertical;
}
if (raw.bayersensor.pixelShiftHoleFill) {
toEdit.raw.bayersensor.pixelShiftHoleFill = mods.raw.bayersensor.pixelShiftHoleFill;
}
@@ -2588,10 +2506,6 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.bayersensor.pixelShiftMedian = mods.raw.bayersensor.pixelShiftMedian;
}
if (raw.bayersensor.pixelShiftMedian3) {
toEdit.raw.bayersensor.pixelShiftMedian3 = mods.raw.bayersensor.pixelShiftMedian3;
}
if (raw.bayersensor.pixelShiftGreen) {
toEdit.raw.bayersensor.pixelShiftGreen = mods.raw.bayersensor.pixelShiftGreen;
}
@@ -2604,18 +2518,10 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.bayersensor.pixelShiftSmoothFactor = mods.raw.bayersensor.pixelShiftSmoothFactor;
}
if (raw.bayersensor.pixelShiftExp0) {
toEdit.raw.bayersensor.pixelShiftExp0 = mods.raw.bayersensor.pixelShiftExp0;
}
if (raw.bayersensor.pixelShiftLmmse) {
toEdit.raw.bayersensor.pixelShiftLmmse = mods.raw.bayersensor.pixelShiftLmmse;
}
if (raw.bayersensor.pixelShiftOneGreen) {
toEdit.raw.bayersensor.pixelShiftOneGreen = mods.raw.bayersensor.pixelShiftOneGreen;
}
if (raw.bayersensor.pixelShiftEqualBright) {
toEdit.raw.bayersensor.pixelShiftEqualBright = mods.raw.bayersensor.pixelShiftEqualBright;
}
@@ -2628,14 +2534,6 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
toEdit.raw.bayersensor.pixelShiftNonGreenCross = mods.raw.bayersensor.pixelShiftNonGreenCross;
}
if (raw.bayersensor.pixelShiftNonGreenCross2) {
toEdit.raw.bayersensor.pixelShiftNonGreenCross2 = mods.raw.bayersensor.pixelShiftNonGreenCross2;
}
if (raw.bayersensor.pixelShiftNonGreenAmaze) {
toEdit.raw.bayersensor.pixelShiftNonGreenAmaze = mods.raw.bayersensor.pixelShiftNonGreenAmaze;
}
if (raw.bayersensor.greenEq) {
toEdit.raw.bayersensor.greenthresh = dontforceSet && options.baBehav[ADDSET_PREPROCESS_GREENEQUIL] ? toEdit.raw.bayersensor.greenthresh + mods.raw.bayersensor.greenthresh : mods.raw.bayersensor.greenthresh;
}
@@ -3157,9 +3055,8 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
bool RAWParamsEdited::BayerSensor::isUnchanged() const
{
return method && imageNum && dcbIterations && dcbEnhance && lmmseIterations/*&& allEnhance*/ && greenEq
&& pixelShiftMotion && pixelShiftMotionCorrection && pixelShiftMotionCorrectionMethod && pixelShiftStddevFactorGreen && pixelShiftStddevFactorRed && pixelShiftStddevFactorBlue && pixelShiftEperIso
&& pixelShiftNreadIso && pixelShiftPrnu && pixelShiftSigma && pixelShiftSum && pixelShiftRedBlueWeight && pixelShiftShowMotion && pixelShiftShowMotionMaskOnly
&& pixelShiftAutomatic && pixelShiftNonGreenHorizontal && pixelShiftNonGreenVertical && pixelShiftHoleFill && pixelShiftMedian && pixelShiftMedian3 && pixelShiftNonGreenCross && pixelShiftNonGreenCross2 && pixelShiftNonGreenAmaze && pixelShiftGreen && pixelShiftBlur && pixelShiftSmooth && pixelShiftExp0 && pixelShiftLmmse && pixelShiftOneGreen && pixelShiftEqualBright && pixelShiftEqualBrightChannel
&& pixelShiftMotionCorrectionMethod && pixelShiftEperIso && pixelShiftSigma && pixelShiftShowMotion && pixelShiftShowMotionMaskOnly
&& pixelShiftHoleFill && pixelShiftMedian && pixelShiftNonGreenCross && pixelShiftGreen && pixelShiftBlur && pixelShiftSmooth && pixelShiftLmmse && pixelShiftEqualBright && pixelShiftEqualBrightChannel
&& linenoise && linenoiseDirection && pdafLinesFilter && exBlack0 && exBlack1 && exBlack2 && exBlack3 && exTwoGreen;
}

17
rtgui/paramsedited.h
View File

@@ -729,37 +729,20 @@ public:
bool dcbIterations;
bool dcbEnhance;
bool lmmseIterations;
bool pixelShiftMotion;
bool pixelShiftMotionCorrection;
bool pixelShiftMotionCorrectionMethod;
bool pixelShiftStddevFactorGreen;
bool pixelShiftStddevFactorRed;
bool pixelShiftStddevFactorBlue;
bool pixelShiftEperIso;
bool pixelShiftNreadIso;
bool pixelShiftPrnu;
bool pixelShiftSigma;
bool pixelShiftSum;
bool pixelShiftRedBlueWeight;
bool pixelShiftShowMotion;
bool pixelShiftShowMotionMaskOnly;
bool pixelShiftAutomatic;
bool pixelShiftNonGreenHorizontal;
bool pixelShiftNonGreenVertical;
bool pixelShiftHoleFill;
bool pixelShiftMedian;
bool pixelShiftMedian3;
bool pixelShiftGreen;
bool pixelShiftBlur;
bool pixelShiftSmooth;
bool pixelShiftExp0;
bool pixelShiftLmmse;
bool pixelShiftOneGreen;
bool pixelShiftEqualBright;
bool pixelShiftEqualBrightChannel;
bool pixelShiftNonGreenCross;
bool pixelShiftNonGreenCross2;
bool pixelShiftNonGreenAmaze;
//bool allEnhance;
bool greenEq;

16
rtgui/partialpastedlg.cc
View File

@@ -846,34 +846,18 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
}
if (!raw_pixelshift->get_active ()) {
filterPE.raw.bayersensor.pixelShiftAutomatic = falsePE.raw.bayersensor.pixelShiftAutomatic;
filterPE.raw.bayersensor.pixelShiftBlur = falsePE.raw.bayersensor.pixelShiftBlur;
filterPE.raw.bayersensor.pixelShiftEperIso = falsePE.raw.bayersensor.pixelShiftEperIso;
filterPE.raw.bayersensor.pixelShiftEqualBright = falsePE.raw.bayersensor.pixelShiftEqualBright;
filterPE.raw.bayersensor.pixelShiftEqualBrightChannel = falsePE.raw.bayersensor.pixelShiftEqualBrightChannel;
filterPE.raw.bayersensor.pixelShiftExp0 = falsePE.raw.bayersensor.pixelShiftExp0;
filterPE.raw.bayersensor.pixelShiftGreen = falsePE.raw.bayersensor.pixelShiftGreen;
filterPE.raw.bayersensor.pixelShiftHoleFill = falsePE.raw.bayersensor.pixelShiftHoleFill;
filterPE.raw.bayersensor.pixelShiftLmmse = falsePE.raw.bayersensor.pixelShiftLmmse;
filterPE.raw.bayersensor.pixelShiftMedian = falsePE.raw.bayersensor.pixelShiftMedian;
filterPE.raw.bayersensor.pixelShiftMedian3 = falsePE.raw.bayersensor.pixelShiftMedian3;
filterPE.raw.bayersensor.pixelShiftMotion = falsePE.raw.bayersensor.pixelShiftMotion;
filterPE.raw.bayersensor.pixelShiftMotionCorrection = falsePE.raw.bayersensor.pixelShiftMotionCorrection;
filterPE.raw.bayersensor.pixelShiftMotionCorrectionMethod = falsePE.raw.bayersensor.pixelShiftMotionCorrectionMethod;
filterPE.raw.bayersensor.pixelShiftNonGreenAmaze = falsePE.raw.bayersensor.pixelShiftNonGreenAmaze;
filterPE.raw.bayersensor.pixelShiftNonGreenCross = falsePE.raw.bayersensor.pixelShiftNonGreenCross;
filterPE.raw.bayersensor.pixelShiftNonGreenCross2 = falsePE.raw.bayersensor.pixelShiftNonGreenCross2;
filterPE.raw.bayersensor.pixelShiftNonGreenHorizontal = falsePE.raw.bayersensor.pixelShiftNonGreenHorizontal;
filterPE.raw.bayersensor.pixelShiftNonGreenVertical = falsePE.raw.bayersensor.pixelShiftNonGreenVertical;
filterPE.raw.bayersensor.pixelShiftNreadIso = falsePE.raw.bayersensor.pixelShiftNreadIso;
filterPE.raw.bayersensor.pixelShiftPrnu = falsePE.raw.bayersensor.pixelShiftPrnu;
filterPE.raw.bayersensor.pixelShiftRedBlueWeight = falsePE.raw.bayersensor.pixelShiftRedBlueWeight;
filterPE.raw.bayersensor.pixelShiftSigma = falsePE.raw.bayersensor.pixelShiftSigma;
filterPE.raw.bayersensor.pixelShiftSmooth = falsePE.raw.bayersensor.pixelShiftSmooth;
filterPE.raw.bayersensor.pixelShiftStddevFactorBlue = falsePE.raw.bayersensor.pixelShiftStddevFactorBlue;
filterPE.raw.bayersensor.pixelShiftStddevFactorGreen = falsePE.raw.bayersensor.pixelShiftStddevFactorGreen;
filterPE.raw.bayersensor.pixelShiftStddevFactorRed = falsePE.raw.bayersensor.pixelShiftStddevFactorRed;
filterPE.raw.bayersensor.pixelShiftSum = falsePE.raw.bayersensor.pixelShiftSum;
filterPE.raw.bayersensor.pixelShiftShowMotion = falsePE.raw.bayersensor.pixelShiftShowMotion;
filterPE.raw.bayersensor.pixelShiftShowMotionMaskOnly = falsePE.raw.bayersensor.pixelShiftShowMotionMaskOnly;
}

6
rtgui/ppversion.h
View File

@@ -1,13 +1,15 @@
#pragma once
// This number has to be incremented whenever the PP3 file format is modified or the behaviour of a tool changes
#define PPVERSION 332
#define PPVERSION 333
#define PPVERSION_AEXP 301 //value of PPVERSION when auto exposure algorithm was modified
/*
Log of version changes
332 2018-04-26
333 2018-04-26
new Shadows/Highlights tool
332 2018-04-18
changed pixelShiftEperIso calculation
331 2018-02-14
changed wavelet.Lmethod to int
330 2018-01-20