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

Issue 1615: added graduated filter tool

Browse Source
This commit is contained in:
torger 2013-11-03 09:39:04 +01:00
parent 207b3df9e7
commit c452ff20b8
20 changed files with 518 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
rtdata/languages/default
View File

@ -443,6 +443,8 @@ HISTORY_MSG_205;CAM02 hot/bad pixels
HISTORY_MSG_206;CAT02 - Adapt scene auto HISTORY_MSG_206;CAT02 - Adapt scene auto
HISTORY_MSG_207;Defringing Hue curve HISTORY_MSG_207;Defringing Hue curve
HISTORY_MSG_208;Blue/Red Equalizer HISTORY_MSG_208;Blue/Red Equalizer
HISTORY_MSG_210;Gradient Filter
HISTORY_MSG_211;Gradient Filter
HISTORY_NEWSNAPSHOTAS;As... HISTORY_NEWSNAPSHOTAS;As...
HISTORY_NEWSNAPSHOT;Add HISTORY_NEWSNAPSHOT;Add
HISTORY_NEWSNAPSHOT_TOOLTIP;Shortcut: <b>Alt-s</b> HISTORY_NEWSNAPSHOT_TOOLTIP;Shortcut: <b>Alt-s</b>
@ -633,6 +635,7 @@ PARTIALPASTE_DIALOGLABEL;Partial paste processing profile
PARTIALPASTE_DIRPYRDENOISE;Noise reduction PARTIALPASTE_DIRPYRDENOISE;Noise reduction
PARTIALPASTE_DIRPYREQUALIZER;Contrast by detail levels PARTIALPASTE_DIRPYREQUALIZER;Contrast by detail levels
PARTIALPASTE_DISTORTION;Distortion correction PARTIALPASTE_DISTORTION;Distortion correction
PARTIALPASTE_GRADIENT;Graduated Filter
PARTIALPASTE_EPD;Tone mapping PARTIALPASTE_EPD;Tone mapping
PARTIALPASTE_EVERYTHING;Everything PARTIALPASTE_EVERYTHING;Everything
PARTIALPASTE_EXIFCHANGES;Changes to Exif data PARTIALPASTE_EXIFCHANGES;Changes to Exif data
@ -1301,6 +1304,18 @@ TP_VIGNETTING_CENTER_Y;Center Y
TP_VIGNETTING_LABEL;Vignetting Correction TP_VIGNETTING_LABEL;Vignetting Correction
TP_VIGNETTING_RADIUS;Radius TP_VIGNETTING_RADIUS;Radius
TP_VIGNETTING_STRENGTH;Strength TP_VIGNETTING_STRENGTH;Strength
TP_GRADIENT_DEGREE;Angle
TP_GRADIENT_CENTER;Center
TP_GRADIENT_CENTER_X;Center X
TP_GRADIENT_CENTER_Y;Center Y
TP_GRADIENT_LABEL;Graduated Filter
TP_GRADIENT_FEATHER;Feather
TP_GRADIENT_STRENGTH;Strength
TP_GRADIENT_DEGREE_TOOLTIP;Rotation angle in degrees
TP_GRADIENT_CENTER_X_TOOLTIP;Rotation anchor point X: -100=left edge, 0=center, +100=right edge
TP_GRADIENT_CENTER_Y_TOOLTIP;Rotation anchor point Y: -100=top edge, 0=center, +100=bottom edge
TP_GRADIENT_FEATHER_TOOLTIP;Gradient width in percent of the image diagonal
TP_GRADIENT_STRENGTH_TOOLTIP;Filter strength in stops
TP_WBALANCE_AUTO;Auto TP_WBALANCE_AUTO;Auto
TP_WBALANCE_CAMERA;Camera TP_WBALANCE_CAMERA;Camera
TP_WBALANCE_CLOUDY;Cloudy TP_WBALANCE_CLOUDY;Cloudy

3
rtengine/improcfun.h
View File

