4582 lines
241 KiB
C++
4582 lines
241 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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <map>
|
|
|
|
#include <locale.h>
|
|
|
|
#include <glib/gstdio.h>
|
|
|
|
#include "curves.h"
|
|
#include "procparams.h"
|
|
#include "rt_math.h"
|
|
|
|
#include "../rtgui/multilangmgr.h"
|
|
#include "../rtgui/options.h"
|
|
#include "../rtgui/paramsedited.h"
|
|
#include "../rtgui/ppversion.h"
|
|
#include "../rtgui/version.h"
|
|
|
|
#define APPVERSION RTVERSION
|
|
|
|
using namespace std;
|
|
extern Options options;
|
|
|
|
namespace
|
|
{
|
|
|
|
void avoidEmptyCurve (std::vector<double> &curve)
|
|
{
|
|
if (curve.empty()) {
|
|
curve.push_back (FCT_Linear);
|
|
}
|
|
}
|
|
|
|
void getFromKeyfile(
|
|
const Glib::KeyFile& keyfile,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
int& value
|
|
)
|
|
{
|
|
value = keyfile.get_integer(group_name, key);
|
|
}
|
|
|
|
void getFromKeyfile(
|
|
const Glib::KeyFile& keyfile,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
double& value
|
|
)
|
|
{
|
|
value = keyfile.get_double(group_name, key);
|
|
}
|
|
|
|
void getFromKeyfile(
|
|
const Glib::KeyFile& keyfile,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
bool& value
|
|
)
|
|
{
|
|
value = keyfile.get_boolean(group_name, key);
|
|
}
|
|
|
|
void getFromKeyfile(
|
|
const Glib::KeyFile& keyfile,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
Glib::ustring& value
|
|
)
|
|
{
|
|
value = keyfile.get_string(group_name, key);
|
|
}
|
|
|
|
void getFromKeyfile(
|
|
const Glib::KeyFile& keyfile,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
std::vector<double>& value
|
|
)
|
|
{
|
|
value = keyfile.get_double_list(group_name, key);
|
|
avoidEmptyCurve(value);
|
|
}
|
|
|
|
template<typename T>
|
|
bool assignFromKeyfile(
|
|
const Glib::KeyFile& keyfile,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
bool has_params_edited,
|
|
T& value,
|
|
bool& params_edited_value
|
|
)
|
|
{
|
|
if (keyfile.has_key(group_name, key)) {
|
|
getFromKeyfile(keyfile, group_name, key, value);
|
|
|
|
if (has_params_edited) {
|
|
params_edited_value = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename T, typename = typename std::enable_if<std::is_enum<T>::value>::type>
|
|
bool assignFromKeyfile(
|
|
const Glib::KeyFile& keyfile,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
bool has_params_edited,
|
|
const std::map<const char*, T>& mapping,
|
|
T& value,
|
|
bool& params_edited_value
|
|
)
|
|
{
|
|
if (keyfile.has_key(group_name, key)) {
|
|
Glib::ustring v;
|
|
getFromKeyfile(keyfile, group_name, key, v);
|
|
|
|
const typename std::map<const char*, T>::const_iterator m = mapping.find(v.c_str());
|
|
|
|
if (m != mapping.end()) {
|
|
value = m->second;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
if (has_params_edited) {
|
|
params_edited_value = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void putToKeyfile(
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
int value,
|
|
Glib::KeyFile& keyfile
|
|
)
|
|
{
|
|
keyfile.set_integer(group_name, key, value);
|
|
}
|
|
|
|
void putToKeyfile(
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
double value,
|
|
Glib::KeyFile& keyfile
|
|
)
|
|
{
|
|
keyfile.set_double(group_name, key, value);
|
|
}
|
|
|
|
void putToKeyfile(
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
bool value,
|
|
Glib::KeyFile& keyfile
|
|
)
|
|
{
|
|
keyfile.set_boolean(group_name, key, value);
|
|
}
|
|
|
|
void putToKeyfile(
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
const Glib::ustring& value,
|
|
Glib::KeyFile& keyfile
|
|
)
|
|
{
|
|
keyfile.set_string(group_name, key, value);
|
|
}
|
|
|
|
void putToKeyfile(
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
const std::vector<double>& value,
|
|
Glib::KeyFile& keyfile
|
|
)
|
|
{
|
|
const Glib::ArrayHandle<double> list = value;
|
|
keyfile.set_double_list(group_name, key, list);
|
|
}
|
|
|
|
template<typename T>
|
|
bool saveToKeyfile(
|
|
bool save,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
const T& value,
|
|
Glib::KeyFile& keyfile
|
|
)
|
|
{
|
|
if (save) {
|
|
putToKeyfile(group_name, key, value, keyfile);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename T, typename = typename std::enable_if<std::is_enum<T>::value>::type>
|
|
bool saveToKeyfile(
|
|
bool save,
|
|
const Glib::ustring& group_name,
|
|
const Glib::ustring& key,
|
|
const std::map<T, const char*>& mapping,
|
|
const T& value,
|
|
Glib::KeyFile& keyfile
|
|
)
|
|
{
|
|
if (save) {
|
|
const typename std::map<T, const char*>::const_iterator m = mapping.find(value);
|
|
|
|
if (m != mapping.end()) {
|
|
keyfile.set_string(group_name, key, m->second);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ( *)if \((!pedited \|\| pedited->.*?)\) \{\R *keyFile\.set_integer \("(.*?)", "(.*?)", (.*?)\);\R *\}\R
|
|
// \1saveToKeyfile(\2, "\3", "\4", \5, keyFile);
|
|
|
|
}
|
|
|
|
namespace rtengine
|
|
{
|
|
namespace procparams
|
|
{
|
|
const int tr = (int) options.rtSettings.top_right;
|
|
const int br = (int) options.rtSettings.bot_right;
|
|
const int tl = (int) options.rtSettings.top_left;
|
|
const int bl = (int) options.rtSettings.bot_left;
|
|
|
|
const char *LensProfParams::methodstring[static_cast<size_t>(LensProfParams::LcMode::LCP) + 1u] = {"none", "lfauto", "lfmanual", "lcp"};
|
|
const char *RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::numMethods] = {"amaze", "igv", "lmmse", "eahd", "hphd", "vng4", "dcb", "ahd", "fast", "mono", "none", "pixelshift" };
|
|
const char *RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::numMethods] = {"3-pass (best)", "1-pass (medium)", "fast", "mono", "none" };
|
|
|
|
const char *RAWParams::ff_BlurTypestring[RAWParams::numFlatFileBlurTypes] = {/*"Parametric",*/ "Area Flatfield", "Vertical Flatfield", "Horizontal Flatfield", "V+H Flatfield"};
|
|
std::vector<WBEntry*> WBParams::wbEntries;
|
|
|
|
bool ToneCurveParams::HLReconstructionNecessary (LUTu &histRedRaw, LUTu &histGreenRaw, LUTu &histBlueRaw)
|
|
{
|
|
if (options.rtSettings.verbose)
|
|
printf ("histRedRaw[ 0]=%07d, histGreenRaw[ 0]=%07d, histBlueRaw[ 0]=%07d\nhistRedRaw[255]=%07d, histGreenRaw[255]=%07d, histBlueRaw[255]=%07d\n",
|
|
histRedRaw[0], histGreenRaw[0], histBlueRaw[0], histRedRaw[255], histGreenRaw[255], histBlueRaw[255]);
|
|
|
|
return histRedRaw[255] > 50 || histGreenRaw[255] > 50 || histBlueRaw[255] > 50 || histRedRaw[0] > 50 || histGreenRaw[0] > 50 || histBlueRaw[0] > 50;
|
|
}
|
|
|
|
void WBParams::init()
|
|
{
|
|
// Creation of the different methods and its associated temperature value
|
|
wbEntries.push_back (new WBEntry ("Camera", WBT_CAMERA, M ("TP_WBALANCE_CAMERA"), 0, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Auto", WBT_AUTO, M ("TP_WBALANCE_AUTO"), 0, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Daylight", WBT_DAYLIGHT, M ("TP_WBALANCE_DAYLIGHT"), 5300, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Cloudy", WBT_CLOUDY, M ("TP_WBALANCE_CLOUDY"), 6200, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Shade", WBT_SHADE, M ("TP_WBALANCE_SHADE"), 7600, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Water 1", WBT_WATER, M ("TP_WBALANCE_WATER1"), 35000, 0.3f, 1.1f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Water 2", WBT_WATER, M ("TP_WBALANCE_WATER2"), 48000, 0.63f, 1.38f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Tungsten", WBT_TUNGSTEN, M ("TP_WBALANCE_TUNGSTEN"), 2856, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F1", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO1"), 6430, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F2", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO2"), 4230, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F3", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO3"), 3450, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F4", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO4"), 2940, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F5", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO5"), 6350, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F6", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO6"), 4150, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F7", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO7"), 6500, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F8", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO8"), 5020, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F9", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO9"), 4330, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F10", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO10"), 5300, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F11", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO11"), 4000, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Fluo F12", WBT_FLUORESCENT, M ("TP_WBALANCE_FLUO12"), 3000, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("HMI Lamp", WBT_LAMP, M ("TP_WBALANCE_HMI"), 4800, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("GTI Lamp", WBT_LAMP, M ("TP_WBALANCE_GTI"), 5000, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("JudgeIII Lamp", WBT_LAMP, M ("TP_WBALANCE_JUDGEIII"), 5100, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Solux Lamp 3500K", WBT_LAMP, M ("TP_WBALANCE_SOLUX35"), 3480, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Solux Lamp 4100K", WBT_LAMP, M ("TP_WBALANCE_SOLUX41"), 3930, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Solux Lamp 4700K", WBT_LAMP, M ("TP_WBALANCE_SOLUX47"), 4700, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("NG Solux Lamp 4700K", WBT_LAMP, M ("TP_WBALANCE_SOLUX47_NG"), 4480, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("LED LSI Lumelex 2040", WBT_LED, M ("TP_WBALANCE_LED_LSI"), 2970, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("LED CRS SP12 WWMR16", WBT_LED, M ("TP_WBALANCE_LED_CRS"), 3050, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Flash 5500K", WBT_FLASH, M ("TP_WBALANCE_FLASH55"), 5500, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Flash 6000K", WBT_FLASH, M ("TP_WBALANCE_FLASH60"), 6000, 1.f, 1.f, 0.f));
|
|
wbEntries.push_back (new WBEntry ("Flash 6500K", WBT_FLASH, M ("TP_WBALANCE_FLASH65"), 6500, 1.f, 1.f, 0.f));
|
|
// Should remain the last one
|
|
wbEntries.push_back (new WBEntry ("Custom", WBT_CUSTOM, M ("TP_WBALANCE_CUSTOM"), 0, 1.f, 1.f, 0.f));
|
|
}
|
|
|
|
void WBParams::cleanup()
|
|
{
|
|
for (unsigned int i = 0; i < wbEntries.size(); i++) {
|
|
delete wbEntries[i];
|
|
}
|
|
}
|
|
|
|
// Maps crop to resized width (e.g. smaller previews)
|
|
void CropParams::mapToResized (int resizedWidth, int resizedHeight, int scale, int &x1, int &x2, int &y1, int &y2) const
|
|
{
|
|
x1 = 0, x2 = resizedWidth, y1 = 0, y2 = resizedHeight;
|
|
|
|
if (enabled) {
|
|
x1 = min (resizedWidth - 1, max (0, x / scale));
|
|
y1 = min (resizedHeight - 1, max (0, y / scale));
|
|
x2 = min (resizedWidth, max (0, (x + w) / scale));
|
|
y2 = min (resizedHeight, max (0, (y + h) / scale));
|
|
}
|
|
}
|
|
|
|
RetinexParams::RetinexParams ()
|
|
{
|
|
setDefaults ();
|
|
}
|
|
|
|
void RetinexParams::getDefaulttransmissionCurve (std::vector<double> &curve)
|
|
{
|
|
double v[12] = { 0.00, 0.50, 0.35, 0.35,
|
|
0.60, 0.75, 0.35, 0.35,
|
|
1.00, 0.50, 0.35, 0.35,
|
|
};
|
|
|
|
|
|
curve.resize (13);
|
|
curve.at (0 ) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
void RetinexParams::getDefaultgaintransmissionCurve (std::vector<double> &curve)
|
|
{
|
|
double v[16] = { 0.00, 0.1, 0.35, 0.00,
|
|
0.25, 0.25, 0.35, 0.35,
|
|
0.70, 0.25, 0.35, 0.35,
|
|
1.00, 0.1, 0.00, 0.00
|
|
};
|
|
|
|
|
|
curve.resize (17);
|
|
curve.at (0 ) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
|
|
void RetinexParams::setDefaults()
|
|
{
|
|
enabled = false;
|
|
str = 20;
|
|
scal = 3;
|
|
iter = 1;
|
|
grad = 1;
|
|
grads = 1;
|
|
gam = 1.30;
|
|
slope = 3.;
|
|
neigh = 80;
|
|
offs = 0;
|
|
vart = 200;
|
|
limd = 8;
|
|
highl = 4;
|
|
highlights = 0;
|
|
htonalwidth = 80;
|
|
shadows = 0;
|
|
stonalwidth = 80;
|
|
radius = 40;
|
|
|
|
skal = 3;
|
|
retinexMethod = "high";
|
|
mapMethod = "none";
|
|
viewMethod = "none";
|
|
retinexcolorspace = "Lab";
|
|
gammaretinex = "none";
|
|
medianmap = false;
|
|
cdcurve.clear();
|
|
cdcurve.push_back (DCT_Linear);
|
|
cdHcurve.clear();
|
|
cdHcurve.push_back (DCT_Linear);
|
|
lhcurve.clear();
|
|
lhcurve.push_back (DCT_Linear);
|
|
mapcurve.clear();
|
|
mapcurve.push_back (DCT_Linear);
|
|
getDefaultgaintransmissionCurve (gaintransmissionCurve);
|
|
|
|
getDefaulttransmissionCurve (transmissionCurve);
|
|
}
|
|
|
|
void RetinexParams::getCurves (RetinextransmissionCurve &transmissionCurveLUT, RetinexgaintransmissionCurve &gaintransmissionCurveLUT) const
|
|
{
|
|
transmissionCurveLUT.Set (this->transmissionCurve);
|
|
gaintransmissionCurveLUT.Set (this->gaintransmissionCurve);
|
|
|
|
}
|
|
|
|
|
|
ColorToningParams::ColorToningParams () : hlColSat (60, 80, false), shadowsColSat (80, 208, false)
|
|
{
|
|
setDefaults();
|
|
}
|
|
|
|
void ColorToningParams::getDefaultColorCurve (std::vector<double> &curve)
|
|
{
|
|
double v[8] = { 0.050, 0.62, 0.25, 0.25,
|
|
0.585, 0.11, 0.25, 0.25
|
|
};
|
|
|
|
curve.resize (9);
|
|
curve.at (0) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
|
|
void ColorToningParams::getDefaultOpacityCurve (std::vector<double> &curve)
|
|
{
|
|
double v[16] = { 0.00, 0.3, 0.35, 0.00,
|
|
0.25, 0.8, 0.35, 0.35,
|
|
0.70, 0.8, 0.35, 0.35,
|
|
1.00, 0.3, 0.00, 0.00
|
|
};
|
|
curve.resize (17);
|
|
curve.at (0 ) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
void ColorToningParams::getDefaultCLCurve (std::vector<double> &curve)
|
|
{
|
|
double v[6] = { 0.00, 0.00,
|
|
0.35, 0.65,
|
|
1.00, 1.00
|
|
};
|
|
|
|
curve.resize (7);
|
|
curve.at (0) = double (DCT_NURBS);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
void ColorToningParams::getDefaultCL2Curve (std::vector<double> &curve)
|
|
{
|
|
double v[6] = { 0.00, 0.00,
|
|
0.35, 0.65,
|
|
1.00, 1.00
|
|
};
|
|
|
|
curve.resize (7);
|
|
curve.at (0) = double (DCT_NURBS);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
void ColorToningParams::setDefaults()
|
|
{
|
|
enabled = false;
|
|
autosat = true;
|
|
method = "Lab";
|
|
|
|
getDefaultColorCurve (colorCurve);
|
|
getDefaultOpacityCurve (opacityCurve);
|
|
getDefaultCLCurve (clcurve);
|
|
getDefaultCL2Curve (cl2curve);
|
|
|
|
hlColSat.setValues (60, 80);
|
|
shadowsColSat.setValues (80, 208);
|
|
balance = 0;
|
|
satProtectionThreshold = 30;
|
|
saturatedOpacity = 80;
|
|
strength = 50;
|
|
lumamode = true;
|
|
twocolor = "Std";
|
|
redlow = 0.0;
|
|
greenlow = 0.0;
|
|
bluelow = 0.0;
|
|
satlow = 0.0;
|
|
sathigh = 0.0;
|
|
redmed = 0.0;
|
|
greenmed = 0.0;
|
|
bluemed = 0.0;
|
|
redhigh = 0.0;
|
|
greenhigh = 0.0;
|
|
bluehigh = 0.0;
|
|
}
|
|
|
|
void ColorToningParams::mixerToCurve (std::vector<double> &colorCurve, std::vector<double> &opacityCurve) const
|
|
{
|
|
// check if non null first
|
|
if (!redlow && !greenlow && !bluelow && !redmed && !greenmed && !bluemed && !redhigh && !greenhigh && !bluehigh) {
|
|
colorCurve.resize (1);
|
|
colorCurve.at (0) = FCT_Linear;
|
|
opacityCurve.resize (1);
|
|
opacityCurve.at (0) = FCT_Linear;
|
|
return;
|
|
}
|
|
|
|
float low[3]; // RGB color for shadows
|
|
float med[3]; // RGB color for mid-tones
|
|
float high[3]; // RGB color for highlights
|
|
float lowSat = 0.f;
|
|
float medSat = 0.f;
|
|
float highSat = 0.f;
|
|
float minTmp, maxTmp;
|
|
|
|
// Fill the shadow mixer values of the Color TOning tool
|
|
low[0] = float (redlow ) / 100.f; // [-1. ; +1.]
|
|
low[1] = float (greenlow) / 100.f; // [-1. ; +1.]
|
|
low[2] = float (bluelow ) / 100.f; // [-1. ; +1.]
|
|
minTmp = min<float> (low[0], low[1], low[2]);
|
|
maxTmp = max<float> (low[0], low[1], low[2]);
|
|
|
|
if (maxTmp - minTmp > 0.005f) {
|
|
float v[3];
|
|
lowSat = (maxTmp - minTmp) / 2.f;
|
|
|
|
if (low[0] == minTmp) {
|
|
v[0] = 0.f;
|
|
} else if (low[1] == minTmp) {
|
|
v[1] = 0.f;
|
|
} else if (low[2] == minTmp) {
|
|
v[2] = 0.f;
|
|
}
|
|
|
|
if (low[0] == maxTmp) {
|
|
v[0] = 1.f;
|
|
} else if (low[1] == maxTmp) {
|
|
v[1] = 1.f;
|
|
} else if (low[2] == maxTmp) {
|
|
v[2] = 1.f;
|
|
}
|
|
|
|
if (low[0] != minTmp && low[0] != maxTmp) {
|
|
v[0] = (low[0] - minTmp) / (maxTmp - minTmp);
|
|
} else if (low[1] != minTmp && low[1] != maxTmp) {
|
|
v[1] = (low[1] - minTmp) / (maxTmp - minTmp);
|
|
} else if (low[2] != minTmp && low[2] != maxTmp) {
|
|
v[2] = (low[2] - minTmp) / (maxTmp - minTmp);
|
|
}
|
|
|
|
low[0] = v[0];
|
|
low[1] = v[1];
|
|
low[2] = v[2];
|
|
} else {
|
|
low[0] = low[1] = low[2] = 1.f;
|
|
}
|
|
|
|
// Fill the mid-tones mixer values of the Color TOning tool
|
|
med[0] = float (redmed ) / 100.f; // [-1. ; +1.]
|
|
med[1] = float (greenmed) / 100.f; // [-1. ; +1.]
|
|
med[2] = float (bluemed ) / 100.f; // [-1. ; +1.]
|
|
minTmp = min<float> (med[0], med[1], med[2]);
|
|
maxTmp = max<float> (med[0], med[1], med[2]);
|
|
|
|
if (maxTmp - minTmp > 0.005f) {
|
|
float v[3];
|
|
medSat = (maxTmp - minTmp) / 2.f;
|
|
|
|
if (med[0] == minTmp) {
|
|
v[0] = 0.f;
|
|
} else if (med[1] == minTmp) {
|
|
v[1] = 0.f;
|
|
} else if (med[2] == minTmp) {
|
|
v[2] = 0.f;
|
|
}
|
|
|
|
if (med[0] == maxTmp) {
|
|
v[0] = 1.f;
|
|
} else if (med[1] == maxTmp) {
|
|
v[1] = 1.f;
|
|
} else if (med[2] == maxTmp) {
|
|
v[2] = 1.f;
|
|
}
|
|
|
|
if (med[0] != minTmp && med[0] != maxTmp) {
|
|
v[0] = (med[0] - minTmp) / (maxTmp - minTmp);
|
|
} else if (med[1] != minTmp && med[1] != maxTmp) {
|
|
v[1] = (med[1] - minTmp) / (maxTmp - minTmp);
|
|
} else if (med[2] != minTmp && med[2] != maxTmp) {
|
|
v[2] = (med[2] - minTmp) / (maxTmp - minTmp);
|
|
}
|
|
|
|
med[0] = v[0];
|
|
med[1] = v[1];
|
|
med[2] = v[2];
|
|
} else {
|
|
med[0] = med[1] = med[2] = 1.f;
|
|
}
|
|
|
|
// Fill the highlight mixer values of the Color TOning tool
|
|
high[0] = float (redhigh ) / 100.f; // [-1. ; +1.]
|
|
high[1] = float (greenhigh) / 100.f; // [-1. ; +1.]
|
|
high[2] = float (bluehigh ) / 100.f; // [-1. ; +1.]
|
|
minTmp = min<float> (high[0], high[1], high[2]);
|
|
maxTmp = max<float> (high[0], high[1], high[2]);
|
|
|
|
if (maxTmp - minTmp > 0.005f) {
|
|
float v[3];
|
|
highSat = (maxTmp - minTmp) / 2.f;
|
|
|
|
if (high[0] == minTmp) {
|
|
v[0] = 0.f;
|
|
} else if (high[1] == minTmp) {
|
|
v[1] = 0.f;
|
|
} else if (high[2] == minTmp) {
|
|
v[2] = 0.f;
|
|
}
|
|
|
|
if (high[0] == maxTmp) {
|
|
v[0] = 1.f;
|
|
} else if (high[1] == maxTmp) {
|
|
v[1] = 1.f;
|
|
} else if (high[2] == maxTmp) {
|
|
v[2] = 1.f;
|
|
}
|
|
|
|
if (high[0] != minTmp && high[0] != maxTmp) {
|
|
v[0] = (high[0] - minTmp) / (maxTmp - minTmp);
|
|
} else if (high[1] != minTmp && high[1] != maxTmp) {
|
|
v[1] = (high[1] - minTmp) / (maxTmp - minTmp);
|
|
} else if (high[2] != minTmp && high[2] != maxTmp) {
|
|
v[2] = (high[2] - minTmp) / (maxTmp - minTmp);
|
|
}
|
|
|
|
high[0] = v[0];
|
|
high[1] = v[1];
|
|
high[2] = v[2];
|
|
} else {
|
|
high[0] = high[1] = high[2] = 1.f;
|
|
}
|
|
|
|
|
|
|
|
|
|
const double xPosLow = 0.1;
|
|
const double xPosMed = 0.4;
|
|
const double xPosHigh = 0.7;
|
|
|
|
|
|
|
|
colorCurve.resize ( medSat != 0.f ? 13 : 9 );
|
|
colorCurve.at (0) = FCT_MinMaxCPoints;
|
|
opacityCurve.resize (13);
|
|
opacityCurve.at (0) = FCT_MinMaxCPoints;
|
|
|
|
float h, s, l;
|
|
int idx = 1;
|
|
|
|
if (lowSat == 0.f) {
|
|
if (medSat != 0.f) {
|
|
Color::rgb2hsl (med[0], med[1], med[2], h, s, l);
|
|
} else { // highSat can't be null if the 2 other ones are!
|
|
Color::rgb2hsl (high[0], high[1], high[2], h, s, l);
|
|
}
|
|
} else {
|
|
Color::rgb2hsl (low[0], low[1], low[2], h, s, l);
|
|
}
|
|
|
|
colorCurve.at (idx++) = xPosLow;
|
|
colorCurve.at (idx++) = h;
|
|
colorCurve.at (idx++) = 0.35;
|
|
colorCurve.at (idx++) = 0.35;
|
|
|
|
if (medSat != 0.f) {
|
|
Color::rgb2hsl (med[0], med[1], med[2], h, s, l);
|
|
colorCurve.at (idx++) = xPosMed;
|
|
colorCurve.at (idx++) = h;
|
|
colorCurve.at (idx++) = 0.35;
|
|
colorCurve.at (idx++) = 0.35;
|
|
}
|
|
|
|
if (highSat == 0.f) {
|
|
if (medSat != 0.f) {
|
|
Color::rgb2hsl (med[0], med[1], med[2], h, s, l);
|
|
} else { // lowSat can't be null if the 2 other ones are!
|
|
Color::rgb2hsl (low[0], low[1], low[2], h, s, l);
|
|
}
|
|
} else {
|
|
Color::rgb2hsl (high[0], high[1], high[2], h, s, l);
|
|
}
|
|
|
|
colorCurve.at (idx++) = xPosHigh;
|
|
colorCurve.at (idx++) = h;
|
|
colorCurve.at (idx++) = 0.35;
|
|
colorCurve.at (idx) = 0.35;
|
|
|
|
opacityCurve.at (1) = xPosLow;
|
|
opacityCurve.at (2) = double (lowSat);
|
|
opacityCurve.at (3) = 0.35;
|
|
opacityCurve.at (4) = 0.35;
|
|
opacityCurve.at (5) = xPosMed;
|
|
opacityCurve.at (6) = double (medSat);
|
|
opacityCurve.at (7) = 0.35;
|
|
opacityCurve.at (8) = 0.35;
|
|
opacityCurve.at (9) = xPosHigh;
|
|
opacityCurve.at (10) = double (highSat);
|
|
opacityCurve.at (11) = 0.35;
|
|
opacityCurve.at (12) = 0.35;
|
|
}
|
|
|
|
void ColorToningParams::slidersToCurve (std::vector<double> &colorCurve, std::vector<double> &opacityCurve) const
|
|
{
|
|
if (hlColSat.value[0] == 0 && shadowsColSat.value[0] == 0) { // if both opacity are null, set both curves to Linear
|
|
colorCurve.resize (1);
|
|
colorCurve.at (0) = FCT_Linear;
|
|
opacityCurve.resize (1);
|
|
opacityCurve.at (0) = FCT_Linear;
|
|
return;
|
|
}
|
|
|
|
colorCurve.resize (9);
|
|
colorCurve.at (0) = FCT_MinMaxCPoints;
|
|
colorCurve.at (1) = 0.26 + 0.12 * double (balance) / 100.;
|
|
colorCurve.at (2) = double (shadowsColSat.value[1]) / 360.;
|
|
colorCurve.at (3) = 0.35;
|
|
colorCurve.at (4) = 0.35;
|
|
colorCurve.at (5) = 0.64 + 0.12 * double (balance) / 100.;
|
|
colorCurve.at (6) = double (hlColSat.value[1]) / 360.;
|
|
colorCurve.at (7) = 0.35;
|
|
colorCurve.at (8) = 0.35;
|
|
|
|
opacityCurve.resize (9);
|
|
opacityCurve.at (0) = FCT_MinMaxCPoints;
|
|
opacityCurve.at (1) = colorCurve.at (1);
|
|
opacityCurve.at (2) = double (shadowsColSat.value[0]) / 100.;
|
|
opacityCurve.at (3) = 0.35;
|
|
opacityCurve.at (4) = 0.35;
|
|
opacityCurve.at (5) = colorCurve.at (5);
|
|
opacityCurve.at (6) = double (hlColSat.value[0]) / 100.;
|
|
opacityCurve.at (7) = 0.35;
|
|
opacityCurve.at (8) = 0.35;
|
|
}
|
|
|
|
void ColorToningParams::getCurves (ColorGradientCurve &colorCurveLUT, OpacityCurve &opacityCurveLUT, const double xyz_rgb[3][3], const double rgb_xyz[3][3], bool &opautili) const
|
|
{
|
|
float satur = 0.8f;
|
|
float lumin = 0.5f; //middle of luminance for optimization of gamut - no real importance...as we work in XYZ and gamut control
|
|
|
|
// Transform slider values to control points
|
|
std::vector<double> cCurve, oCurve;
|
|
|
|
if (method == "RGBSliders" || method == "Splitlr") {
|
|
slidersToCurve (cCurve, oCurve);
|
|
} else if (method == "Splitco") {
|
|
mixerToCurve (cCurve, oCurve);
|
|
} else {
|
|
cCurve = this->colorCurve;
|
|
oCurve = this->opacityCurve;
|
|
}
|
|
|
|
if (method == "Lab") {
|
|
if (twocolor == "Separ") {
|
|
satur = 0.9f;
|
|
}
|
|
|
|
if (twocolor == "All" || twocolor == "Two") {
|
|
satur = 0.9f;
|
|
}
|
|
|
|
colorCurveLUT.SetXYZ (cCurve, xyz_rgb, rgb_xyz, satur, lumin);
|
|
opacityCurveLUT.Set (oCurve, opautili);
|
|
} else if (method == "Splitlr" || method == "Splitco") {
|
|
colorCurveLUT.SetXYZ (cCurve, xyz_rgb, rgb_xyz, satur, lumin);
|
|
opacityCurveLUT.Set (oCurve, opautili);
|
|
} else if (method.substr (0, 3) == "RGB") {
|
|
colorCurveLUT.SetRGB (cCurve, xyz_rgb, rgb_xyz);
|
|
opacityCurveLUT.Set (oCurve, opautili);
|
|
}
|
|
}
|
|
|
|
SharpeningParams::SharpeningParams() :
|
|
enabled (false),
|
|
radius (0.5),
|
|
amount (200),
|
|
threshold (20, 80, 2000, 1200, false),
|
|
edgesonly (false),
|
|
edges_radius (1.9),
|
|
edges_tolerance (1800),
|
|
halocontrol (false),
|
|
halocontrol_amount (85),
|
|
deconvamount (75),
|
|
deconvradius (0.75),
|
|
deconviter (30),
|
|
deconvdamping (20)
|
|
{};
|
|
|
|
|
|
VibranceParams::VibranceParams() :
|
|
enabled (false),
|
|
pastels (0),
|
|
saturated (0),
|
|
psthreshold (0, 75, false),
|
|
protectskins (false),
|
|
avoidcolorshift (true),
|
|
pastsattog (true)
|
|
{};
|
|
|
|
|
|
//WaveletParams::WaveletParams (): hueskin(-5, 25, 170, 120, false), hueskin2(-260, -250, -130, -140, false), hllev(50, 75, 100, 98, false), bllev(0, 2, 50, 25, false), pastlev(0, 2, 30, 20, false), satlev(30, 45, 130, 100, false), edgcont(0, 20, 100, 75, false){
|
|
|
|
WaveletParams::WaveletParams() :
|
|
hueskin ( -5, 25, 170, 120, false),
|
|
hueskin2 (-260, -250, -130, -140, false),
|
|
hllev ( 50, 75, 100, 98, false),
|
|
bllev ( 0, 2, 50, 25, false),
|
|
pastlev ( 0, 2, 30, 20, false),
|
|
satlev ( 30, 45, 130, 100, false),
|
|
edgcont ( bl, tl, br, tr, false),
|
|
/*edgcont ( 0, 10, 75, 40, false),*/
|
|
level0noise (0, 0, false),
|
|
level1noise (0, 0, false),
|
|
level2noise (0, 0, false),
|
|
level3noise (0, 0, false)
|
|
{
|
|
setDefaults ();
|
|
}
|
|
|
|
void WaveletParams::getDefaultOpacityCurveRG (std::vector<double> &curve)
|
|
{
|
|
double v[8] = { 0.0, 0.50, 0.35, 0.35,
|
|
1.00, 0.50, 0.35, 0.35
|
|
};
|
|
|
|
curve.resize (9);
|
|
curve.at (0) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
void WaveletParams::getDefaultOpacityCurveBY (std::vector<double> &curve)
|
|
{
|
|
double v[8] = { 0.0, 0.50, 0.35, 0.35,
|
|
1.00, 0.50, 0.35, 0.35
|
|
};
|
|
|
|
curve.resize (9);
|
|
curve.at (0 ) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
|
|
void WaveletParams::getDefaultOpacityCurveW (std::vector<double> &curve)
|
|
{
|
|
double v[16] = { 0.00, 0.35, 0.35, 0.00,
|
|
0.35, 0.75, 0.35, 0.35,
|
|
0.60, 0.75, 0.35, 0.35,
|
|
1.00, 0.35, 0.00, 0.00
|
|
};
|
|
curve.resize (17);
|
|
curve.at (0) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
void WaveletParams::getDefaultOpacityCurveWL (std::vector<double> &curve)
|
|
{
|
|
double v[8] = { 0.0, 0.50, 0.35, 0.35,
|
|
1.00, 0.50, 0.35, 0.35
|
|
};
|
|
|
|
/*double v[12]={ 0.00, 0.53, 0.35, 0.00,
|
|
0.42, 0.53, 0.35, 0.35,
|
|
1.00, 0.15, 0.00, 0.00 };
|
|
*/
|
|
curve.resize (9);
|
|
curve.at (0) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
|
|
void WaveletParams::getDefaultCCWCurve (std::vector<double> &curve)
|
|
{
|
|
double v[12] = { 0.0, 0.25, 0.35, 0.35,
|
|
0.50, 0.75, 0.35, 0.35,
|
|
0.90, 0.0, 0.35, 0.35
|
|
};
|
|
|
|
curve.resize (13);
|
|
curve.at (0 ) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
|
|
}
|
|
|
|
void WaveletParams::getCurves (WavCurve &cCurve, WavOpacityCurveRG &opacityCurveLUTRG, WavOpacityCurveBY &opacityCurveLUTBY, WavOpacityCurveW &opacityCurveLUTW, WavOpacityCurveWL &opacityCurveLUTWL) const
|
|
{
|
|
cCurve.Set (this->ccwcurve);
|
|
opacityCurveLUTRG.Set (this->opacityCurveRG);
|
|
opacityCurveLUTBY.Set (this->opacityCurveBY);
|
|
opacityCurveLUTW.Set (this->opacityCurveW);
|
|
opacityCurveLUTWL.Set (this->opacityCurveWL);
|
|
|
|
}
|
|
|
|
void WaveletParams::setDefaults()
|
|
{
|
|
getDefaultCCWCurve (ccwcurve);
|
|
getDefaultOpacityCurveRG (opacityCurveRG);
|
|
getDefaultOpacityCurveBY (opacityCurveBY);
|
|
getDefaultOpacityCurveW (opacityCurveW);
|
|
getDefaultOpacityCurveWL (opacityCurveWL);
|
|
enabled = false;
|
|
median = false;
|
|
medianlev = false;
|
|
linkedg = true;
|
|
cbenab = false;
|
|
lipst = false;
|
|
Medgreinf = "less"; //"none";
|
|
avoid = false;
|
|
tmr = false;
|
|
strength = 100;
|
|
balance = 0;
|
|
iter = 0;
|
|
wavclCurve.clear ();
|
|
wavclCurve.push_back (DCT_Linear);
|
|
|
|
Lmethod = "4_";
|
|
CHmethod = "without";
|
|
CHSLmethod = "SL";
|
|
EDmethod = "CU";
|
|
NPmethod = "none";
|
|
BAmethod = "none";
|
|
TMmethod = "cont";
|
|
HSmethod = "with";
|
|
CLmethod = "all";
|
|
Backmethod = "grey";
|
|
Dirmethod = "all";
|
|
Tilesmethod = "full";
|
|
daubcoeffmethod = "4_";
|
|
rescon = 0;
|
|
resconH = 0;
|
|
reschro = 0;
|
|
tmrs = 0;
|
|
gamma = 1;
|
|
sky = 0.;
|
|
sup = 0;
|
|
thres = 7;
|
|
chroma = 5;
|
|
chro = 0;
|
|
contrast = 0;
|
|
edgrad = 15;
|
|
edgval = 0;
|
|
edgthresh = 10;
|
|
thr = 35;
|
|
thrH = 65;
|
|
skinprotect = 0.;
|
|
hueskin.setValues ( -5, 25, 170, 120);
|
|
hueskin2.setValues (-260, -250, -130, -140);
|
|
threshold = 5;
|
|
threshold2 = 4;
|
|
edgedetect = 90;
|
|
edgedetectthr = 20;
|
|
edgedetectthr2 = 0;
|
|
edgesensi = 60;
|
|
edgeampli = 10;
|
|
hllev.setValues (50, 75, 100, 98);
|
|
bllev.setValues ( 0, 2, 50, 25);
|
|
pastlev.setValues ( 0, 2, 30, 20);
|
|
satlev.setValues (30, 45, 130, 100);
|
|
//edgcont.setValues (bl, tl, br, tr);
|
|
edgcont.setValues ( 0, 10, 75, 40);
|
|
level0noise.setValues (0, 0);
|
|
level1noise.setValues (0, 0);
|
|
level2noise.setValues (0, 0);
|
|
level3noise.setValues (0, 0);
|
|
hhcurve.clear ();
|
|
hhcurve.push_back (FCT_Linear);
|
|
Chcurve.clear ();
|
|
Chcurve.push_back (FCT_Linear);
|
|
expcontrast = false;
|
|
expchroma = false;
|
|
expedge = false;
|
|
expresid = false;
|
|
expfinal = false;
|
|
exptoning = false;
|
|
expnoise = false;
|
|
|
|
for (int i = 0; i < 9; i ++) {
|
|
c[i] = 0;
|
|
}
|
|
|
|
for (int i = 0; i < 9; i ++) {
|
|
ch[i] = 0;
|
|
}
|
|
|
|
greenlow = greenmed = greenhigh = 0.0;
|
|
bluelow = bluemed = bluehigh = 0.0;
|
|
|
|
}
|
|
|
|
|
|
DirPyrDenoiseParams::DirPyrDenoiseParams ()
|
|
{
|
|
setDefaults ();
|
|
}
|
|
|
|
void DirPyrDenoiseParams::getDefaultNoisCurve (std::vector<double> &curve)
|
|
{
|
|
double v[8] = { 0.05, 0.15, 0.35, 0.35,
|
|
0.55, 0.04, 0.35, 0.35
|
|
};
|
|
curve.resize (9);
|
|
curve.at (0 ) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
void DirPyrDenoiseParams::getDefaultCCCurve (std::vector<double> &curve)
|
|
{
|
|
// double v[8]= { 0.15, 0.00,0.35,0.35,
|
|
// 0.60, 0.05,0.35,0.35};
|
|
double v[8] = { 0.05, 0.50, 0.35, 0.35,
|
|
0.35, 0.05, 0.35, 0.35
|
|
};
|
|
|
|
curve.resize (9);
|
|
curve.at (0 ) = double (FCT_MinMaxCPoints);
|
|
|
|
for (size_t i = 1; i < curve.size(); ++i) {
|
|
curve.at (i) = v[i - 1];
|
|
}
|
|
}
|
|
|
|
|
|
void DirPyrDenoiseParams::setDefaults()
|
|
{
|
|
|
|
getDefaultNoisCurve (lcurve);
|
|
getDefaultCCCurve (cccurve);
|
|
|
|
enabled = false;
|
|
enhance = false;
|
|
median = false;
|
|
perform = false;
|
|
luma = 0;
|
|
passes = 1;
|
|
dmethod = "Lab";
|
|
Lmethod = "SLI";//"CUR";// SLIDER method with value 0 is set as default, while the default Lcurve is populated via getDefaultNoisCurve and can be switched to by the user
|
|
Cmethod = "MAN";
|
|
C2method = "AUTO";
|
|
smethod = "shal";
|
|
medmethod = "soft";
|
|
methodmed = "none";
|
|
rgbmethod = "soft";
|
|
Ldetail = 0;
|
|
chroma = 15;
|
|
redchro = 0;
|
|
bluechro = 0;
|
|
gamma = 1.7;
|
|
perform = false;
|
|
}
|
|
|
|
void DirPyrDenoiseParams::getCurves (NoiseCurve &lCurve, NoiseCurve &cCurve) const
|
|
{
|
|
lCurve.Set (this->lcurve);
|
|
cCurve.Set (this->cccurve);
|
|
}
|
|
|
|
void ToneCurveParams::setDefaults()
|
|
{
|
|
autoexp = false;
|
|
clip = 0.02;
|
|
expcomp = 0;
|
|
brightness = 0;
|
|
contrast = 0;
|
|
saturation = 0;
|
|
black = 0;
|
|
hlcompr = 0;
|
|
hlcomprthresh = 33;
|
|
shcompr = 50;
|
|
curve.clear ();
|
|
curve.push_back (DCT_Linear);
|
|
curve2.clear ();
|
|
curve2.push_back (DCT_Linear);
|
|
curveMode = ToneCurveParams::TC_MODE_STD;
|
|
curveMode2 = ToneCurveParams::TC_MODE_STD;
|
|
hrenabled = false;
|
|
method = "Blend";
|
|
}
|
|
|
|
void LensProfParams::setDefaults()
|
|
{
|
|
lcMode = LcMode::NONE;
|
|
lcpFile = "";
|
|
useDist = useVign = true;
|
|
useCA = false;
|
|
lfCameraMake = "";
|
|
lfCameraModel = "";
|
|
lfLens = "";
|
|
}
|
|
|
|
void CoarseTransformParams::setDefaults()
|
|
{
|
|
rotate = 0;
|
|
hflip = false;
|
|
vflip = false;
|
|
}
|
|
void RAWParams::BayerSensor::setPixelShiftDefaults()
|
|
{
|
|
pixelShiftMotion = 0;
|
|
pixelShiftMotionCorrection = RAWParams::BayerSensor::Grid3x3New;
|
|
pixelShiftMotionCorrectionMethod = RAWParams::BayerSensor::Automatic;
|
|
pixelShiftStddevFactorGreen = 5.0;
|
|
pixelShiftStddevFactorRed = 5.0;
|
|
pixelShiftStddevFactorBlue = 5.0;
|
|
pixelShiftEperIso = 0.0;
|
|
pixelShiftNreadIso = 0.0;
|
|
pixelShiftPrnu = 1.0;
|
|
pixelShiftSigma = 1.0;
|
|
pixelShiftSum = 3.0;
|
|
pixelShiftRedBlueWeight = 0.7;
|
|
pixelShiftAutomatic = true;
|
|
pixelShiftNonGreenHorizontal = false;
|
|
pixelShiftNonGreenVertical = false;
|
|
pixelShiftHoleFill = true;
|
|
pixelShiftMedian = false;
|
|
pixelShiftMedian3 = false;
|
|
pixelShiftGreen = true;
|
|
pixelShiftBlur = true;
|
|
pixelShiftSmoothFactor = 0.7;
|
|
pixelShiftExp0 = false;
|
|
pixelShiftLmmse = false;
|
|
pixelShiftEqualBright = false;
|
|
pixelShiftEqualBrightChannel = false;
|
|
pixelShiftNonGreenCross = true;
|
|
pixelShiftNonGreenCross2 = false;
|
|
pixelShiftNonGreenAmaze = false;
|
|
}
|
|
|
|
void RAWParams::setDefaults()
|
|
{
|
|
bayersensor.method = RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::amaze];
|
|
bayersensor.imageNum = 0;
|
|
bayersensor.ccSteps = 0;
|
|
bayersensor.dcb_iterations = 2;
|
|
bayersensor.dcb_enhance = true;
|
|
//bayersensor.all_enhance = false;
|
|
bayersensor.lmmse_iterations = 2;
|
|
bayersensor.black0 = 0.0;
|
|
bayersensor.black1 = 0.0;
|
|
bayersensor.black2 = 0.0;
|
|
bayersensor.black3 = 0.0;
|
|
bayersensor.twogreen = true;
|
|
bayersensor.linenoise = 0;
|
|
bayersensor.greenthresh = 0;
|
|
|
|
xtranssensor.method = RAWParams::XTransSensor::methodstring[RAWParams::XTransSensor::threePass];
|
|
xtranssensor.ccSteps = 0;
|
|
xtranssensor.blackred = 0.0;
|
|
xtranssensor.blackgreen = 0.0;
|
|
xtranssensor.blackblue = 0.0;
|
|
|
|
expos = 1.0;
|
|
preser = 0.0;
|
|
df_autoselect = false;
|
|
ff_AutoSelect = false;
|
|
ff_BlurRadius = 32;
|
|
ff_BlurType = RAWParams::ff_BlurTypestring[RAWParams::area_ff];
|
|
ff_AutoClipControl = false;
|
|
ff_clipControl = 0;
|
|
cared = 0;
|
|
cablue = 0;
|
|
ca_autocorrect = false;
|
|
hotPixelFilter = false;
|
|
deadPixelFilter = false;
|
|
hotdeadpix_thresh = 100;
|
|
bayersensor.setPixelShiftDefaults();
|
|
bayersensor.pixelShiftShowMotion = false;
|
|
bayersensor.pixelShiftShowMotionMaskOnly = false;
|
|
|
|
}
|
|
|
|
void ColorManagementParams::setDefaults()
|
|
{
|
|
input = "(cameraICC)";
|
|
toneCurve = false;
|
|
applyLookTable = false;
|
|
applyBaselineExposureOffset = true;
|
|
applyHueSatMap = true;
|
|
dcpIlluminant = 0;
|
|
working = "ProPhoto";
|
|
output = "RT_sRGB";
|
|
outputIntent = RI_RELATIVE;
|
|
outputBPC = true;
|
|
gamma = "default";
|
|
gampos = 2.22;
|
|
slpos = 4.5;
|
|
freegamma = false;
|
|
}
|
|
|
|
ProcParams::ProcParams ()
|
|
{
|
|
|
|
setDefaults ();
|
|
}
|
|
|
|
void ProcParams::init ()
|
|
{
|
|
|
|
WBParams::init();
|
|
}
|
|
|
|
void ProcParams::cleanup ()
|
|
{
|
|
|
|
WBParams::cleanup();
|
|
}
|
|
|
|
ProcParams* ProcParams::create ()
|
|
{
|
|
|
|
return new ProcParams();
|
|
}
|
|
|
|
void ProcParams::destroy (ProcParams* pp)
|
|
{
|
|
|
|
delete pp;
|
|
}
|
|
|
|
void ProcParams::setDefaults ()
|
|
{
|
|
|
|
toneCurve.setDefaults();
|
|
|
|
labCurve.brightness = 0;
|
|
labCurve.contrast = 0;
|
|
labCurve.chromaticity = 0;
|
|
labCurve.avoidcolorshift = false;
|
|
labCurve.lcredsk = true;
|
|
labCurve.rstprotection = 0;
|
|
labCurve.lcurve.clear ();
|
|
labCurve.lcurve.push_back (DCT_Linear);
|
|
labCurve.acurve.clear ();
|
|
labCurve.acurve.push_back (DCT_Linear);
|
|
labCurve.bcurve.clear ();
|
|
labCurve.bcurve.push_back (DCT_Linear);
|
|
labCurve.cccurve.clear ();
|
|
labCurve.cccurve.push_back (DCT_Linear);
|
|
labCurve.chcurve.clear ();
|
|
labCurve.chcurve.push_back (FCT_Linear);
|
|
labCurve.lhcurve.clear ();
|
|
labCurve.lhcurve.push_back (FCT_Linear);
|
|
labCurve.hhcurve.clear ();
|
|
labCurve.hhcurve.push_back (FCT_Linear);
|
|
|
|
labCurve.lccurve.clear ();
|
|
labCurve.lccurve.push_back (DCT_Linear);
|
|
labCurve.clcurve.clear ();
|
|
labCurve.clcurve.push_back (DCT_Linear);
|
|
|
|
rgbCurves.lumamode = false;
|
|
rgbCurves.rcurve.clear ();
|
|
rgbCurves.rcurve.push_back (DCT_Linear);
|
|
rgbCurves.gcurve.clear ();
|
|
rgbCurves.gcurve.push_back (DCT_Linear);
|
|
rgbCurves.bcurve.clear ();
|
|
rgbCurves.bcurve.push_back (DCT_Linear);
|
|
|
|
colorToning.setDefaults();
|
|
|
|
sharpenEdge.enabled = false;
|
|
sharpenEdge.passes = 2;
|
|
sharpenEdge.amount = 50.0;
|
|
sharpenEdge.threechannels = false;
|
|
|
|
sharpenMicro.enabled = false;
|
|
sharpenMicro.amount = 20.0;
|
|
sharpenMicro.uniformity = 50.0;
|
|
sharpenMicro.matrix = false;
|
|
|
|
sharpening.enabled = false;
|
|
sharpening.radius = 0.5;
|
|
sharpening.amount = 200;
|
|
sharpening.threshold.setValues (20, 80, 2000, 1200);
|
|
sharpening.edgesonly = false;
|
|
sharpening.edges_radius = 1.9;
|
|
sharpening.edges_tolerance = 1800;
|
|
sharpening.halocontrol = false;
|
|
sharpening.halocontrol_amount = 85;
|
|
sharpening.method = "usm";
|
|
sharpening.deconvradius = 0.75;
|
|
sharpening.deconviter = 30;
|
|
sharpening.deconvdamping = 20;
|
|
sharpening.deconvamount = 75;
|
|
|
|
prsharpening.enabled = false;
|
|
prsharpening.radius = 0.5;
|
|
prsharpening.amount = 200;
|
|
prsharpening.threshold.setValues (20, 80, 2000, 1200);
|
|
prsharpening.edgesonly = false;
|
|
prsharpening.edges_radius = 1.9;
|
|
prsharpening.edges_tolerance = 1800;
|
|
prsharpening.halocontrol = false;
|
|
prsharpening.halocontrol_amount = 85;
|
|
prsharpening.method = "rld";
|
|
prsharpening.deconvradius = 0.45;
|
|
prsharpening.deconviter = 100;
|
|
prsharpening.deconvdamping = 0;
|
|
prsharpening.deconvamount = 100;
|
|
|
|
vibrance.enabled = false;
|
|
vibrance.pastels = 0;
|
|
vibrance.saturated = 0;
|
|
vibrance.psthreshold.setValues (0, 75);
|
|
vibrance.protectskins = false;
|
|
vibrance.avoidcolorshift = true;
|
|
vibrance.pastsattog = true;
|
|
vibrance.skintonescurve.clear ();
|
|
vibrance.skintonescurve.push_back (DCT_Linear);
|
|
|
|
wb.method = "Camera";
|
|
wb.temperature = 6504;
|
|
wb.green = 1.0;
|
|
wb.equal = 1.0;
|
|
wb.tempBias = 0.0;
|
|
colorappearance.enabled = false;
|
|
colorappearance.degree = 90;
|
|
colorappearance.autodegree = true;
|
|
colorappearance.degreeout = 90;
|
|
colorappearance.autodegreeout = true;
|
|
colorappearance.surround = "Average";
|
|
colorappearance.surrsrc = "Average";
|
|
colorappearance.adaplum = 16;
|
|
colorappearance.badpixsl = 0;
|
|
colorappearance.adapscen = 2000.0;
|
|
colorappearance.autoadapscen = true;
|
|
colorappearance.ybscen = 18;
|
|
colorappearance.autoybscen = true;
|
|
colorappearance.algo = "No";
|
|
colorappearance.wbmodel = "RawT";
|
|
colorappearance.jlight = 0.0;
|
|
colorappearance.qbright = 0.0;
|
|
colorappearance.chroma = 0.0;
|
|
colorappearance.schroma = 0.0;
|
|
colorappearance.mchroma = 0.0;
|
|
colorappearance.rstprotection = 0.0;
|
|
colorappearance.contrast = 0.0;
|
|
colorappearance.qcontrast = 0.0;
|
|
colorappearance.colorh = 0.0;
|
|
colorappearance.surrsource = false;
|
|
colorappearance.gamut = true;
|
|
// colorappearance.badpix = false;
|
|
colorappearance.datacie = false;
|
|
colorappearance.tonecie = false;
|
|
// colorappearance.sharpcie = false;
|
|
colorappearance.curve.clear ();
|
|
colorappearance.curve.push_back (DCT_Linear);
|
|
colorappearance.curve2.clear ();
|
|
colorappearance.curve2.push_back (DCT_Linear);
|
|
colorappearance.curveMode = ColorAppearanceParams::TC_MODE_LIGHT;
|
|
colorappearance.curveMode2 = ColorAppearanceParams::TC_MODE_LIGHT;
|
|
colorappearance.curve3.clear ();
|
|
colorappearance.curve3.push_back (DCT_Linear);
|
|
colorappearance.curveMode3 = ColorAppearanceParams::TC_MODE_CHROMA;
|
|
colorappearance.tempout = 5000;
|
|
colorappearance.greenout = 1.0;
|
|
colorappearance.ybout = 18;
|
|
colorappearance.tempsc = 5000;
|
|
colorappearance.greensc = 1.0;
|
|
|
|
impulseDenoise.enabled = false;
|
|
impulseDenoise.thresh = 50;
|
|
|
|
defringe.enabled = false;
|
|
defringe.radius = 2.0;
|
|
defringe.threshold = 13;
|
|
defringe.huecurve.resize (25);
|
|
defringe.huecurve.at (0) = FCT_MinMaxCPoints;
|
|
defringe.huecurve.at (1) = 0.166666667;
|
|
defringe.huecurve.at (2) = 0.;
|
|
defringe.huecurve.at (3) = 0.35;
|
|
defringe.huecurve.at (4) = 0.35;
|
|
defringe.huecurve.at (5) = 0.347;
|
|
defringe.huecurve.at (6) = 0.;
|
|
defringe.huecurve.at (7) = 0.35;
|
|
defringe.huecurve.at (8) = 0.35;
|
|
defringe.huecurve.at (9) = 0.513667426;
|
|
defringe.huecurve.at (10) = 0;
|
|
defringe.huecurve.at (11) = 0.35;
|
|
defringe.huecurve.at (12) = 0.35;
|
|
defringe.huecurve.at (13) = 0.668944571;
|
|
defringe.huecurve.at (14) = 0.;
|
|
defringe.huecurve.at (15) = 0.35;
|
|
defringe.huecurve.at (16) = 0.35;
|
|
defringe.huecurve.at (17) = 0.8287775246;
|
|
defringe.huecurve.at (18) = 0.97835991;
|
|
defringe.huecurve.at (19) = 0.35;
|
|
defringe.huecurve.at (20) = 0.35;
|
|
defringe.huecurve.at (21) = 0.9908883827;
|
|
defringe.huecurve.at (22) = 0.;
|
|
defringe.huecurve.at (23) = 0.35;
|
|
defringe.huecurve.at (24) = 0.35;
|
|
|
|
dirpyrDenoise.setDefaults();
|
|
|
|
epd.enabled = false;
|
|
epd.strength = 0.5;
|
|
epd.gamma = 1.0;
|
|
epd.edgeStopping = 1.4;
|
|
epd.scale = 1.0;
|
|
epd.reweightingIterates = 0;
|
|
|
|
fattal.setDefaults();
|
|
|
|
sh.enabled = false;
|
|
sh.hq = false;
|
|
sh.highlights = 0;
|
|
sh.htonalwidth = 80;
|
|
sh.shadows = 0;
|
|
sh.stonalwidth = 80;
|
|
sh.localcontrast = 0;
|
|
sh.radius = 40;
|
|
|
|
crop.enabled = false;
|
|
crop.x = -1;
|
|
crop.y = -1;
|
|
crop.w = 15000;
|
|
crop.h = 15000;
|
|
crop.fixratio = true;
|
|
crop.ratio = "3:2";
|
|
crop.orientation = "As Image";
|
|
crop.guide = "Frame";
|
|
|
|
coarse.setDefaults();
|
|
|
|
commonTrans.autofill = true;
|
|
|
|
rotate.degree = 0;
|
|
|
|
distortion.amount = 0;
|
|
|
|
perspective.horizontal = 0;
|
|
perspective.vertical = 0;
|
|
|
|
gradient.enabled = false;
|
|
gradient.degree = 0;
|
|
gradient.feather = 25;
|
|
gradient.strength = 0.60;
|
|
gradient.centerX = 0;
|
|
gradient.centerY = 0;
|
|
|
|
pcvignette.enabled = false;
|
|
pcvignette.strength = 0.60;
|
|
pcvignette.feather = 50;
|
|
pcvignette.roundness = 50;
|
|
|
|
cacorrection.red = 0;
|
|
cacorrection.blue = 0;
|
|
|
|
|
|
vignetting.amount = 0;
|
|
vignetting.radius = 50;
|
|
vignetting.strength = 1;
|
|
vignetting.centerX = 0;
|
|
vignetting.centerY = 0;
|
|
|
|
lensProf.setDefaults();
|
|
|
|
chmixer.red[0] = 100;
|
|
chmixer.red[1] = 0;
|
|
chmixer.red[2] = 0;
|
|
chmixer.green[0] = 0;
|
|
chmixer.green[1] = 100;
|
|
chmixer.green[2] = 0;
|
|
chmixer.blue[0] = 0;
|
|
chmixer.blue[1] = 0;
|
|
chmixer.blue[2] = 100;
|
|
|
|
blackwhite.autoc = false;
|
|
blackwhite.enabledcc = true;
|
|
blackwhite.enabled = false;
|
|
blackwhite.mixerRed = 33;
|
|
blackwhite.mixerGreen = 33;
|
|
blackwhite.mixerBlue = 33;
|
|
blackwhite.mixerOrange = 33;
|
|
blackwhite.mixerYellow = 33;
|
|
blackwhite.mixerCyan = 33;
|
|
blackwhite.mixerMagenta = 33;
|
|
blackwhite.mixerPurple = 33;
|
|
blackwhite.gammaRed = 0;
|
|
blackwhite.gammaGreen = 0;
|
|
blackwhite.gammaBlue = 0;
|
|
blackwhite.luminanceCurve.clear ();
|
|
blackwhite.luminanceCurve.push_back (FCT_Linear);
|
|
blackwhite.method = "Desaturation";
|
|
blackwhite.filter = "None";
|
|
blackwhite.setting = "NormalContrast";
|
|
blackwhite.beforeCurve.clear ();
|
|
blackwhite.beforeCurve.push_back (DCT_Linear);
|
|
blackwhite.beforeCurveMode = BlackWhiteParams::TC_MODE_STD_BW;
|
|
blackwhite.afterCurve.clear ();
|
|
blackwhite.afterCurve.push_back (DCT_Linear);
|
|
blackwhite.afterCurveMode = BlackWhiteParams::TC_MODE_STD_BW;
|
|
blackwhite.algo = "SP";
|
|
|
|
resize.enabled = false;
|
|
resize.scale = 1.0;
|
|
resize.appliesTo = "Cropped area";
|
|
resize.method = "Lanczos";
|
|
resize.dataspec = 3;
|
|
resize.width = 900;
|
|
resize.height = 900;
|
|
|
|
icm.setDefaults();
|
|
|
|
dirpyrequalizer.enabled = false;
|
|
dirpyrequalizer.gamutlab = false;
|
|
dirpyrequalizer.cbdlMethod = "bef";
|
|
|
|
|
|
for (int i = 0; i < 6; i ++) {
|
|
dirpyrequalizer.mult[i] = 1.0;
|
|
}
|
|
|
|
dirpyrequalizer.threshold = 0.2;
|
|
dirpyrequalizer.skinprotect = 0.;
|
|
dirpyrequalizer.hueskin.setValues (-5, 25, 170, 120); //default (b_l 0, t_l 30, b_r 170, t_r 120);
|
|
// dirpyrequalizer.algo = "FI";
|
|
|
|
hsvequalizer.hcurve.clear ();
|
|
hsvequalizer.hcurve.push_back (FCT_Linear);
|
|
hsvequalizer.scurve.clear ();
|
|
hsvequalizer.scurve.push_back (FCT_Linear);
|
|
hsvequalizer.vcurve.clear ();
|
|
hsvequalizer.vcurve.push_back (FCT_Linear);
|
|
|
|
filmSimulation.setDefaults();
|
|
|
|
raw.setDefaults();
|
|
|
|
exif.clear ();
|
|
iptc.clear ();
|
|
|
|
rank = 0;
|
|
colorlabel = 0;
|
|
inTrash = false;
|
|
|
|
ppVersion = PPVERSION;
|
|
}
|
|
|
|
static Glib::ustring expandRelativePath (const Glib::ustring &procparams_fname, const Glib::ustring &prefix, Glib::ustring embedded_fname)
|
|
{
|
|
if (embedded_fname == "" || !Glib::path_is_absolute (procparams_fname)) {
|
|
return embedded_fname;
|
|
}
|
|
|
|
if (prefix != "") {
|
|
if (embedded_fname.length() < prefix.length() || embedded_fname.substr (0, prefix.length()) != prefix) {
|
|
return embedded_fname;
|
|
}
|
|
|
|
embedded_fname = embedded_fname.substr (prefix.length());
|
|
}
|
|
|
|
if (Glib::path_is_absolute (embedded_fname)) {
|
|
return prefix + embedded_fname;
|
|
}
|
|
|
|
Glib::ustring absPath = prefix + Glib::path_get_dirname (procparams_fname) + G_DIR_SEPARATOR_S + embedded_fname;
|
|
return absPath;
|
|
}
|
|
|
|
static Glib::ustring relativePathIfInside (const Glib::ustring &procparams_fname, bool fnameAbsolute, Glib::ustring embedded_fname)
|
|
{
|
|
if (fnameAbsolute || embedded_fname == "" || !Glib::path_is_absolute (procparams_fname)) {
|
|
return embedded_fname;
|
|
}
|
|
|
|
Glib::ustring prefix = "";
|
|
|
|
if (embedded_fname.length() > 5 && embedded_fname.substr (0, 5) == "file:") {
|
|
embedded_fname = embedded_fname.substr (5);
|
|
prefix = "file:";
|
|
}
|
|
|
|
if (!Glib::path_is_absolute (embedded_fname)) {
|
|
return prefix + embedded_fname;
|
|
}
|
|
|
|
Glib::ustring dir1 = Glib::path_get_dirname (procparams_fname) + G_DIR_SEPARATOR_S;
|
|
Glib::ustring dir2 = Glib::path_get_dirname (embedded_fname) + G_DIR_SEPARATOR_S;
|
|
|
|
if (dir2.substr (0, dir1.length()) != dir1) {
|
|
// it's in a different directory, ie not inside
|
|
return prefix + embedded_fname;
|
|
}
|
|
|
|
return prefix + embedded_fname.substr (dir1.length());
|
|
}
|
|
|
|
int ProcParams::save (const Glib::ustring &fname, const Glib::ustring &fname2, bool fnameAbsolute, ParamsEdited* pedited)
|
|
{
|
|
|
|
if (fname.empty () && fname2.empty ()) {
|
|
return 0;
|
|
}
|
|
|
|
Glib::ustring sPParams;
|
|
|
|
try {
|
|
|
|
Glib::KeyFile keyFile;
|
|
|
|
keyFile.set_string ("Version", "AppVersion", APPVERSION);
|
|
keyFile.set_integer ("Version", "Version", PPVERSION);
|
|
|
|
saveToKeyfile(!pedited || pedited->general.rank, "General", "Rank", rank, keyFile);
|
|
saveToKeyfile(!pedited || pedited->general.colorlabel, "General", "ColorLabel", colorlabel, keyFile);
|
|
saveToKeyfile(!pedited || pedited->general.intrash, "General", "InTrash", inTrash, keyFile);
|
|
// save tone curve
|
|
saveToKeyfile(!pedited || pedited->toneCurve.autoexp, "Exposure", "Auto", toneCurve.autoexp, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.clip, "Exposure", "Clip", toneCurve.clip, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.expcomp, "Exposure", "Compensation", toneCurve.expcomp, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.brightness, "Exposure", "Brightness", toneCurve.brightness, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.contrast, "Exposure", "Contrast", toneCurve.contrast, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.saturation, "Exposure", "Saturation", toneCurve.saturation, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.black, "Exposure", "Black", toneCurve.black, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.hlcompr, "Exposure", "HighlightCompr", toneCurve.hlcompr, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.hlcomprthresh, "Exposure", "HighlightComprThreshold", toneCurve.hlcomprthresh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.shcompr, "Exposure", "ShadowCompr", toneCurve.shcompr, keyFile);
|
|
// save highlight recovery settings
|
|
saveToKeyfile(!pedited || pedited->toneCurve.hrenabled, "HLRecovery", "Enabled", toneCurve.hrenabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.method, "HLRecovery", "Method", toneCurve.method, keyFile);
|
|
|
|
const std::map<ToneCurveParams::eTCModeId, const char*> tc_mapping = {
|
|
{ToneCurveParams::TC_MODE_STD, "Standard"},
|
|
{ToneCurveParams::TC_MODE_FILMLIKE, "FilmLike"},
|
|
{ToneCurveParams::TC_MODE_SATANDVALBLENDING, "SatAndValueBlending"},
|
|
{ToneCurveParams::TC_MODE_WEIGHTEDSTD,"WeightedStd"},
|
|
{ToneCurveParams::TC_MODE_LUMINANCE, "Luminance"},
|
|
{ToneCurveParams::TC_MODE_PERCEPTUAL, "Perceptual"}
|
|
};
|
|
|
|
saveToKeyfile(!pedited || pedited->toneCurve.curveMode, "Exposure", "CurveMode", tc_mapping, toneCurve.curveMode, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.curveMode2, "Exposure", "CurveMode2", tc_mapping, toneCurve.curveMode2, keyFile);
|
|
|
|
saveToKeyfile(!pedited || pedited->toneCurve.curve, "Exposure", "Curve", toneCurve.curve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->toneCurve.curve2, "Exposure", "Curve2", toneCurve.curve2, keyFile);
|
|
//save retinex
|
|
|
|
saveToKeyfile(!pedited || pedited->retinex.enabled, "Retinex", "Enabled", retinex.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.str, "Retinex", "Str", retinex.str, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.scal, "Retinex", "Scal", retinex.scal, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.iter, "Retinex", "Iter", retinex.iter, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.grad, "Retinex", "Grad", retinex.grad, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.grads, "Retinex", "Grads", retinex.grads, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.gam, "Retinex", "Gam", retinex.gam, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.slope, "Retinex", "Slope", retinex.slope, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.medianmap, "Retinex", "Median", retinex.medianmap, keyFile);
|
|
|
|
|
|
saveToKeyfile(!pedited || pedited->retinex.neigh, "Retinex", "Neigh", retinex.neigh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.offs, "Retinex", "Offs", retinex.offs, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.vart, "Retinex", "Vart", retinex.vart, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.limd, "Retinex", "Limd", retinex.limd, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.highl, "Retinex", "highl", retinex.highl, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.skal, "Retinex", "skal", retinex.skal, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.retinexMethod, "Retinex", "RetinexMethod", retinex.retinexMethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.mapMethod, "Retinex", "mapMethod", retinex.mapMethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.viewMethod, "Retinex", "viewMethod", retinex.viewMethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.retinexcolorspace, "Retinex", "Retinexcolorspace", retinex.retinexcolorspace, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.gammaretinex, "Retinex", "Gammaretinex", retinex.gammaretinex, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.cdcurve, "Retinex", "CDCurve", retinex.cdcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.mapcurve, "Retinex", "MAPCurve", retinex.mapcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.cdHcurve, "Retinex", "CDHCurve", retinex.cdHcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.lhcurve, "Retinex", "LHCurve", retinex.lhcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.highlights, "Retinex", "Highlights", retinex.highlights, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.htonalwidth, "Retinex", "HighlightTonalWidth", retinex.htonalwidth, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.shadows, "Retinex", "Shadows", retinex.shadows, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.stonalwidth, "Retinex", "ShadowTonalWidth", retinex.stonalwidth, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.radius, "Retinex", "Radius", retinex.radius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.transmissionCurve, "Retinex", "TransmissionCurve", retinex.transmissionCurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->retinex.gaintransmissionCurve, "Retinex", "GainTransmissionCurve", retinex.gaintransmissionCurve, keyFile);
|
|
// save channel mixer
|
|
if (!pedited || pedited->chmixer.red[0] || pedited->chmixer.red[1] || pedited->chmixer.red[2]) {
|
|
Glib::ArrayHandle<int> rmix (chmixer.red, 3, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Channel Mixer", "Red", rmix);
|
|
}
|
|
|
|
if (!pedited || pedited->chmixer.green[0] || pedited->chmixer.green[1] || pedited->chmixer.green[2]) {
|
|
Glib::ArrayHandle<int> gmix (chmixer.green, 3, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Channel Mixer", "Green", gmix);
|
|
}
|
|
|
|
if (!pedited || pedited->chmixer.blue[0] || pedited->chmixer.blue[1] || pedited->chmixer.blue[2]) {
|
|
Glib::ArrayHandle<int> bmix (chmixer.blue, 3, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Channel Mixer", "Blue", bmix);
|
|
}
|
|
|
|
//save Black & White
|
|
saveToKeyfile(!pedited || pedited->blackwhite.enabled, "Black & White", "Enabled", blackwhite.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.method, "Black & White", "Method", blackwhite.method , keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.autoc, "Black & White", "Auto", blackwhite.autoc, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.enabledcc, "Black & White", "ComplementaryColors", blackwhite.enabledcc, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.setting, "Black & White", "Setting", blackwhite.setting , keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.filter, "Black & White", "Filter", blackwhite.filter , keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerRed, "Black & White", "MixerRed", blackwhite.mixerRed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerOrange, "Black & White", "MixerOrange", blackwhite.mixerOrange, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerYellow, "Black & White", "MixerYellow", blackwhite.mixerYellow, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerGreen, "Black & White", "MixerGreen", blackwhite.mixerGreen, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerCyan, "Black & White", "MixerCyan", blackwhite.mixerCyan, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerBlue, "Black & White", "MixerBlue", blackwhite.mixerBlue, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerMagenta, "Black & White", "MixerMagenta", blackwhite.mixerMagenta, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.mixerPurple, "Black & White", "MixerPurple", blackwhite.mixerPurple, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.gammaRed, "Black & White", "GammaRed", blackwhite.gammaRed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.gammaGreen, "Black & White", "GammaGreen", blackwhite.gammaGreen, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.gammaBlue, "Black & White", "GammaBlue", blackwhite.gammaBlue, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.algo, "Black & White", "Algorithm", blackwhite.algo, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.luminanceCurve, "Black & White", "LuminanceCurve", blackwhite.luminanceCurve, keyFile);
|
|
saveToKeyfile(
|
|
!pedited || pedited->blackwhite.beforeCurveMode,
|
|
"Black & White",
|
|
"BeforeCurveMode",
|
|
{
|
|
{BlackWhiteParams::TC_MODE_STD_BW, "Standard"},
|
|
{BlackWhiteParams::TC_MODE_FILMLIKE_BW, "FilmLike"},
|
|
{BlackWhiteParams::TC_MODE_SATANDVALBLENDING_BW, "SatAndValueBlending"},
|
|
{BlackWhiteParams::TC_MODE_WEIGHTEDSTD_BW, "WeightedStd"}
|
|
|
|
},
|
|
blackwhite.beforeCurveMode,
|
|
keyFile
|
|
);
|
|
saveToKeyfile(
|
|
!pedited || pedited->blackwhite.afterCurveMode,
|
|
"Black & White",
|
|
"AfterCurveMode",
|
|
{
|
|
{BlackWhiteParams::TC_MODE_STD_BW, "Standard"},
|
|
{BlackWhiteParams::TC_MODE_WEIGHTEDSTD_BW, "WeightedStd"}
|
|
|
|
},
|
|
blackwhite.afterCurveMode,
|
|
keyFile
|
|
);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.beforeCurve, "Black & White", "BeforeCurve", blackwhite.beforeCurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->blackwhite.afterCurve, "Black & White", "AfterCurve", blackwhite.afterCurve, keyFile);
|
|
// save luma curve
|
|
saveToKeyfile(!pedited || pedited->labCurve.brightness, "Luminance Curve", "Brightness", labCurve.brightness, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.contrast, "Luminance Curve", "Contrast", labCurve.contrast, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.chromaticity, "Luminance Curve", "Chromaticity", labCurve.chromaticity, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.avoidcolorshift, "Luminance Curve", "AvoidColorShift", labCurve.avoidcolorshift, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.rstprotection, "Luminance Curve", "RedAndSkinTonesProtection", labCurve.rstprotection, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.lcredsk, "Luminance Curve", "LCredsk", labCurve.lcredsk, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.lcurve, "Luminance Curve", "LCurve", labCurve.lcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.acurve, "Luminance Curve", "aCurve", labCurve.acurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.bcurve, "Luminance Curve", "bCurve", labCurve.bcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.cccurve, "Luminance Curve", "ccCurve", labCurve.cccurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.chcurve, "Luminance Curve", "chCurve", labCurve.chcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.lhcurve, "Luminance Curve", "lhCurve", labCurve.lhcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.hhcurve, "Luminance Curve", "hhCurve", labCurve.hhcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.lccurve, "Luminance Curve", "LcCurve", labCurve.lccurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->labCurve.clcurve, "Luminance Curve", "ClCurve", labCurve.clcurve, keyFile);
|
|
// save sharpening
|
|
saveToKeyfile(!pedited || pedited->sharpening.enabled, "Sharpening", "Enabled", sharpening.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.method, "Sharpening", "Method", sharpening.method, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.radius, "Sharpening", "Radius", sharpening.radius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.amount, "Sharpening", "Amount", sharpening.amount, keyFile);
|
|
if (!pedited || pedited->sharpening.threshold) {
|
|
Glib::ArrayHandle<int> thresh (sharpening.threshold.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Sharpening", "Threshold", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->sharpening.edgesonly, "Sharpening", "OnlyEdges", sharpening.edgesonly, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.edges_radius, "Sharpening", "EdgedetectionRadius", sharpening.edges_radius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.edges_tolerance, "Sharpening", "EdgeTolerance", sharpening.edges_tolerance, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.halocontrol, "Sharpening", "HalocontrolEnabled", sharpening.halocontrol, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.halocontrol_amount, "Sharpening", "HalocontrolAmount", sharpening.halocontrol_amount, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.deconvradius, "Sharpening", "DeconvRadius", sharpening.deconvradius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.deconvamount, "Sharpening", "DeconvAmount", sharpening.deconvamount, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.deconvdamping, "Sharpening", "DeconvDamping", sharpening.deconvdamping, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpening.deconviter, "Sharpening", "DeconvIterations", sharpening.deconviter, keyFile);
|
|
// save vibrance
|
|
saveToKeyfile(!pedited || pedited->vibrance.enabled, "Vibrance", "Enabled", vibrance.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vibrance.pastels, "Vibrance", "Pastels", vibrance.pastels, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vibrance.saturated, "Vibrance", "Saturated", vibrance.saturated, keyFile);
|
|
if (!pedited || pedited->vibrance.psthreshold) {
|
|
Glib::ArrayHandle<int> thresh (vibrance.psthreshold.value, 2, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Vibrance", "PSThreshold", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->vibrance.protectskins, "Vibrance", "ProtectSkins", vibrance.protectskins, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vibrance.avoidcolorshift, "Vibrance", "AvoidColorShift", vibrance.avoidcolorshift, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vibrance.pastsattog, "Vibrance", "PastSatTog", vibrance.pastsattog, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vibrance.skintonescurve, "Vibrance", "SkinTonesCurve", vibrance.skintonescurve, keyFile);
|
|
//save edge sharpening
|
|
saveToKeyfile(!pedited || pedited->sharpenEdge.enabled, "SharpenEdge", "Enabled", sharpenEdge.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpenEdge.passes, "SharpenEdge", "Passes", sharpenEdge.passes, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpenEdge.amount, "SharpenEdge", "Strength", sharpenEdge.amount, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpenEdge.threechannels, "SharpenEdge", "ThreeChannels", sharpenEdge.threechannels, keyFile);
|
|
//save micro-contrast sharpening
|
|
saveToKeyfile(!pedited || pedited->sharpenMicro.enabled, "SharpenMicro", "Enabled", sharpenMicro.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpenMicro.matrix, "SharpenMicro", "Matrix", sharpenMicro.matrix, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpenMicro.amount, "SharpenMicro", "Strength", sharpenMicro.amount, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sharpenMicro.uniformity, "SharpenMicro", "Uniformity", sharpenMicro.uniformity, keyFile);
|
|
/*
|
|
// save colorBoost
|
|
if (!pedited || pedited->colorBoost.amount) keyFile.set_integer ("Color Boost", "Amount", colorBoost.amount);
|
|
if (!pedited || pedited->colorBoost.avoidclip) keyFile.set_boolean ("Color Boost", "AvoidColorClipping", colorBoost.avoidclip);
|
|
if (!pedited || pedited->colorBoost.enable_saturationlimiter) keyFile.set_boolean ("Color Boost", "SaturationLimiter", colorBoost.enable_saturationlimiter);
|
|
if (!pedited || pedited->colorBoost.saturationlimit) keyFile.set_double ("Color Boost", "SaturationLimit", colorBoost.saturationlimit);
|
|
*/
|
|
|
|
// save wb
|
|
saveToKeyfile(!pedited || pedited->wb.method, "White Balance", "Setting", wb.method, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wb.temperature, "White Balance", "Temperature", wb.temperature, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wb.green, "White Balance", "Green", wb.green, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wb.equal, "White Balance", "Equal", wb.equal, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wb.tempBias, "White Balance", "TemperatureBias", wb.tempBias, keyFile);
|
|
/*
|
|
// save colorShift
|
|
if (!pedited || pedited->colorShift.a) keyFile.set_double ("Color Shift", "ChannelA", colorShift.a);
|
|
if (!pedited || pedited->colorShift.b) keyFile.set_double ("Color Shift", "ChannelB", colorShift.b);
|
|
*/
|
|
// save colorappearance
|
|
saveToKeyfile(!pedited || pedited->colorappearance.enabled, "Color appearance", "Enabled", colorappearance.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.degree, "Color appearance", "Degree", colorappearance.degree, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.autodegree, "Color appearance", "AutoDegree", colorappearance.autodegree, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.degreeout, "Color appearance", "Degreeout", colorappearance.degreeout, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.autodegreeout, "Color appearance", "AutoDegreeout", colorappearance.autodegreeout, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.surround, "Color appearance", "Surround", colorappearance.surround, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.surrsrc, "Color appearance", "Surrsrc", colorappearance.surrsrc, keyFile);
|
|
// if (!pedited || pedited->colorappearance.backgrd) keyFile.set_integer ("Color appearance", "Background", colorappearance.backgrd);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.adaplum, "Color appearance", "AdaptLum", colorappearance.adaplum, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.badpixsl, "Color appearance", "Badpixsl", colorappearance.badpixsl, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.wbmodel, "Color appearance", "Model", colorappearance.wbmodel, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.algo, "Color appearance", "Algorithm", colorappearance.algo, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.jlight, "Color appearance", "J-Light", colorappearance.jlight, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.qbright, "Color appearance", "Q-Bright", colorappearance.qbright, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.chroma, "Color appearance", "C-Chroma", colorappearance.chroma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.schroma, "Color appearance", "S-Chroma", colorappearance.schroma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.mchroma, "Color appearance", "M-Chroma", colorappearance.mchroma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.contrast, "Color appearance", "J-Contrast", colorappearance.contrast, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.qcontrast, "Color appearance", "Q-Contrast", colorappearance.qcontrast, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.colorh, "Color appearance", "H-Hue", colorappearance.colorh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.rstprotection, "Color appearance", "RSTProtection", colorappearance.rstprotection, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.adapscen, "Color appearance", "AdaptScene", colorappearance.adapscen, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.autoadapscen, "Color appearance", "AutoAdapscen", colorappearance.autoadapscen, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.ybscen, "Color appearance", "YbScene", colorappearance.ybscen, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.autoybscen, "Color appearance", "Autoybscen", colorappearance.autoybscen, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.surrsource, "Color appearance", "SurrSource", colorappearance.surrsource, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.gamut, "Color appearance", "Gamut", colorappearance.gamut, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.tempout, "Color appearance", "Tempout", colorappearance.tempout, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.greenout, "Color appearance", "Greenout", colorappearance.greenout, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.tempsc, "Color appearance", "Tempsc", colorappearance.tempsc, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.greensc, "Color appearance", "Greensc", colorappearance.greensc, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.ybout, "Color appearance", "Ybout", colorappearance.ybout, keyFile);
|
|
// if (!pedited || pedited->colorappearance.badpix) keyFile.set_boolean ("Color appearance", "Badpix", colorappearance.badpix);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.datacie, "Color appearance", "Datacie", colorappearance.datacie, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.tonecie, "Color appearance", "Tonecie", colorappearance.tonecie, keyFile);
|
|
// if (!pedited || pedited->colorappearance.sharpcie) keyFile.set_boolean ("Color appearance", "Sharpcie", colorappearance.sharpcie);
|
|
|
|
const std::map<ColorAppearanceParams::eTCModeId, const char*> ca_mapping = {
|
|
{ColorAppearanceParams::TC_MODE_LIGHT, "Lightness"},
|
|
{ColorAppearanceParams::TC_MODE_BRIGHT, "Brightness"}
|
|
};
|
|
|
|
saveToKeyfile(!pedited || pedited->colorappearance.curveMode, "Color appearance", "CurveMode", ca_mapping, colorappearance.curveMode, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.curveMode2, "Color appearance", "CurveMode2", ca_mapping, colorappearance.curveMode2, keyFile);
|
|
saveToKeyfile(
|
|
!pedited || colorappearance.curveMode3,
|
|
"Color appearance",
|
|
"CurveMode3",
|
|
{
|
|
{ColorAppearanceParams::TC_MODE_CHROMA, "Chroma"},
|
|
{ColorAppearanceParams::TC_MODE_SATUR, "Saturation"},
|
|
{ColorAppearanceParams::TC_MODE_COLORF, "Colorfullness"}
|
|
|
|
},
|
|
colorappearance.curveMode3,
|
|
keyFile
|
|
);
|
|
|
|
saveToKeyfile(!pedited || pedited->colorappearance.curve, "Color appearance", "Curve", colorappearance.curve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.curve2, "Color appearance", "Curve2", colorappearance.curve2, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorappearance.curve3, "Color appearance", "Curve3", colorappearance.curve3, keyFile);
|
|
|
|
|
|
// save impulseDenoise
|
|
saveToKeyfile(!pedited || pedited->impulseDenoise.enabled, "Impulse Denoising", "Enabled", impulseDenoise.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->impulseDenoise.thresh, "Impulse Denoising", "Threshold", impulseDenoise.thresh, keyFile);
|
|
// save defringe
|
|
saveToKeyfile(!pedited || pedited->defringe.enabled, "Defringing", "Enabled", defringe.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->defringe.radius, "Defringing", "Radius", defringe.radius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->defringe.threshold, "Defringing", "Threshold", defringe.threshold, keyFile);
|
|
saveToKeyfile(!pedited || pedited->defringe.huecurve, "Defringing", "HueCurve", defringe.huecurve, keyFile);
|
|
// save dirpyrDenoise
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.enabled, "Directional Pyramid Denoising", "Enabled", dirpyrDenoise.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.enhance, "Directional Pyramid Denoising", "Enhance", dirpyrDenoise.enhance, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.median, "Directional Pyramid Denoising", "Median", dirpyrDenoise.median, keyFile);
|
|
// if (!pedited || pedited->dirpyrDenoise.perform) keyFile.set_boolean ("Directional Pyramid Denoising", "Perform", dirpyrDenoise.perform);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.luma, "Directional Pyramid Denoising", "Luma", dirpyrDenoise.luma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.Ldetail, "Directional Pyramid Denoising", "Ldetail", dirpyrDenoise.Ldetail, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.chroma, "Directional Pyramid Denoising", "Chroma", dirpyrDenoise.chroma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.dmethod, "Directional Pyramid Denoising", "Method", dirpyrDenoise.dmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.Lmethod, "Directional Pyramid Denoising", "LMethod", dirpyrDenoise.Lmethod, keyFile);
|
|
// never save 'auto chroma preview mode' to pp3
|
|
if (dirpyrDenoise.Cmethod == "PRE") {
|
|
dirpyrDenoise.Cmethod = "MAN";
|
|
}
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.Cmethod, "Directional Pyramid Denoising", "CMethod", dirpyrDenoise.Cmethod, keyFile);
|
|
|
|
if (dirpyrDenoise.C2method == "PREV") {
|
|
dirpyrDenoise.C2method = "MANU";
|
|
}
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.C2method, "Directional Pyramid Denoising", "C2Method", dirpyrDenoise.C2method, keyFile);
|
|
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.smethod, "Directional Pyramid Denoising", "SMethod", dirpyrDenoise.smethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.medmethod, "Directional Pyramid Denoising", "MedMethod", dirpyrDenoise.medmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.rgbmethod, "Directional Pyramid Denoising", "RGBMethod", dirpyrDenoise.rgbmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.methodmed, "Directional Pyramid Denoising", "MethodMed", dirpyrDenoise.methodmed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.redchro, "Directional Pyramid Denoising", "Redchro", dirpyrDenoise.redchro, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.bluechro, "Directional Pyramid Denoising", "Bluechro", dirpyrDenoise.bluechro, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.gamma, "Directional Pyramid Denoising", "Gamma", dirpyrDenoise.gamma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.passes, "Directional Pyramid Denoising", "Passes", dirpyrDenoise.passes, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.lcurve, "Directional Pyramid Denoising", "LCurve", dirpyrDenoise.lcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrDenoise.cccurve, "Directional Pyramid Denoising", "CCCurve", dirpyrDenoise.cccurve, keyFile);
|
|
// save epd.
|
|
saveToKeyfile(!pedited || pedited->epd.enabled, "EPD", "Enabled", epd.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->epd.strength, "EPD", "Strength", epd.strength, keyFile);
|
|
saveToKeyfile(!pedited || pedited->epd.gamma, "EPD", "Gamma", epd.gamma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->epd.edgeStopping, "EPD", "EdgeStopping", epd.edgeStopping, keyFile);
|
|
saveToKeyfile(!pedited || pedited->epd.scale, "EPD", "Scale", epd.scale, keyFile);
|
|
saveToKeyfile(!pedited || pedited->epd.reweightingIterates, "EPD", "ReweightingIterates", epd.reweightingIterates, keyFile);
|
|
// save fattal
|
|
saveToKeyfile(!pedited || pedited->fattal.enabled, "FattalToneMapping", "Enabled", fattal.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->fattal.threshold, "FattalToneMapping", "Threshold", fattal.threshold, keyFile);
|
|
saveToKeyfile(!pedited || pedited->fattal.amount, "FattalToneMapping", "Amount", fattal.amount, keyFile);
|
|
/*
|
|
// save lumaDenoise
|
|
if (!pedited || pedited->lumaDenoise.enabled) keyFile.set_boolean ("Luminance Denoising", "Enabled", lumaDenoise.enabled);
|
|
if (!pedited || pedited->lumaDenoise.radius) keyFile.set_double ("Luminance Denoising", "Radius", lumaDenoise.radius);
|
|
if (!pedited || pedited->lumaDenoise.edgetolerance) keyFile.set_integer ("Luminance Denoising", "EdgeTolerance", lumaDenoise.edgetolerance);
|
|
*/
|
|
|
|
/*
|
|
// save colorDenoise
|
|
//if (!pedited || pedited->colorDenoise.enabled) keyFile.set_boolean ("Chrominance Denoising", "Enabled", colorDenoise.enabled);
|
|
if (!pedited || pedited->colorDenoise.amount) keyFile.set_integer ("Chrominance Denoising", "Amount", colorDenoise.amount);
|
|
*/
|
|
|
|
// save sh
|
|
saveToKeyfile(!pedited || pedited->sh.enabled, "Shadows & Highlights", "Enabled", sh.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sh.hq, "Shadows & Highlights", "HighQuality", sh.hq, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sh.highlights, "Shadows & Highlights", "Highlights", sh.highlights, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sh.htonalwidth, "Shadows & Highlights", "HighlightTonalWidth", sh.htonalwidth, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sh.shadows, "Shadows & Highlights", "Shadows", sh.shadows, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sh.stonalwidth, "Shadows & Highlights", "ShadowTonalWidth", sh.stonalwidth, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sh.localcontrast, "Shadows & Highlights", "LocalContrast", sh.localcontrast, keyFile);
|
|
saveToKeyfile(!pedited || pedited->sh.radius, "Shadows & Highlights", "Radius", sh.radius, keyFile);
|
|
// save crop
|
|
saveToKeyfile(!pedited || pedited->crop.enabled, "Crop", "Enabled", crop.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.x, "Crop", "X", crop.x, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.y, "Crop", "Y", crop.y, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.w, "Crop", "W", crop.w, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.h, "Crop", "H", crop.h, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.fixratio, "Crop", "FixedRatio", crop.fixratio, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.ratio, "Crop", "Ratio", crop.ratio, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.orientation, "Crop", "Orientation", crop.orientation, keyFile);
|
|
saveToKeyfile(!pedited || pedited->crop.guide, "Crop", "Guide", crop.guide, keyFile);
|
|
// save coarse
|
|
saveToKeyfile(!pedited || pedited->coarse.rotate, "Coarse Transformation", "Rotate", coarse.rotate, keyFile);
|
|
saveToKeyfile(!pedited || pedited->coarse.hflip, "Coarse Transformation", "HorizontalFlip", coarse.hflip, keyFile);
|
|
saveToKeyfile(!pedited || pedited->coarse.vflip, "Coarse Transformation", "VerticalFlip", coarse.vflip, keyFile);
|
|
// save commonTrans
|
|
saveToKeyfile(!pedited || pedited->commonTrans.autofill, "Common Properties for Transformations", "AutoFill", commonTrans.autofill, keyFile);
|
|
// save rotate
|
|
saveToKeyfile(!pedited || pedited->rotate.degree, "Rotation", "Degree", rotate.degree, keyFile);
|
|
// save distortion
|
|
saveToKeyfile(!pedited || pedited->distortion.amount, "Distortion", "Amount", distortion.amount, keyFile);
|
|
// lens profile
|
|
saveToKeyfile(!pedited || pedited->lensProf.lcMode, "LensProfile", "LcMode", lensProf.getMethodString (lensProf.lcMode), keyFile);
|
|
saveToKeyfile(!pedited || pedited->lensProf.lcpFile, "LensProfile", "LCPFile", relativePathIfInside (fname, fnameAbsolute, lensProf.lcpFile), keyFile);
|
|
saveToKeyfile(!pedited || pedited->lensProf.useDist, "LensProfile", "UseDistortion", lensProf.useDist, keyFile);
|
|
saveToKeyfile(!pedited || pedited->lensProf.useVign, "LensProfile", "UseVignette", lensProf.useVign, keyFile);
|
|
saveToKeyfile(!pedited || pedited->lensProf.useCA, "LensProfile", "UseCA", lensProf.useCA, keyFile);
|
|
saveToKeyfile(!pedited || pedited->lensProf.lfCameraMake, "LensProfile", "LFCameraMake", lensProf.lfCameraMake, keyFile);
|
|
saveToKeyfile(!pedited || pedited->lensProf.lfCameraModel, "LensProfile", "LFCameraModel", lensProf.lfCameraModel, keyFile);
|
|
saveToKeyfile(!pedited || pedited->lensProf.lfLens, "LensProfile", "LFLens", lensProf.lfLens, keyFile);
|
|
// save perspective correction
|
|
saveToKeyfile(!pedited || pedited->perspective.horizontal, "Perspective", "Horizontal", perspective.horizontal, keyFile);
|
|
saveToKeyfile(!pedited || pedited->perspective.vertical, "Perspective", "Vertical", perspective.vertical, keyFile);
|
|
// save gradient
|
|
saveToKeyfile(!pedited || pedited->gradient.enabled, "Gradient", "Enabled", gradient.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->gradient.degree, "Gradient", "Degree", gradient.degree, keyFile);
|
|
saveToKeyfile(!pedited || pedited->gradient.feather, "Gradient", "Feather", gradient.feather, keyFile);
|
|
saveToKeyfile(!pedited || pedited->gradient.strength, "Gradient", "Strength", gradient.strength, keyFile);
|
|
saveToKeyfile(!pedited || pedited->gradient.centerX, "Gradient", "CenterX", gradient.centerX, keyFile);
|
|
saveToKeyfile(!pedited || pedited->gradient.centerY, "Gradient", "CenterY", gradient.centerY, keyFile);
|
|
// save post-crop vignette
|
|
saveToKeyfile(!pedited || pedited->pcvignette.enabled, "PCVignette", "Enabled", pcvignette.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->pcvignette.strength, "PCVignette", "Strength", pcvignette.strength, keyFile);
|
|
saveToKeyfile(!pedited || pedited->pcvignette.feather, "PCVignette", "Feather", pcvignette.feather, keyFile);
|
|
saveToKeyfile(!pedited || pedited->pcvignette.roundness, "PCVignette", "Roundness", pcvignette.roundness, keyFile);
|
|
// save C/A correction
|
|
saveToKeyfile(!pedited || pedited->cacorrection.red, "CACorrection", "Red", cacorrection.red, keyFile);
|
|
saveToKeyfile(!pedited || pedited->cacorrection.blue, "CACorrection", "Blue", cacorrection.blue, keyFile);
|
|
// save vignetting correction
|
|
saveToKeyfile(!pedited || pedited->vignetting.amount, "Vignetting Correction", "Amount", vignetting.amount, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vignetting.radius, "Vignetting Correction", "Radius", vignetting.radius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vignetting.strength, "Vignetting Correction", "Strength", vignetting.strength, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vignetting.centerX, "Vignetting Correction", "CenterX", vignetting.centerX, keyFile);
|
|
saveToKeyfile(!pedited || pedited->vignetting.centerY, "Vignetting Correction", "CenterY", vignetting.centerY, keyFile);
|
|
|
|
saveToKeyfile(!pedited || pedited->resize.enabled, "Resize", "Enabled", resize.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->resize.scale, "Resize", "Scale", resize.scale, keyFile);
|
|
saveToKeyfile(!pedited || pedited->resize.appliesTo, "Resize", "AppliesTo", resize.appliesTo, keyFile);
|
|
saveToKeyfile(!pedited || pedited->resize.method, "Resize", "Method", resize.method, keyFile);
|
|
saveToKeyfile(!pedited || pedited->resize.dataspec, "Resize", "DataSpecified", resize.dataspec, keyFile);
|
|
saveToKeyfile(!pedited || pedited->resize.width, "Resize", "Width", resize.width, keyFile);
|
|
saveToKeyfile(!pedited || pedited->resize.height, "Resize", "Height", resize.height, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.enabled, "PostResizeSharpening", "Enabled", prsharpening.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.method, "PostResizeSharpening", "Method", prsharpening.method, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.radius, "PostResizeSharpening", "Radius", prsharpening.radius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.amount, "PostResizeSharpening", "Amount", prsharpening.amount, keyFile);
|
|
if (!pedited || pedited->prsharpening.threshold) {
|
|
Glib::ArrayHandle<int> thresh (prsharpening.threshold.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("PostResizeSharpening", "Threshold", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->prsharpening.edgesonly, "PostResizeSharpening", "OnlyEdges", prsharpening.edgesonly, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.edges_radius, "PostResizeSharpening", "EdgedetectionRadius", prsharpening.edges_radius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.edges_tolerance, "PostResizeSharpening", "EdgeTolerance", prsharpening.edges_tolerance, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.halocontrol, "PostResizeSharpening", "HalocontrolEnabled", prsharpening.halocontrol, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.halocontrol_amount, "PostResizeSharpening", "HalocontrolAmount", prsharpening.halocontrol_amount, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.deconvradius, "PostResizeSharpening", "DeconvRadius", prsharpening.deconvradius, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.deconvamount, "PostResizeSharpening", "DeconvAmount", prsharpening.deconvamount, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.deconvdamping, "PostResizeSharpening", "DeconvDamping", prsharpening.deconvdamping, keyFile);
|
|
saveToKeyfile(!pedited || pedited->prsharpening.deconviter, "PostResizeSharpening", "DeconvIterations", prsharpening.deconviter, keyFile);
|
|
|
|
// save color management settings
|
|
saveToKeyfile(!pedited || pedited->icm.input, "Color Management", "InputProfile", relativePathIfInside (fname, fnameAbsolute, icm.input), keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.toneCurve, "Color Management", "ToneCurve", icm.toneCurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.applyLookTable, "Color Management", "ApplyLookTable", icm.applyLookTable, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.applyBaselineExposureOffset, "Color Management", "ApplyBaselineExposureOffset", icm.applyBaselineExposureOffset, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.applyHueSatMap, "Color Management", "ApplyHueSatMap", icm.applyHueSatMap, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.dcpIlluminant, "Color Management", "DCPIlluminant", icm.dcpIlluminant, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.working, "Color Management", "WorkingProfile", icm.working, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.output, "Color Management", "OutputProfile", icm.output, keyFile);
|
|
saveToKeyfile(
|
|
!pedited || icm.outputIntent,
|
|
"Color Management",
|
|
"OutputProfileIntent",
|
|
{
|
|
{RI_PERCEPTUAL, "Perceptual"},
|
|
{RI_RELATIVE, "Relative"},
|
|
{RI_SATURATION, "Saturation"},
|
|
{RI_ABSOLUTE, "Absolute"}
|
|
|
|
},
|
|
icm.outputIntent,
|
|
keyFile
|
|
);
|
|
saveToKeyfile(!pedited || pedited->icm.outputBPC, "Color Management", "OutputBPC", icm.outputBPC, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.gamma, "Color Management", "Gammafree", icm.gamma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.freegamma, "Color Management", "Freegamma", icm.freegamma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.gampos, "Color Management", "GammaValue", icm.gampos, keyFile);
|
|
saveToKeyfile(!pedited || pedited->icm.slpos, "Color Management", "GammaSlope", icm.slpos, keyFile);
|
|
|
|
|
|
// save wavelet parameters
|
|
saveToKeyfile(!pedited || pedited->wavelet.enabled, "Wavelet", "Enabled", wavelet.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.strength, "Wavelet", "Strength", wavelet.strength, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.balance, "Wavelet", "Balance", wavelet.balance, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.iter, "Wavelet", "Iter", wavelet.iter, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.thres, "Wavelet", "MaxLev", wavelet.thres, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.Tilesmethod, "Wavelet", "TilesMethod", wavelet.Tilesmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.daubcoeffmethod, "Wavelet", "DaubMethod", wavelet.daubcoeffmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.CLmethod, "Wavelet", "ChoiceLevMethod", wavelet.CLmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.Backmethod, "Wavelet", "BackMethod", wavelet.Backmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.Lmethod, "Wavelet", "LevMethod", wavelet.Lmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.Dirmethod, "Wavelet", "DirMethod", wavelet.Dirmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.greenhigh, "Wavelet", "CBgreenhigh", wavelet.greenhigh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.greenmed, "Wavelet", "CBgreenmed", wavelet.greenmed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.greenlow, "Wavelet", "CBgreenlow", wavelet.greenlow, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.bluehigh, "Wavelet", "CBbluehigh", wavelet.bluehigh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.bluemed, "Wavelet", "CBbluemed", wavelet.bluemed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.bluelow, "Wavelet", "CBbluelow", wavelet.bluelow, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.expcontrast, "Wavelet", "Expcontrast", wavelet.expcontrast, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.expchroma, "Wavelet", "Expchroma", wavelet.expchroma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.expedge, "Wavelet", "Expedge", wavelet.expedge, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.expresid, "Wavelet", "Expresid", wavelet.expresid, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.expfinal, "Wavelet", "Expfinal", wavelet.expfinal, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.exptoning, "Wavelet", "Exptoning", wavelet.exptoning, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.expnoise, "Wavelet", "Expnoise", wavelet.expnoise, keyFile);
|
|
for (int i = 0; i < 9; i++) {
|
|
std::stringstream ss;
|
|
ss << "Contrast" << (i + 1);
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.c[i], "Wavelet", ss.str(), wavelet.c[i], keyFile); }
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
std::stringstream ss;
|
|
ss << "Chroma" << (i + 1);
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.ch[i], "Wavelet", ss.str(), wavelet.ch[i], keyFile); }
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.sup, "Wavelet", "ContExtra", wavelet.sup, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.HSmethod, "Wavelet", "HSMethod", wavelet.HSmethod, keyFile);
|
|
if (!pedited || pedited->wavelet.hllev) {
|
|
Glib::ArrayHandle<int> thresh (wavelet.hllev.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Wavelet", "HLRange", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->wavelet.bllev) {
|
|
Glib::ArrayHandle<int> thresh (wavelet.bllev.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Wavelet", "SHRange", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->wavelet.edgcont) {
|
|
Glib::ArrayHandle<int> thresh (wavelet.edgcont.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Wavelet", "Edgcont", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->wavelet.level0noise) {
|
|
Glib::ArrayHandle<double> thresh (wavelet.level0noise.value, 2, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_double_list ("Wavelet", "Level0noise", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->wavelet.level1noise) {
|
|
Glib::ArrayHandle<double> thresh (wavelet.level1noise.value, 2, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_double_list ("Wavelet", "Level1noise", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->wavelet.level2noise) {
|
|
Glib::ArrayHandle<double> thresh (wavelet.level2noise.value, 2, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_double_list ("Wavelet", "Level2noise", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->wavelet.level3noise) {
|
|
Glib::ArrayHandle<double> thresh (wavelet.level3noise.value, 2, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_double_list ("Wavelet", "Level3noise", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.threshold, "Wavelet", "ThresholdHighlight", wavelet.threshold, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.threshold2, "Wavelet", "ThresholdShadow", wavelet.threshold2, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgedetect, "Wavelet", "Edgedetect", wavelet.edgedetect, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgedetectthr, "Wavelet", "Edgedetectthr", wavelet.edgedetectthr, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgedetectthr2, "Wavelet", "EdgedetectthrHi", wavelet.edgedetectthr2, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgesensi, "Wavelet", "Edgesensi", wavelet.edgesensi, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgeampli, "Wavelet", "Edgeampli", wavelet.edgeampli, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.chroma, "Wavelet", "ThresholdChroma", wavelet.chroma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.CHmethod, "Wavelet", "CHromaMethod", wavelet.CHmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.Medgreinf, "Wavelet", "Medgreinf", wavelet.Medgreinf, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.CHSLmethod, "Wavelet", "CHSLromaMethod", wavelet.CHSLmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.EDmethod, "Wavelet", "EDMethod", wavelet.EDmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.NPmethod, "Wavelet", "NPMethod", wavelet.NPmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.BAmethod, "Wavelet", "BAMethod", wavelet.BAmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.TMmethod, "Wavelet", "TMMethod", wavelet.TMmethod, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.chro, "Wavelet", "ChromaLink", wavelet.chro, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.ccwcurve, "Wavelet", "ContrastCurve", wavelet.ccwcurve, keyFile);
|
|
if (!pedited || pedited->wavelet.pastlev) {
|
|
Glib::ArrayHandle<int> thresh (wavelet.pastlev.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Wavelet", "Pastlev", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->wavelet.satlev) {
|
|
Glib::ArrayHandle<int> thresh (wavelet.satlev.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Wavelet", "Satlev", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.opacityCurveRG, "Wavelet", "OpacityCurveRG", wavelet.opacityCurveRG, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.opacityCurveBY, "Wavelet", "OpacityCurveBY", wavelet.opacityCurveBY, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.opacityCurveW, "Wavelet", "OpacityCurveW", wavelet.opacityCurveW, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.opacityCurveWL, "Wavelet", "OpacityCurveWL", wavelet.opacityCurveWL, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.hhcurve, "Wavelet", "HHcurve", wavelet.hhcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.Chcurve, "Wavelet", "CHcurve", wavelet.Chcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.wavclCurve, "Wavelet", "WavclCurve", wavelet.wavclCurve, keyFile);
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.median, "Wavelet", "Median", wavelet.median, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.medianlev, "Wavelet", "Medianlev", wavelet.medianlev, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.linkedg, "Wavelet", "Linkedg", wavelet.linkedg, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.cbenab, "Wavelet", "CBenab", wavelet.cbenab, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.lipst, "Wavelet", "Lipst", wavelet.lipst, keyFile);
|
|
// if (!pedited || pedited->wavelet.edgreinf) keyFile.set_boolean ("Wavelet", "Edgreinf", wavelet.edgreinf);
|
|
saveToKeyfile(!pedited || pedited->wavelet.skinprotect, "Wavelet", "Skinprotect", wavelet.skinprotect, keyFile);
|
|
if (!pedited || pedited->wavelet.hueskin) {
|
|
Glib::ArrayHandle<int> thresh (wavelet.hueskin.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Wavelet", "Hueskin", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgrad, "Wavelet", "Edgrad", wavelet.edgrad, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgval, "Wavelet", "Edgval", wavelet.edgval, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.edgthresh, "Wavelet", "ThrEdg", wavelet.edgthresh, keyFile);
|
|
// if (!pedited || pedited->wavelet.strength) keyFile.set_integer ("Wavelet", "Strength", wavelet.strength);
|
|
// if (!pedited || pedited->wavelet.balance) keyFile.set_integer ("Wavelet", "Balance", wavelet.balance);
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.avoid, "Wavelet", "AvoidColorShift", wavelet.avoid, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.tmr, "Wavelet", "TMr", wavelet.tmr, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.rescon, "Wavelet", "ResidualcontShadow", wavelet.rescon, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.resconH, "Wavelet", "ResidualcontHighlight", wavelet.resconH, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.thr, "Wavelet", "ThresholdResidShadow", wavelet.thr, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.thrH, "Wavelet", "ThresholdResidHighLight", wavelet.thrH, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.reschro, "Wavelet", "Residualchroma", wavelet.reschro, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.tmrs, "Wavelet", "ResidualTM", wavelet.tmrs, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.gamma, "Wavelet", "Residualgamma", wavelet.gamma, keyFile);
|
|
saveToKeyfile(!pedited || pedited->wavelet.sky, "Wavelet", "HueRangeResidual", wavelet.sky, keyFile);
|
|
if (!pedited || pedited->wavelet.hueskin2) {
|
|
Glib::ArrayHandle<int> thresh (wavelet.hueskin2.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Wavelet", "HueRange", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->wavelet.contrast, "Wavelet", "Contrast", wavelet.contrast, keyFile);
|
|
|
|
// save directional pyramid wavelet parameters
|
|
saveToKeyfile(!pedited || pedited->dirpyrequalizer.enabled, "Directional Pyramid Equalizer", "Enabled", dirpyrequalizer.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrequalizer.gamutlab, "Directional Pyramid Equalizer", "Gamutlab", dirpyrequalizer.gamutlab, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrequalizer.cbdlMethod, "Directional Pyramid Equalizer", "cbdlMethod", dirpyrequalizer.cbdlMethod, keyFile);
|
|
for (int i = 0; i < 6; i++) {
|
|
std::stringstream ss;
|
|
ss << "Mult" << i;
|
|
|
|
saveToKeyfile(!pedited || pedited->dirpyrequalizer.mult[i], "Directional Pyramid Equalizer", ss.str(), dirpyrequalizer.mult[i], keyFile); }
|
|
|
|
saveToKeyfile(!pedited || pedited->dirpyrequalizer.threshold, "Directional Pyramid Equalizer", "Threshold", dirpyrequalizer.threshold, keyFile);
|
|
saveToKeyfile(!pedited || pedited->dirpyrequalizer.skinprotect, "Directional Pyramid Equalizer", "Skinprotect", dirpyrequalizer.skinprotect, keyFile);
|
|
// if (!pedited || pedited->dirpyrequalizer.algo) keyFile.set_string ("Directional Pyramid Equalizer", "Algorithm", dirpyrequalizer.algo);
|
|
if (!pedited || pedited->dirpyrequalizer.hueskin) {
|
|
Glib::ArrayHandle<int> thresh (dirpyrequalizer.hueskin.value, 4, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("Directional Pyramid Equalizer", "Hueskin", thresh);
|
|
}
|
|
|
|
// save hsv wavelet parameters
|
|
saveToKeyfile(!pedited || pedited->hsvequalizer.hcurve, "HSV Equalizer", "HCurve", hsvequalizer.hcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->hsvequalizer.scurve, "HSV Equalizer", "SCurve", hsvequalizer.scurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->hsvequalizer.vcurve, "HSV Equalizer", "VCurve", hsvequalizer.vcurve, keyFile);
|
|
//save film simulation parameters
|
|
saveToKeyfile(!pedited || pedited->filmSimulation.enabled, "Film Simulation", "Enabled", filmSimulation.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->filmSimulation.clutFilename, "Film Simulation", "ClutFilename", filmSimulation.clutFilename, keyFile);
|
|
saveToKeyfile(!pedited || pedited->filmSimulation.strength, "Film Simulation", "Strength", filmSimulation.strength, keyFile);
|
|
|
|
saveToKeyfile(!pedited || pedited->rgbCurves.lumamode, "RGB Curves", "LumaMode", rgbCurves.lumamode, keyFile);
|
|
saveToKeyfile(!pedited || pedited->rgbCurves.rcurve, "RGB Curves", "rCurve", rgbCurves.rcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->rgbCurves.gcurve, "RGB Curves", "gCurve", rgbCurves.gcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->rgbCurves.bcurve, "RGB Curves", "bCurve", rgbCurves.bcurve, keyFile);
|
|
// save Color Toning
|
|
saveToKeyfile(!pedited || pedited->colorToning.enabled, "ColorToning", "Enabled", colorToning.enabled, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.method, "ColorToning", "Method", colorToning.method, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.lumamode, "ColorToning", "Lumamode", colorToning.lumamode, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.twocolor, "ColorToning", "Twocolor", colorToning.twocolor, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.redlow, "ColorToning", "Redlow", colorToning.redlow, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.greenlow, "ColorToning", "Greenlow", colorToning.greenlow, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.bluelow, "ColorToning", "Bluelow", colorToning.bluelow, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.satlow, "ColorToning", "Satlow", colorToning.satlow, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.balance, "ColorToning", "Balance", colorToning.balance, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.sathigh, "ColorToning", "Sathigh", colorToning.sathigh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.redmed, "ColorToning", "Redmed", colorToning.redmed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.greenmed, "ColorToning", "Greenmed", colorToning.greenmed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.bluemed, "ColorToning", "Bluemed", colorToning.bluemed, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.redhigh, "ColorToning", "Redhigh", colorToning.redhigh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.greenhigh, "ColorToning", "Greenhigh", colorToning.greenhigh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.bluehigh, "ColorToning", "Bluehigh", colorToning.bluehigh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.autosat, "ColorToning", "Autosat", colorToning.autosat, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.opacityCurve, "ColorToning", "OpacityCurve", colorToning.opacityCurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.colorCurve, "ColorToning", "ColorCurve", colorToning.colorCurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.satprotectionthreshold, "ColorToning", "SatProtectionThreshold", colorToning.satProtectionThreshold , keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.saturatedopacity, "ColorToning", "SaturatedOpacity", colorToning.saturatedOpacity , keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.strength, "ColorToning", "Strength", colorToning.strength , keyFile);
|
|
if (!pedited || pedited->colorToning.hlColSat) {
|
|
Glib::ArrayHandle<int> thresh (colorToning.hlColSat.value, 2, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("ColorToning", "HighlightsColorSaturation", thresh);
|
|
}
|
|
|
|
if (!pedited || pedited->colorToning.shadowsColSat) {
|
|
Glib::ArrayHandle<int> thresh (colorToning.shadowsColSat.value, 2, Glib::OWNERSHIP_NONE);
|
|
keyFile.set_integer_list ("ColorToning", "ShadowsColorSaturation", thresh);
|
|
}
|
|
|
|
saveToKeyfile(!pedited || pedited->colorToning.clcurve, "ColorToning", "ClCurve", colorToning.clcurve, keyFile);
|
|
saveToKeyfile(!pedited || pedited->colorToning.cl2curve, "ColorToning", "Cl2Curve", colorToning.cl2curve, keyFile);
|
|
// save raw parameters
|
|
saveToKeyfile(!pedited || pedited->raw.darkFrame, "RAW", "DarkFrame", relativePathIfInside (fname, fnameAbsolute, raw.dark_frame) , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.dfAuto, "RAW", "DarkFrameAuto", raw.df_autoselect , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.ff_file, "RAW", "FlatFieldFile", relativePathIfInside (fname, fnameAbsolute, raw.ff_file) , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.ff_AutoSelect, "RAW", "FlatFieldAutoSelect", raw.ff_AutoSelect , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.ff_BlurRadius, "RAW", "FlatFieldBlurRadius", raw.ff_BlurRadius , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.ff_BlurType, "RAW", "FlatFieldBlurType", raw.ff_BlurType , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.ff_AutoClipControl, "RAW", "FlatFieldAutoClipControl", raw.ff_AutoClipControl , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.ff_clipControl, "RAW", "FlatFieldClipControl", raw.ff_clipControl , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.caCorrection, "RAW", "CA", raw.ca_autocorrect , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.caRed, "RAW", "CARed", raw.cared , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.caBlue, "RAW", "CABlue", raw.cablue , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.hotPixelFilter, "RAW", "HotPixelFilter", raw.hotPixelFilter , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.deadPixelFilter, "RAW", "DeadPixelFilter", raw.deadPixelFilter , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.hotDeadPixelThresh, "RAW", "HotDeadPixelThresh", raw.hotdeadpix_thresh , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.method, "RAW Bayer", "Method", raw.bayersensor.method , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.imageNum, "RAW Bayer", "ImageNum", raw.bayersensor.imageNum + 1 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.ccSteps, "RAW Bayer", "CcSteps", raw.bayersensor.ccSteps, keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.exBlack0, "RAW Bayer", "PreBlack0", raw.bayersensor.black0 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.exBlack1, "RAW Bayer", "PreBlack1", raw.bayersensor.black1 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.exBlack2, "RAW Bayer", "PreBlack2", raw.bayersensor.black2 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.exBlack3, "RAW Bayer", "PreBlack3", raw.bayersensor.black3 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.exTwoGreen, "RAW Bayer", "PreTwoGreen", raw.bayersensor.twogreen , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.linenoise, "RAW Bayer", "LineDenoise", raw.bayersensor.linenoise, keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.greenEq, "RAW Bayer", "GreenEqThreshold", raw.bayersensor.greenthresh, keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.dcbIterations, "RAW Bayer", "DCBIterations", raw.bayersensor.dcb_iterations , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.dcbEnhance, "RAW Bayer", "DCBEnhance", raw.bayersensor.dcb_enhance , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.lmmseIterations, "RAW Bayer", "LMMSEIterations", raw.bayersensor.lmmse_iterations , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftMotion, "RAW Bayer", "PixelShiftMotion", raw.bayersensor.pixelShiftMotion , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftMotionCorrection, "RAW Bayer", "PixelShiftMotionCorrection", raw.bayersensor.pixelShiftMotionCorrection , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftMotionCorrectionMethod, "RAW Bayer", "PixelShiftMotionCorrectionMethod", raw.bayersensor.pixelShiftMotionCorrectionMethod , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftStddevFactorGreen, "RAW Bayer", "pixelShiftStddevFactorGreen", raw.bayersensor.pixelShiftStddevFactorGreen , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftStddevFactorRed, "RAW Bayer", "pixelShiftStddevFactorRed", raw.bayersensor.pixelShiftStddevFactorRed , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftStddevFactorBlue, "RAW Bayer", "pixelShiftStddevFactorBlue", raw.bayersensor.pixelShiftStddevFactorBlue , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftEperIso, "RAW Bayer", "PixelShiftEperIso", raw.bayersensor.pixelShiftEperIso , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftNreadIso, "RAW Bayer", "PixelShiftNreadIso", raw.bayersensor.pixelShiftNreadIso , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftPrnu, "RAW Bayer", "PixelShiftPrnu", raw.bayersensor.pixelShiftPrnu , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftSigma, "RAW Bayer", "PixelShiftSigma", raw.bayersensor.pixelShiftSigma , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftSum, "RAW Bayer", "PixelShiftSum", raw.bayersensor.pixelShiftSum , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftRedBlueWeight, "RAW Bayer", "PixelShiftRedBlueWeight", raw.bayersensor.pixelShiftRedBlueWeight , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftShowMotion, "RAW Bayer", "PixelShiftShowMotion", raw.bayersensor.pixelShiftShowMotion , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftShowMotionMaskOnly, "RAW Bayer", "PixelShiftShowMotionMaskOnly", raw.bayersensor.pixelShiftShowMotionMaskOnly , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftAutomatic, "RAW Bayer", "pixelShiftAutomatic", raw.bayersensor.pixelShiftAutomatic , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftNonGreenHorizontal, "RAW Bayer", "pixelShiftNonGreenHorizontal", raw.bayersensor.pixelShiftNonGreenHorizontal , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftNonGreenVertical, "RAW Bayer", "pixelShiftNonGreenVertical", raw.bayersensor.pixelShiftNonGreenVertical , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftHoleFill, "RAW Bayer", "pixelShiftHoleFill", raw.bayersensor.pixelShiftHoleFill , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftMedian, "RAW Bayer", "pixelShiftMedian", raw.bayersensor.pixelShiftMedian , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftMedian3, "RAW Bayer", "pixelShiftMedian3", raw.bayersensor.pixelShiftMedian3 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftGreen, "RAW Bayer", "pixelShiftGreen", raw.bayersensor.pixelShiftGreen , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftBlur, "RAW Bayer", "pixelShiftBlur", raw.bayersensor.pixelShiftBlur , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftSmooth, "RAW Bayer", "pixelShiftSmoothFactor", raw.bayersensor.pixelShiftSmoothFactor , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftExp0, "RAW Bayer", "pixelShiftExp0", raw.bayersensor.pixelShiftExp0 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftLmmse, "RAW Bayer", "pixelShiftLmmse", raw.bayersensor.pixelShiftLmmse , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftEqualBright, "RAW Bayer", "pixelShiftEqualBright", raw.bayersensor.pixelShiftEqualBright , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftEqualBrightChannel, "RAW Bayer", "pixelShiftEqualBrightChannel", raw.bayersensor.pixelShiftEqualBrightChannel , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftNonGreenCross, "RAW Bayer", "pixelShiftNonGreenCross", raw.bayersensor.pixelShiftNonGreenCross , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftNonGreenCross2, "RAW Bayer", "pixelShiftNonGreenCross2", raw.bayersensor.pixelShiftNonGreenCross2 , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.bayersensor.pixelShiftNonGreenAmaze, "RAW Bayer", "pixelShiftNonGreenAmaze", raw.bayersensor.pixelShiftNonGreenAmaze , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.xtranssensor.method, "RAW X-Trans", "Method", raw.xtranssensor.method , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.xtranssensor.ccSteps, "RAW X-Trans", "CcSteps", raw.xtranssensor.ccSteps, keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.xtranssensor.exBlackRed, "RAW X-Trans", "PreBlackRed", raw.xtranssensor.blackred , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.xtranssensor.exBlackGreen, "RAW X-Trans", "PreBlackGreen", raw.xtranssensor.blackgreen , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.xtranssensor.exBlackBlue, "RAW X-Trans", "PreBlackBlue", raw.xtranssensor.blackblue , keyFile);
|
|
|
|
// save raw exposition
|
|
saveToKeyfile(!pedited || pedited->raw.exPos, "RAW", "PreExposure", raw.expos , keyFile);
|
|
saveToKeyfile(!pedited || pedited->raw.exPreser, "RAW", "PrePreserv", raw.preser , keyFile);
|
|
// save exif change list
|
|
if (!pedited || pedited->exif) {
|
|
for (ExifPairs::const_iterator i = exif.begin(); i != exif.end(); ++i) {
|
|
keyFile.set_string ("Exif", i->first, i->second);
|
|
}
|
|
}
|
|
|
|
// save iptc change list
|
|
if (!pedited || pedited->iptc) {
|
|
for (IPTCPairs::const_iterator i = iptc.begin(); i != iptc.end(); ++i) {
|
|
Glib::ArrayHandle<Glib::ustring> values = i->second;
|
|
keyFile.set_string_list ("IPTC", i->first, values);
|
|
}
|
|
}
|
|
|
|
sPParams = keyFile.to_data();
|
|
|
|
} catch (Glib::KeyFileError&) {}
|
|
|
|
if (sPParams.empty ()) {
|
|
return 1;
|
|
}
|
|
|
|
int error1, error2;
|
|
error1 = write (fname, sPParams);
|
|
|
|
if (!fname2.empty ()) {
|
|
|
|
error2 = write (fname2, sPParams);
|
|
// If at least one file has been saved, it's a success
|
|
return error1 & error2;
|
|
} else {
|
|
return error1;
|
|
}
|
|
}
|
|
|
|
int ProcParams::write (const Glib::ustring &fname, const Glib::ustring &content) const
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
if (fname.length()) {
|
|
FILE *f;
|
|
f = g_fopen (fname.c_str (), "wt");
|
|
|
|
if (f == nullptr) {
|
|
error = 1;
|
|
} else {
|
|
fprintf (f, "%s", content.c_str());
|
|
fclose (f);
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
int ProcParams::load (const Glib::ustring &fname, ParamsEdited* pedited)
|
|
{
|
|
setlocale (LC_NUMERIC, "C"); // to set decimal point to "."
|
|
|
|
if (fname.empty()) {
|
|
return 1;
|
|
}
|
|
|
|
Glib::KeyFile keyFile;
|
|
|
|
try {
|
|
|
|
if (pedited) {
|
|
pedited->set (false);
|
|
}
|
|
|
|
FILE* f = g_fopen (fname.c_str (), "rt");
|
|
|
|
if (!f) {
|
|
return 1;
|
|
}
|
|
|
|
char* buffer = new char[1024];
|
|
std::ostringstream ostr;
|
|
|
|
while (fgets (buffer, 1024, f)) {
|
|
ostr << buffer << "\n";
|
|
}
|
|
|
|
delete [] buffer;
|
|
|
|
if (!keyFile.load_from_data (ostr.str())) {
|
|
return 1;
|
|
}
|
|
|
|
fclose (f);
|
|
|
|
// load tonecurve:
|
|
|
|
ppVersion = PPVERSION;
|
|
appVersion = APPVERSION;
|
|
|
|
if (keyFile.has_group ("Version")) {
|
|
if (keyFile.has_key ("Version", "AppVersion")) {
|
|
appVersion = keyFile.get_string ("Version", "AppVersion");
|
|
}
|
|
|
|
if (keyFile.has_key ("Version", "Version")) {
|
|
ppVersion = keyFile.get_integer ("Version", "Version");
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_group ("General")) {
|
|
assignFromKeyfile(keyFile, "General", "Rank", pedited, rank, pedited->general.rank);
|
|
assignFromKeyfile(keyFile, "General", "ColorLabel", pedited, colorlabel, pedited->general.colorlabel);
|
|
assignFromKeyfile(keyFile, "General", "InTrash", pedited, inTrash, pedited->general.intrash);
|
|
}
|
|
|
|
if (keyFile.has_group ("Exposure")) {
|
|
if (ppVersion < PPVERSION_AEXP) {
|
|
toneCurve.autoexp = false; // prevent execution of autoexp when opening file created with earlier verions of autoexp algorithm
|
|
} else {
|
|
assignFromKeyfile(keyFile, "Exposure", "Auto", pedited, toneCurve.autoexp, pedited->toneCurve.autoexp);
|
|
}
|
|
assignFromKeyfile(keyFile, "Exposure", "Clip", pedited, toneCurve.clip, pedited->toneCurve.clip);
|
|
assignFromKeyfile(keyFile, "Exposure", "Compensation", pedited, toneCurve.expcomp, pedited->toneCurve.expcomp);
|
|
assignFromKeyfile(keyFile, "Exposure", "Brightness", pedited, toneCurve.brightness, pedited->toneCurve.brightness);
|
|
assignFromKeyfile(keyFile, "Exposure", "Contrast", pedited, toneCurve.contrast, pedited->toneCurve.contrast);
|
|
assignFromKeyfile(keyFile, "Exposure", "Saturation", pedited, toneCurve.saturation, pedited->toneCurve.saturation);
|
|
assignFromKeyfile(keyFile, "Exposure", "Black", pedited, toneCurve.black, pedited->toneCurve.black);
|
|
assignFromKeyfile(keyFile, "Exposure", "HighlightCompr", pedited, toneCurve.hlcompr, pedited->toneCurve.hlcompr);
|
|
assignFromKeyfile(keyFile, "Exposure", "HighlightComprThreshold", pedited, toneCurve.hlcomprthresh, pedited->toneCurve.hlcomprthresh);
|
|
assignFromKeyfile(keyFile, "Exposure", "ShadowCompr", pedited, toneCurve.shcompr, pedited->toneCurve.shcompr);
|
|
// load highlight recovery settings
|
|
if (toneCurve.shcompr > 100) {
|
|
toneCurve.shcompr = 100; // older pp3 files can have values above 100.
|
|
}
|
|
|
|
const std::map<const char*, ToneCurveParams::eTCModeId> tc_mapping = {
|
|
{"Standard", ToneCurveParams::TC_MODE_STD},
|
|
{"FilmLike", ToneCurveParams::TC_MODE_FILMLIKE},
|
|
{"SatAndValueBlending", ToneCurveParams::TC_MODE_SATANDVALBLENDING},
|
|
{"WeightedStd", ToneCurveParams::TC_MODE_WEIGHTEDSTD},
|
|
{"Luminance", ToneCurveParams::TC_MODE_LUMINANCE},
|
|
{"Perceptual", ToneCurveParams::TC_MODE_PERCEPTUAL}
|
|
};
|
|
|
|
assignFromKeyfile(keyFile, "Exposure", "CurveMode", pedited, tc_mapping, toneCurve.curveMode, pedited->toneCurve.curveMode);
|
|
assignFromKeyfile(keyFile, "Exposure", "CurveMode2", pedited, tc_mapping, toneCurve.curveMode, pedited->toneCurve.curveMode);
|
|
|
|
if (ppVersion > 200) {
|
|
assignFromKeyfile(keyFile, "Exposure", "Curve", pedited, toneCurve.curve, pedited->toneCurve.curve);
|
|
assignFromKeyfile(keyFile, "Exposure", "Curve2", pedited, toneCurve.curve2, pedited->toneCurve.curve2);
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_group ("HLRecovery")) {
|
|
assignFromKeyfile(keyFile, "HLRecovery", "Enabled", pedited, toneCurve.hrenabled, pedited->toneCurve.hrenabled);
|
|
assignFromKeyfile(keyFile, "HLRecovery", "Method", pedited, toneCurve.method, pedited->toneCurve.method);
|
|
}
|
|
|
|
// load channel mixer curve
|
|
if (keyFile.has_group ("Channel Mixer")) {
|
|
if (keyFile.has_key ("Channel Mixer", "Red") && keyFile.has_key ("Channel Mixer", "Green") && keyFile.has_key ("Channel Mixer", "Blue")) {
|
|
const std::vector<int> rmix = keyFile.get_integer_list ("Channel Mixer", "Red");
|
|
const std::vector<int> gmix = keyFile.get_integer_list ("Channel Mixer", "Green");
|
|
const std::vector<int> bmix = keyFile.get_integer_list ("Channel Mixer", "Blue");
|
|
|
|
if (rmix.size() == 3 && gmix.size() == 3 && bmix.size() == 3) {
|
|
memcpy (chmixer.red, rmix.data(), 3 * sizeof (int));
|
|
memcpy (chmixer.green, gmix.data(), 3 * sizeof (int));
|
|
memcpy (chmixer.blue, bmix.data(), 3 * sizeof (int));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->chmixer.red[0] = pedited->chmixer.red[1] = pedited->chmixer.red[2] = true;
|
|
pedited->chmixer.green[0] = pedited->chmixer.green[1] = pedited->chmixer.green[2] = true;
|
|
pedited->chmixer.blue[0] = pedited->chmixer.blue[1] = pedited->chmixer.blue[2] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// load black & white
|
|
if (keyFile.has_group ("Black & White")) {
|
|
assignFromKeyfile(keyFile, "Black & White", "Enabled", pedited, blackwhite.enabled, pedited->blackwhite.enabled);
|
|
assignFromKeyfile(keyFile, "Black & White", "Method", pedited, blackwhite.method, pedited->blackwhite.method);
|
|
assignFromKeyfile(keyFile, "Black & White", "Auto", pedited, blackwhite.autoc, pedited->blackwhite.autoc);
|
|
assignFromKeyfile(keyFile, "Black & White", "ComplementaryColors", pedited, blackwhite.enabledcc, pedited->blackwhite.enabledcc);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerRed", pedited, blackwhite.mixerRed, pedited->blackwhite.mixerRed);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerOrange", pedited, blackwhite.mixerOrange, pedited->blackwhite.mixerOrange);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerYellow", pedited, blackwhite.mixerYellow, pedited->blackwhite.mixerYellow);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerGreen", pedited, blackwhite.mixerGreen, pedited->blackwhite.mixerGreen);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerCyan", pedited, blackwhite.mixerCyan, pedited->blackwhite.mixerCyan);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerBlue", pedited, blackwhite.mixerBlue, pedited->blackwhite.mixerBlue);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerMagenta", pedited, blackwhite.mixerMagenta, pedited->blackwhite.mixerMagenta);
|
|
assignFromKeyfile(keyFile, "Black & White", "MixerPurple", pedited, blackwhite.mixerPurple, pedited->blackwhite.mixerPurple);
|
|
assignFromKeyfile(keyFile, "Black & White", "GammaRed", pedited, blackwhite.gammaRed, pedited->blackwhite.gammaRed);
|
|
assignFromKeyfile(keyFile, "Black & White", "GammaGreen", pedited, blackwhite.gammaGreen, pedited->blackwhite.gammaGreen);
|
|
assignFromKeyfile(keyFile, "Black & White", "GammaBlue", pedited, blackwhite.gammaBlue, pedited->blackwhite.gammaBlue);
|
|
assignFromKeyfile(keyFile, "Black & White", "Filter", pedited, blackwhite.filter, pedited->blackwhite.filter);
|
|
assignFromKeyfile(keyFile, "Black & White", "Setting", pedited, blackwhite.setting, pedited->blackwhite.setting);
|
|
assignFromKeyfile(keyFile, "Black & White", "LuminanceCurve", pedited, blackwhite.luminanceCurve, pedited->blackwhite.luminanceCurve);
|
|
|
|
assignFromKeyfile(keyFile, "Black & White", "BeforeCurve", pedited, blackwhite.beforeCurve, pedited->blackwhite.beforeCurve);
|
|
|
|
assignFromKeyfile(keyFile, "Black & White", "Algorithm", pedited, blackwhite.algo, pedited->blackwhite.algo);
|
|
assignFromKeyfile(
|
|
keyFile,
|
|
"Black & White",
|
|
"BeforeCurveMode",
|
|
pedited,
|
|
{
|
|
{"Standard", BlackWhiteParams::TC_MODE_STD_BW},
|
|
{"FilmLike", BlackWhiteParams::TC_MODE_FILMLIKE_BW},
|
|
{"SatAndValueBlending", BlackWhiteParams::TC_MODE_SATANDVALBLENDING_BW},
|
|
{"WeightedStd", BlackWhiteParams::TC_MODE_WEIGHTEDSTD_BW}
|
|
},
|
|
blackwhite.beforeCurveMode,
|
|
pedited->blackwhite.beforeCurveMode
|
|
);
|
|
|
|
assignFromKeyfile(keyFile, "Black & White", "AfterCurve", pedited, blackwhite.afterCurve, pedited->blackwhite.afterCurve);
|
|
assignFromKeyfile(
|
|
keyFile,
|
|
"Black & White",
|
|
"AfterCurveMode",
|
|
pedited,
|
|
{
|
|
{"Standard", BlackWhiteParams::TC_MODE_STD_BW},
|
|
{"WeightedStd", BlackWhiteParams::TC_MODE_WEIGHTEDSTD_BW}
|
|
},
|
|
blackwhite.afterCurveMode,
|
|
pedited->blackwhite.afterCurveMode
|
|
);
|
|
}
|
|
|
|
//load retinex
|
|
if (keyFile.has_group ("Retinex")) {
|
|
assignFromKeyfile(keyFile, "Retinex", "Median", pedited, retinex.medianmap, pedited->retinex.medianmap);
|
|
assignFromKeyfile(keyFile, "Retinex", "RetinexMethod", pedited, retinex.retinexMethod, pedited->retinex.retinexMethod);
|
|
assignFromKeyfile(keyFile, "Retinex", "mapMethod", pedited, retinex.mapMethod, pedited->retinex.mapMethod);
|
|
assignFromKeyfile(keyFile, "Retinex", "viewMethod", pedited, retinex.viewMethod, pedited->retinex.viewMethod);
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "Retinexcolorspace", pedited, retinex.retinexcolorspace, pedited->retinex.retinexcolorspace);
|
|
assignFromKeyfile(keyFile, "Retinex", "Gammaretinex", pedited, retinex.gammaretinex, pedited->retinex.gammaretinex);
|
|
assignFromKeyfile(keyFile, "Retinex", "Enabled", pedited, retinex.enabled, pedited->retinex.enabled);
|
|
assignFromKeyfile(keyFile, "Retinex", "Neigh", pedited, retinex.neigh, pedited->retinex.neigh);
|
|
assignFromKeyfile(keyFile, "Retinex", "Str", pedited, retinex.str, pedited->retinex.str);
|
|
assignFromKeyfile(keyFile, "Retinex", "Scal", pedited, retinex.scal, pedited->retinex.scal);
|
|
assignFromKeyfile(keyFile, "Retinex", "Iter", pedited, retinex.iter, pedited->retinex.iter);
|
|
assignFromKeyfile(keyFile, "Retinex", "Grad", pedited, retinex.grad, pedited->retinex.grad);
|
|
assignFromKeyfile(keyFile, "Retinex", "Grads", pedited, retinex.grads, pedited->retinex.grads);
|
|
assignFromKeyfile(keyFile, "Retinex", "Gam", pedited, retinex.gam, pedited->retinex.gam);
|
|
assignFromKeyfile(keyFile, "Retinex", "Slope", pedited, retinex.slope, pedited->retinex.slope);
|
|
assignFromKeyfile(keyFile, "Retinex", "Offs", pedited, retinex.offs, pedited->retinex.offs);
|
|
assignFromKeyfile(keyFile, "Retinex", "Vart", pedited, retinex.vart, pedited->retinex.vart);
|
|
assignFromKeyfile(keyFile, "Retinex", "Limd", pedited, retinex.limd, pedited->retinex.limd);
|
|
assignFromKeyfile(keyFile, "Retinex", "highl", pedited, retinex.highl, pedited->retinex.highl);
|
|
assignFromKeyfile(keyFile, "Retinex", "skal", pedited, retinex.skal, pedited->retinex.skal);
|
|
assignFromKeyfile(keyFile, "Retinex", "CDCurve", pedited, retinex.cdcurve, pedited->retinex.cdcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "MAPCurve", pedited, retinex.mapcurve, pedited->retinex.mapcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "CDHCurve", pedited, retinex.cdHcurve, pedited->retinex.cdHcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "LHCurve", pedited, retinex.lhcurve, pedited->retinex.lhcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "Highlights", pedited, retinex.highlights, pedited->retinex.highlights);
|
|
assignFromKeyfile(keyFile, "Retinex", "HighlightTonalWidth", pedited, retinex.htonalwidth, pedited->retinex.htonalwidth);
|
|
assignFromKeyfile(keyFile, "Retinex", "Shadows", pedited, retinex.shadows, pedited->retinex.shadows);
|
|
assignFromKeyfile(keyFile, "Retinex", "ShadowTonalWidth", pedited, retinex.stonalwidth, pedited->retinex.stonalwidth);
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "Radius", pedited, retinex.radius, pedited->retinex.radius);
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "TransmissionCurve", pedited, retinex.transmissionCurve, pedited->retinex.transmissionCurve);
|
|
|
|
|
|
assignFromKeyfile(keyFile, "Retinex", "GainTransmissionCurve", pedited, retinex.gaintransmissionCurve, pedited->retinex.gaintransmissionCurve);
|
|
}
|
|
|
|
|
|
// load luma curve
|
|
if (keyFile.has_group ("Luminance Curve")) {
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "Brightness", pedited, labCurve.brightness, pedited->labCurve.brightness);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "Contrast", pedited, labCurve.contrast, pedited->labCurve.contrast);
|
|
if (ppVersion < 303) {
|
|
// transform Saturation into Chromaticity
|
|
// if Saturation == 0, should we set BWToning on?
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "Saturation", pedited, labCurve.chromaticity, pedited->labCurve.chromaticity);
|
|
// transform AvoidColorClipping into AvoidColorShift
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "AvoidColorClipping", pedited, labCurve.avoidcolorshift, pedited->labCurve.avoidcolorshift);
|
|
} else {
|
|
if (keyFile.has_key ("Luminance Curve", "Chromaticity")) {
|
|
labCurve.chromaticity = keyFile.get_integer ("Luminance Curve", "Chromaticity");
|
|
|
|
if (ppVersion >= 303 && ppVersion < 314 && labCurve.chromaticity == -100) {
|
|
blackwhite.enabled = true;
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->labCurve.chromaticity = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "AvoidColorShift", pedited, labCurve.avoidcolorshift, pedited->labCurve.avoidcolorshift);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "RedAndSkinTonesProtection", pedited, labCurve.rstprotection, pedited->labCurve.rstprotection);
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "LCredsk", pedited, labCurve.lcredsk, pedited->labCurve.lcredsk);
|
|
if (ppVersion < 314)
|
|
|
|
// Backward compatibility: If BWtoning is true, Chromaticity has to be set to -100, which will produce the same effect
|
|
// and will enable the b&w toning mode ('a' & 'b' curves)
|
|
if (keyFile.has_key ("Luminance Curve", "BWtoning")) {
|
|
if ( keyFile.get_boolean ("Luminance Curve", "BWtoning")) {
|
|
labCurve.chromaticity = -100;
|
|
|
|
if (pedited) {
|
|
pedited->labCurve.chromaticity = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "LCurve", pedited, labCurve.lcurve, pedited->labCurve.lcurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "aCurve", pedited, labCurve.acurve, pedited->labCurve.acurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "bCurve", pedited, labCurve.bcurve, pedited->labCurve.bcurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "ccCurve", pedited, labCurve.cccurve, pedited->labCurve.cccurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "chCurve", pedited, labCurve.chcurve, pedited->labCurve.chcurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "lhCurve", pedited, labCurve.lhcurve, pedited->labCurve.lhcurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "hhCurve", pedited, labCurve.hhcurve, pedited->labCurve.hhcurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "LcCurve", pedited, labCurve.lccurve, pedited->labCurve.lccurve);
|
|
assignFromKeyfile(keyFile, "Luminance Curve", "ClCurve", pedited, labCurve.clcurve, pedited->labCurve.clcurve);
|
|
|
|
}
|
|
|
|
// load sharpening
|
|
if (keyFile.has_group ("Sharpening")) {
|
|
assignFromKeyfile(keyFile, "Sharpening", "Enabled", pedited, sharpening.enabled, pedited->sharpening.enabled);
|
|
assignFromKeyfile(keyFile, "Sharpening", "Radius", pedited, sharpening.radius, pedited->sharpening.radius);
|
|
assignFromKeyfile(keyFile, "Sharpening", "Amount", pedited, sharpening.amount, pedited->sharpening.amount);
|
|
if (keyFile.has_key ("Sharpening", "Threshold")) {
|
|
if (ppVersion < 302) {
|
|
int thresh = min (keyFile.get_integer ("Sharpening", "Threshold"), 2000);
|
|
sharpening.threshold.setValues (thresh, thresh, 2000, 2000); // TODO: 2000 is the maximum value and is taken of rtgui/sharpening.cc ; should be changed by the tool modularization
|
|
} else {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Sharpening", "Threshold");
|
|
|
|
if (thresh.size() >= 4) {
|
|
sharpening.threshold.setValues (thresh[0], thresh[1], min (thresh[2], 2000), min (thresh[3], 2000));
|
|
}
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->sharpening.threshold = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Sharpening", "OnlyEdges", pedited, sharpening.edgesonly, pedited->sharpening.edgesonly);
|
|
assignFromKeyfile(keyFile, "Sharpening", "EdgedetectionRadius", pedited, sharpening.edges_radius, pedited->sharpening.edges_radius);
|
|
assignFromKeyfile(keyFile, "Sharpening", "EdgeTolerance", pedited, sharpening.edges_tolerance, pedited->sharpening.edges_tolerance);
|
|
assignFromKeyfile(keyFile, "Sharpening", "HalocontrolEnabled", pedited, sharpening.halocontrol, pedited->sharpening.halocontrol);
|
|
assignFromKeyfile(keyFile, "Sharpening", "HalocontrolAmount", pedited, sharpening.halocontrol_amount, pedited->sharpening.halocontrol_amount);
|
|
assignFromKeyfile(keyFile, "Sharpening", "Method", pedited, sharpening.method, pedited->sharpening.method);
|
|
assignFromKeyfile(keyFile, "Sharpening", "DeconvRadius", pedited, sharpening.deconvradius, pedited->sharpening.deconvradius);
|
|
assignFromKeyfile(keyFile, "Sharpening", "DeconvAmount", pedited, sharpening.deconvamount, pedited->sharpening.deconvamount);
|
|
assignFromKeyfile(keyFile, "Sharpening", "DeconvDamping", pedited, sharpening.deconvdamping, pedited->sharpening.deconvdamping);
|
|
assignFromKeyfile(keyFile, "Sharpening", "DeconvIterations", pedited, sharpening.deconviter, pedited->sharpening.deconviter);
|
|
}
|
|
|
|
// load edge sharpening
|
|
if (keyFile.has_group ("SharpenEdge")) {
|
|
assignFromKeyfile(keyFile, "SharpenEdge", "Enabled", pedited, sharpenEdge.enabled, pedited->sharpenEdge.enabled);
|
|
assignFromKeyfile(keyFile, "SharpenEdge", "Passes", pedited, sharpenEdge.passes, pedited->sharpenEdge.passes);
|
|
assignFromKeyfile(keyFile, "SharpenEdge", "Strength", pedited, sharpenEdge.amount, pedited->sharpenEdge.amount);
|
|
assignFromKeyfile(keyFile, "SharpenEdge", "ThreeChannels", pedited, sharpenEdge.threechannels, pedited->sharpenEdge.threechannels);
|
|
}
|
|
|
|
// load micro-contrast sharpening
|
|
if (keyFile.has_group ("SharpenMicro")) {
|
|
assignFromKeyfile(keyFile, "SharpenMicro", "Enabled", pedited, sharpenMicro.enabled, pedited->sharpenMicro.enabled);
|
|
assignFromKeyfile(keyFile, "SharpenMicro", "Matrix", pedited, sharpenMicro.matrix, pedited->sharpenMicro.matrix);
|
|
assignFromKeyfile(keyFile, "SharpenMicro", "Strength", pedited, sharpenMicro.amount, pedited->sharpenMicro.amount);
|
|
assignFromKeyfile(keyFile, "SharpenMicro", "Uniformity", pedited, sharpenMicro.uniformity, pedited->sharpenMicro.uniformity);
|
|
}
|
|
|
|
// load vibrance
|
|
if (keyFile.has_group ("Vibrance")) {
|
|
assignFromKeyfile(keyFile, "Vibrance", "Enabled", pedited, vibrance.enabled, pedited->vibrance.enabled);
|
|
assignFromKeyfile(keyFile, "Vibrance", "Pastels", pedited, vibrance.pastels, pedited->vibrance.pastels);
|
|
assignFromKeyfile(keyFile, "Vibrance", "Saturated", pedited, vibrance.saturated, pedited->vibrance.saturated);
|
|
if (keyFile.has_key ("Vibrance", "PSThreshold")) {
|
|
if (ppVersion < 302) {
|
|
int thresh = keyFile.get_integer ("Vibrance", "PSThreshold");
|
|
vibrance.psthreshold.setValues (thresh, thresh);
|
|
} else {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Vibrance", "PSThreshold");
|
|
|
|
if (thresh.size() >= 2 ) {
|
|
vibrance.psthreshold.setValues (thresh[0], thresh[1]);
|
|
}
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->vibrance.psthreshold = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Vibrance", "ProtectSkins", pedited, vibrance.protectskins, pedited->vibrance.protectskins);
|
|
assignFromKeyfile(keyFile, "Vibrance", "AvoidColorShift", pedited, vibrance.avoidcolorshift, pedited->vibrance.avoidcolorshift);
|
|
assignFromKeyfile(keyFile, "Vibrance", "PastSatTog", pedited, vibrance.pastsattog, pedited->vibrance.pastsattog);
|
|
assignFromKeyfile(keyFile, "Vibrance", "SkinTonesCurve", pedited, vibrance.skintonescurve, pedited->vibrance.skintonescurve);
|
|
}
|
|
|
|
// load colorBoost
|
|
/*if (keyFile.has_group ("Color Boost")) {
|
|
if (keyFile.has_key ("Color Boost", "Amount")) { colorBoost.amount = keyFile.get_integer ("Color Boost", "Amount"); if (pedited) pedited->colorBoost.amount = true; }
|
|
else {
|
|
int a=0, b=0;
|
|
if (keyFile.has_key ("Color Boost", "ChannelA")) { a = keyFile.get_integer ("Color Boost", "ChannelA"); }
|
|
if (keyFile.has_key ("Color Boost", "ChannelB")) { b = keyFile.get_integer ("Color Boost", "ChannelB"); }
|
|
colorBoost.amount = (a+b) / 2;
|
|
if (pedited) pedited->colorBoost.amount = true;
|
|
}
|
|
if (keyFile.has_key ("Color Boost", "AvoidColorClipping")) { colorBoost.avoidclip = keyFile.get_boolean ("Color Boost", "AvoidColorClipping"); if (pedited) pedited->colorBoost.avoidclip = true; }
|
|
if (keyFile.has_key ("Color Boost", "SaturationLimiter")) { colorBoost.enable_saturationlimiter= keyFile.get_boolean ("Color Boost", "SaturationLimiter"); if (pedited) pedited->colorBoost.enable_saturationlimiter = true; }
|
|
if (keyFile.has_key ("Color Boost", "SaturationLimit")) { colorBoost.saturationlimit = keyFile.get_double ("Color Boost", "SaturationLimit"); if (pedited) pedited->colorBoost.saturationlimit = true; }
|
|
}*/
|
|
|
|
// load wb
|
|
if (keyFile.has_group ("White Balance")) {
|
|
assignFromKeyfile(keyFile, "White Balance", "Setting", pedited, wb.method, pedited->wb.method);
|
|
assignFromKeyfile(keyFile, "White Balance", "Temperature", pedited, wb.temperature, pedited->wb.temperature);
|
|
assignFromKeyfile(keyFile, "White Balance", "Green", pedited, wb.green, pedited->wb.green);
|
|
assignFromKeyfile(keyFile, "White Balance", "Equal", pedited, wb.equal, pedited->wb.equal);
|
|
assignFromKeyfile(keyFile, "White Balance", "TemperatureBias", pedited, wb.tempBias, pedited->wb.tempBias);
|
|
}
|
|
|
|
// load colorShift
|
|
/*if (keyFile.has_group ("Color Shift")) {
|
|
if (keyFile.has_key ("Color Shift", "ChannelA")) { colorShift.a = keyFile.get_double ("Color Shift", "ChannelA"); if (pedited) pedited->colorShift.a = true; }
|
|
if (keyFile.has_key ("Color Shift", "ChannelB")) { colorShift.b = keyFile.get_double ("Color Shift", "ChannelB"); if (pedited) pedited->colorShift.b = true; }
|
|
}*/
|
|
|
|
// load defringe
|
|
if (keyFile.has_group ("Defringing")) {
|
|
assignFromKeyfile(keyFile, "Defringing", "Enabled", pedited, defringe.enabled, pedited->defringe.enabled);
|
|
assignFromKeyfile(keyFile, "Defringing", "Radius", pedited, defringe.radius, pedited->defringe.radius);
|
|
if (keyFile.has_key ("Defringing", "Threshold")) {
|
|
defringe.threshold = (float)keyFile.get_integer ("Defringing", "Threshold");
|
|
|
|
if (pedited) {
|
|
pedited->defringe.threshold = true;
|
|
}
|
|
}
|
|
|
|
if (ppVersion < 310) {
|
|
defringe.threshold = sqrt (defringe.threshold * 33.f / 5.f);
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Defringing", "HueCurve", pedited, defringe.huecurve, pedited->defringe.huecurve);
|
|
}
|
|
|
|
// load colorappearance
|
|
if (keyFile.has_group ("Color appearance")) {
|
|
assignFromKeyfile(keyFile, "Color appearance", "Enabled", pedited, colorappearance.enabled, pedited->colorappearance.enabled);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Degree", pedited, colorappearance.degree, pedited->colorappearance.degree);
|
|
assignFromKeyfile(keyFile, "Color appearance", "AutoDegree", pedited, colorappearance.autodegree, pedited->colorappearance.autodegree);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Degreeout", pedited, colorappearance.degreeout, pedited->colorappearance.degreeout);
|
|
|
|
assignFromKeyfile(keyFile, "Color appearance", "AutoDegreeout", pedited, colorappearance.autodegreeout, pedited->colorappearance.autodegreeout);
|
|
|
|
assignFromKeyfile(keyFile, "Color appearance", "Surround", pedited, colorappearance.surround, pedited->colorappearance.surround);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Surrsrc", pedited, colorappearance.surrsrc, pedited->colorappearance.surrsrc);
|
|
// if (keyFile.has_key ("Color appearance", "Background")) {colorappearance.backgrd = keyFile.get_integer ("Color appearance", "Background"); if (pedited) pedited->colorappearance.backgrd = true; }
|
|
assignFromKeyfile(keyFile, "Color appearance", "AdaptLum", pedited, colorappearance.adaplum, pedited->colorappearance.adaplum);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Badpixsl", pedited, colorappearance.badpixsl, pedited->colorappearance.badpixsl);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Model", pedited, colorappearance.wbmodel, pedited->colorappearance.wbmodel);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Algorithm", pedited, colorappearance.algo, pedited->colorappearance.algo);
|
|
assignFromKeyfile(keyFile, "Color appearance", "J-Light", pedited, colorappearance.jlight, pedited->colorappearance.jlight);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Q-Bright", pedited, colorappearance.qbright, pedited->colorappearance.qbright);
|
|
assignFromKeyfile(keyFile, "Color appearance", "C-Chroma", pedited, colorappearance.chroma, pedited->colorappearance.chroma);
|
|
assignFromKeyfile(keyFile, "Color appearance", "S-Chroma", pedited, colorappearance.schroma, pedited->colorappearance.schroma);
|
|
assignFromKeyfile(keyFile, "Color appearance", "M-Chroma", pedited, colorappearance.mchroma, pedited->colorappearance.mchroma);
|
|
assignFromKeyfile(keyFile, "Color appearance", "RSTProtection", pedited, colorappearance.rstprotection, pedited->colorappearance.rstprotection);
|
|
assignFromKeyfile(keyFile, "Color appearance", "J-Contrast", pedited, colorappearance.contrast, pedited->colorappearance.contrast);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Q-Contrast", pedited, colorappearance.qcontrast, pedited->colorappearance.qcontrast);
|
|
assignFromKeyfile(keyFile, "Color appearance", "H-Hue", pedited, colorappearance.colorh, pedited->colorappearance.colorh);
|
|
assignFromKeyfile(keyFile, "Color appearance", "AdaptScene", pedited, colorappearance.adapscen, pedited->colorappearance.adapscen);
|
|
assignFromKeyfile(keyFile, "Color appearance", "AutoAdapscen", pedited, colorappearance.autoadapscen, pedited->colorappearance.autoadapscen);
|
|
assignFromKeyfile(keyFile, "Color appearance", "YbScene", pedited, colorappearance.ybscen, pedited->colorappearance.ybscen);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Autoybscen", pedited, colorappearance.autoybscen, pedited->colorappearance.autoybscen);
|
|
assignFromKeyfile(keyFile, "Color appearance", "SurrSource", pedited, colorappearance.surrsource, pedited->colorappearance.surrsource);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Gamut", pedited, colorappearance.gamut, pedited->colorappearance.gamut);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Tempout", pedited, colorappearance.tempout, pedited->colorappearance.tempout);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Greenout", pedited, colorappearance.greenout, pedited->colorappearance.greenout);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Tempsc", pedited, colorappearance.tempsc, pedited->colorappearance.tempsc);
|
|
|
|
assignFromKeyfile(keyFile, "Color appearance", "Greensc", pedited, colorappearance.greensc, pedited->colorappearance.greensc);
|
|
|
|
assignFromKeyfile(keyFile, "Color appearance", "Ybout", pedited, colorappearance.ybout, pedited->colorappearance.ybout);
|
|
// if (keyFile.has_key ("Color appearance", "Badpix")) {colorappearance.badpix = keyFile.get_boolean ("Color appearance", "Badpix"); if (pedited) pedited->colorappearance.badpix = true; }
|
|
assignFromKeyfile(keyFile, "Color appearance", "Datacie", pedited, colorappearance.datacie, pedited->colorappearance.datacie);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Tonecie", pedited, colorappearance.tonecie, pedited->colorappearance.tonecie);
|
|
// if (keyFile.has_key ("Color appearance", "Sharpcie")) {colorappearance.sharpcie = keyFile.get_boolean ("Color appearance", "Sharpcie"); if (pedited) pedited->colorappearance.sharpcie = true; }
|
|
|
|
const std::map<const char*, ColorAppearanceParams::eTCModeId> tc_mapping = {
|
|
{"Lightness", ColorAppearanceParams::TC_MODE_LIGHT},
|
|
{"Brightness", ColorAppearanceParams::TC_MODE_BRIGHT}
|
|
};
|
|
assignFromKeyfile(keyFile, "Color appearance", "CurveMode", pedited, tc_mapping, colorappearance.curveMode, pedited->colorappearance.curveMode);
|
|
assignFromKeyfile(keyFile, "Color appearance", "CurveMode2", pedited, tc_mapping, colorappearance.curveMode2, pedited->colorappearance.curveMode2);
|
|
|
|
assignFromKeyfile(
|
|
keyFile,
|
|
"Color appearance",
|
|
"CurveMode3",
|
|
pedited,
|
|
{
|
|
{"Chroma", ColorAppearanceParams::TC_MODE_CHROMA},
|
|
{"Saturation", ColorAppearanceParams::TC_MODE_SATUR},
|
|
{"Colorfullness", ColorAppearanceParams::TC_MODE_COLORF}
|
|
},
|
|
colorappearance.curveMode3,
|
|
pedited->colorappearance.curveMode3
|
|
);
|
|
|
|
if (ppVersion > 200) {
|
|
assignFromKeyfile(keyFile, "Color appearance", "Curve", pedited, colorappearance.curve, pedited->colorappearance.curve);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Curve2", pedited, colorappearance.curve2, pedited->colorappearance.curve2);
|
|
assignFromKeyfile(keyFile, "Color appearance", "Curve3", pedited, colorappearance.curve3, pedited->colorappearance.curve3);
|
|
}
|
|
|
|
}
|
|
|
|
// load impulseDenoise
|
|
if (keyFile.has_group ("Impulse Denoising")) {
|
|
assignFromKeyfile(keyFile, "Impulse Denoising", "Enabled", pedited, impulseDenoise.enabled, pedited->impulseDenoise.enabled);
|
|
assignFromKeyfile(keyFile, "Impulse Denoising", "Threshold", pedited, impulseDenoise.thresh, pedited->impulseDenoise.thresh);
|
|
}
|
|
|
|
// load dirpyrDenoise
|
|
if (keyFile.has_group ("Directional Pyramid Denoising")) {//TODO: No longer an accurate description for FT denoise
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Enabled", pedited, dirpyrDenoise.enabled, pedited->dirpyrDenoise.enabled);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Enhance", pedited, dirpyrDenoise.enhance, pedited->dirpyrDenoise.enhance);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Median", pedited, dirpyrDenoise.median, pedited->dirpyrDenoise.median);
|
|
// if (keyFile.has_key ("Directional Pyramid Denoising", "Perform")) { dirpyrDenoise.perform = keyFile.get_boolean ("Directional Pyramid Denoising", "Perform"); if (pedited) pedited->dirpyrDenoise.perform = true; }
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Luma", pedited, dirpyrDenoise.luma, pedited->dirpyrDenoise.luma);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Ldetail", pedited, dirpyrDenoise.Ldetail, pedited->dirpyrDenoise.Ldetail);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Chroma", pedited, dirpyrDenoise.chroma, pedited->dirpyrDenoise.chroma);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Method", pedited, dirpyrDenoise.dmethod, pedited->dirpyrDenoise.dmethod);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "LMethod", pedited, dirpyrDenoise.Lmethod, pedited->dirpyrDenoise.Lmethod);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "CMethod", pedited, dirpyrDenoise.Cmethod, pedited->dirpyrDenoise.Cmethod);
|
|
// never load 'auto chroma preview mode' from pp3
|
|
if (dirpyrDenoise.Cmethod == "PRE") {
|
|
dirpyrDenoise.Cmethod = "MAN";
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "C2Method", pedited, dirpyrDenoise.C2method, pedited->dirpyrDenoise.C2method);
|
|
if (dirpyrDenoise.C2method == "PREV") {
|
|
dirpyrDenoise.C2method = "MANU";
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "SMethod", pedited, dirpyrDenoise.smethod, pedited->dirpyrDenoise.smethod);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "MedMethod", pedited, dirpyrDenoise.medmethod, pedited->dirpyrDenoise.medmethod);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "MethodMed", pedited, dirpyrDenoise.methodmed, pedited->dirpyrDenoise.methodmed);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "RGBMethod", pedited, dirpyrDenoise.rgbmethod, pedited->dirpyrDenoise.rgbmethod);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "LCurve", pedited, dirpyrDenoise.lcurve, pedited->dirpyrDenoise.lcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "CCCurve", pedited, dirpyrDenoise.cccurve, pedited->dirpyrDenoise.cccurve);
|
|
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Redchro", pedited, dirpyrDenoise.redchro, pedited->dirpyrDenoise.redchro);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Bluechro", pedited, dirpyrDenoise.bluechro, pedited->dirpyrDenoise.bluechro);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Gamma", pedited, dirpyrDenoise.gamma, pedited->dirpyrDenoise.gamma);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Denoising", "Passes", pedited, dirpyrDenoise.passes, pedited->dirpyrDenoise.passes);
|
|
}
|
|
|
|
//Load EPD.
|
|
if (keyFile.has_group ("EPD")) {
|
|
assignFromKeyfile(keyFile, "EPD", "Enabled", pedited, epd.enabled, pedited->epd.enabled);
|
|
assignFromKeyfile(keyFile, "EPD", "Strength", pedited, epd.strength, pedited->epd.strength);
|
|
assignFromKeyfile(keyFile, "EPD", "Gamma", pedited, epd.gamma, pedited->epd.gamma);
|
|
assignFromKeyfile(keyFile, "EPD", "EdgeStopping", pedited, epd.edgeStopping, pedited->epd.edgeStopping);
|
|
assignFromKeyfile(keyFile, "EPD", "Scale", pedited, epd.scale, pedited->epd.scale);
|
|
assignFromKeyfile(keyFile, "EPD", "ReweightingIterates", pedited, epd.reweightingIterates, pedited->epd.reweightingIterates);
|
|
}
|
|
|
|
//Load FattalToneMapping
|
|
if (keyFile.has_group ("FattalToneMapping")) {
|
|
assignFromKeyfile(keyFile, "FattalToneMapping", "Enabled", pedited, fattal.enabled, pedited->fattal.enabled);
|
|
assignFromKeyfile(keyFile, "FattalToneMapping", "Threshold", pedited, fattal.threshold, pedited->fattal.threshold);
|
|
assignFromKeyfile(keyFile, "FattalToneMapping", "Amount", pedited, fattal.amount, pedited->fattal.amount);
|
|
}
|
|
|
|
// load lumaDenoise
|
|
/*if (keyFile.has_group ("Luminance Denoising")) {
|
|
if (keyFile.has_key ("Luminance Denoising", "Enabled")) { lumaDenoise.enabled = keyFile.get_boolean ("Luminance Denoising", "Enabled"); if (pedited) pedited->lumaDenoise.enabled = true; }
|
|
if (keyFile.has_key ("Luminance Denoising", "Radius")) { lumaDenoise.radius = keyFile.get_double ("Luminance Denoising", "Radius"); if (pedited) pedited->lumaDenoise.radius = true; }
|
|
if (keyFile.has_key ("Luminance Denoising", "EdgeTolerance")) { lumaDenoise.edgetolerance = keyFile.get_integer ("Luminance Denoising", "EdgeTolerance"); if (pedited) pedited->lumaDenoise.edgetolerance = true; }
|
|
}*/
|
|
|
|
// load colorDenoise
|
|
/*if (keyFile.has_group ("Chrominance Denoising")) {
|
|
if (keyFile.has_key ("Chrominance Denoising", "Enabled")) { colorDenoise.enabled = keyFile.get_boolean ("Chrominance Denoising", "Enabled"); if (pedited) pedited->colorDenoise.enabled = true; }
|
|
// WARNING: radius doesn't exist anymore; is there any compatibility issue that require to keep the following line?
|
|
if (keyFile.has_key ("Chrominance Denoising", "Radius")) { colorDenoise.amount = 10*keyFile.get_double ("Chrominance Denoising", "Radius"); }
|
|
if (keyFile.has_key ("Chrominance Denoising", "Amount")) { colorDenoise.amount = keyFile.get_integer ("Chrominance Denoising", "Amount"); if (pedited) pedited->colorDenoise.amount = true; }
|
|
}*/
|
|
|
|
// load sh
|
|
if (keyFile.has_group ("Shadows & Highlights")) {
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "Enabled", pedited, sh.enabled, pedited->sh.enabled);
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "HighQuality", pedited, sh.hq, pedited->sh.hq);
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "Highlights", pedited, sh.highlights, pedited->sh.highlights);
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "HighlightTonalWidth", pedited, sh.htonalwidth, pedited->sh.htonalwidth);
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "Shadows", pedited, sh.shadows, pedited->sh.shadows);
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "ShadowTonalWidth", pedited, sh.stonalwidth, pedited->sh.stonalwidth);
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "LocalContrast", pedited, sh.localcontrast, pedited->sh.localcontrast);
|
|
assignFromKeyfile(keyFile, "Shadows & Highlights", "Radius", pedited, sh.radius, pedited->sh.radius);
|
|
}
|
|
|
|
// load crop
|
|
if (keyFile.has_group ("Crop")) {
|
|
assignFromKeyfile(keyFile, "Crop", "Enabled", pedited, crop.enabled, pedited->crop.enabled);
|
|
assignFromKeyfile(keyFile, "Crop", "X", pedited, crop.x, pedited->crop.x);
|
|
assignFromKeyfile(keyFile, "Crop", "Y", pedited, crop.y, pedited->crop.y);
|
|
if (keyFile.has_key ("Crop", "W")) {
|
|
crop.w = std::max (keyFile.get_integer ("Crop", "W"), 1);
|
|
|
|
if (pedited) {
|
|
pedited->crop.w = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Crop", "H")) {
|
|
crop.h = std::max (keyFile.get_integer ("Crop", "H"), 1);
|
|
|
|
if (pedited) {
|
|
pedited->crop.h = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Crop", "FixedRatio", pedited, crop.fixratio, pedited->crop.fixratio);
|
|
if (assignFromKeyfile(keyFile, "Crop", "Ratio", pedited, crop.ratio, pedited->crop.ratio)) {
|
|
//backwards compatibility for crop.ratio
|
|
if (crop.ratio == "DIN") {
|
|
crop.ratio = "1.414 - DIN EN ISO 216";
|
|
}
|
|
|
|
if (crop.ratio == "8.5:11") {
|
|
crop.ratio = "8.5:11 - US Letter";
|
|
}
|
|
|
|
if (crop.ratio == "11:17") {
|
|
crop.ratio = "11:17 - Tabloid";
|
|
}
|
|
}
|
|
assignFromKeyfile(keyFile, "Crop", "Orientation", pedited, crop.orientation, pedited->crop.orientation);
|
|
assignFromKeyfile(keyFile, "Crop", "Guide", pedited, crop.guide, pedited->crop.guide);
|
|
}
|
|
|
|
// load coarse
|
|
if (keyFile.has_group ("Coarse Transformation")) {
|
|
assignFromKeyfile(keyFile, "Coarse Transformation", "Rotate", pedited, coarse.rotate, pedited->coarse.rotate);
|
|
assignFromKeyfile(keyFile, "Coarse Transformation", "HorizontalFlip", pedited, coarse.hflip, pedited->coarse.hflip);
|
|
assignFromKeyfile(keyFile, "Coarse Transformation", "VerticalFlip", pedited, coarse.vflip, pedited->coarse.vflip);
|
|
}
|
|
|
|
// load rotate
|
|
if (keyFile.has_group ("Rotation")) {
|
|
assignFromKeyfile(keyFile, "Rotation", "Degree", pedited, rotate.degree, pedited->rotate.degree);
|
|
}
|
|
|
|
// load commonTrans
|
|
if (keyFile.has_group ("Common Properties for Transformations")) {
|
|
assignFromKeyfile(keyFile, "Common Properties for Transformations", "AutoFill", pedited, commonTrans.autofill, pedited->commonTrans.autofill);
|
|
}
|
|
|
|
// load distortion
|
|
if (keyFile.has_group ("Distortion")) {
|
|
assignFromKeyfile(keyFile, "Distortion", "Amount", pedited, distortion.amount, pedited->distortion.amount);
|
|
}
|
|
|
|
// lens profile
|
|
if (keyFile.has_group ("LensProfile")) {
|
|
if (keyFile.has_key ("LensProfile", "LcMode")) {
|
|
lensProf.lcMode = lensProf.getMethodNumber (keyFile.get_string ("LensProfile", "LcMode"));
|
|
|
|
if (pedited) {
|
|
pedited->lensProf.lcMode = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("LensProfile", "LCPFile")) {
|
|
lensProf.lcpFile = expandRelativePath (fname, "", keyFile.get_string ("LensProfile", "LCPFile"));
|
|
|
|
if (pedited) {
|
|
pedited->lensProf.lcpFile = true;
|
|
}
|
|
|
|
if(ppVersion < 327 && !lensProf.lcpFile.empty()) {
|
|
lensProf.lcMode = LensProfParams::LcMode::LCP;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "LensProfile", "UseDistortion", pedited, lensProf.useDist, pedited->lensProf.useDist);
|
|
assignFromKeyfile(keyFile, "LensProfile", "UseVignette", pedited, lensProf.useVign, pedited->lensProf.useVign);
|
|
assignFromKeyfile(keyFile, "LensProfile", "UseCA", pedited, lensProf.useCA, pedited->lensProf.useCA);
|
|
if (keyFile.has_key("LensProfile", "LFCameraMake")) {
|
|
lensProf.lfCameraMake = keyFile.get_string("LensProfile", "LFCameraMake");
|
|
if (pedited) {
|
|
pedited->lensProf.lfCameraMake = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key("LensProfile", "LFCameraModel")) {
|
|
lensProf.lfCameraModel = keyFile.get_string("LensProfile", "LFCameraModel");
|
|
if (pedited) {
|
|
pedited->lensProf.lfCameraModel = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key("LensProfile", "LFLens")) {
|
|
lensProf.lfLens = keyFile.get_string("LensProfile", "LFLens");
|
|
if (pedited) {
|
|
pedited->lensProf.lfLens = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// load perspective correction
|
|
if (keyFile.has_group ("Perspective")) {
|
|
assignFromKeyfile(keyFile, "Perspective", "Horizontal", pedited, perspective.horizontal, pedited->perspective.horizontal);
|
|
assignFromKeyfile(keyFile, "Perspective", "Vertical", pedited, perspective.vertical, pedited->perspective.vertical);
|
|
}
|
|
|
|
// load gradient
|
|
if (keyFile.has_group ("Gradient")) {
|
|
assignFromKeyfile(keyFile, "Gradient", "Enabled", pedited, gradient.enabled, pedited->gradient.enabled);
|
|
assignFromKeyfile(keyFile, "Gradient", "Degree", pedited, gradient.degree, pedited->gradient.degree);
|
|
assignFromKeyfile(keyFile, "Gradient", "Feather", pedited, gradient.feather, pedited->gradient.feather);
|
|
assignFromKeyfile(keyFile, "Gradient", "Strength", pedited, gradient.strength, pedited->gradient.strength);
|
|
assignFromKeyfile(keyFile, "Gradient", "CenterX", pedited, gradient.centerX, pedited->gradient.centerX);
|
|
assignFromKeyfile(keyFile, "Gradient", "CenterY", pedited, gradient.centerY, pedited->gradient.centerY);
|
|
}
|
|
|
|
if (keyFile.has_group ("PCVignette")) {
|
|
assignFromKeyfile(keyFile, "PCVignette", "Enabled", pedited, pcvignette.enabled, pedited->pcvignette.enabled);
|
|
assignFromKeyfile(keyFile, "PCVignette", "Strength", pedited, pcvignette.strength, pedited->pcvignette.strength);
|
|
assignFromKeyfile(keyFile, "PCVignette", "Feather", pedited, pcvignette.feather, pedited->pcvignette.feather);
|
|
assignFromKeyfile(keyFile, "PCVignette", "Roundness", pedited, pcvignette.roundness, pedited->pcvignette.roundness);
|
|
}
|
|
|
|
// load c/a correction
|
|
if (keyFile.has_group ("CACorrection")) {
|
|
assignFromKeyfile(keyFile, "CACorrection", "Red", pedited, cacorrection.red, pedited->cacorrection.red);
|
|
assignFromKeyfile(keyFile, "CACorrection", "Blue", pedited, cacorrection.blue, pedited->cacorrection.blue);
|
|
}
|
|
|
|
// load vignetting correction
|
|
if (keyFile.has_group ("Vignetting Correction")) {
|
|
assignFromKeyfile(keyFile, "Vignetting Correction", "Amount", pedited, vignetting.amount, pedited->vignetting.amount);
|
|
assignFromKeyfile(keyFile, "Vignetting Correction", "Radius", pedited, vignetting.radius, pedited->vignetting.radius);
|
|
assignFromKeyfile(keyFile, "Vignetting Correction", "Strength", pedited, vignetting.strength, pedited->vignetting.strength);
|
|
assignFromKeyfile(keyFile, "Vignetting Correction", "CenterX", pedited, vignetting.centerX, pedited->vignetting.centerX);
|
|
assignFromKeyfile(keyFile, "Vignetting Correction", "CenterY", pedited, vignetting.centerY, pedited->vignetting.centerY);
|
|
}
|
|
|
|
// load resize settings
|
|
if (keyFile.has_group ("Resize")) {
|
|
assignFromKeyfile(keyFile, "Resize", "Enabled", pedited, resize.enabled, pedited->resize.enabled);
|
|
assignFromKeyfile(keyFile, "Resize", "Scale", pedited, resize.scale, pedited->resize.scale);
|
|
assignFromKeyfile(keyFile, "Resize", "AppliesTo", pedited, resize.appliesTo, pedited->resize.appliesTo);
|
|
assignFromKeyfile(keyFile, "Resize", "Method", pedited, resize.method, pedited->resize.method);
|
|
assignFromKeyfile(keyFile, "Resize", "DataSpecified", pedited, resize.dataspec, pedited->resize.dataspec);
|
|
assignFromKeyfile(keyFile, "Resize", "Width", pedited, resize.width, pedited->resize.width);
|
|
assignFromKeyfile(keyFile, "Resize", "Height", pedited, resize.height, pedited->resize.height);
|
|
}
|
|
|
|
// load post resize sharpening
|
|
if (keyFile.has_group ("PostResizeSharpening")) {
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "Enabled", pedited, prsharpening.enabled, pedited->prsharpening.enabled);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "Radius", pedited, prsharpening.radius, pedited->prsharpening.radius);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "Amount", pedited, prsharpening.amount, pedited->prsharpening.amount);
|
|
if (keyFile.has_key ("PostResizeSharpening", "Threshold")) {
|
|
if (ppVersion < 302) {
|
|
int thresh = min (keyFile.get_integer ("PostResizeSharpening", "Threshold"), 2000);
|
|
prsharpening.threshold.setValues (thresh, thresh, 2000, 2000); // TODO: 2000 is the maximum value and is taken of rtgui/sharpening.cc ; should be changed by the tool modularization
|
|
} else {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("PostResizeSharpening", "Threshold");
|
|
|
|
if (thresh.size() >= 4) {
|
|
prsharpening.threshold.setValues (thresh[0], thresh[1], min (thresh[2], 2000), min (thresh[3], 2000));
|
|
}
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->prsharpening.threshold = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "OnlyEdges", pedited, prsharpening.edgesonly, pedited->prsharpening.edgesonly);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "EdgedetectionRadius", pedited, prsharpening.edges_radius, pedited->prsharpening.edges_radius);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "EdgeTolerance", pedited, prsharpening.edges_tolerance, pedited->prsharpening.edges_tolerance);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "HalocontrolEnabled", pedited, prsharpening.halocontrol, pedited->prsharpening.halocontrol);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "HalocontrolAmount", pedited, prsharpening.halocontrol_amount, pedited->prsharpening.halocontrol_amount);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "Method", pedited, prsharpening.method, pedited->prsharpening.method);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "DeconvRadius", pedited, prsharpening.deconvradius, pedited->prsharpening.deconvradius);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "DeconvAmount", pedited, prsharpening.deconvamount, pedited->prsharpening.deconvamount);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "DeconvDamping", pedited, prsharpening.deconvdamping, pedited->prsharpening.deconvdamping);
|
|
assignFromKeyfile(keyFile, "PostResizeSharpening", "DeconvIterations", pedited, prsharpening.deconviter, pedited->prsharpening.deconviter);
|
|
}
|
|
|
|
// load color management settings
|
|
if (keyFile.has_group ("Color Management")) {
|
|
if (keyFile.has_key ("Color Management", "InputProfile")) {
|
|
icm.input = expandRelativePath (fname, "file:", keyFile.get_string ("Color Management", "InputProfile"));
|
|
|
|
if (pedited) {
|
|
pedited->icm.input = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Color Management", "ToneCurve", pedited, icm.toneCurve, pedited->icm.toneCurve);
|
|
assignFromKeyfile(keyFile, "Color Management", "ApplyLookTable", pedited, icm.applyLookTable, pedited->icm.applyLookTable);
|
|
assignFromKeyfile(keyFile, "Color Management", "ApplyBaselineExposureOffset", pedited, icm.applyBaselineExposureOffset, pedited->icm.applyBaselineExposureOffset);
|
|
assignFromKeyfile(keyFile, "Color Management", "ApplyHueSatMap", pedited, icm.applyHueSatMap, pedited->icm.applyHueSatMap);
|
|
assignFromKeyfile(keyFile, "Color Management", "DCPIlluminant", pedited, icm.dcpIlluminant, pedited->icm.dcpIlluminant);
|
|
assignFromKeyfile(keyFile, "Color Management", "WorkingProfile", pedited, icm.working, pedited->icm.working);
|
|
assignFromKeyfile(keyFile, "Color Management", "OutputProfile", pedited, icm.output, pedited->icm.output);
|
|
if (keyFile.has_key ("Color Management", "OutputProfileIntent")) {
|
|
Glib::ustring intent = keyFile.get_string ("Color Management", "OutputProfileIntent");
|
|
|
|
if (intent == "Perceptual") {
|
|
icm.outputIntent = RI_PERCEPTUAL;
|
|
} else if (intent == "Relative") {
|
|
icm.outputIntent = RI_RELATIVE;
|
|
} else if (intent == "Saturation") {
|
|
icm.outputIntent = RI_SATURATION;
|
|
} else if (intent == "Absolute") {
|
|
icm.outputIntent = RI_ABSOLUTE;
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->icm.outputIntent = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Color Management", "OutputBPC", pedited, icm.outputBPC, pedited->icm.outputBPC);
|
|
assignFromKeyfile(keyFile, "Color Management", "Gammafree", pedited, icm.gamma, pedited->icm.gamfree);
|
|
assignFromKeyfile(keyFile, "Color Management", "Freegamma", pedited, icm.freegamma, pedited->icm.freegamma);
|
|
assignFromKeyfile(keyFile, "Color Management", "GammaValue", pedited, icm.gampos, pedited->icm.gampos);
|
|
assignFromKeyfile(keyFile, "Color Management", "GammaSlope", pedited, icm.slpos, pedited->icm.slpos);
|
|
}
|
|
|
|
// load wavelet wavelet parameters
|
|
if (keyFile.has_group ("Wavelet")) {
|
|
assignFromKeyfile(keyFile, "Wavelet", "Enabled", pedited, wavelet.enabled, pedited->wavelet.enabled);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Strength", pedited, wavelet.strength, pedited->wavelet.strength);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Balance", pedited, wavelet.balance, pedited->wavelet.balance);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Iter", pedited, wavelet.iter, pedited->wavelet.iter);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Median", pedited, wavelet.median, pedited->wavelet.median);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Medianlev", pedited, wavelet.medianlev, pedited->wavelet.medianlev);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Linkedg", pedited, wavelet.linkedg, pedited->wavelet.linkedg);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CBenab", pedited, wavelet.cbenab, pedited->wavelet.cbenab);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CBgreenhigh", pedited, wavelet.greenhigh, pedited->wavelet.greenhigh);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CBgreenmed", pedited, wavelet.greenmed, pedited->wavelet.greenmed);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CBgreenlow", pedited, wavelet.greenlow, pedited->wavelet.greenlow);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CBbluehigh", pedited, wavelet.bluehigh, pedited->wavelet.bluehigh);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CBbluemed", pedited, wavelet.bluemed, pedited->wavelet.bluemed);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CBbluelow", pedited, wavelet.bluelow, pedited->wavelet.bluelow);
|
|
// if (keyFile.has_key ("Wavelet", "Edgreinf")) {wavelet.edgreinf = keyFile.get_boolean ("Wavelet", "Edgreinf");if (pedited) pedited->wavelet.edgreinf = true;}
|
|
assignFromKeyfile(keyFile, "Wavelet", "Lipst", pedited, wavelet.lipst, pedited->wavelet.lipst);
|
|
assignFromKeyfile(keyFile, "Wavelet", "AvoidColorShift", pedited, wavelet.avoid, pedited->wavelet.avoid);
|
|
assignFromKeyfile(keyFile, "Wavelet", "TMr", pedited, wavelet.tmr, pedited->wavelet.tmr);
|
|
assignFromKeyfile(keyFile, "Wavelet", "LevMethod", pedited, wavelet.Lmethod, pedited->wavelet.Lmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ChoiceLevMethod", pedited, wavelet.CLmethod, pedited->wavelet.CLmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "BackMethod", pedited, wavelet.Backmethod, pedited->wavelet.Backmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "TilesMethod", pedited, wavelet.Tilesmethod, pedited->wavelet.Tilesmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "DaubMethod", pedited, wavelet.daubcoeffmethod, pedited->wavelet.daubcoeffmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CHromaMethod", pedited, wavelet.CHmethod, pedited->wavelet.CHmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Medgreinf", pedited, wavelet.Medgreinf, pedited->wavelet.Medgreinf);
|
|
assignFromKeyfile(keyFile, "Wavelet", "CHSLromaMethod", pedited, wavelet.CHSLmethod, pedited->wavelet.CHSLmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "EDMethod", pedited, wavelet.EDmethod, pedited->wavelet.EDmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "NPMethod", pedited, wavelet.NPmethod, pedited->wavelet.NPmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "BAMethod", pedited, wavelet.BAmethod, pedited->wavelet.BAmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "TMMethod", pedited, wavelet.TMmethod, pedited->wavelet.TMmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "HSMethod", pedited, wavelet.HSmethod, pedited->wavelet.HSmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "DirMethod", pedited, wavelet.Dirmethod, pedited->wavelet.Dirmethod);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ResidualcontShadow", pedited, wavelet.rescon, pedited->wavelet.rescon);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ResidualcontHighlight", pedited, wavelet.resconH, pedited->wavelet.resconH);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Residualchroma", pedited, wavelet.reschro, pedited->wavelet.reschro);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ResidualTM", pedited, wavelet.tmrs, pedited->wavelet.tmrs);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Residualgamma", pedited, wavelet.gamma, pedited->wavelet.gamma);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ContExtra", pedited, wavelet.sup, pedited->wavelet.sup);
|
|
assignFromKeyfile(keyFile, "Wavelet", "HueRangeResidual", pedited, wavelet.sky, pedited->wavelet.sky);
|
|
assignFromKeyfile(keyFile, "Wavelet", "MaxLev", pedited, wavelet.thres, pedited->wavelet.thres);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ThresholdHighLight", pedited, wavelet.threshold, pedited->wavelet.threshold);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ThresholdShadow", pedited, wavelet.threshold2, pedited->wavelet.threshold2);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Edgedetect", pedited, wavelet.edgedetect, pedited->wavelet.edgedetect);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Edgedetectthr", pedited, wavelet.edgedetectthr, pedited->wavelet.edgedetectthr);
|
|
assignFromKeyfile(keyFile, "Wavelet", "EdgedetectthrHi", pedited, wavelet.edgedetectthr2, pedited->wavelet.edgedetectthr2);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Edgesensi", pedited, wavelet.edgesensi, pedited->wavelet.edgesensi);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Edgeampli", pedited, wavelet.edgeampli, pedited->wavelet.edgeampli);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ThresholdChroma", pedited, wavelet.chroma, pedited->wavelet.chroma);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ChromaLink", pedited, wavelet.chro, pedited->wavelet.chro);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Contrast", pedited, wavelet.contrast, pedited->wavelet.contrast);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Edgrad", pedited, wavelet.edgrad, pedited->wavelet.edgrad);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Edgval", pedited, wavelet.edgval, pedited->wavelet.edgval);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ThrEdg", pedited, wavelet.edgthresh, pedited->wavelet.edgthresh);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ThresholdResidShadow", pedited, wavelet.thr, pedited->wavelet.thr);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ThresholdResidHighLight", pedited, wavelet.thrH, pedited->wavelet.thrH);
|
|
assignFromKeyfile(keyFile, "Wavelet", "ContrastCurve", pedited, wavelet.ccwcurve, pedited->wavelet.ccwcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "OpacityCurveRG", pedited, wavelet.opacityCurveRG, pedited->wavelet.opacityCurveRG);
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "OpacityCurveBY", pedited, wavelet.opacityCurveBY, pedited->wavelet.opacityCurveBY);
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "OpacityCurveW", pedited, wavelet.opacityCurveW, pedited->wavelet.opacityCurveW);
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "OpacityCurveWL", pedited, wavelet.opacityCurveWL, pedited->wavelet.opacityCurveWL);
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "HHcurve", pedited, wavelet.hhcurve, pedited->wavelet.hhcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "CHcurve", pedited, wavelet.Chcurve, pedited->wavelet.Chcurve);
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "WavclCurve", pedited, wavelet.wavclCurve, pedited->wavelet.wavclCurve);
|
|
|
|
if (keyFile.has_key ("Wavelet", "Hueskin")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Wavelet", "Hueskin");
|
|
|
|
if (thresh.size() >= 4) {
|
|
wavelet.hueskin.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.hueskin = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "HueRange")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Wavelet", "HueRange");
|
|
|
|
if (thresh.size() >= 4) {
|
|
wavelet.hueskin2.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.hueskin2 = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "HLRange")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Wavelet", "HLRange");
|
|
|
|
if (thresh.size() >= 4) {
|
|
wavelet.hllev.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.hllev = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "SHRange")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Wavelet", "SHRange");
|
|
|
|
if (thresh.size() >= 4) {
|
|
wavelet.bllev.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.bllev = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "Edgcont")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Wavelet", "Edgcont");
|
|
|
|
if (thresh.size() >= 4) {
|
|
wavelet.edgcont.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.edgcont = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "Level0noise")) {
|
|
const std::vector<double> thresh = keyFile.get_double_list ("Wavelet", "Level0noise");
|
|
|
|
if (thresh.size() >= 2) {
|
|
wavelet.level0noise.setValues (thresh[0], thresh[1]);
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.level0noise = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "Level1noise")) {
|
|
const std::vector<double> thresh = keyFile.get_double_list ("Wavelet", "Level1noise");
|
|
|
|
if (thresh.size() >= 2) {
|
|
wavelet.level1noise.setValues (thresh[0], thresh[1]);
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.level1noise = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "Level2noise")) {
|
|
const std::vector<double> thresh = keyFile.get_double_list ("Wavelet", "Level2noise");
|
|
|
|
if (thresh.size() >= 2) {
|
|
wavelet.level2noise.setValues (thresh[0], thresh[1]);
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.level2noise = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "Level3noise")) {
|
|
const std::vector<double> thresh = keyFile.get_double_list ("Wavelet", "Level3noise");
|
|
|
|
if (thresh.size() >= 2) {
|
|
wavelet.level3noise.setValues (thresh[0], thresh[1]);
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.level3noise = true;
|
|
}
|
|
}
|
|
|
|
|
|
if (keyFile.has_key ("Wavelet", "Pastlev")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Wavelet", "Pastlev");
|
|
|
|
if (thresh.size() >= 4) {
|
|
wavelet.pastlev.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.pastlev = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("Wavelet", "Satlev")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Wavelet", "Satlev");
|
|
|
|
if (thresh.size() >= 4) {
|
|
wavelet.satlev.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.satlev = true;
|
|
}
|
|
}
|
|
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "Skinprotect", pedited, wavelet.skinprotect, pedited->wavelet.skinprotect);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Expcontrast", pedited, wavelet.expcontrast, pedited->wavelet.expcontrast);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Expchroma", pedited, wavelet.expchroma, pedited->wavelet.expchroma);
|
|
for (int i = 0; i < 9; i ++) {
|
|
std::stringstream ss;
|
|
ss << "Contrast" << (i + 1);
|
|
|
|
if (keyFile.has_key ("Wavelet", ss.str())) {
|
|
wavelet.c[i] = keyFile.get_integer ("Wavelet", ss.str());
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.c[i] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 9; i ++) {
|
|
std::stringstream ss;
|
|
ss << "Chroma" << (i + 1);
|
|
|
|
if (keyFile.has_key ("Wavelet", ss.str())) {
|
|
wavelet.ch[i] = keyFile.get_integer ("Wavelet", ss.str());
|
|
|
|
if (pedited) {
|
|
pedited->wavelet.ch[i] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Wavelet", "Expedge", pedited, wavelet.expedge, pedited->wavelet.expedge);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Expresid", pedited, wavelet.expresid, pedited->wavelet.expresid);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Expfinal", pedited, wavelet.expfinal, pedited->wavelet.expfinal);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Exptoning", pedited, wavelet.exptoning, pedited->wavelet.exptoning);
|
|
assignFromKeyfile(keyFile, "Wavelet", "Expnoise", pedited, wavelet.expnoise, pedited->wavelet.expnoise);
|
|
|
|
}
|
|
|
|
// load directional pyramid equalizer parameters
|
|
if (keyFile.has_group ("Directional Pyramid Equalizer")) {
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Equalizer", "Enabled", pedited, dirpyrequalizer.enabled, pedited->dirpyrequalizer.enabled);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Equalizer", "Gamutlab", pedited, dirpyrequalizer.gamutlab, pedited->dirpyrequalizer.gamutlab);
|
|
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Equalizer", "cbdlMethod", pedited, dirpyrequalizer.cbdlMethod, pedited->dirpyrequalizer.cbdlMethod);
|
|
|
|
// if (keyFile.has_key ("Directional Pyramid Equalizer", "Algorithm")) { dirpyrequalizer.algo = keyFile.get_string ("Directional Pyramid Equalizer", "Algorithm"); if (pedited) pedited->dirpyrequalizer.algo = true; }
|
|
if (keyFile.has_key ("Directional Pyramid Equalizer", "Hueskin")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("Directional Pyramid Equalizer", "Hueskin");
|
|
|
|
if (thresh.size() >= 4) {
|
|
dirpyrequalizer.hueskin.setValues (thresh[0], thresh[1], min (thresh[2], 300), min (thresh[3], 300));
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->dirpyrequalizer.hueskin = true;
|
|
}
|
|
}
|
|
|
|
if (ppVersion < 316) {
|
|
for (int i = 0; i < 5; i ++) {
|
|
std::stringstream ss;
|
|
ss << "Mult" << i;
|
|
|
|
if (keyFile.has_key ("Directional Pyramid Equalizer", ss.str())) {
|
|
if (i == 4) {
|
|
dirpyrequalizer.threshold = keyFile.get_double ("Directional Pyramid Equalizer", ss.str());
|
|
|
|
if (pedited) {
|
|
pedited->dirpyrequalizer.threshold = true;
|
|
}
|
|
} else {
|
|
dirpyrequalizer.mult[i] = keyFile.get_double ("Directional Pyramid Equalizer", ss.str());
|
|
|
|
if (pedited) {
|
|
pedited->dirpyrequalizer.mult[i] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
dirpyrequalizer.mult[4] = 1.0;
|
|
} else {
|
|
// 5 level wavelet + dedicated threshold parameter
|
|
for (int i = 0; i < 6; i ++) {
|
|
std::stringstream ss;
|
|
ss << "Mult" << i;
|
|
|
|
if (keyFile.has_key ("Directional Pyramid Equalizer", ss.str())) {
|
|
dirpyrequalizer.mult[i] = keyFile.get_double ("Directional Pyramid Equalizer", ss.str());
|
|
|
|
if (pedited) {
|
|
pedited->dirpyrequalizer.mult[i] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Equalizer", "Threshold", pedited, dirpyrequalizer.threshold, pedited->dirpyrequalizer.threshold);
|
|
assignFromKeyfile(keyFile, "Directional Pyramid Equalizer", "Skinprotect", pedited, dirpyrequalizer.skinprotect, pedited->dirpyrequalizer.skinprotect);
|
|
}
|
|
}
|
|
|
|
// load CLUT parameters
|
|
if ( keyFile.has_group ( "Film Simulation" ) ) {
|
|
if ( keyFile.has_key ( "Film Simulation", "Enabled" ) ) {
|
|
filmSimulation.enabled = keyFile.get_boolean ( "Film Simulation", "Enabled" );
|
|
|
|
if ( pedited ) {
|
|
pedited->filmSimulation.enabled = true;
|
|
}
|
|
}
|
|
|
|
if ( keyFile.has_key ( "Film Simulation", "ClutFilename" ) ) {
|
|
filmSimulation.clutFilename = keyFile.get_string ( "Film Simulation", "ClutFilename" );
|
|
|
|
if ( pedited ) {
|
|
pedited->filmSimulation.clutFilename = true;
|
|
}
|
|
}
|
|
|
|
if ( keyFile.has_key ( "Film Simulation", "Strength" ) ) {
|
|
if (ppVersion < 321) {
|
|
filmSimulation.strength = int (keyFile.get_double ( "Film Simulation", "Strength" ) * 100 + 0.1);
|
|
} else {
|
|
filmSimulation.strength = keyFile.get_integer ( "Film Simulation", "Strength" );
|
|
}
|
|
|
|
if ( pedited ) {
|
|
pedited->filmSimulation.strength = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// load HSV wavelet parameters
|
|
if (keyFile.has_group ("HSV Equalizer")) {
|
|
if (ppVersion >= 300) {
|
|
assignFromKeyfile(keyFile, "HSV Equalizer", "HCurve", pedited, hsvequalizer.hcurve, pedited->hsvequalizer.hcurve);
|
|
|
|
assignFromKeyfile(keyFile, "HSV Equalizer", "SCurve", pedited, hsvequalizer.scurve, pedited->hsvequalizer.scurve);
|
|
|
|
assignFromKeyfile(keyFile, "HSV Equalizer", "VCurve", pedited, hsvequalizer.vcurve, pedited->hsvequalizer.vcurve);
|
|
}
|
|
}
|
|
|
|
// load RGB curves
|
|
if (keyFile.has_group ("RGB Curves")) {
|
|
assignFromKeyfile(keyFile, "RGB Curves", "LumaMode", pedited, rgbCurves.lumamode, pedited->rgbCurves.lumamode);
|
|
assignFromKeyfile(keyFile, "RGB Curves", "rCurve", pedited, rgbCurves.rcurve, pedited->rgbCurves.rcurve);
|
|
|
|
assignFromKeyfile(keyFile, "RGB Curves", "gCurve", pedited, rgbCurves.gcurve, pedited->rgbCurves.gcurve);
|
|
|
|
assignFromKeyfile(keyFile, "RGB Curves", "bCurve", pedited, rgbCurves.bcurve, pedited->rgbCurves.bcurve);
|
|
}
|
|
|
|
// load Color Toning
|
|
if (keyFile.has_group ("ColorToning")) {
|
|
assignFromKeyfile(keyFile, "ColorToning", "Enabled", pedited, colorToning.enabled, pedited->colorToning.enabled);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Method", pedited, colorToning.method, pedited->colorToning.method);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Lumamode", pedited, colorToning.lumamode, pedited->colorToning.lumamode);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Twocolor", pedited, colorToning.twocolor, pedited->colorToning.twocolor);
|
|
assignFromKeyfile(keyFile, "ColorToning", "OpacityCurve", pedited, colorToning.opacityCurve, pedited->colorToning.opacityCurve);
|
|
|
|
assignFromKeyfile(keyFile, "ColorToning", "ColorCurve", pedited, colorToning.colorCurve, pedited->colorToning.colorCurve);
|
|
|
|
assignFromKeyfile(keyFile, "ColorToning", "Autosat", pedited, colorToning.autosat, pedited->colorToning.autosat);
|
|
assignFromKeyfile(keyFile, "ColorToning", "SatProtectionThreshold", pedited, colorToning.satProtectionThreshold, pedited->colorToning.satprotectionthreshold);
|
|
assignFromKeyfile(keyFile, "ColorToning", "SaturatedOpacity", pedited, colorToning.saturatedOpacity, pedited->colorToning.saturatedopacity);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Strength", pedited, colorToning.strength, pedited->colorToning.strength);
|
|
if (keyFile.has_key ("ColorToning", "HighlightsColorSaturation")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("ColorToning", "HighlightsColorSaturation");
|
|
|
|
if (thresh.size() >= 2) {
|
|
colorToning.hlColSat.setValues (thresh[0], thresh[1]);
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->colorToning.hlColSat = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("ColorToning", "ShadowsColorSaturation")) {
|
|
const std::vector<int> thresh = keyFile.get_integer_list ("ColorToning", "ShadowsColorSaturation");
|
|
|
|
if (thresh.size() >= 2) {
|
|
colorToning.shadowsColSat.setValues (thresh[0], thresh[1]);
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->colorToning.shadowsColSat = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "ColorToning", "ClCurve", pedited, colorToning.clcurve, pedited->colorToning.clcurve);
|
|
|
|
assignFromKeyfile(keyFile, "ColorToning", "Cl2Curve", pedited, colorToning.cl2curve, pedited->colorToning.cl2curve);
|
|
|
|
assignFromKeyfile(keyFile, "ColorToning", "Redlow", pedited, colorToning.redlow, pedited->colorToning.redlow);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Greenlow", pedited, colorToning.greenlow, pedited->colorToning.greenlow);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Bluelow", pedited, colorToning.bluelow, pedited->colorToning.bluelow);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Satlow", pedited, colorToning.satlow, pedited->colorToning.satlow);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Balance", pedited, colorToning.balance, pedited->colorToning.balance);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Sathigh", pedited, colorToning.sathigh, pedited->colorToning.sathigh);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Redmed", pedited, colorToning.redmed, pedited->colorToning.redmed);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Greenmed", pedited, colorToning.greenmed, pedited->colorToning.greenmed);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Bluemed", pedited, colorToning.bluemed, pedited->colorToning.bluemed);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Redhigh", pedited, colorToning.redhigh, pedited->colorToning.redhigh);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Greenhigh", pedited, colorToning.greenhigh, pedited->colorToning.greenhigh);
|
|
assignFromKeyfile(keyFile, "ColorToning", "Bluehigh", pedited, colorToning.bluehigh, pedited->colorToning.bluehigh);
|
|
}
|
|
|
|
// load raw settings
|
|
if (keyFile.has_group ("RAW")) {
|
|
if (keyFile.has_key ("RAW", "DarkFrame")) {
|
|
raw.dark_frame = expandRelativePath (fname, "", keyFile.get_string ("RAW", "DarkFrame" ));
|
|
|
|
if (pedited) {
|
|
pedited->raw.darkFrame = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "DarkFrameAuto")) {
|
|
raw.df_autoselect = keyFile.get_boolean ("RAW", "DarkFrameAuto" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.dfAuto = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "FlatFieldFile")) {
|
|
raw.ff_file = expandRelativePath (fname, "", keyFile.get_string ("RAW", "FlatFieldFile" ));
|
|
|
|
if (pedited) {
|
|
pedited->raw.ff_file = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "FlatFieldAutoSelect")) {
|
|
raw.ff_AutoSelect = keyFile.get_boolean ("RAW", "FlatFieldAutoSelect" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.ff_AutoSelect = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "FlatFieldBlurRadius")) {
|
|
raw.ff_BlurRadius = keyFile.get_integer ("RAW", "FlatFieldBlurRadius" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.ff_BlurRadius = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "FlatFieldBlurType")) {
|
|
raw.ff_BlurType = keyFile.get_string ("RAW", "FlatFieldBlurType" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.ff_BlurType = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "FlatFieldAutoClipControl")) {
|
|
raw.ff_AutoClipControl = keyFile.get_boolean ("RAW", "FlatFieldAutoClipControl" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.ff_AutoClipControl = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "FlatFieldClipControl")) {
|
|
raw.ff_clipControl = keyFile.get_boolean ("RAW", "FlatFieldClipControl" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.ff_clipControl = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "CA")) {
|
|
raw.ca_autocorrect = keyFile.get_boolean ("RAW", "CA" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.caCorrection = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "CARed")) {
|
|
raw.cared = keyFile.get_double ("RAW", "CARed" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.caRed = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "CABlue")) {
|
|
raw.cablue = keyFile.get_double ("RAW", "CABlue" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.caBlue = true;
|
|
}
|
|
}
|
|
|
|
// for compatibility to elder pp3 versions
|
|
if (keyFile.has_key ("RAW", "HotDeadPixels")) {
|
|
raw.deadPixelFilter = raw.hotPixelFilter = keyFile.get_boolean ("RAW", "HotDeadPixels" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.hotPixelFilter = pedited->raw.deadPixelFilter = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "HotPixelFilter")) {
|
|
raw.hotPixelFilter = keyFile.get_boolean ("RAW", "HotPixelFilter" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.hotPixelFilter = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "DeadPixelFilter")) {
|
|
raw.deadPixelFilter = keyFile.get_boolean ("RAW", "DeadPixelFilter" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.deadPixelFilter = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW", "HotDeadPixelThresh")) {
|
|
raw.hotdeadpix_thresh = keyFile.get_integer ("RAW", "HotDeadPixelThresh" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.hotDeadPixelThresh = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "RAW", "PreExposure", pedited, raw.expos, pedited->raw.exPos);
|
|
assignFromKeyfile(keyFile, "RAW", "PrePreserv", pedited, raw.preser, pedited->raw.exPreser);
|
|
if (ppVersion < 320) {
|
|
assignFromKeyfile(keyFile, "RAW", "Method", pedited, raw.bayersensor.method, pedited->raw.bayersensor.method);
|
|
assignFromKeyfile(keyFile, "RAW", "CcSteps", pedited, raw.bayersensor.ccSteps, pedited->raw.bayersensor.ccSteps);
|
|
if (keyFile.has_key ("RAW", "LineDenoise")) {
|
|
raw.bayersensor.linenoise = keyFile.get_integer ("RAW", "LineDenoise" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.bayersensor.linenoise = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "RAW", "GreenEqThreshold", pedited, raw.bayersensor.greenthresh, pedited->raw.bayersensor.greenEq);
|
|
assignFromKeyfile(keyFile, "RAW", "DCBIterations", pedited, raw.bayersensor.dcb_iterations, pedited->raw.bayersensor.dcbIterations);
|
|
assignFromKeyfile(keyFile, "RAW", "DCBEnhance", pedited, raw.bayersensor.dcb_enhance, pedited->raw.bayersensor.dcbEnhance);
|
|
assignFromKeyfile(keyFile, "RAW", "LMMSEIterations", pedited, raw.bayersensor.lmmse_iterations, pedited->raw.bayersensor.lmmseIterations);
|
|
assignFromKeyfile(keyFile, "RAW", "PreBlackzero", pedited, raw.bayersensor.black0, pedited->raw.bayersensor.exBlack0);
|
|
assignFromKeyfile(keyFile, "RAW", "PreBlackone", pedited, raw.bayersensor.black1, pedited->raw.bayersensor.exBlack1);
|
|
assignFromKeyfile(keyFile, "RAW", "PreBlacktwo", pedited, raw.bayersensor.black2, pedited->raw.bayersensor.exBlack2);
|
|
assignFromKeyfile(keyFile, "RAW", "PreBlackthree", pedited, raw.bayersensor.black3, pedited->raw.bayersensor.exBlack3);
|
|
assignFromKeyfile(keyFile, "RAW", "PreTwoGreen", pedited, raw.bayersensor.twogreen, pedited->raw.bayersensor.exTwoGreen);
|
|
//if (keyFile.has_key ("RAW", "ALLEnhance")) { raw.bayersensor.all_enhance = keyFile.get_boolean("RAW", "ALLEnhance"); if (pedited) pedited->raw.bayersensor.allEnhance = true; }
|
|
}
|
|
}
|
|
|
|
// load Bayer sensors' raw settings
|
|
if (keyFile.has_group ("RAW Bayer")) {
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "Method", pedited, raw.bayersensor.method, pedited->raw.bayersensor.method);
|
|
if (keyFile.has_key ("RAW Bayer", "ImageNum")) {
|
|
raw.bayersensor.imageNum = keyFile.get_integer ("RAW Bayer", "ImageNum") - 1;
|
|
|
|
if (pedited) {
|
|
pedited->raw.bayersensor.imageNum = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "CcSteps", pedited, raw.bayersensor.ccSteps, pedited->raw.bayersensor.ccSteps);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PreBlack0", pedited, raw.bayersensor.black0, pedited->raw.bayersensor.exBlack0);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PreBlack1", pedited, raw.bayersensor.black1, pedited->raw.bayersensor.exBlack1);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PreBlack2", pedited, raw.bayersensor.black2, pedited->raw.bayersensor.exBlack2);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PreBlack3", pedited, raw.bayersensor.black3, pedited->raw.bayersensor.exBlack3);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PreTwoGreen", pedited, raw.bayersensor.twogreen, pedited->raw.bayersensor.exTwoGreen);
|
|
if (keyFile.has_key ("RAW Bayer", "LineDenoise")) {
|
|
raw.bayersensor.linenoise = keyFile.get_integer ("RAW Bayer", "LineDenoise" );
|
|
|
|
if (pedited) {
|
|
pedited->raw.bayersensor.linenoise = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "GreenEqThreshold", pedited, raw.bayersensor.greenthresh, pedited->raw.bayersensor.greenEq);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "DCBIterations", pedited, raw.bayersensor.dcb_iterations, pedited->raw.bayersensor.dcbIterations);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "DCBEnhance", pedited, raw.bayersensor.dcb_enhance, pedited->raw.bayersensor.dcbEnhance);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "LMMSEIterations", pedited, raw.bayersensor.lmmse_iterations, pedited->raw.bayersensor.lmmseIterations);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftMotion", pedited, raw.bayersensor.pixelShiftMotion, pedited->raw.bayersensor.pixelShiftMotion);
|
|
if (keyFile.has_key ("RAW Bayer", "PixelShiftMotionCorrection")) {
|
|
raw.bayersensor.pixelShiftMotionCorrection = (RAWParams::BayerSensor::ePSMotionCorrection)keyFile.get_integer ("RAW Bayer", "PixelShiftMotionCorrection");
|
|
|
|
if (pedited) {
|
|
pedited->raw.bayersensor.pixelShiftMotionCorrection = true;
|
|
}
|
|
}
|
|
|
|
if (keyFile.has_key ("RAW Bayer", "PixelShiftMotionCorrectionMethod")) {
|
|
raw.bayersensor.pixelShiftMotionCorrectionMethod = (RAWParams::BayerSensor::ePSMotionCorrectionMethod)keyFile.get_integer ("RAW Bayer", "PixelShiftMotionCorrectionMethod");
|
|
|
|
if (pedited) {
|
|
pedited->raw.bayersensor.pixelShiftMotionCorrectionMethod = true;
|
|
}
|
|
}
|
|
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftStddevFactorGreen", pedited, raw.bayersensor.pixelShiftStddevFactorGreen, pedited->raw.bayersensor.pixelShiftStddevFactorGreen);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftStddevFactorRed", pedited, raw.bayersensor.pixelShiftStddevFactorRed, pedited->raw.bayersensor.pixelShiftStddevFactorRed);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftStddevFactorBlue", pedited, raw.bayersensor.pixelShiftStddevFactorBlue, pedited->raw.bayersensor.pixelShiftStddevFactorBlue);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftEperIso", pedited, raw.bayersensor.pixelShiftEperIso, pedited->raw.bayersensor.pixelShiftEperIso);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftNreadIso", pedited, raw.bayersensor.pixelShiftNreadIso, pedited->raw.bayersensor.pixelShiftNreadIso);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftPrnu", pedited, raw.bayersensor.pixelShiftPrnu, pedited->raw.bayersensor.pixelShiftPrnu);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftSigma", pedited, raw.bayersensor.pixelShiftSigma, pedited->raw.bayersensor.pixelShiftSigma);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftSum", pedited, raw.bayersensor.pixelShiftSum, pedited->raw.bayersensor.pixelShiftSum);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftRedBlueWeight", pedited, raw.bayersensor.pixelShiftRedBlueWeight, pedited->raw.bayersensor.pixelShiftRedBlueWeight);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftShowMotion", pedited, raw.bayersensor.pixelShiftShowMotion, pedited->raw.bayersensor.pixelShiftShowMotion);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "PixelShiftShowMotionMaskOnly", pedited, raw.bayersensor.pixelShiftShowMotionMaskOnly, pedited->raw.bayersensor.pixelShiftShowMotionMaskOnly);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftAutomatic", pedited, raw.bayersensor.pixelShiftAutomatic, pedited->raw.bayersensor.pixelShiftAutomatic);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftNonGreenHorizontal", pedited, raw.bayersensor.pixelShiftNonGreenHorizontal, pedited->raw.bayersensor.pixelShiftNonGreenHorizontal);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftNonGreenVertical", pedited, raw.bayersensor.pixelShiftNonGreenVertical, pedited->raw.bayersensor.pixelShiftNonGreenVertical);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftHoleFill", pedited, raw.bayersensor.pixelShiftHoleFill, pedited->raw.bayersensor.pixelShiftHoleFill);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftMedian", pedited, raw.bayersensor.pixelShiftMedian, pedited->raw.bayersensor.pixelShiftMedian);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftMedian3", pedited, raw.bayersensor.pixelShiftMedian3, pedited->raw.bayersensor.pixelShiftMedian3);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftGreen", pedited, raw.bayersensor.pixelShiftGreen, pedited->raw.bayersensor.pixelShiftGreen);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftBlur", pedited, raw.bayersensor.pixelShiftBlur, pedited->raw.bayersensor.pixelShiftBlur);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftSmoothFactor", pedited, raw.bayersensor.pixelShiftSmoothFactor, pedited->raw.bayersensor.pixelShiftSmooth);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftExp0", pedited, raw.bayersensor.pixelShiftExp0, pedited->raw.bayersensor.pixelShiftExp0);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftLmmse", pedited, raw.bayersensor.pixelShiftLmmse, pedited->raw.bayersensor.pixelShiftLmmse);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftEqualBright", pedited, raw.bayersensor.pixelShiftEqualBright, pedited->raw.bayersensor.pixelShiftEqualBright);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftEqualBrightChannel", pedited, raw.bayersensor.pixelShiftEqualBrightChannel, pedited->raw.bayersensor.pixelShiftEqualBrightChannel);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftNonGreenCross", pedited, raw.bayersensor.pixelShiftNonGreenCross, pedited->raw.bayersensor.pixelShiftNonGreenCross);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftNonGreenCross2", pedited, raw.bayersensor.pixelShiftNonGreenCross2, pedited->raw.bayersensor.pixelShiftNonGreenCross2);
|
|
assignFromKeyfile(keyFile, "RAW Bayer", "pixelShiftNonGreenAmaze", pedited, raw.bayersensor.pixelShiftNonGreenAmaze, pedited->raw.bayersensor.pixelShiftNonGreenAmaze);
|
|
}
|
|
|
|
// load X-Trans sensors' raw settings
|
|
if (keyFile.has_group ("RAW X-Trans")) {
|
|
assignFromKeyfile(keyFile, "RAW X-Trans", "Method", pedited, raw.xtranssensor.method, pedited->raw.xtranssensor.method);
|
|
assignFromKeyfile(keyFile, "RAW X-Trans", "CcSteps", pedited, raw.xtranssensor.ccSteps, pedited->raw.xtranssensor.ccSteps);
|
|
assignFromKeyfile(keyFile, "RAW X-Trans", "PreBlackRed", pedited, raw.xtranssensor.blackred, pedited->raw.xtranssensor.exBlackRed);
|
|
assignFromKeyfile(keyFile, "RAW X-Trans", "PreBlackGreen", pedited, raw.xtranssensor.blackgreen, pedited->raw.xtranssensor.exBlackGreen);
|
|
assignFromKeyfile(keyFile, "RAW X-Trans", "PreBlackBlue", pedited, raw.xtranssensor.blackblue, pedited->raw.xtranssensor.exBlackBlue);
|
|
}
|
|
|
|
// load exif change settings
|
|
if (keyFile.has_group ("Exif")) {
|
|
std::vector<Glib::ustring> keys = keyFile.get_keys ("Exif");
|
|
|
|
for (int i = 0; i < (int)keys.size(); i++) {
|
|
Glib::ustring tmpStr = keyFile.get_string ("Exif", keys[i]);
|
|
exif[keys[i]] = keyFile.get_string ("Exif", keys[i]);
|
|
|
|
if (pedited) {
|
|
pedited->exif = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Load iptc change settings
|
|
*
|
|
* Existing values are preserved, and the stored values
|
|
* are added to the list. To reset a field, the user has to
|
|
* save the profile with the field leaved empty, but still
|
|
* terminated by a semi-column ";"
|
|
*
|
|
* Please note that the old Keywords and SupplementalCategories
|
|
* tag content is fully replaced by the new one,
|
|
* i.e. they don't merge
|
|
*/
|
|
if (keyFile.has_group ("IPTC")) {
|
|
std::vector<Glib::ustring> keys = keyFile.get_keys ("IPTC");
|
|
IPTCPairs::iterator element;
|
|
|
|
for (unsigned int i = 0; i < keys.size(); i++) {
|
|
// does this key already exist?
|
|
element = iptc.find (keys[i]);
|
|
|
|
if (element != iptc.end()) {
|
|
// it already exist so we cleanup the values
|
|
element->second.clear();
|
|
}
|
|
|
|
// TODO: look out if merging Keywords and SupplementalCategories from the procparams chain would be interesting
|
|
std::vector<Glib::ustring> currIptc = keyFile.get_string_list ("IPTC", keys[i]);
|
|
|
|
for (
|
|
std::vector<Glib::ustring>::iterator currLoadedTagValue = currIptc.begin();
|
|
currLoadedTagValue != currIptc.end();
|
|
++currLoadedTagValue) {
|
|
iptc[keys[i]].push_back (currLoadedTagValue->data());
|
|
}
|
|
|
|
if (pedited) {
|
|
pedited->iptc = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return 0;
|
|
} catch (const Glib::Error& e) {
|
|
printf ("-->%s\n", e.what().c_str());
|
|
setDefaults ();
|
|
return 1;
|
|
} catch (...) {
|
|
printf ("-->unknown exception!\n");
|
|
setDefaults ();
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
const Glib::ustring ColorManagementParams::NoICMString = Glib::ustring ("No ICM: sRGB output");
|
|
|
|
bool operator== (const WaveletParams & a, const WaveletParams & b)
|
|
{
|
|
if (a.enabled != b.enabled) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
if (a.c[i] != b.c[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
if (a.ch[i] != b.ch[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool operator== (const DirPyrEqualizerParams & a, const DirPyrEqualizerParams & b)
|
|
{
|
|
if (a.enabled != b.enabled) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < 6; i++) {
|
|
if (a.mult[i] != b.mult[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return a.threshold == b.threshold;
|
|
}
|
|
|
|
/*bool operator==(const ExifPairs& a, const ExifPairs& b) {
|
|
|
|
return a.field == b.field && a.value == b.value;
|
|
}
|
|
|
|
bool operator==(const IPTCPairs& a, const IPTCPairs& b) {
|
|
|
|
return a.field == b.field && a.values == b.values;
|
|
}*/
|
|
bool ProcParams::operator== (const ProcParams& other)
|
|
{
|
|
|
|
return
|
|
toneCurve.curve == other.toneCurve.curve
|
|
&& toneCurve.curve2 == other.toneCurve.curve2
|
|
&& toneCurve.brightness == other.toneCurve.brightness
|
|
&& toneCurve.black == other.toneCurve.black
|
|
&& toneCurve.contrast == other.toneCurve.contrast
|
|
&& toneCurve.saturation == other.toneCurve.saturation
|
|
&& toneCurve.shcompr == other.toneCurve.shcompr
|
|
&& toneCurve.hlcompr == other.toneCurve.hlcompr
|
|
&& toneCurve.hlcomprthresh == other.toneCurve.hlcomprthresh
|
|
&& toneCurve.autoexp == other.toneCurve.autoexp
|
|
&& toneCurve.clip == other.toneCurve.clip
|
|
&& toneCurve.expcomp == other.toneCurve.expcomp
|
|
&& toneCurve.curveMode == other.toneCurve.curveMode
|
|
&& toneCurve.curveMode2 == other.toneCurve.curveMode2
|
|
&& toneCurve.hrenabled == other.toneCurve.hrenabled
|
|
&& toneCurve.method == other.toneCurve.method
|
|
&& retinex.cdcurve == other.retinex.cdcurve
|
|
&& retinex.mapcurve == other.retinex.mapcurve
|
|
&& retinex.cdHcurve == other.retinex.cdHcurve
|
|
&& retinex.lhcurve == other.retinex.lhcurve
|
|
&& retinex.transmissionCurve == other.retinex.transmissionCurve
|
|
&& retinex.gaintransmissionCurve == other.retinex.gaintransmissionCurve
|
|
&& retinex.str == other.retinex.str
|
|
&& retinex.scal == other.retinex.scal
|
|
&& retinex.iter == other.retinex.iter
|
|
&& retinex.grad == other.retinex.grad
|
|
&& retinex.grads == other.retinex.grads
|
|
&& retinex.gam == other.retinex.gam
|
|
&& retinex.slope == other.retinex.slope
|
|
&& retinex.neigh == other.retinex.neigh
|
|
&& retinex.limd == other.retinex.limd
|
|
&& retinex.highl == other.retinex.highl
|
|
&& retinex.highlights == other.retinex.highlights
|
|
&& retinex.htonalwidth == other.retinex.htonalwidth
|
|
&& retinex.shadows == other.retinex.shadows
|
|
&& retinex.stonalwidth == other.retinex.stonalwidth
|
|
&& retinex.radius == other.retinex.radius
|
|
&& retinex.skal == other.retinex.skal
|
|
&& retinex.offs == other.retinex.offs
|
|
&& retinex.retinexMethod == other.retinex.retinexMethod
|
|
&& retinex.mapMethod == other.retinex.mapMethod
|
|
&& retinex.viewMethod == other.retinex.viewMethod
|
|
&& retinex.retinexcolorspace == other.retinex.retinexcolorspace
|
|
&& retinex.gammaretinex == other.retinex.gammaretinex
|
|
&& retinex.vart == other.retinex.vart
|
|
&& retinex.medianmap == other.retinex.medianmap
|
|
&& retinex.enabled == other.retinex.enabled
|
|
&& labCurve.lcurve == other.labCurve.lcurve
|
|
&& labCurve.acurve == other.labCurve.acurve
|
|
&& labCurve.bcurve == other.labCurve.bcurve
|
|
&& labCurve.cccurve == other.labCurve.cccurve
|
|
&& labCurve.chcurve == other.labCurve.chcurve
|
|
&& labCurve.lhcurve == other.labCurve.lhcurve
|
|
&& labCurve.hhcurve == other.labCurve.hhcurve
|
|
&& labCurve.lccurve == other.labCurve.lccurve
|
|
&& labCurve.clcurve == other.labCurve.clcurve
|
|
&& labCurve.brightness == other.labCurve.brightness
|
|
&& labCurve.contrast == other.labCurve.contrast
|
|
&& labCurve.chromaticity == other.labCurve.chromaticity
|
|
&& labCurve.avoidcolorshift == other.labCurve.avoidcolorshift
|
|
&& labCurve.rstprotection == other.labCurve.rstprotection
|
|
&& labCurve.lcredsk == other.labCurve.lcredsk
|
|
&& sharpenEdge.enabled == other.sharpenEdge.enabled
|
|
&& sharpenEdge.passes == other.sharpenEdge.passes
|
|
&& sharpenEdge.amount == other.sharpenEdge.amount
|
|
&& sharpenEdge.threechannels == other.sharpenEdge.threechannels
|
|
&& sharpenMicro.enabled == other.sharpenMicro.enabled
|
|
&& sharpenMicro.matrix == other.sharpenMicro.matrix
|
|
&& sharpenMicro.amount == other.sharpenMicro.amount
|
|
&& sharpenMicro.uniformity == other.sharpenMicro.uniformity
|
|
&& sharpening.enabled == other.sharpening.enabled
|
|
&& sharpening.radius == other.sharpening.radius
|
|
&& sharpening.amount == other.sharpening.amount
|
|
&& sharpening.threshold == other.sharpening.threshold
|
|
&& sharpening.edgesonly == other.sharpening.edgesonly
|
|
&& sharpening.edges_radius == other.sharpening.edges_radius
|
|
&& sharpening.edges_tolerance == other.sharpening.edges_tolerance
|
|
&& sharpening.halocontrol == other.sharpening.halocontrol
|
|
&& sharpening.halocontrol_amount == other.sharpening.halocontrol_amount
|
|
&& sharpening.method == other.sharpening.method
|
|
&& sharpening.deconvamount == other.sharpening.deconvamount
|
|
&& sharpening.deconvradius == other.sharpening.deconvradius
|
|
&& sharpening.deconviter == other.sharpening.deconviter
|
|
&& sharpening.deconvdamping == other.sharpening.deconvdamping
|
|
&& prsharpening.enabled == other.prsharpening.enabled
|
|
&& prsharpening.radius == other.prsharpening.radius
|
|
&& prsharpening.amount == other.prsharpening.amount
|
|
&& prsharpening.threshold == other.prsharpening.threshold
|
|
&& prsharpening.edgesonly == other.prsharpening.edgesonly
|
|
&& prsharpening.edges_radius == other.prsharpening.edges_radius
|
|
&& prsharpening.edges_tolerance == other.prsharpening.edges_tolerance
|
|
&& prsharpening.halocontrol == other.prsharpening.halocontrol
|
|
&& prsharpening.halocontrol_amount == other.prsharpening.halocontrol_amount
|
|
&& prsharpening.method == other.prsharpening.method
|
|
&& prsharpening.deconvamount == other.prsharpening.deconvamount
|
|
&& prsharpening.deconvradius == other.prsharpening.deconvradius
|
|
&& prsharpening.deconviter == other.prsharpening.deconviter
|
|
&& prsharpening.deconvdamping == other.prsharpening.deconvdamping
|
|
&& vibrance.enabled == other.vibrance.enabled
|
|
&& vibrance.pastels == other.vibrance.pastels
|
|
&& vibrance.saturated == other.vibrance.saturated
|
|
&& vibrance.psthreshold == other.vibrance.psthreshold
|
|
&& vibrance.protectskins == other.vibrance.protectskins
|
|
&& vibrance.avoidcolorshift == other.vibrance.avoidcolorshift
|
|
&& vibrance.pastsattog == other.vibrance.pastsattog
|
|
&& vibrance.skintonescurve == other.vibrance.skintonescurve
|
|
//&& colorBoost.amount == other.colorBoost.amount
|
|
//&& colorBoost.avoidclip == other.colorBoost.avoidclip
|
|
//&& colorBoost.enable_saturationlimiter == other.colorBoost.enable_saturationlimiter
|
|
//&& colorBoost.saturationlimit == other.colorBoost.saturationlimit
|
|
&& wb.method == other.wb.method
|
|
&& wb.green == other.wb.green
|
|
&& wb.temperature == other.wb.temperature
|
|
&& wb.equal == other.wb.equal
|
|
//&& colorShift.a == other.colorShift.a
|
|
//&& colorShift.b == other.colorShift.b
|
|
&& colorappearance.enabled == other.colorappearance.enabled
|
|
&& colorappearance.degree == other.colorappearance.degree
|
|
&& colorappearance.autodegree == other.colorappearance.autodegree
|
|
&& colorappearance.degreeout == other.colorappearance.degreeout
|
|
&& colorappearance.autodegreeout == other.colorappearance.autodegreeout
|
|
&& colorappearance.surround == other.colorappearance.surround
|
|
&& colorappearance.surrsrc == other.colorappearance.surrsrc
|
|
&& colorappearance.adapscen == other.colorappearance.adapscen
|
|
&& colorappearance.autoadapscen == other.colorappearance.autoadapscen
|
|
&& colorappearance.ybscen == other.colorappearance.ybscen
|
|
&& colorappearance.autoybscen == other.colorappearance.autoybscen
|
|
&& colorappearance.adaplum == other.colorappearance.adaplum
|
|
&& colorappearance.badpixsl == other.colorappearance.badpixsl
|
|
&& colorappearance.wbmodel == other.colorappearance.wbmodel
|
|
&& colorappearance.algo == other.colorappearance.algo
|
|
&& colorappearance.curveMode == other.colorappearance.curveMode
|
|
&& colorappearance.curveMode2 == other.colorappearance.curveMode2
|
|
&& colorappearance.curveMode3 == other.colorappearance.curveMode3
|
|
&& colorappearance.jlight == other.colorappearance.jlight
|
|
&& colorappearance.qbright == other.colorappearance.qbright
|
|
&& colorappearance.chroma == other.colorappearance.chroma
|
|
&& colorappearance.schroma == other.colorappearance.schroma
|
|
&& colorappearance.mchroma == other.colorappearance.mchroma
|
|
&& colorappearance.rstprotection == other.colorappearance.rstprotection
|
|
&& colorappearance.contrast == other.colorappearance.contrast
|
|
&& colorappearance.qcontrast == other.colorappearance.qcontrast
|
|
&& colorappearance.colorh == other.colorappearance.colorh
|
|
&& colorappearance.tempout == other.colorappearance.tempout
|
|
&& colorappearance.greenout == other.colorappearance.greenout
|
|
&& colorappearance.tempsc == other.colorappearance.tempsc
|
|
&& colorappearance.greensc == other.colorappearance.greensc
|
|
&& colorappearance.ybout == other.colorappearance.ybout
|
|
&& impulseDenoise.enabled == other.impulseDenoise.enabled
|
|
&& impulseDenoise.thresh == other.impulseDenoise.thresh
|
|
&& dirpyrDenoise.enabled == other.dirpyrDenoise.enabled
|
|
&& dirpyrDenoise.enhance == other.dirpyrDenoise.enhance
|
|
&& dirpyrDenoise.median == other.dirpyrDenoise.median
|
|
// && dirpyrDenoise.perform == other.dirpyrDenoise.perform
|
|
&& dirpyrDenoise.luma == other.dirpyrDenoise.luma
|
|
&& dirpyrDenoise.lcurve == other.dirpyrDenoise.lcurve
|
|
&& dirpyrDenoise.cccurve == other.dirpyrDenoise.cccurve
|
|
&& dirpyrDenoise.Ldetail == other.dirpyrDenoise.Ldetail
|
|
&& dirpyrDenoise.chroma == other.dirpyrDenoise.chroma
|
|
&& dirpyrDenoise.dmethod == other.dirpyrDenoise.dmethod
|
|
&& dirpyrDenoise.Lmethod == other.dirpyrDenoise.Lmethod
|
|
&& dirpyrDenoise.Cmethod == other.dirpyrDenoise.Cmethod
|
|
&& dirpyrDenoise.C2method == other.dirpyrDenoise.C2method
|
|
&& dirpyrDenoise.smethod == other.dirpyrDenoise.smethod
|
|
&& dirpyrDenoise.medmethod == other.dirpyrDenoise.medmethod
|
|
&& dirpyrDenoise.methodmed == other.dirpyrDenoise.methodmed
|
|
&& dirpyrDenoise.rgbmethod == other.dirpyrDenoise.rgbmethod
|
|
&& dirpyrDenoise.redchro == other.dirpyrDenoise.redchro
|
|
&& dirpyrDenoise.bluechro == other.dirpyrDenoise.bluechro
|
|
&& dirpyrDenoise.gamma == other.dirpyrDenoise.gamma
|
|
&& dirpyrDenoise.passes == other.dirpyrDenoise.passes
|
|
&& epd.enabled == other.epd.enabled
|
|
&& epd.strength == other.epd.strength
|
|
&& epd.gamma == other.epd.gamma
|
|
&& epd.edgeStopping == other.epd.edgeStopping
|
|
&& epd.scale == other.epd.scale
|
|
&& epd.reweightingIterates == other.epd.reweightingIterates
|
|
&& fattal.enabled == other.fattal.enabled
|
|
&& fattal.threshold == other.fattal.threshold
|
|
&& fattal.amount == other.fattal.amount
|
|
&& defringe.enabled == other.defringe.enabled
|
|
&& defringe.radius == other.defringe.radius
|
|
&& defringe.threshold == other.defringe.threshold
|
|
&& defringe.huecurve == other.defringe.huecurve
|
|
|
|
//&& lumaDenoise.enabled == other.lumaDenoise.enabled
|
|
//&& lumaDenoise.radius == other.lumaDenoise.radius
|
|
//&& lumaDenoise.edgetolerance == other.lumaDenoise.edgetolerance
|
|
//&& colorDenoise.enabled == other.colorDenoise.enabled
|
|
//&& colorDenoise.edgetolerance == other.colorDenoise.edgetolerance
|
|
//&& colorDenoise.edgesensitive == other.colorDenoise.edgesensitive
|
|
&& sh.enabled == other.sh.enabled
|
|
&& sh.hq == other.sh.hq
|
|
&& sh.highlights == other.sh.highlights
|
|
&& sh.htonalwidth == other.sh.htonalwidth
|
|
&& sh.shadows == other.sh.shadows
|
|
&& sh.stonalwidth == other.sh.stonalwidth
|
|
&& sh.localcontrast == other.sh.localcontrast
|
|
&& sh.radius == other.sh.radius
|
|
&& crop.enabled == other.crop.enabled
|
|
&& crop.x == other.crop.x
|
|
&& crop.y == other.crop.y
|
|
&& crop.w == other.crop.w
|
|
&& crop.h == other.crop.h
|
|
&& crop.fixratio == other.crop.fixratio
|
|
&& crop.ratio == other.crop.ratio
|
|
&& crop.orientation == other.crop.orientation
|
|
&& crop.guide == other.crop.guide
|
|
&& coarse.rotate == other.coarse.rotate
|
|
&& coarse.hflip == other.coarse.hflip
|
|
&& coarse.vflip == other.coarse.vflip
|
|
&& rotate.degree == other.rotate.degree
|
|
&& commonTrans.autofill == other.commonTrans.autofill
|
|
&& distortion.amount == other.distortion.amount
|
|
&& lensProf.lcMode == other.lensProf.lcMode
|
|
&& lensProf.lcpFile == other.lensProf.lcpFile
|
|
&& lensProf.useDist == other.lensProf.useDist
|
|
&& lensProf.useVign == other.lensProf.useVign
|
|
&& lensProf.useCA == other.lensProf.useCA
|
|
&& lensProf.lfCameraMake == other.lensProf.lfCameraMake
|
|
&& lensProf.lfCameraModel == other.lensProf.lfCameraModel
|
|
&& lensProf.lfLens == other.lensProf.lfLens
|
|
&& perspective.horizontal == other.perspective.horizontal
|
|
&& perspective.vertical == other.perspective.vertical
|
|
&& gradient.enabled == other.gradient.enabled
|
|
&& gradient.degree == other.gradient.degree
|
|
&& gradient.feather == other.gradient.feather
|
|
&& gradient.strength == other.gradient.strength
|
|
&& gradient.centerX == other.gradient.centerX
|
|
&& gradient.centerY == other.gradient.centerY
|
|
&& pcvignette.enabled == other.pcvignette.enabled
|
|
&& pcvignette.strength == other.pcvignette.strength
|
|
&& pcvignette.feather == other.pcvignette.feather
|
|
&& pcvignette.roundness == other.pcvignette.roundness
|
|
&& cacorrection.red == other.cacorrection.red
|
|
&& cacorrection.blue == other.cacorrection.blue
|
|
&& vignetting.amount == other.vignetting.amount
|
|
&& vignetting.radius == other.vignetting.radius
|
|
&& vignetting.strength == other.vignetting.strength
|
|
&& vignetting.centerX == other.vignetting.centerX
|
|
&& vignetting.centerY == other.vignetting.centerY
|
|
&& !memcmp (&chmixer.red, &other.chmixer.red, 3 * sizeof (int))
|
|
&& !memcmp (&chmixer.green, &other.chmixer.green, 3 * sizeof (int))
|
|
&& !memcmp (&chmixer.blue, &other.chmixer.blue, 3 * sizeof (int))
|
|
&& blackwhite.mixerRed == other.blackwhite.mixerRed
|
|
&& blackwhite.mixerOrange == other.blackwhite.mixerOrange
|
|
&& blackwhite.mixerYellow == other.blackwhite.mixerYellow
|
|
&& blackwhite.mixerGreen == other.blackwhite.mixerGreen
|
|
&& blackwhite.mixerCyan == other.blackwhite.mixerCyan
|
|
&& blackwhite.mixerBlue == other.blackwhite.mixerBlue
|
|
&& blackwhite.mixerMagenta == other.blackwhite.mixerMagenta
|
|
&& blackwhite.mixerPurple == other.blackwhite.mixerPurple
|
|
&& blackwhite.gammaRed == other.blackwhite.gammaRed
|
|
&& blackwhite.gammaGreen == other.blackwhite.gammaGreen
|
|
&& blackwhite.gammaBlue == other.blackwhite.gammaBlue
|
|
&& blackwhite.filter == other.blackwhite.filter
|
|
&& blackwhite.setting == other.blackwhite.setting
|
|
&& blackwhite.method == other.blackwhite.method
|
|
&& blackwhite.luminanceCurve == other.blackwhite.luminanceCurve
|
|
&& blackwhite.beforeCurve == other.blackwhite.beforeCurve
|
|
&& blackwhite.afterCurve == other.blackwhite.afterCurve
|
|
&& blackwhite.beforeCurveMode == other.blackwhite.beforeCurveMode
|
|
&& blackwhite.afterCurveMode == other.blackwhite.afterCurveMode
|
|
&& blackwhite.autoc == other.blackwhite.autoc
|
|
&& blackwhite.algo == other.blackwhite.algo
|
|
&& resize.scale == other.resize.scale
|
|
&& resize.appliesTo == other.resize.appliesTo
|
|
&& resize.method == other.resize.method
|
|
&& resize.dataspec == other.resize.dataspec
|
|
&& resize.width == other.resize.width
|
|
&& resize.height == other.resize.height
|
|
&& raw.bayersensor.method == other.raw.bayersensor.method
|
|
&& raw.bayersensor.imageNum == other.raw.bayersensor.imageNum
|
|
&& raw.bayersensor.ccSteps == other.raw.bayersensor.ccSteps
|
|
&& raw.bayersensor.black0 == other.raw.bayersensor.black0
|
|
&& raw.bayersensor.black1 == other.raw.bayersensor.black1
|
|
&& raw.bayersensor.black2 == other.raw.bayersensor.black2
|
|
&& raw.bayersensor.black3 == other.raw.bayersensor.black3
|
|
&& raw.bayersensor.twogreen == other.raw.bayersensor.twogreen
|
|
&& raw.bayersensor.greenthresh == other.raw.bayersensor.greenthresh
|
|
&& raw.bayersensor.linenoise == other.raw.bayersensor.linenoise
|
|
&& raw.bayersensor.dcb_iterations == other.raw.bayersensor.dcb_iterations
|
|
&& raw.bayersensor.lmmse_iterations == other.raw.bayersensor.lmmse_iterations
|
|
&& raw.bayersensor.pixelShiftMotion == other.raw.bayersensor.pixelShiftMotion
|
|
&& raw.bayersensor.pixelShiftMotionCorrection == other.raw.bayersensor.pixelShiftMotionCorrection
|
|
&& raw.bayersensor.pixelShiftMotionCorrectionMethod == other.raw.bayersensor.pixelShiftMotionCorrectionMethod
|
|
&& raw.bayersensor.pixelShiftStddevFactorGreen == other.raw.bayersensor.pixelShiftStddevFactorGreen
|
|
&& raw.bayersensor.pixelShiftStddevFactorRed == other.raw.bayersensor.pixelShiftStddevFactorRed
|
|
&& raw.bayersensor.pixelShiftStddevFactorBlue == other.raw.bayersensor.pixelShiftStddevFactorBlue
|
|
&& raw.bayersensor.pixelShiftEperIso == other.raw.bayersensor.pixelShiftEperIso
|
|
&& raw.bayersensor.pixelShiftNreadIso == other.raw.bayersensor.pixelShiftNreadIso
|
|
&& raw.bayersensor.pixelShiftPrnu == other.raw.bayersensor.pixelShiftPrnu
|
|
&& raw.bayersensor.pixelShiftSigma == other.raw.bayersensor.pixelShiftSigma
|
|
&& raw.bayersensor.pixelShiftSum == other.raw.bayersensor.pixelShiftSum
|
|
&& raw.bayersensor.pixelShiftRedBlueWeight == other.raw.bayersensor.pixelShiftRedBlueWeight
|
|
&& raw.bayersensor.pixelShiftShowMotion == other.raw.bayersensor.pixelShiftShowMotion
|
|
&& raw.bayersensor.pixelShiftShowMotionMaskOnly == other.raw.bayersensor.pixelShiftShowMotionMaskOnly
|
|
&& raw.bayersensor.pixelShiftAutomatic == other.raw.bayersensor.pixelShiftAutomatic
|
|
&& raw.bayersensor.pixelShiftNonGreenHorizontal == other.raw.bayersensor.pixelShiftNonGreenHorizontal
|
|
&& raw.bayersensor.pixelShiftNonGreenVertical == other.raw.bayersensor.pixelShiftNonGreenVertical
|
|
&& raw.bayersensor.pixelShiftHoleFill == other.raw.bayersensor.pixelShiftHoleFill
|
|
&& raw.bayersensor.pixelShiftMedian == other.raw.bayersensor.pixelShiftMedian
|
|
&& raw.bayersensor.pixelShiftMedian3 == other.raw.bayersensor.pixelShiftMedian3
|
|
&& raw.bayersensor.pixelShiftGreen == other.raw.bayersensor.pixelShiftGreen
|
|
&& raw.bayersensor.pixelShiftBlur == other.raw.bayersensor.pixelShiftBlur
|
|
&& raw.bayersensor.pixelShiftSmoothFactor == other.raw.bayersensor.pixelShiftSmoothFactor
|
|
&& raw.bayersensor.pixelShiftExp0 == other.raw.bayersensor.pixelShiftExp0
|
|
&& raw.bayersensor.pixelShiftLmmse == other.raw.bayersensor.pixelShiftLmmse
|
|
&& raw.bayersensor.pixelShiftEqualBright == other.raw.bayersensor.pixelShiftEqualBright
|
|
&& raw.bayersensor.pixelShiftEqualBrightChannel == other.raw.bayersensor.pixelShiftEqualBrightChannel
|
|
&& raw.bayersensor.pixelShiftNonGreenCross == other.raw.bayersensor.pixelShiftNonGreenCross
|
|
&& raw.bayersensor.pixelShiftNonGreenCross2 == other.raw.bayersensor.pixelShiftNonGreenCross2
|
|
&& raw.bayersensor.pixelShiftNonGreenAmaze == other.raw.bayersensor.pixelShiftNonGreenAmaze
|
|
&& raw.bayersensor.dcb_enhance == other.raw.bayersensor.dcb_enhance
|
|
&& raw.xtranssensor.method == other.raw.xtranssensor.method
|
|
&& raw.xtranssensor.ccSteps == other.raw.xtranssensor.ccSteps
|
|
&& raw.xtranssensor.blackred == other.raw.xtranssensor.blackred
|
|
&& raw.xtranssensor.blackgreen == other.raw.xtranssensor.blackgreen
|
|
&& raw.xtranssensor.blackblue == other.raw.xtranssensor.blackblue
|
|
&& raw.dark_frame == other.raw.dark_frame
|
|
&& raw.df_autoselect == other.raw.df_autoselect
|
|
&& raw.ff_file == other.raw.ff_file
|
|
&& raw.ff_AutoSelect == other.raw.ff_AutoSelect
|
|
&& raw.ff_BlurRadius == other.raw.ff_BlurRadius
|
|
&& raw.ff_BlurType == other.raw.ff_BlurType
|
|
&& raw.ff_AutoClipControl == other.raw.ff_AutoClipControl
|
|
&& raw.ff_clipControl == other.raw.ff_clipControl
|
|
&& raw.expos == other.raw.expos
|
|
&& raw.preser == other.raw.preser
|
|
&& raw.ca_autocorrect == other.raw.ca_autocorrect
|
|
&& raw.cared == other.raw.cared
|
|
&& raw.cablue == other.raw.cablue
|
|
&& raw.hotPixelFilter == other.raw.hotPixelFilter
|
|
&& raw.deadPixelFilter == other.raw.deadPixelFilter
|
|
&& raw.hotdeadpix_thresh == other.raw.hotdeadpix_thresh
|
|
&& icm.input == other.icm.input
|
|
&& icm.toneCurve == other.icm.toneCurve
|
|
&& icm.applyLookTable == other.icm.applyLookTable
|
|
&& icm.applyBaselineExposureOffset == other.icm.applyBaselineExposureOffset
|
|
&& icm.applyHueSatMap == other.icm.applyHueSatMap
|
|
&& icm.dcpIlluminant == other.icm.dcpIlluminant
|
|
&& icm.working == other.icm.working
|
|
&& icm.output == other.icm.output
|
|
&& icm.gamma == other.icm.gamma
|
|
&& icm.freegamma == other.icm.freegamma
|
|
&& icm.gampos == other.icm.gampos
|
|
&& icm.slpos == other.icm.slpos
|
|
&& wavelet == other.wavelet
|
|
&& wavelet.Lmethod == other.wavelet.Lmethod
|
|
&& wavelet.CLmethod == other.wavelet.CLmethod
|
|
&& wavelet.Backmethod == other.wavelet.Backmethod
|
|
&& wavelet.Tilesmethod == other.wavelet.Tilesmethod
|
|
&& wavelet.daubcoeffmethod == other.wavelet.daubcoeffmethod
|
|
&& wavelet.CHmethod == other.wavelet.CHmethod
|
|
&& wavelet.CHSLmethod == other.wavelet.CHSLmethod
|
|
&& wavelet.EDmethod == other.wavelet.EDmethod
|
|
&& wavelet.NPmethod == other.wavelet.NPmethod
|
|
&& wavelet.BAmethod == other.wavelet.BAmethod
|
|
&& wavelet.TMmethod == other.wavelet.TMmethod
|
|
&& wavelet.HSmethod == other.wavelet.HSmethod
|
|
&& wavelet.Dirmethod == other.wavelet.Dirmethod
|
|
&& wavelet.rescon == other.wavelet.rescon
|
|
&& wavelet.resconH == other.wavelet.resconH
|
|
&& wavelet.reschro == other.wavelet.reschro
|
|
&& wavelet.tmrs == other.wavelet.tmrs
|
|
&& wavelet.gamma == other.wavelet.gamma
|
|
&& wavelet.sup == other.wavelet.sup
|
|
&& wavelet.sky == other.wavelet.sky
|
|
&& wavelet.thres == other.wavelet.thres
|
|
&& wavelet.chroma == other.wavelet.chroma
|
|
&& wavelet.chro == other.wavelet.chro
|
|
&& wavelet.tmr == other.wavelet.tmr
|
|
&& wavelet.contrast == other.wavelet.contrast
|
|
&& wavelet.median == other.wavelet.median
|
|
&& wavelet.expcontrast == other.wavelet.expcontrast
|
|
&& wavelet.expchroma == other.wavelet.expchroma
|
|
&& wavelet.expedge == other.wavelet.expedge
|
|
&& wavelet.expresid == other.wavelet.expresid
|
|
&& wavelet.expfinal == other.wavelet.expfinal
|
|
&& wavelet.exptoning == other.wavelet.exptoning
|
|
&& wavelet.expnoise == other.wavelet.expnoise
|
|
&& wavelet.medianlev == other.wavelet.medianlev
|
|
&& wavelet.linkedg == other.wavelet.linkedg
|
|
&& wavelet.cbenab == other.wavelet.cbenab
|
|
&& wavelet.lipst == other.wavelet.lipst
|
|
&& wavelet.Medgreinf == other.wavelet.Medgreinf
|
|
&& wavelet.edgrad == other.wavelet.edgrad
|
|
&& wavelet.edgval == other.wavelet.edgval
|
|
&& wavelet.edgthresh == other.wavelet.edgthresh
|
|
&& wavelet.thr == other.wavelet.thr
|
|
&& wavelet.thrH == other.wavelet.thrH
|
|
&& wavelet.threshold == other.wavelet.threshold
|
|
&& wavelet.threshold2 == other.wavelet.threshold2
|
|
&& wavelet.edgedetect == other.wavelet.edgedetect
|
|
&& wavelet.edgedetectthr == other.wavelet.edgedetectthr
|
|
&& wavelet.edgedetectthr2 == other.wavelet.edgedetectthr2
|
|
&& wavelet.edgesensi == other.wavelet.edgesensi
|
|
&& wavelet.edgeampli == other.wavelet.edgeampli
|
|
&& wavelet.hueskin == other.wavelet.hueskin
|
|
&& wavelet.hueskin2 == other.wavelet.hueskin2
|
|
&& wavelet.hllev == other.wavelet.hllev
|
|
&& wavelet.bllev == other.wavelet.bllev
|
|
&& wavelet.edgcont == other.wavelet.edgcont
|
|
&& wavelet.level0noise == other.wavelet.level0noise
|
|
&& wavelet.level1noise == other.wavelet.level1noise
|
|
&& wavelet.level2noise == other.wavelet.level2noise
|
|
&& wavelet.level3noise == other.wavelet.level3noise
|
|
&& wavelet.pastlev == other.wavelet.pastlev
|
|
&& wavelet.satlev == other.wavelet.satlev
|
|
&& wavelet.opacityCurveRG == other.wavelet.opacityCurveRG
|
|
&& wavelet.opacityCurveBY == other.wavelet.opacityCurveBY
|
|
&& wavelet.opacityCurveW == other.wavelet.opacityCurveW
|
|
&& wavelet.opacityCurveWL == other.wavelet.opacityCurveWL
|
|
&& wavelet.hhcurve == other.wavelet.hhcurve
|
|
&& wavelet.Chcurve == other.wavelet.Chcurve
|
|
&& wavelet.ccwcurve == other.wavelet.ccwcurve
|
|
&& wavelet.wavclCurve == other.wavelet.wavclCurve
|
|
&& wavelet.skinprotect == other.wavelet.skinprotect
|
|
&& wavelet.strength == other.wavelet.strength
|
|
&& wavelet.balance == other.wavelet.balance
|
|
&& wavelet.greenhigh == other.wavelet.greenhigh
|
|
&& wavelet.greenmed == other.wavelet.greenmed
|
|
&& wavelet.greenlow == other.wavelet.greenlow
|
|
&& wavelet.bluehigh == other.wavelet.bluehigh
|
|
&& wavelet.bluemed == other.wavelet.bluemed
|
|
&& wavelet.bluelow == other.wavelet.bluelow
|
|
&& wavelet.iter == other.wavelet.iter
|
|
&& dirpyrequalizer == other.dirpyrequalizer
|
|
// && dirpyrequalizer.algo == other.dirpyrequalizer.algo
|
|
&& dirpyrequalizer.hueskin == other.dirpyrequalizer.hueskin
|
|
&& dirpyrequalizer.threshold == other.dirpyrequalizer.threshold
|
|
&& dirpyrequalizer.cbdlMethod == other.dirpyrequalizer.cbdlMethod
|
|
&& dirpyrequalizer.skinprotect == other.dirpyrequalizer.skinprotect
|
|
&& hsvequalizer.hcurve == other.hsvequalizer.hcurve
|
|
&& hsvequalizer.scurve == other.hsvequalizer.scurve
|
|
&& hsvequalizer.vcurve == other.hsvequalizer.vcurve
|
|
&& filmSimulation.enabled == other.filmSimulation.enabled
|
|
&& filmSimulation.clutFilename == other.filmSimulation.clutFilename
|
|
&& filmSimulation.strength == other.filmSimulation.strength
|
|
&& rgbCurves.rcurve == other.rgbCurves.rcurve
|
|
&& rgbCurves.gcurve == other.rgbCurves.gcurve
|
|
&& rgbCurves.bcurve == other.rgbCurves.bcurve
|
|
&& colorToning.enabled == other.colorToning.enabled
|
|
&& colorToning.twocolor == other.colorToning.twocolor
|
|
&& colorToning.method == other.colorToning.method
|
|
&& colorToning.colorCurve == other.colorToning.colorCurve
|
|
&& colorToning.opacityCurve == other.colorToning.opacityCurve
|
|
&& colorToning.autosat == other.colorToning.autosat
|
|
&& colorToning.satProtectionThreshold == other.colorToning.satProtectionThreshold
|
|
&& colorToning.saturatedOpacity == other.colorToning.saturatedOpacity
|
|
&& colorToning.strength == other.colorToning.strength
|
|
&& colorToning.hlColSat == other.colorToning.hlColSat
|
|
&& colorToning.shadowsColSat == other.colorToning.shadowsColSat
|
|
&& colorToning.balance == other.colorToning.balance
|
|
&& colorToning.clcurve == other.colorToning.clcurve
|
|
&& colorToning.cl2curve == other.colorToning.cl2curve
|
|
&& colorToning.redlow == other.colorToning.redlow
|
|
&& colorToning.greenlow == other.colorToning.greenlow
|
|
&& colorToning.bluelow == other.colorToning.bluelow
|
|
&& colorToning.satlow == other.colorToning.satlow
|
|
&& colorToning.sathigh == other.colorToning.sathigh
|
|
&& colorToning.redmed == other.colorToning.redmed
|
|
&& colorToning.greenmed == other.colorToning.greenmed
|
|
&& colorToning.bluemed == other.colorToning.bluemed
|
|
&& colorToning.redhigh == other.colorToning.redhigh
|
|
&& colorToning.greenhigh == other.colorToning.greenhigh
|
|
&& colorToning.bluehigh == other.colorToning.bluehigh
|
|
&& exif == other.exif
|
|
&& iptc == other.iptc;
|
|
}
|
|
|
|
bool ProcParams::operator!= (const ProcParams& other)
|
|
{
|
|
|
|
return ! (*this == other);
|
|
}
|
|
|
|
PartialProfile::PartialProfile (bool createInstance, bool paramsEditedValue)
|
|
{
|
|
if (createInstance) {
|
|
pparams = new ProcParams();
|
|
pedited = new ParamsEdited (paramsEditedValue);
|
|
} else {
|
|
pparams = nullptr;
|
|
pedited = nullptr;
|
|
}
|
|
}
|
|
|
|
PartialProfile::PartialProfile (ProcParams* pp, ParamsEdited* pe, bool fullCopy)
|
|
{
|
|
if (fullCopy && pp) {
|
|
pparams = new ProcParams (*pp);
|
|
} else {
|
|
pparams = pp;
|
|
}
|
|
|
|
if (fullCopy && pe) {
|
|
pedited = new ParamsEdited (*pe);
|
|
} else {
|
|
pedited = pe;
|
|
}
|
|
}
|
|
|
|
PartialProfile::PartialProfile (const ProcParams* pp, const ParamsEdited* pe)
|
|
{
|
|
if (pp) {
|
|
pparams = new ProcParams (*pp);
|
|
} else {
|
|
pparams = nullptr;
|
|
}
|
|
|
|
if (pe) {
|
|
pedited = new ParamsEdited (*pe);
|
|
} else {
|
|
pedited = nullptr;
|
|
}
|
|
}
|
|
|
|
int PartialProfile::load (const Glib::ustring &fName)
|
|
{
|
|
if (!pparams) {
|
|
pparams = new ProcParams();
|
|
}
|
|
|
|
if (!pedited) {
|
|
pedited = new ParamsEdited();
|
|
}
|
|
|
|
if (fName == DEFPROFILE_INTERNAL) {
|
|
return 0;
|
|
} else if (fName == DEFPROFILE_DYNAMIC) {
|
|
return -1; // should not happen here
|
|
} else {
|
|
return pparams->load (fName, pedited);
|
|
}
|
|
}
|
|
|
|
void PartialProfile::deleteInstance ()
|
|
{
|
|
if (pparams) {
|
|
delete pparams;
|
|
pparams = nullptr;
|
|
}
|
|
|
|
if (pedited) {
|
|
delete pedited;
|
|
pedited = nullptr;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set the all values of the General section to false
|
|
* in order to preserve them in applyTo
|
|
*/
|
|
void PartialProfile::clearGeneral ()
|
|
{
|
|
if (pedited) {
|
|
pedited->general.colorlabel = false;
|
|
pedited->general.intrash = false;
|
|
pedited->general.rank = false;
|
|
}
|
|
}
|
|
|
|
const void PartialProfile::applyTo (ProcParams *destParams) const
|
|
{
|
|
if (destParams && pparams && pedited) {
|
|
pedited->combine (*destParams, *pparams, true);
|
|
}
|
|
}
|
|
|
|
void PartialProfile::set (bool v)
|
|
{
|
|
if (pedited) {
|
|
pedited->set (v);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|