@ -52,7 +52,7 @@ class ImProcFunctions {
void calcVignettingParams(int oW, int oH, const VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul); void calcVignettingParams(int oW, int oH, const VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul);
void transformPreview (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int sx, int sy, int oW, int oH, const LCPMapper *pLCPMap); void transformPreview (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int sx, int sy, int oW, int oH, const LCPMapper *pLCPMap);
void transformVignetteOnly (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int oW, int oH); void transformLuminanceOnly (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int oW, int oH);
void transformHighQuality (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int sx, int sy, int oW, int oH, const LCPMapper *pLCPMap, bool fullImage); void transformHighQuality (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int sx, int sy, int oW, int oH, const LCPMapper *pLCPMap, bool fullImage);
void sharpenHaloCtrl (LabImage* lab, float** blurmap, float** base, int W, int H); void sharpenHaloCtrl (LabImage* lab, float** blurmap, float** base, int W, int H);
@ -64,6 +64,7 @@ class ImProcFunctions {
bool needsDistortion (); bool needsDistortion ();
bool needsRotation (); bool needsRotation ();
bool needsPerspective (); bool needsPerspective ();
bool needsGradient ();
bool needsVignetting (); bool needsVignetting ();
bool needsLCP (); bool needsLCP ();
// static cmsUInt8Number* Mempro = NULL; // static cmsUInt8Number* Mempro = NULL;

176
rtengine/iptransform.cc
View File

@ -211,8 +211,8 @@ void ImProcFunctions::transform (Imagefloat* original, Imagefloat* transformed,
original->width, original->height, params->coarse, rawRotationDeg); original->width, original->height, params->coarse, rawRotationDeg);
} }
if (!(needsCA() || needsDistortion() || needsRotation() || needsPerspective() || needsLCP()) && needsVignetting()) if (!(needsCA() || needsDistortion() || needsRotation() || needsPerspective() || needsLCP()) && (needsVignetting() || needsGradient()))
transformVignetteOnly (original, transformed, cx, cy, oW, oH); transformLuminanceOnly (original, transformed, cx, cy, oW, oH);
else if (!needsCA() && scale!=1) else if (!needsCA() && scale!=1)
transformPreview (original, transformed, cx, cy, sx, sy, oW, oH, pLCPMap); transformPreview (original, transformed, cx, cy, sx, sy, oW, oH, pLCPMap);
else else
@ -241,11 +241,146 @@ void ImProcFunctions::calcVignettingParams(int oW, int oH, const VignettingParam
mul = (1.0-v) / tanh(b); mul = (1.0-v) / tanh(b);
} }
struct grad_params {
bool angle_is_zero, transpose, bright_top;
float ta, yc, xc;
float ys, ys_inv;
float scale, botmul, topmul;
float gamma;
float top_edge_0;
int h;
};
static void calcGradientParams(int oW, int oH, const GradientParams& gradient, struct grad_params& gp)
{
int w = oW;
int h = oH;
double gradient_stops = gradient.strength;
double gradient_span = gradient.feather / 100.0;
double gradient_center_x = gradient.centerX / 200.0 + 0.5;
double gradient_center_y = gradient.centerY / 200.0 + 0.5;
double gradient_angle = gradient.degree / 180.0 * M_PI;
//fprintf(stderr, "%f %f %f %f %f %d %d\n", gradient_stops, gradient_span, gradient_center_x, gradient_center_y, gradient_angle, w, h);
// make 0.0 <= gradient_angle < 2 * M_PI
gradient_angle = fmod(gradient_angle, 2 * M_PI);
if (gradient_angle < 0.0) {
gradient_angle += 2.0 * M_PI;
}
gp.bright_top = false;
gp.transpose = false;
gp.angle_is_zero = false;
gp.h = h;
double cosgrad = cos(gradient_angle);
if (fabs(cosgrad) < 0.707) {
// we transpose to avoid division by zero at 90 degrees
// (actually we could transpose only for 90 degrees, but this way we avoid
// division with extremely small numbers
gp.transpose = true;
gradient_angle += 0.5 * M_PI;
cosgrad = cos(gradient_angle);
double gxc = gradient_center_x;
gradient_center_x = 1.0 - gradient_center_y;
gradient_center_y = gxc;
}
gradient_angle = fmod(gradient_angle, 2 * M_PI);
if (gradient_angle > 0.5 * M_PI && gradient_angle < M_PI) {
gradient_angle += M_PI;
gp.bright_top = true;
} else if (gradient_angle >= M_PI && gradient_angle < 1.5 * M_PI) {
gradient_angle -= M_PI;
gp.bright_top = true;
}
if (fabs(gradient_angle) < 0.001 || fabs(gradient_angle - 2 * M_PI) < 0.001) {
gradient_angle = 0;
gp.angle_is_zero = true;
}
if (gp.transpose) {
gp.bright_top = !gp.bright_top;
}
float *grad = (float *)malloc(w * h * sizeof(float));
if (gp.transpose) {
int tmp = w;
w = h;
h = tmp;
}
gp.scale = 1.0 / pow(2, gradient_stops);
if (gp.bright_top) {
gp.topmul = 1.0;
gp.botmul = gp.scale;
} else {
gp.topmul = gp.scale;
gp.botmul = 1.0;
}
gp.ta = tan(gradient_angle);
gp.xc = w * gradient_center_x;
gp.yc = h * gradient_center_y;
gp.ys = sqrt((float)h * h + (float)w * w) * (gradient_span / cos(gradient_angle));
gp.ys_inv = 1.0 / gp.ys;
gp.top_edge_0 = gp.yc - gp.ys/2.0;
if (gp.ys < 1.0 / h) {
gp.ys_inv = 0;
gp.ys = 0;
}
gp.gamma = 1.5; // tested to be "visually pleasing"
}
static float calcGradientFactor(const struct grad_params& gp, int x, int y) {
if (gp.angle_is_zero) {
int gy = gp.transpose ? x : y;
int gx = gp.transpose ? y : x;
if (gy < gp.top_edge_0) {
return gp.topmul;
} else if (gy >= gp.top_edge_0 + gp.ys) {
return gp.botmul;
} else {
float val = ((float)(gy - gp.top_edge_0) * gp.ys_inv);
if (gp.bright_top) {
val = 1.0 - val;
}
val = 2 * val - 1.0; // adjust range to -1 to 1
val = 0.5 * (3 * val - powf(val, 3)); // s-curve
val = 0.5 * (1.0 + val); // adjust range back to 0 to 1
val = powf(val, gp.gamma); // apply gamma
return gp.scale + val * (1.0 - gp.scale);
}
} else {
int gy = gp.transpose ? x : y;
int gx = gp.transpose ? gp.h - y - 1 : x;
float top_edge = gp.yc - gp.ys/2.0 - gp.ta * (gx - gp.xc);
if (gy < top_edge) {
return gp.topmul;
} else if (gy >= top_edge + gp.ys) {
return gp.botmul;
} else {
float val = ((float)(gy - top_edge) * gp.ys_inv);
if (gp.bright_top) {
val = 1.0 - val;
}
val = 2 * val - 1.0;
val = 0.5 * (3 * val - powf(val, 3));
val = 0.5 * (1.0 + val);
val = powf(val, gp.gamma);
return gp.scale + val * (1.0 - gp.scale);
}
}
}
// Transform vignetting only // Transform vignetting only
void ImProcFunctions::transformVignetteOnly (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int oW, int oH) { void ImProcFunctions::transformLuminanceOnly (Imagefloat* original, Imagefloat* transformed, int cx, int cy, int oW, int oH) {
const bool applyVignetting = needsVignetting();
const bool applyGradient = needsGradient();
double vig_w2, vig_h2, maxRadius, v, b, mul; double vig_w2, vig_h2, maxRadius, v, b, mul;
if (applyVignetting) {
calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul);
}
struct grad_params gp;
if (applyGradient) {
calcGradientParams(transformed->width, transformed->height, params->gradient, gp);
}
#pragma omp parallel for if (multiThread) #pragma omp parallel for if (multiThread)
for (int y=0; y<transformed->height; y++) { for (int y=0; y<transformed->height; y++) {
@ -253,10 +388,16 @@ void ImProcFunctions::transformVignetteOnly (Imagefloat* original, Imagefloat* t
for (int x=0; x<transformed->width; x++) { for (int x=0; x<transformed->width; x++) {
double vig_x_d = (double) (x + cx) - vig_w2 ; double vig_x_d = (double) (x + cx) - vig_w2 ;
double r = sqrt(vig_x_d*vig_x_d + vig_y_d*vig_y_d); double r = sqrt(vig_x_d*vig_x_d + vig_y_d*vig_y_d);
double vign = std::max(v + mul * tanh (b*(maxRadius-r) / maxRadius), 0.001); double mul = 1.0;
transformed->r(y,x) = original->r(y,x) / vign; if (applyVignetting) {
transformed->g(y,x) = original->g(y,x) / vign; mul /= std::max(v + mul * tanh (b*(maxRadius-r) / maxRadius), 0.001);
transformed->b(y,x) = original->b(y,x) / vign; }
if (applyGradient) {
mul *= calcGradientFactor(gp, x, y);
}
transformed->r(y,x) = original->r(y,x) * mul;
transformed->g(y,x) = original->g(y,x) * mul;
transformed->b(y,x) = original->b(y,x) * mul;
} }
} }
} }
@ -274,6 +415,11 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr
double vig_w2,vig_h2,maxRadius,v,b,mul; double vig_w2,vig_h2,maxRadius,v,b,mul;
calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul);
struct grad_params gp;
if (needsGradient()) {
calcGradientParams(transformed->width, transformed->height, params->gradient, gp);
}
float** chOrig[3]; float** chOrig[3];
chOrig[0] = original->r.ptrs; chOrig[0] = original->r.ptrs;
chOrig[1] = original->g.ptrs; chOrig[1] = original->g.ptrs;
@ -385,6 +531,9 @@ void ImProcFunctions::transformHighQuality (Imagefloat* original, Imagefloat* tr
double vignmul = 1.0; double vignmul = 1.0;
if (needsVignetting()) if (needsVignetting())
vignmul /= std::max(v + mul * tanh (b*(maxRadius-s*r2) / maxRadius), 0.001); vignmul /= std::max(v + mul * tanh (b*(maxRadius-s*r2) / maxRadius), 0.001);
if (needsGradient()) {
vignmul *= calcGradientFactor(gp, x, y);
}
if (yc > 0 && yc < original->height-2 && xc > 0 && xc < original->width-2) { if (yc > 0 && yc < original->height-2 && xc > 0 && xc < original->width-2) {
// all interpolation pixels inside image // all interpolation pixels inside image
@ -432,6 +581,11 @@ void ImProcFunctions::transformPreview (Imagefloat* original, Imagefloat* transf
double vig_w2, vig_h2, maxRadius, v, b, mul; double vig_w2, vig_h2, maxRadius, v, b, mul;
calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul); calcVignettingParams(oW, oH, params->vignetting, vig_w2, vig_h2, maxRadius, v, b, mul);
struct grad_params gp;
if (needsGradient()) {
calcGradientParams(transformed->width, transformed->height, params->gradient, gp);
}
// auxiliary variables for distortion correction // auxiliary variables for distortion correction
bool needsDist = needsDistortion(); // for performance bool needsDist = needsDistortion(); // for performance
double distAmount = params->distortion.amount; double distAmount = params->distortion.amount;
@ -514,6 +668,8 @@ void ImProcFunctions::transformPreview (Imagefloat* original, Imagefloat* transf
double vignmul = 1.0; double vignmul = 1.0;
if (needsVignetting()) if (needsVignetting())
vignmul /= std::max(v + mul * tanh (b*(maxRadius-s*r2) / maxRadius), 0.001); vignmul /= std::max(v + mul * tanh (b*(maxRadius-s*r2) / maxRadius), 0.001);
if (needsGradient())
vignmul *= calcGradientFactor(gp, x, y);
if (yc < original->height-1 && xc < original->width-1) { if (yc < original->height-1 && xc < original->width-1) {
// all interpolation pixels inside image // all interpolation pixels inside image
@ -579,6 +735,10 @@ bool ImProcFunctions::needsPerspective () {
return params->perspective.horizontal || params->perspective.vertical; return params->perspective.horizontal || params->perspective.vertical;
} }
bool ImProcFunctions::needsGradient () {
return params->gradient.enabled && fabs(params->gradient.strength) > 1e-15;
}
bool ImProcFunctions::needsVignetting () { bool ImProcFunctions::needsVignetting () {
return params->vignetting.amount; return params->vignetting.amount;
} }
@ -588,7 +748,7 @@ bool ImProcFunctions::needsLCP () {
} }
bool ImProcFunctions::needsTransform () { bool ImProcFunctions::needsTransform () {
return needsCA () || needsDistortion () || needsRotation () || needsPerspective () || needsVignetting () || needsLCP(); return needsCA () || needsDistortion () || needsRotation () || needsPerspective () || needsGradient () || needsVignetting () || needsLCP();
} }

4
rtengine/procevents.h
View File

@ -232,7 +232,9 @@ enum ProcEvent {
EvPFCurve=206, EvPFCurve=206,
EvWBequal=207, EvWBequal=207,
EvWBequalbo=208, EvWBequalbo=208,
NUMOFEVENTS=209 EvGradient=209,
EvGradientEnabled=210,
NUMOFEVENTS=211
}; };
} }
#endif #endif

31
rtengine/procparams.cc
View File

@ -331,6 +331,13 @@ void ProcParams::setDefaults () {
perspective.horizontal = 0; perspective.horizontal = 0;
perspective.vertical = 0; perspective.vertical = 0;
gradient.enabled = false;
gradient.degree = 0;
gradient.feather = 25;
gradient.strength = 0;
gradient.centerX = 0;
gradient.centerY = 0;
cacorrection.red = 0; cacorrection.red = 0;
cacorrection.blue = 0; cacorrection.blue = 0;
@ -823,6 +830,14 @@ int ProcParams::save (Glib::ustring fname, Glib::ustring fname2, bool fnameAbsol
if (!pedited || pedited->perspective.horizontal) keyFile.set_double ("Perspective", "Horizontal", perspective.horizontal); if (!pedited || pedited->perspective.horizontal) keyFile.set_double ("Perspective", "Horizontal", perspective.horizontal);
if (!pedited || pedited->perspective.vertical) keyFile.set_double ("Perspective", "Vertical", perspective.vertical); if (!pedited || pedited->perspective.vertical) keyFile.set_double ("Perspective", "Vertical", perspective.vertical);
// save gradient
if (!pedited || pedited->gradient.enabled) keyFile.set_boolean ("Gradient", "Enabled", gradient.enabled);
if (!pedited || pedited->gradient.degree) keyFile.set_double ("Gradient", "Degree", gradient.degree);
if (!pedited || pedited->gradient.feather) keyFile.set_integer ("Gradient", "Feather", gradient.feather);
if (!pedited || pedited->gradient.strength) keyFile.set_double ("Gradient", "Strength", gradient.strength);
if (!pedited || pedited->gradient.centerX) keyFile.set_integer ("Gradient", "CenterX", gradient.centerX);
if (!pedited || pedited->gradient.centerY) keyFile.set_integer ("Gradient", "CenterY", gradient.centerY);
// save C/A correction // save C/A correction
if (!pedited || pedited->cacorrection.red) keyFile.set_double ("CACorrection", "Red", cacorrection.red); if (!pedited || pedited->cacorrection.red) keyFile.set_double ("CACorrection", "Red", cacorrection.red);
if (!pedited || pedited->cacorrection.blue) keyFile.set_double ("CACorrection", "Blue", cacorrection.blue); if (!pedited || pedited->cacorrection.blue) keyFile.set_double ("CACorrection", "Blue", cacorrection.blue);
@ -1368,6 +1383,16 @@ if (keyFile.has_group ("Perspective")) {
if (keyFile.has_key ("Perspective", "Vertical")) { perspective.vertical = keyFile.get_double ("Perspective", "Vertical"); if (pedited) pedited->perspective.vertical = true; } if (keyFile.has_key ("Perspective", "Vertical")) { perspective.vertical = keyFile.get_double ("Perspective", "Vertical"); if (pedited) pedited->perspective.vertical = true; }
} }
// load gradient
if (keyFile.has_group ("Gradient")) {
if (keyFile.has_key ("Gradient", "Enabled")) { gradient.enabled = keyFile.get_boolean ("Gradient", "Enabled"); if (pedited) pedited->gradient.enabled = true; }
if (keyFile.has_key ("Gradient", "Degree")) { gradient.degree = keyFile.get_double ("Gradient", "Degree"); if (pedited) pedited->gradient.degree = true; }
if (keyFile.has_key ("Gradient", "Feather")) { gradient.feather = keyFile.get_integer ("Gradient", "Feather"); if (pedited) pedited->gradient.feather = true; }
if (keyFile.has_key ("Gradient", "Strength")) { gradient.strength = keyFile.get_double ("Gradient", "Strength");if (pedited) pedited->gradient.strength = true; }
if (keyFile.has_key ("Gradient", "CenterX")) { gradient.centerX = keyFile.get_integer ("Gradient", "CenterX"); if (pedited) pedited->gradient.centerX = true; }
if (keyFile.has_key ("Gradient", "CenterY")) { gradient.centerY = keyFile.get_integer ("Gradient", "CenterY"); if (pedited) pedited->gradient.centerY = true; }
}
// load c/a correction // load c/a correction
if (keyFile.has_group ("CACorrection")) { if (keyFile.has_group ("CACorrection")) {
if (keyFile.has_key ("CACorrection", "Red")) { cacorrection.red = keyFile.get_double ("CACorrection", "Red"); if (pedited) pedited->cacorrection.red = true; } if (keyFile.has_key ("CACorrection", "Red")) { cacorrection.red = keyFile.get_double ("CACorrection", "Red"); if (pedited) pedited->cacorrection.red = true; }
@ -1703,6 +1728,12 @@ bool ProcParams::operator== (const ProcParams& other) {
&& lensProf.useCA == other.lensProf.useCA && lensProf.useCA == other.lensProf.useCA
&& perspective.horizontal == other.perspective.horizontal && perspective.horizontal == other.perspective.horizontal
&& perspective.vertical == other.perspective.vertical && 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
&& cacorrection.red == other.cacorrection.red && cacorrection.red == other.cacorrection.red
&& cacorrection.blue == other.cacorrection.blue && cacorrection.blue == other.cacorrection.blue
&& vignetting.amount == other.vignetting.amount && vignetting.amount == other.vignetting.amount

15
rtengine/procparams.h
View File

@ -576,6 +576,20 @@ class PerspectiveParams {
double vertical; double vertical;
}; };
/**
* Parameters of the gradient filter
*/
class GradientParams {
public:
bool enabled;
double degree;
int feather;
double strength;
int centerX;
int centerY;
};
/** /**
* Parameters of the vignetting correction * Parameters of the vignetting correction
*/ */
@ -771,6 +785,7 @@ class ProcParams {
DistortionParams distortion; ///< Lens distortion correction parameters DistortionParams distortion; ///< Lens distortion correction parameters
LensProfParams lensProf; ///< Lens correction profile parameters LensProfParams lensProf; ///< Lens correction profile parameters
PerspectiveParams perspective; ///< Perspective correction parameters PerspectiveParams perspective; ///< Perspective correction parameters
GradientParams gradient; ///< Gradient filter parameters
CACorrParams cacorrection; ///< Lens c/a correction parameters CACorrParams cacorrection; ///< Lens c/a correction parameters
VignettingParams vignetting; ///< Lens vignetting correction parameters VignettingParams vignetting; ///< Lens vignetting correction parameters
ChannelMixerParams chmixer; ///< Channel mixer parameters ChannelMixerParams chmixer; ///< Channel mixer parameters

4
rtengine/refreshmap.cc
View File

@ -228,7 +228,9 @@ LUMINANCECURVE, // EvCATbadpix
LUMINANCECURVE, // EvCATAutoadap LUMINANCECURVE, // EvCATAutoadap
DEFRINGE, // EvPFCurve, DEFRINGE, // EvPFCurve,
WHITEBALANCE, // EvWBequal, WHITEBALANCE, // EvWBequal,
WHITEBALANCE // EvWBequalbo, WHITEBALANCE, // EvWBequalbo,
TRANSFORM, // EvGradient
TRANSFORM // EvGradientEnabled
//LUMINANCECURVE // EvCATsharpcie //LUMINANCECURVE // EvCATsharpcie

2
rtgui/CMakeLists.txt
View File

@ -10,7 +10,7 @@ set (BASESOURCEFILES
impulsedenoise.cc dirpyrdenoise.cc epd.cc impulsedenoise.cc dirpyrdenoise.cc epd.cc
exifpanel.cc toolpanel.cc lensprofile.cc exifpanel.cc toolpanel.cc lensprofile.cc
sharpening.cc vibrance.cc rgbcurves.cc sharpening.cc vibrance.cc rgbcurves.cc
whitebalance.cc vignetting.cc rotate.cc distortion.cc whitebalance.cc vignetting.cc gradient.cc rotate.cc distortion.cc
crophandler.cc dirbrowser.cc crophandler.cc dirbrowser.cc
curveeditor.cc curveeditorgroup.cc diagonalcurveeditorsubgroup.cc flatcurveeditorsubgroup.cc curveeditor.cc curveeditorgroup.cc diagonalcurveeditorsubgroup.cc flatcurveeditorsubgroup.cc
filecatalog.cc extprog.cc filecatalog.cc extprog.cc

6
rtgui/addsetids.h
View File

@ -66,8 +66,12 @@
#define ADDSET_CAT_HUE 58 #define ADDSET_CAT_HUE 58
#define ADDSET_CAT_BADPIX 59 #define ADDSET_CAT_BADPIX 59
#define ADDSET_WB_EQUAL 60 #define ADDSET_WB_EQUAL 60
#define ADDSET_GRADIENT_DEGREE 61
#define ADDSET_GRADIENT_FEATHER 62
#define ADDSET_GRADIENT_STRENGTH 63
#define ADDSET_GRADIENT_CENTER 64
// When adding items, make sure to update ADDSET_PARAM_NUM // When adding items, make sure to update ADDSET_PARAM_NUM
#define ADDSET_PARAM_NUM 61 // THIS IS USED AS A DELIMITER!! #define ADDSET_PARAM_NUM 65 // THIS IS USED AS A DELIMITER!!
#endif #endif

7
rtgui/batchtoolpanelcoord.cc
View File

@ -133,6 +133,7 @@ void BatchToolPanelCoordinator::initSession () {
rotate->setAdjusterBehavior (false); rotate->setAdjusterBehavior (false);
distortion->setAdjusterBehavior (false); distortion->setAdjusterBehavior (false);
perspective->setAdjusterBehavior (false); perspective->setAdjusterBehavior (false);
gradient->setAdjusterBehavior (false, false, false, false);
cacorrection->setAdjusterBehavior (false); cacorrection->setAdjusterBehavior (false);
sharpening->setAdjusterBehavior (false); sharpening->setAdjusterBehavior (false);
sharpenEdge->setAdjusterBehavior (false, false); sharpenEdge->setAdjusterBehavior (false, false);
@ -160,6 +161,7 @@ void BatchToolPanelCoordinator::initSession () {
rotate->setAdjusterBehavior (options.baBehav[ADDSET_ROTATE_DEGREE]); rotate->setAdjusterBehavior (options.baBehav[ADDSET_ROTATE_DEGREE]);
distortion->setAdjusterBehavior (options.baBehav[ADDSET_DIST_AMOUNT]); distortion->setAdjusterBehavior (options.baBehav[ADDSET_DIST_AMOUNT]);
perspective->setAdjusterBehavior (options.baBehav[ADDSET_PERSPECTIVE]); perspective->setAdjusterBehavior (options.baBehav[ADDSET_PERSPECTIVE]);
gradient->setAdjusterBehavior (options.baBehav[ADDSET_GRADIENT_DEGREE], options.baBehav[ADDSET_GRADIENT_FEATHER], options.baBehav[ADDSET_GRADIENT_STRENGTH], options.baBehav[ADDSET_GRADIENT_CENTER]);
cacorrection->setAdjusterBehavior (options.baBehav[ADDSET_CA]); cacorrection->setAdjusterBehavior (options.baBehav[ADDSET_CA]);
sharpening->setAdjusterBehavior (options.baBehav[ADDSET_SHARP_AMOUNT]); sharpening->setAdjusterBehavior (options.baBehav[ADDSET_SHARP_AMOUNT]);
sharpenEdge->setAdjusterBehavior (options.baBehav[ADDSET_SHARPENEDGE_AMOUNT],options.baBehav[ADDSET_SHARPENEDGE_PASS]); sharpenEdge->setAdjusterBehavior (options.baBehav[ADDSET_SHARPENEDGE_AMOUNT],options.baBehav[ADDSET_SHARPENEDGE_PASS]);
@ -231,6 +233,11 @@ void BatchToolPanelCoordinator::initSession () {
if (options.baBehav[ADDSET_ROTATE_DEGREE]) pparams.rotate.degree = 0; if (options.baBehav[ADDSET_ROTATE_DEGREE]) pparams.rotate.degree = 0;
if (options.baBehav[ADDSET_DIST_AMOUNT]) pparams.distortion.amount = 0; if (options.baBehav[ADDSET_DIST_AMOUNT]) pparams.distortion.amount = 0;
if (options.baBehav[ADDSET_PERSPECTIVE]) pparams.perspective.horizontal = pparams.perspective.vertical = 0; if (options.baBehav[ADDSET_PERSPECTIVE]) pparams.perspective.horizontal = pparams.perspective.vertical = 0;
if (options.baBehav[ADDSET_GRADIENT_DEGREE]) pparams.gradient.degree = 0;
if (options.baBehav[ADDSET_GRADIENT_FEATHER]) pparams.gradient.feather = 0;
if (options.baBehav[ADDSET_GRADIENT_STRENGTH]) pparams.gradient.strength = 0;
if (options.baBehav[ADDSET_GRADIENT_CENTER]) pparams.gradient.centerX = 0;
if (options.baBehav[ADDSET_GRADIENT_CENTER]) pparams.gradient.centerY = 0;
if (options.baBehav[ADDSET_CA]) pparams.cacorrection.red = 0; if (options.baBehav[ADDSET_CA]) pparams.cacorrection.red = 0;
if (options.baBehav[ADDSET_CA]) pparams.cacorrection.blue = 0; if (options.baBehav[ADDSET_CA]) pparams.cacorrection.blue = 0;
if (options.baBehav[ADDSET_VIGN_AMOUNT]) pparams.vignetting.amount = 0; if (options.baBehav[ADDSET_VIGN_AMOUNT]) pparams.vignetting.amount = 0;

173
rtgui/gradient.cc Normal file
View File

@ -0,0 +1,173 @@
/*
* This file is part of RawTherapee.
*/
#include "gradient.h"
#include <iomanip>
using namespace rtengine;
using namespace rtengine::procparams;
Gradient::Gradient () : Gtk::VBox(), FoldableToolPanel(this)
{
set_border_width(4);
enabled = Gtk::manage (new Gtk::CheckButton (M("GENERAL_ENABLED")));
enabled->set_active (false);
enaConn = enabled->signal_toggled().connect( sigc::mem_fun(*this, &Gradient::enabledChanged) );
strength = Gtk::manage (new Adjuster (M("TP_GRADIENT_STRENGTH"), -5, 5, 0.01, 0));
strength->set_tooltip_text (M("TP_GRADIENT_STRENGTH_TOOLTIP"));
strength->setAdjusterListener (this);
degree = Gtk::manage (new Adjuster (M("TP_GRADIENT_DEGREE"), -180, 180, 1, 0));
degree->set_tooltip_text (M("TP_GRADIENT_DEGREE_TOOLTIP"));
degree->setAdjusterListener (this);
feather = Gtk::manage (new Adjuster (M("TP_GRADIENT_FEATHER"), 0, 100, 1, 25));
feather->set_tooltip_text (M("TP_GRADIENT_FEATHER_TOOLTIP"));
feather->setAdjusterListener (this);
centerX = Gtk::manage (new Adjuster (M("TP_GRADIENT_CENTER_X"), -100, 100, 1, 0));
centerX->set_tooltip_text (M("TP_GRADIENT_CENTER_X_TOOLTIP"));
centerX->setAdjusterListener (this);
centerY = Gtk::manage (new Adjuster (M("TP_GRADIENT_CENTER_Y"), -100, 100, 1, 0));
centerY->set_tooltip_text (M("TP_GRADIENT_CENTER_Y_TOOLTIP"));
centerY->setAdjusterListener (this);
pack_start(*enabled);
pack_start(*Gtk::manage (new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET, 4);
pack_start (*strength);
pack_start (*degree);
pack_start (*feather);
pack_start (*centerX);
pack_start (*centerY);
show_all();
}
void Gradient::read (const ProcParams* pp, const ParamsEdited* pedited)
{
disableListener ();
if (pedited) {
degree->setEditedState (pedited->gradient.degree ? Edited : UnEdited);
feather->setEditedState (pedited->gradient.feather ? Edited : UnEdited);
strength->setEditedState (pedited->gradient.strength ? Edited : UnEdited);
centerX->setEditedState (pedited->gradient.centerX ? Edited : UnEdited);
centerY->setEditedState (pedited->gradient.centerY ? Edited : UnEdited);
enabled->set_inconsistent (!pedited->gradient.enabled);
}
enaConn.block (true);
enabled->set_active (pp->gradient.enabled);
enaConn.block (false);
degree->setValue (pp->gradient.degree);
feather->setValue (pp->gradient.feather);
strength->setValue (pp->gradient.strength);
centerX->setValue (pp->gradient.centerX);
centerY->setValue (pp->gradient.centerY);
lastEnabled = pp->gradient.enabled;
enableListener ();
}
void Gradient::write (ProcParams* pp, ParamsEdited* pedited)
{
pp->gradient.degree = degree->getValue ();
pp->gradient.feather = (int)feather->getValue ();
pp->gradient.strength = strength->getValue ();
pp->gradient.centerX = (int)centerX->getValue ();
pp->gradient.centerY = (int)centerY->getValue ();
pp->gradient.enabled = enabled->get_active();
if (pedited) {
pedited->gradient.degree = degree->getEditedState ();
pedited->gradient.feather = feather->getEditedState ();
pedited->gradient.strength = strength->getEditedState ();
pedited->gradient.centerX = centerX->getEditedState ();
pedited->gradient.centerY = centerY->getEditedState ();
pedited->gradient.enabled = !enabled->get_inconsistent();
}
}
void Gradient::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited)
{
degree->setDefault (defParams->gradient.degree);
feather->setDefault (defParams->gradient.feather);
strength->setDefault (defParams->gradient.strength);
centerX->setDefault (defParams->gradient.centerX);
centerY->setDefault (defParams->gradient.centerY);
if (pedited) {
degree->setDefaultEditedState (pedited->gradient.degree ? Edited : UnEdited);
feather->setDefaultEditedState (pedited->gradient.feather ? Edited : UnEdited);
strength->setDefaultEditedState (pedited->gradient.strength ? Edited : UnEdited);
centerX->setDefaultEditedState (pedited->gradient.centerX ? Edited : UnEdited);
centerY->setDefaultEditedState (pedited->gradient.centerY ? Edited : UnEdited);
} else {
degree->setDefaultEditedState (Irrelevant);
feather->setDefaultEditedState (Irrelevant);
strength->setDefaultEditedState (Irrelevant);
centerX->setDefaultEditedState (Irrelevant);
centerY->setDefaultEditedState (Irrelevant);
}
}
void Gradient::adjusterChanged (Adjuster* a, double newval) {
if (listener && enabled->get_active()) {
listener->panelChanged (EvGradient, Glib::ustring::compose ("%1=%5\n%2=%6\n%3=%7\n%4=%8 %9", M("TP_GRADIENT_DEGREE"), M("TP_GRADIENT_FEATHER"), M("TP_GRADIENT_STRENGTH"), M("TP_GRADIENT_CENTER"), degree->getValue(), (int)feather->getValue(), strength->getValue(), (int)centerX->getValue(), (int)centerY->getValue()));
}
}
void Gradient::enabledChanged () {
if (batchMode) {
if (enabled->get_inconsistent()) {
enabled->set_inconsistent (false);
enaConn.block (true);
enabled->set_active (false);
enaConn.block (false);
}
else if (lastEnabled)
enabled->set_inconsistent (true);
lastEnabled = enabled->get_active ();
}
if (listener) {
if (enabled->get_active())
listener->panelChanged (EvGradientEnabled, M("GENERAL_ENABLED"));
else
listener->panelChanged (EvGradientEnabled, M("GENERAL_DISABLED"));
}
}
void Gradient::setAdjusterBehavior (bool degreeadd, bool featheradd, bool strengthadd, bool centeradd)
{
degree->setAddMode(degreeadd);
feather->setAddMode(featheradd);
strength->setAddMode(strengthadd);
centerX->setAddMode(centeradd);
centerY->setAddMode(centeradd);
}
void Gradient::trimValues (rtengine::procparams::ProcParams* pp)
{
degree->trimValue(pp->gradient.degree);
feather->trimValue(pp->gradient.feather);
strength->trimValue(pp->gradient.strength);
centerX->trimValue(pp->gradient.centerX);
centerY->trimValue(pp->gradient.centerY);
}
void Gradient::setBatchMode (bool batchMode)
{
ToolPanel::setBatchMode (batchMode);
degree->showEditedCB ();
feather->showEditedCB ();
strength->showEditedCB ();
centerX->showEditedCB ();
centerY->showEditedCB ();
}

38
rtgui/gradient.h Normal file
View File

@ -0,0 +1,38 @@
/*
* This file is part of RawTherapee.
*/
#ifndef _GRADIENT_H_
#define _GRADIENT_H_
#include <gtkmm.h>
#include "adjuster.h"
#include "toolpanel.h"
class Gradient : public Gtk::VBox, public AdjusterListener, public FoldableToolPanel {
protected:
Gtk::CheckButton* enabled;
Adjuster* degree;
Adjuster* feather;
Adjuster* strength;
Adjuster* centerX;
Adjuster* centerY;
bool lastEnabled;
sigc::connection enaConn;
public:
Gradient ();
void read (const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited=NULL);
void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited=NULL);
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited=NULL);
void setBatchMode (bool batchMode);
void adjusterChanged (Adjuster* a, double newval);
void enabledChanged ();
void setAdjusterBehavior (bool degreeadd, bool featheradd, bool strengthadd, bool centeradd);
void trimValues (rtengine::procparams::ProcParams* pp);
};
#endif

4
rtgui/options.cc
View File

@ -452,6 +452,10 @@ void Options::setDefaults () {
0, // ADDSET_CAT_CHROMA 0, // ADDSET_CAT_CHROMA
0, // ADDSET_CAT_CONTRAST 0, // ADDSET_CAT_CONTRAST
0, // ADDSET_WB_EQUAL 0, // ADDSET_WB_EQUAL
0, // ADDSET_GRADIENT_AMOUNT
0, // ADDSET_GRADIENT_RADIUS
0, // ADDSET_GRADIENT_STRENGTH
0, // ADDSET_GRADIENT_CENTER
}; };
baBehav = std::vector<int> (babehav, babehav+ADDSET_PARAM_NUM); baBehav = std::vector<int> (babehav, babehav+ADDSET_PARAM_NUM);

18
rtgui/paramsedited.cc
View File

@ -190,6 +190,12 @@ void ParamsEdited::set (bool v) {
lensProf.useCA = v; lensProf.useCA = v;
perspective.horizontal = v; perspective.horizontal = v;
perspective.vertical = v; perspective.vertical = v;
gradient.enabled = v;
gradient.degree = v;
gradient.feather = v;
gradient.strength = v;
gradient.centerX = v;
gradient.centerY = v;
cacorrection.red = v; cacorrection.red = v;
cacorrection.blue = v; cacorrection.blue = v;
vignetting.amount = v; vignetting.amount = v;
@ -438,6 +444,12 @@ void ParamsEdited::initFrom (const std::vector<rtengine::procparams::ProcParams>
lensProf.useCA = lensProf.useCA && p.lensProf.useCA == other.lensProf.useCA; lensProf.useCA = lensProf.useCA && p.lensProf.useCA == other.lensProf.useCA;
perspective.horizontal = perspective.horizontal && p.perspective.horizontal == other.perspective.horizontal; perspective.horizontal = perspective.horizontal && p.perspective.horizontal == other.perspective.horizontal;
perspective.vertical = perspective.vertical && p.perspective.vertical == other.perspective.vertical; perspective.vertical = perspective.vertical && p.perspective.vertical == other.perspective.vertical;
gradient.enabled = gradient.enabled && p.gradient.enabled == other.gradient.enabled;
gradient.degree = gradient.degree && p.gradient.degree == other.gradient.degree;
gradient.feather = gradient.feather && p.gradient.feather == other.gradient.feather;
gradient.strength = gradient.strength && p.gradient.strength == other.gradient.strength;
gradient.centerX = gradient.centerX && p.gradient.centerX == other.gradient.centerX;
gradient.centerY = gradient.centerY && p.gradient.centerY == other.gradient.centerY;
cacorrection.red = cacorrection.red && p.cacorrection.red == other.cacorrection.red; cacorrection.red = cacorrection.red && p.cacorrection.red == other.cacorrection.red;
cacorrection.blue = cacorrection.blue && p.cacorrection.blue == other.cacorrection.blue; cacorrection.blue = cacorrection.blue && p.cacorrection.blue == other.cacorrection.blue;
vignetting.amount = vignetting.amount && p.vignetting.amount == other.vignetting.amount; vignetting.amount = vignetting.amount && p.vignetting.amount == other.vignetting.amount;
@ -693,6 +705,12 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
if (perspective.horizontal) toEdit.perspective.horizontal = dontforceSet && options.baBehav[ADDSET_PERSPECTIVE] ? toEdit.perspective.horizontal + mods.perspective.horizontal : mods.perspective.horizontal; if (perspective.horizontal) toEdit.perspective.horizontal = dontforceSet && options.baBehav[ADDSET_PERSPECTIVE] ? toEdit.perspective.horizontal + mods.perspective.horizontal : mods.perspective.horizontal;
if (perspective.vertical) toEdit.perspective.vertical = dontforceSet && options.baBehav[ADDSET_PERSPECTIVE] ? toEdit.perspective.vertical + mods.perspective.vertical : mods.perspective.vertical; if (perspective.vertical) toEdit.perspective.vertical = dontforceSet && options.baBehav[ADDSET_PERSPECTIVE] ? toEdit.perspective.vertical + mods.perspective.vertical : mods.perspective.vertical;
if (gradient.enabled) toEdit.gradient.enabled = mods.gradient.enabled;
if (gradient.degree) toEdit.gradient.degree = dontforceSet && options.baBehav[ADDSET_GRADIENT_DEGREE] ? toEdit.gradient.degree + mods.gradient.degree : mods.gradient.degree;
if (gradient.feather) toEdit.gradient.feather = mods.gradient.feather;
if (gradient.strength) toEdit.gradient.strength = mods.gradient.strength;
if (gradient.centerX) toEdit.gradient.centerX = mods.gradient.centerX;
if (gradient.centerY) toEdit.gradient.centerY = mods.gradient.centerY;
if (cacorrection.red) toEdit.cacorrection.red = dontforceSet && options.baBehav[ADDSET_CA] ? toEdit.cacorrection.red + mods.cacorrection.red : mods.cacorrection.red; if (cacorrection.red) toEdit.cacorrection.red = dontforceSet && options.baBehav[ADDSET_CA] ? toEdit.cacorrection.red + mods.cacorrection.red : mods.cacorrection.red;
if (cacorrection.blue) toEdit.cacorrection.blue = dontforceSet && options.baBehav[ADDSET_CA] ? toEdit.cacorrection.blue + mods.cacorrection.blue : mods.cacorrection.blue; if (cacorrection.blue) toEdit.cacorrection.blue = dontforceSet && options.baBehav[ADDSET_CA] ? toEdit.cacorrection.blue + mods.cacorrection.blue : mods.cacorrection.blue;
if (vignetting.amount) toEdit.vignetting.amount = dontforceSet && options.baBehav[ADDSET_VIGN_AMOUNT] ? toEdit.vignetting.amount + mods.vignetting.amount : mods.vignetting.amount; if (vignetting.amount) toEdit.vignetting.amount = dontforceSet && options.baBehav[ADDSET_VIGN_AMOUNT] ? toEdit.vignetting.amount + mods.vignetting.amount : mods.vignetting.amount;

12
rtgui/paramsedited.h
View File

@ -313,6 +313,17 @@ class PerspectiveParamsEdited {
bool vertical; bool vertical;
}; };
class GradientParamsEdited {
public:
bool enabled;
bool degree;
bool feather;
bool strength;
bool centerX;
bool centerY;
};
class VignettingParamsEdited { class VignettingParamsEdited {
public: public:
@ -450,6 +461,7 @@ class ParamsEdited {
DistortionParamsEdited distortion; DistortionParamsEdited distortion;
LensProfParamsEdited lensProf; LensProfParamsEdited lensProf;
PerspectiveParamsEdited perspective; PerspectiveParamsEdited perspective;
GradientParamsEdited gradient;
CACorrParamsEdited cacorrection; CACorrParamsEdited cacorrection;
VignettingParamsEdited vignetting; VignettingParamsEdited vignetting;
ChannelMixerParamsEdited chmixer; ChannelMixerParamsEdited chmixer;

7
rtgui/partialpastedlg.cc
View File

@ -49,6 +49,7 @@ PartialPasteDlg::PartialPasteDlg (Glib::ustring title) {
hlrec = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_HLRECONSTRUCTION"))); hlrec = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_HLRECONSTRUCTION")));
sh = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_SHADOWSHIGHLIGHTS"))); sh = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_SHADOWSHIGHLIGHTS")));
epd = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_EPD"))); epd = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_EPD")));
gradient = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_GRADIENT")));
labcurve = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_LABCURVE"))); labcurve = Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_LABCURVE")));
colorappearance= Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_COLORAPP"))); colorappearance= Gtk::manage (new Gtk::CheckButton (M("PARTIALPASTE_COLORAPP")));
// options in detail: // options in detail:
@ -126,6 +127,7 @@ PartialPasteDlg::PartialPasteDlg (Glib::ustring title) {
vboxes[0]->pack_start (*hlrec, Gtk::PACK_SHRINK, 2); vboxes[0]->pack_start (*hlrec, Gtk::PACK_SHRINK, 2);
vboxes[0]->pack_start (*sh, Gtk::PACK_SHRINK, 2); vboxes[0]->pack_start (*sh, Gtk::PACK_SHRINK, 2);
vboxes[0]->pack_start (*epd, Gtk::PACK_SHRINK, 2); vboxes[0]->pack_start (*epd, Gtk::PACK_SHRINK, 2);
vboxes[0]->pack_start (*gradient, Gtk::PACK_SHRINK, 2);
vboxes[0]->pack_start (*labcurve, Gtk::PACK_SHRINK, 2); vboxes[0]->pack_start (*labcurve, Gtk::PACK_SHRINK, 2);
vboxes[0]->pack_start (*colorappearance, Gtk::PACK_SHRINK, 2); vboxes[0]->pack_start (*colorappearance, Gtk::PACK_SHRINK, 2);
@ -246,6 +248,7 @@ PartialPasteDlg::PartialPasteDlg (Glib::ustring title) {
hlrecConn = hlrec->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true)); hlrecConn = hlrec->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true));
shConn = sh->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true)); shConn = sh->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true));
epdConn = epd->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true)); epdConn = epd->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true));
gradientConn = gradient->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true));
labcurveConn = labcurve->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true)); labcurveConn = labcurve->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true));
colorappearanceConn=colorappearance->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true)); colorappearanceConn=colorappearance->signal_toggled().connect (sigc::bind (sigc::mem_fun(*basic, &Gtk::CheckButton::set_inconsistent), true));
@ -427,6 +430,7 @@ void PartialPasteDlg::basicToggled () {
hlrecConn.block (true); hlrecConn.block (true);
shConn.block (true); shConn.block (true);
epdConn.block(true); epdConn.block(true);
gradientConn.block (true);
labcurveConn.block (true); labcurveConn.block (true);
colorappearanceConn.block (true); colorappearanceConn.block (true);
@ -437,6 +441,7 @@ void PartialPasteDlg::basicToggled () {
hlrec->set_active (basic->get_active ()); hlrec->set_active (basic->get_active ());
sh->set_active (basic->get_active ()); sh->set_active (basic->get_active ());
epd->set_active (basic->get_active ()); epd->set_active (basic->get_active ());
gradient->set_active (basic->get_active ());
labcurve->set_active (basic->get_active ()); labcurve->set_active (basic->get_active ());
colorappearance->set_active (basic->get_active ()); colorappearance->set_active (basic->get_active ());
@ -445,6 +450,7 @@ void PartialPasteDlg::basicToggled () {
hlrecConn.block (false); hlrecConn.block (false);
shConn.block (false); shConn.block (false);
epdConn.block (false); epdConn.block (false);
gradientConn.block (false);
labcurveConn.block (false); labcurveConn.block (false);
colorappearanceConn.block (false); colorappearanceConn.block (false);
} }
@ -598,6 +604,7 @@ void PartialPasteDlg::applyPaste (rtengine::procparams::ProcParams* dstPP, Param
if (!hlrec->get_active ()) filterPE.hlrecovery = falsePE.hlrecovery; if (!hlrec->get_active ()) filterPE.hlrecovery = falsePE.hlrecovery;
if (!sh->get_active ()) filterPE.sh = falsePE.sh; if (!sh->get_active ()) filterPE.sh = falsePE.sh;
if (!epd->get_active ()) filterPE.edgePreservingDecompositionUI = falsePE.edgePreservingDecompositionUI; if (!epd->get_active ()) filterPE.edgePreservingDecompositionUI = falsePE.edgePreservingDecompositionUI;
if (!gradient->get_active ()) filterPE.gradient = falsePE.gradient;
if (!labcurve->get_active ()) filterPE.labCurve = falsePE.labCurve; if (!labcurve->get_active ()) filterPE.labCurve = falsePE.labCurve;
if (!colorappearance->get_active ()) filterPE.colorappearance= falsePE.colorappearance; if (!colorappearance->get_active ()) filterPE.colorappearance= falsePE.colorappearance;

3
rtgui/partialpastedlg.h
View File

@ -43,6 +43,7 @@ class PartialPasteDlg : public Gtk::Dialog {
Gtk::CheckButton* hlrec; Gtk::CheckButton* hlrec;
Gtk::CheckButton* sh; Gtk::CheckButton* sh;
Gtk::CheckButton* epd; Gtk::CheckButton* epd;
Gtk::CheckButton* gradient;
Gtk::CheckButton* labcurve; Gtk::CheckButton* labcurve;
Gtk::CheckButton* colorappearance; Gtk::CheckButton* colorappearance;
@ -109,7 +110,7 @@ class PartialPasteDlg : public Gtk::Dialog {
sigc::connection everythingConn, basicConn, detailConn, colorConn, lensConn, compositionConn, metaicmConn, rawConn; sigc::connection everythingConn, basicConn, detailConn, colorConn, lensConn, compositionConn, metaicmConn, rawConn;
sigc::connection wbConn, exposureConn, hlrecConn, shConn, labcurveConn, colorappearanceConn; sigc::connection wbConn, exposureConn, hlrecConn, shConn, gradientConn, labcurveConn, colorappearanceConn;
sigc::connection sharpenConn, gradsharpenConn, microcontrastConn, impdenConn, dirpyrdenConn, waveqConn, defringeConn, epdConn, dirpyreqConn; sigc::connection sharpenConn, gradsharpenConn, microcontrastConn, impdenConn, dirpyrdenConn, waveqConn, defringeConn, epdConn, dirpyreqConn;
sigc::connection vibranceConn, chmixerConn, hsveqConn, rgbcurvesConn; sigc::connection vibranceConn, chmixerConn, hsveqConn, rgbcurvesConn;
sigc::connection distortionConn, cacorrConn, vignettingConn, lcpConn; sigc::connection distortionConn, cacorrConn, vignettingConn, lcpConn;

7
rtgui/preferences.cc
View File

@ -248,6 +248,13 @@ Gtk::Widget* Preferences::getBatchProcPanel () {
mi->set_value (behavColumns.label, M("TP_PERSPECTIVE_LABEL")); mi->set_value (behavColumns.label, M("TP_PERSPECTIVE_LABEL"));
appendBehavList (mi, M("TP_PERSPECTIVE_HORIZONTAL")+", "+M("TP_PERSPECTIVE_VERTICAL"), ADDSET_PERSPECTIVE, false); appendBehavList (mi, M("TP_PERSPECTIVE_HORIZONTAL")+", "+M("TP_PERSPECTIVE_VERTICAL"), ADDSET_PERSPECTIVE, false);
mi = behModel->append ();
mi->set_value (behavColumns.label, M("TP_GRADIENT_LABEL"));
appendBehavList (mi, M("TP_GRADIENT_DEGREE"), ADDSET_GRADIENT_DEGREE, false);
appendBehavList (mi, M("TP_GRADIENT_FEATHER"), ADDSET_GRADIENT_FEATHER, false);
appendBehavList (mi, M("TP_GRADIENT_STRENGTH"), ADDSET_GRADIENT_STRENGTH, false);
appendBehavList (mi, M("TP_GRADIENT_CENTER_X")+", "+M("TP_GRADIENT_CENTER_Y"), ADDSET_GRADIENT_CENTER, false);
mi = behModel->append (); mi = behModel->append ();
mi->set_value (behavColumns.label, M("TP_CACORRECTION_LABEL")); mi->set_value (behavColumns.label, M("TP_CACORRECTION_LABEL"));
appendBehavList (mi, M("TP_CACORRECTION_BLUE")+", "+M("TP_CACORRECTION_RED"), ADDSET_CA, true); appendBehavList (mi, M("TP_CACORRECTION_BLUE")+", "+M("TP_CACORRECTION_RED"), ADDSET_CA, true);

2
rtgui/toolpanelcoord.cc
View File

@ -59,6 +59,7 @@ ToolPanelCoordinator::ToolPanelCoordinator () : ipc(NULL) {
colorappearance = Gtk::manage (new ColorAppearance ()); colorappearance = Gtk::manage (new ColorAppearance ());
whitebalance = Gtk::manage (new WhiteBalance ()); whitebalance = Gtk::manage (new WhiteBalance ());
vignetting = Gtk::manage (new Vignetting ()); vignetting = Gtk::manage (new Vignetting ());
gradient = Gtk::manage (new Gradient ());
perspective = Gtk::manage (new PerspCorrection ()); perspective = Gtk::manage (new PerspCorrection ());
cacorrection = Gtk::manage (new CACorrection ()); cacorrection = Gtk::manage (new CACorrection ());
hlrecovery = Gtk::manage (new HLRecovery ()); hlrecovery = Gtk::manage (new HLRecovery ());
@ -89,6 +90,7 @@ ToolPanelCoordinator::ToolPanelCoordinator () : ipc(NULL) {
addPanel (colorPanel, hsvequalizer, M("TP_HSVEQUALIZER_LABEL")); toolPanels.push_back (hsvequalizer); addPanel (colorPanel, hsvequalizer, M("TP_HSVEQUALIZER_LABEL")); toolPanels.push_back (hsvequalizer);
addPanel (colorPanel, rgbcurves, M("TP_RGBCURVES_LABEL")); toolPanels.push_back (rgbcurves); addPanel (colorPanel, rgbcurves, M("TP_RGBCURVES_LABEL")); toolPanels.push_back (rgbcurves);
addPanel (exposurePanel, edgePreservingDecompositionUI, M("TP_EPD_LABEL")); toolPanels.push_back (edgePreservingDecompositionUI); addPanel (exposurePanel, edgePreservingDecompositionUI, M("TP_EPD_LABEL")); toolPanels.push_back (edgePreservingDecompositionUI);
addPanel (exposurePanel, gradient, M("TP_GRADIENT_LABEL")); toolPanels.push_back (gradient);
addPanel (exposurePanel, lcurve, M("TP_LABCURVE_LABEL")); toolPanels.push_back (lcurve); addPanel (exposurePanel, lcurve, M("TP_LABCURVE_LABEL")); toolPanels.push_back (lcurve);
// addPanel (exposurePanel, edgePreservingDecompositionUI, M("TP_EPD_LABEL")); toolPanels.push_back (edgePreservingDecompositionUI); // addPanel (exposurePanel, edgePreservingDecompositionUI, M("TP_EPD_LABEL")); toolPanels.push_back (edgePreservingDecompositionUI);
addPanel (exposurePanel, colorappearance, M("TP_COLORAPP_LABEL")); toolPanels.push_back (colorappearance); addPanel (exposurePanel, colorappearance, M("TP_COLORAPP_LABEL")); toolPanels.push_back (colorappearance);

2
rtgui/toolpanelcoord.h
View File

@ -51,6 +51,7 @@
#include "perspective.h" #include "perspective.h"
#include "rotate.h" #include "rotate.h"
#include "vignetting.h" #include "vignetting.h"
#include "gradient.h"
#include "toolbar.h" #include "toolbar.h"
#include "lensgeom.h" #include "lensgeom.h"
#include "lensgeomlistener.h" #include "lensgeomlistener.h"
@ -86,6 +87,7 @@ class ToolPanelCoordinator : public ToolPanelListener,
WhiteBalance* whitebalance; WhiteBalance* whitebalance;
Vignetting* vignetting; Vignetting* vignetting;
Gradient* gradient;
LensGeometry* lensgeom; LensGeometry* lensgeom;
LensProfilePanel* lensProf; LensProfilePanel* lensProf;
Rotate* rotate; Rotate* rotate;