pixelshift: experimental changes for Ilias :)
This commit is contained in:
heckflosse
parent
efde91c226
commit
fb043e9f5d
@ -1654,12 +1654,16 @@ TP_RAW_IMAGENUM;Some raw files might embed several sub-images (HDR, Pixel-Shift,
|
||||
TP_RAW_LABEL;Demosaicing
|
||||
TP_RAW_LMMSEITERATIONS;LMMSE enhancement steps
|
||||
TP_RAW_LMMSE_TOOLTIP;Adds gamma (step 1), median (steps 2-4) and refinement (steps 5-6) to reduce artifacts and improve the signal-to-noise ratio.
|
||||
TP_RAW_PIXELSHIFTADAPTIVE;Automatic detection
|
||||
TP_RAW_PIXELSHIFTADAPTIVE;Adaptive detection
|
||||
TP_RAW_PIXELSHIFTMOTION;Pixelshift motion detection
|
||||
TP_RAW_PIXELSHIFTMOTION_TOOLTIP;0 means no motion detection\n1 - 99 means motion will be detected according to this value. Increase value to increase detection rate\n100 means the Amaze demosaiced frame will be used
|
||||
TP_RAW_PIXELSHIFTMOTIONCORRECTION;Pixelshift motion correction
|
||||
TP_RAW_PIXELSHIFTMOTIONCORRECTION_TOOLTIP;1 = 2 pixels\n3 = 3x3 grid\n5 = 5x5 grid
|
||||
TP_RAW_PIXELSHIFTSHOWMOTION;Show motion
|
||||
TP_RAW_PIXELSHIFTSTDDEVFACTOR;StdDev factor
|
||||
TP_RAW_PIXELSHIFTEPERISO;e per ISO
|
||||
TP_RAW_PIXELSHIFTNREADISO;nRead per ISO
|
||||
TP_RAW_PIXELSHIFTPRNU;PRNU
|
||||
TP_RAW_SENSOR_BAYER_LABEL;Sensor with Bayer Matrix
|
||||
TP_RAW_SENSOR_XTRANS_DMETHOD_TOOLTIP;3-pass gives best results (recommended for low ISO images).\n1-pass is almost undistinguishable from 3-pass for high ISO images and is faster.
|
||||
TP_RAW_SENSOR_XTRANS_LABEL;Sensor with X-Trans Matrix
|
||||
|
||||
@ -36,13 +36,18 @@
|
||||
namespace
|
||||
{
|
||||
|
||||
float greenDiff(float a, float b, bool adaptive, float scale)
|
||||
float greenDiff(float a, float b, bool adaptive, float scale, float stddevFactor, float eperIso, float nreadIso, float prnu)
|
||||
{
|
||||
// calculate the difference between to green samples
|
||||
// add a small epsilon to avoid division by zero
|
||||
float diff = std::fabs(a - b) / (std::max(a, b) + 0.01f);
|
||||
if(adaptive)
|
||||
diff -= ((5.f / sqrtf(scale * (a+b) / 2.f)) / 0.75f);
|
||||
if(adaptive) {
|
||||
float avg = (a+b)/2.f;
|
||||
avg *= scale;
|
||||
float stddev = sqrtf(avg * eperIso + nreadIso * nreadIso + prnu * prnu);
|
||||
float korr = stddevFactor * stddev / (a * scale);
|
||||
diff -= korr;
|
||||
}
|
||||
return diff;
|
||||
}
|
||||
|
||||
@ -51,7 +56,7 @@ float greenDiff(float a, float b, bool adaptive, float scale)
|
||||
using namespace std;
|
||||
using namespace rtengine;
|
||||
|
||||
void RawImageSource::pixelshift_simple(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, unsigned int frame, unsigned int gridSize, bool adaptive)
|
||||
void RawImageSource::pixelshift_simple(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, unsigned int frame, unsigned int gridSize, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu)
|
||||
{
|
||||
|
||||
BENCHFUN
|
||||
@ -62,6 +67,7 @@ void RawImageSource::pixelshift_simple(int winx, int winy, int winw, int winh, b
|
||||
}
|
||||
|
||||
|
||||
gridSize += ((gridSize & 1) == 0 ? 1 : 0);
|
||||
// Lookup table for non adaptive (slider) mode
|
||||
LUTf log2Lut(32768, LUT_CLIP_BELOW | LUT_CLIP_ABOVE);
|
||||
log2Lut[0] = 0;
|
||||
@ -70,13 +76,18 @@ void RawImageSource::pixelshift_simple(int winx, int winy, int winw, int winh, b
|
||||
for(int i=2; i < 65536; i+=2)
|
||||
log2Lut[i>>1] = 2.f * log2(i) / 100.f;
|
||||
|
||||
|
||||
// const float eperIso = 0.75f * idata->getISOSpeed() / 100;
|
||||
eperIso *= (idata->getISOSpeed() / 100);
|
||||
nreadIso *= (idata->getISOSpeed() / 100);
|
||||
// const float nreadIso = 5.f * idata->getISOSpeed() / 100;
|
||||
// const float prnu = 1.f;
|
||||
// const float stddevFactor = 4.f;
|
||||
// If the values of two corresponding green pixels differ my more then motionThreshold %, the pixel will be treated as a badGreen pixel
|
||||
float motionThreshold = 1.f - (motion / 100.f);
|
||||
// For shades of green motion indicators
|
||||
const float blendFactor = (motion == 0.f ? 1.f : 1.f / (1.f - motionThreshold));
|
||||
|
||||
bool checkRedBlue = (gridSize == 5);
|
||||
// bool checkRedBlue = (gridSize == 5);
|
||||
// bool checkRedBlue = false;
|
||||
unsigned int offsX = 0, offsY = 0;
|
||||
// We have to adjust the offsets for the selected subframe we use for areas with motion
|
||||
@ -118,45 +129,44 @@ void RawImageSource::pixelshift_simple(int winx, int winy, int winw, int winh, b
|
||||
// offset to keep the code short. It changes its value between 0 and 1 for each iteration of the loop
|
||||
unsigned int offset = (c & 1);
|
||||
|
||||
|
||||
float greenDifMax[gridSize];
|
||||
// motion detection checks the grid around the pixel for differences in green channels
|
||||
if(detectMotion || adaptive) {
|
||||
if(gridSize == 3) {
|
||||
// compute maximum of differences for first two columns of 3x3 grid
|
||||
greenDifMax[0] = max(greenDiff(riFrames[0 + offset]->data[i + offset][j - 1], riFrames[2 + offset]->data[i - offset + 1][j], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, scaleGreen)
|
||||
greenDifMax[0] = max(greenDiff(riFrames[0 + offset]->data[i + offset][j - 1], riFrames[2 + offset]->data[i - offset + 1][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
greenDifMax[1] = max(greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, scaleGreen)
|
||||
greenDifMax[1] = max(greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
} else if(gridSize == 5) {
|
||||
// compute maximum of differences for first four columns of 5x5 grid
|
||||
greenDifMax[0] = max(greenDiff(riFrames[1 - offset]->data[i - offset - 1][j-2], riFrames[3 - offset]->data[i + offset -2][j - 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 1][j-2], riFrames[3 - offset]->data[i + offset][j - 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 3][j-2], riFrames[3 - offset]->data[i + offset +2][j - 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j-2], riFrames[2 + offset]->data[i - offset][j - 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j-2], riFrames[2 + offset]->data[i - offset + 2][j - 1], adaptive, scaleGreen)
|
||||
greenDifMax[0] = max(greenDiff(riFrames[1 - offset]->data[i - offset - 1][j-2], riFrames[3 - offset]->data[i + offset -2][j - 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 1][j-2], riFrames[3 - offset]->data[i + offset][j - 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 3][j-2], riFrames[3 - offset]->data[i + offset +2][j - 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j-2], riFrames[2 + offset]->data[i - offset][j - 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j-2], riFrames[2 + offset]->data[i - offset + 2][j - 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
greenDifMax[1] = max(greenDiff(riFrames[0 + offset]->data[i + offset-2][j - 1], riFrames[2 + offset]->data[i - offset - 1][j], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset][j - 1], riFrames[2 + offset]->data[i - offset + 1][j], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset+2][j - 1], riFrames[2 + offset]->data[i - offset + 3][j], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, scaleGreen)
|
||||
greenDifMax[1] = max(greenDiff(riFrames[0 + offset]->data[i + offset-2][j - 1], riFrames[2 + offset]->data[i - offset - 1][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset][j - 1], riFrames[2 + offset]->data[i - offset + 1][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset+2][j - 1], riFrames[2 + offset]->data[i - offset + 3][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
greenDifMax[2] = max(greenDiff(riFrames[1 - offset]->data[i - offset - 1][j], riFrames[3 - offset]->data[i + offset -2][j + 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 3][j], riFrames[3 - offset]->data[i + offset +2][j + 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, scaleGreen)
|
||||
greenDifMax[2] = max(greenDiff(riFrames[1 - offset]->data[i - offset - 1][j], riFrames[3 - offset]->data[i + offset -2][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 3][j], riFrames[3 - offset]->data[i + offset +2][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
greenDifMax[3] = max(greenDiff(riFrames[0 + offset]->data[i + offset-2][j + 1], riFrames[2 + offset]->data[i - offset - 1][j+2], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset][j + 1], riFrames[2 + offset]->data[i - offset + 1][j+2], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset+2][j + 1], riFrames[2 + offset]->data[i - offset + 3][j+2], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j+2], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j +- 1], riFrames[3 - offset]->data[i + offset + 1][j+2], adaptive, scaleGreen)
|
||||
greenDifMax[3] = max(greenDiff(riFrames[0 + offset]->data[i + offset-2][j + 1], riFrames[2 + offset]->data[i - offset - 1][j+2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset][j + 1], riFrames[2 + offset]->data[i - offset + 1][j+2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset+2][j + 1], riFrames[2 + offset]->data[i - offset + 3][j+2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j+2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j +- 1], riFrames[3 - offset]->data[i + offset + 1][j+2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
}
|
||||
}
|
||||
@ -174,22 +184,22 @@ void RawImageSource::pixelshift_simple(int winx, int winy, int winw, int winh, b
|
||||
float gridMax;
|
||||
if(gridSize == 1) {
|
||||
// compute difference for current pixel and skip next pixel, that's the method from dcrawps
|
||||
gridMax = greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, scaleGreen);
|
||||
gridMax = greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu);
|
||||
skipNext = !showMotion;
|
||||
} else if(gridSize == 3) {
|
||||
// compute maximum of differences for third column of 3x3 grid and save at position lastIndex
|
||||
greenDifMax[lastIndex] = max(greenDiff(riFrames[0 + offset]->data[i + offset][j + 1], riFrames[2 + offset]->data[i - offset + 1][j + 2], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j + 2], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j + 1], riFrames[3 - offset]->data[i + offset + 1][j + 2], adaptive, scaleGreen)
|
||||
greenDifMax[lastIndex] = max(greenDiff(riFrames[0 + offset]->data[i + offset][j + 1], riFrames[2 + offset]->data[i - offset + 1][j + 2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j + 2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 2][j + 1], riFrames[3 - offset]->data[i + offset + 1][j + 2], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
gridMax = max(greenDifMax[0],greenDifMax[1],greenDifMax[2]);
|
||||
} else if(gridSize == 5) {
|
||||
// compute maximum of differences for fifth column of 5x5 grid and save at position lastIndex
|
||||
greenDifMax[lastIndex] = max(greenDiff(riFrames[1 - offset]->data[i - offset - 1][j+2], riFrames[3 - offset]->data[i + offset -2][j + 3], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 1][j+2], riFrames[3 - offset]->data[i + offset][j + 3], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 3][j+2], riFrames[3 - offset]->data[i + offset +2][j + 3], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j+2], riFrames[2 + offset]->data[i - offset][j + 3], adaptive, scaleGreen),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j+2], riFrames[2 + offset]->data[i - offset + 2][j + 3], adaptive, scaleGreen)
|
||||
greenDifMax[lastIndex] = max(greenDiff(riFrames[1 - offset]->data[i - offset - 1][j+2], riFrames[3 - offset]->data[i + offset -2][j + 3], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 1][j+2], riFrames[3 - offset]->data[i + offset][j + 3], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[1 - offset]->data[i - offset + 3][j+2], riFrames[3 - offset]->data[i + offset +2][j + 3], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset - 1][j+2], riFrames[2 + offset]->data[i - offset][j + 3], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu),
|
||||
greenDiff(riFrames[0 + offset]->data[i + offset + 1][j+2], riFrames[2 + offset]->data[i - offset + 2][j + 3], adaptive, scaleGreen, stddevFactor, eperIso, nreadIso, prnu)
|
||||
);
|
||||
gridMax = max(greenDifMax[0],greenDifMax[1],greenDifMax[2],greenDifMax[3],greenDifMax[4]);
|
||||
}
|
||||
|
||||
@ -887,8 +887,12 @@ void RAWParams::setDefaults()
|
||||
bayersensor.lmmse_iterations = 2;
|
||||
bayersensor.pixelshiftMotion = 70;
|
||||
bayersensor.pixelshiftMotionCorrection = 3;
|
||||
bayersensor.pixelShiftStddevFactor = 5.0;
|
||||
bayersensor.pixelShiftEperIso = 0.75;
|
||||
bayersensor.pixelShiftNreadIso = 5.0;
|
||||
bayersensor.pixelShiftPrnu = 1.0;
|
||||
bayersensor.pixelshiftShowMotion = false;
|
||||
bayersensor.pixelshiftBlendMotion = false;
|
||||
bayersensor.pixelShiftAutomatic = false;
|
||||
bayersensor.black0 = 0.0;
|
||||
bayersensor.black1 = 0.0;
|
||||
bayersensor.black2 = 0.0;
|
||||
@ -3376,12 +3380,28 @@ int ProcParams::save (const Glib::ustring &fname, const Glib::ustring &fname2, b
|
||||
keyFile.set_integer ("RAW Bayer", "PixelShiftMotionCorrection", raw.bayersensor.pixelshiftMotionCorrection );
|
||||
}
|
||||
|
||||
if (!pedited || pedited->raw.bayersensor.pixelShiftStddevFactor) {
|
||||
keyFile.set_double ("RAW Bayer", "PixelShiftStddevFactor", raw.bayersensor.pixelShiftStddevFactor );
|
||||
}
|
||||
|
||||
if (!pedited || pedited->raw.bayersensor.pixelShiftEperIso) {
|
||||
keyFile.set_double ("RAW Bayer", "PixelShiftEperIso", raw.bayersensor.pixelShiftEperIso );
|
||||
}
|
||||
|
||||
if (!pedited || pedited->raw.bayersensor.pixelShiftNreadIso) {
|
||||
keyFile.set_double ("RAW Bayer", "PixelShiftNreadIso", raw.bayersensor.pixelShiftNreadIso );
|
||||
}
|
||||
|
||||
if (!pedited || pedited->raw.bayersensor.pixelShiftPrnu) {
|
||||
keyFile.set_double ("RAW Bayer", "PixelShiftPrnu", raw.bayersensor.pixelShiftPrnu );
|
||||
}
|
||||
|
||||
if (!pedited || pedited->raw.bayersensor.pixelshiftShowMotion) {
|
||||
keyFile.set_boolean ("RAW Bayer", "PixelShiftShowMotion", raw.bayersensor.pixelshiftShowMotion );
|
||||
}
|
||||
|
||||
if (!pedited || pedited->raw.bayersensor.pixelshiftBlendMotion) {
|
||||
keyFile.set_boolean ("RAW Bayer", "PixelShiftBlendMotion", raw.bayersensor.pixelshiftBlendMotion );
|
||||
if (!pedited || pedited->raw.bayersensor.pixelShiftAutomatic) {
|
||||
keyFile.set_boolean ("RAW Bayer", "pixelShiftAutomatic", raw.bayersensor.pixelShiftAutomatic );
|
||||
}
|
||||
|
||||
//if (!pedited || pedited->raw.bayersensor.allEnhance) keyFile.set_boolean ("RAW Bayer", "ALLEnhance", raw.bayersensor.all_enhance );
|
||||
@ -7458,6 +7478,38 @@ int ProcParams::load (const Glib::ustring &fname, ParamsEdited* pedited)
|
||||
}
|
||||
}
|
||||
|
||||
if (keyFile.has_key ("RAW Bayer", "PixelShiftStddevFactor")) {
|
||||
raw.bayersensor.pixelShiftStddevFactor = keyFile.get_double("RAW Bayer", "PixelShiftStddevFactor");
|
||||
|
||||
if (pedited) {
|
||||
pedited->raw.bayersensor.pixelShiftStddevFactor = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (keyFile.has_key ("RAW Bayer", "PixelShiftEperIso")) {
|
||||
raw.bayersensor.pixelShiftEperIso = keyFile.get_double("RAW Bayer", "PixelShiftEperIso");
|
||||
|
||||
if (pedited) {
|
||||
pedited->raw.bayersensor.pixelShiftEperIso = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (keyFile.has_key ("RAW Bayer", "PixelShiftNreadIso")) {
|
||||
raw.bayersensor.pixelShiftNreadIso = keyFile.get_double("RAW Bayer", "PixelShiftNreadIso");
|
||||
|
||||
if (pedited) {
|
||||
pedited->raw.bayersensor.pixelShiftNreadIso = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (keyFile.has_key ("RAW Bayer", "PixelShiftPrnu")) {
|
||||
raw.bayersensor.pixelShiftPrnu = keyFile.get_double("RAW Bayer", "PixelShiftPrnu");
|
||||
|
||||
if (pedited) {
|
||||
pedited->raw.bayersensor.pixelShiftPrnu = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (keyFile.has_key ("RAW Bayer", "PixelShiftShowMotion")) {
|
||||
raw.bayersensor.pixelshiftShowMotion = keyFile.get_boolean("RAW Bayer", "PixelShiftShowMotion");
|
||||
|
||||
@ -7466,11 +7518,11 @@ int ProcParams::load (const Glib::ustring &fname, ParamsEdited* pedited)
|
||||
}
|
||||
}
|
||||
|
||||
if (keyFile.has_key ("RAW Bayer", "PixelShiftBlendMotion")) {
|
||||
raw.bayersensor.pixelshiftBlendMotion = keyFile.get_boolean("RAW Bayer", "PixelShiftBlendMotion");
|
||||
if (keyFile.has_key ("RAW Bayer", "pixelShiftAutomatic")) {
|
||||
raw.bayersensor.pixelShiftAutomatic = keyFile.get_boolean("RAW Bayer", "pixelShiftAutomatic");
|
||||
|
||||
if (pedited) {
|
||||
pedited->raw.bayersensor.pixelshiftBlendMotion = true;
|
||||
pedited->raw.bayersensor.pixelShiftAutomatic = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1184,8 +1184,12 @@ public:
|
||||
int lmmse_iterations;
|
||||
int pixelshiftMotion;
|
||||
int pixelshiftMotionCorrection;
|
||||
double pixelShiftStddevFactor;
|
||||
double pixelShiftEperIso;
|
||||
double pixelShiftNreadIso;
|
||||
double pixelShiftPrnu;
|
||||
bool pixelshiftShowMotion;
|
||||
bool pixelshiftBlendMotion;
|
||||
bool pixelShiftAutomatic;
|
||||
bool dcb_enhance;
|
||||
//bool all_enhance;
|
||||
};
|
||||
|
||||
@ -1962,11 +1962,11 @@ void RawImageSource::demosaic(const RAWParams &raw)
|
||||
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::amaze] ) {
|
||||
amaze_demosaic_RT (0, 0, W, H);
|
||||
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::pixelshift_simple] ) {
|
||||
if(raw.bayersensor.pixelshiftMotion > 0 || raw.bayersensor.pixelshiftBlendMotion) {
|
||||
if(raw.bayersensor.pixelshiftMotion > 0 || raw.bayersensor.pixelShiftAutomatic) {
|
||||
amaze_demosaic_RT (0, 0, W, H); // for non pixelshift files use amaze if pixelshift is selected. We need it also for motion correction
|
||||
}
|
||||
if(numFrames == 4) {
|
||||
pixelshift_simple(0, 0, W, H, raw.bayersensor.pixelshiftMotion > 0, raw.bayersensor.pixelshiftMotion, raw.bayersensor.pixelshiftShowMotion, currFrame, raw.bayersensor.pixelshiftMotionCorrection, raw.bayersensor.pixelshiftBlendMotion);
|
||||
pixelshift_simple(0, 0, W, H, raw.bayersensor.pixelshiftMotion > 0, raw.bayersensor.pixelshiftMotion, raw.bayersensor.pixelshiftShowMotion, currFrame, raw.bayersensor.pixelshiftMotionCorrection, raw.bayersensor.pixelShiftAutomatic, raw.bayersensor.pixelShiftStddevFactor, raw.bayersensor.pixelShiftEperIso, raw.bayersensor.pixelShiftNreadIso, raw.bayersensor.pixelShiftPrnu);
|
||||
}
|
||||
} else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::dcb] ) {
|
||||
dcb_demosaic(raw.bayersensor.dcb_iterations, raw.bayersensor.dcb_enhance);
|
||||
|
||||
@ -263,7 +263,7 @@ protected:
|
||||
void xtransborder_interpolate (int border);
|
||||
void xtrans_interpolate (const int passes, const bool useCieLab);
|
||||
void fast_xtrans_interpolate ();
|
||||
void pixelshift_simple(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, unsigned int frame, unsigned int gridSize, bool blendMotion);
|
||||
void pixelshift_simple(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, unsigned int frame, unsigned int gridSize, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu);
|
||||
void hflip (Imagefloat* im);
|
||||
void vflip (Imagefloat* im);
|
||||
|
||||
|
||||
@ -86,8 +86,8 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
|
||||
pixelShiftShowMotion = Gtk::manage (new Gtk::CheckButton(M("TP_RAW_PIXELSHIFTSHOWMOTION")));
|
||||
pixelShiftOptions->pack_start(*pixelShiftShowMotion);
|
||||
|
||||
pixelShiftBlendMotion = Gtk::manage (new Gtk::CheckButton(M("TP_RAW_PIXELSHIFTADAPTIVE")));
|
||||
pixelShiftOptions->pack_start(*pixelShiftBlendMotion);
|
||||
pixelShiftAutomatic = Gtk::manage (new Gtk::CheckButton(M("TP_RAW_PIXELSHIFTADAPTIVE")));
|
||||
pixelShiftOptions->pack_start(*pixelShiftAutomatic);
|
||||
|
||||
pixelShiftMotion = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTMOTION"), 0, 100, 1, 70));
|
||||
pixelShiftMotion->setAdjusterListener (this);
|
||||
@ -109,6 +109,52 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
|
||||
|
||||
pixelShiftMotionCorrection->show();
|
||||
pixelShiftOptions->pack_start(*pixelShiftMotionCorrection);
|
||||
|
||||
pixelShiftStddevFactor = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTSTDDEVFACTOR"), 2, 8, 0.1, 5));
|
||||
pixelShiftStddevFactor->setAdjusterListener (this);
|
||||
// pixelShiftStddevFactor->set_tooltip_markup (M("TP_RAW_PIXELSHIFTSTDDEVFACTOR_TOOLTIP"));
|
||||
|
||||
if (pixelShiftStddevFactor->delay < options.adjusterMaxDelay) {
|
||||
pixelShiftStddevFactor->delay = options.adjusterMaxDelay;
|
||||
}
|
||||
|
||||
pixelShiftStddevFactor->show();
|
||||
pixelShiftOptions->pack_start(*pixelShiftStddevFactor);
|
||||
|
||||
pixelShiftEperIso = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTEPERISO"), 0.3, 1.0, 0.05, 0.75));
|
||||
pixelShiftEperIso->setAdjusterListener (this);
|
||||
// pixelShiftStddevFactor->set_tooltip_markup (M("TP_RAW_PIXELSHIFTSTDDEVFACTOR_TOOLTIP"));
|
||||
|
||||
if (pixelShiftEperIso->delay < options.adjusterMaxDelay) {
|
||||
pixelShiftEperIso->delay = options.adjusterMaxDelay;
|
||||
}
|
||||
|
||||
pixelShiftEperIso->show();
|
||||
pixelShiftOptions->pack_start(*pixelShiftEperIso);
|
||||
|
||||
pixelShiftNreadIso = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTNREADISO"), 1.0, 10.0, 0.5, 5.0));
|
||||
pixelShiftNreadIso->setAdjusterListener (this);
|
||||
// pixelShiftStddevFactor->set_tooltip_markup (M("TP_RAW_PIXELSHIFTSTDDEVFACTOR_TOOLTIP"));
|
||||
|
||||
if (pixelShiftNreadIso->delay < options.adjusterMaxDelay) {
|
||||
pixelShiftNreadIso->delay = options.adjusterMaxDelay;
|
||||
}
|
||||
|
||||
pixelShiftNreadIso->show();
|
||||
pixelShiftOptions->pack_start(*pixelShiftNreadIso);
|
||||
|
||||
|
||||
pixelShiftPrnu = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTPRNU"), 0.3, 2.0, 0.1, 1.0));
|
||||
pixelShiftPrnu->setAdjusterListener (this);
|
||||
// pixelShiftStddevFactor->set_tooltip_markup (M("TP_RAW_PIXELSHIFTSTDDEVFACTOR_TOOLTIP"));
|
||||
|
||||
if (pixelShiftPrnu->delay < options.adjusterMaxDelay) {
|
||||
pixelShiftPrnu->delay = options.adjusterMaxDelay;
|
||||
}
|
||||
|
||||
pixelShiftPrnu->show();
|
||||
pixelShiftOptions->pack_start(*pixelShiftPrnu);
|
||||
|
||||
pack_start( *pixelShiftOptions, Gtk::PACK_SHRINK, 4);
|
||||
|
||||
|
||||
@ -134,7 +180,7 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
|
||||
imagenumberconn = imageNumber->signal_changed().connect( sigc::mem_fun(*this, &BayerProcess::imageNumberChanged) );
|
||||
dcbEnhconn = dcbEnhance->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::dcbEnhanceChanged), true);
|
||||
pixelShiftShowMotionconn = pixelShiftShowMotion->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::pixelShiftShowMotionChanged), true);
|
||||
pixelShiftBlendMotionconn = pixelShiftBlendMotion->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::pixelShiftBlendMotionChanged), true);
|
||||
pixelShiftAutomaticconn = pixelShiftAutomatic->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::pixelShiftAutomaticChanged), true);
|
||||
//allEnhconn = allEnhance->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::allEnhanceChanged), true);
|
||||
}
|
||||
|
||||
@ -163,11 +209,15 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
|
||||
dcbIterations->setEditedState ( pedited->raw.bayersensor.dcbIterations ? Edited : UnEdited);
|
||||
dcbEnhance->set_inconsistent(!pedited->raw.bayersensor.dcbEnhance);
|
||||
pixelShiftShowMotion->set_inconsistent(!pedited->raw.bayersensor.pixelshiftShowMotion);
|
||||
pixelShiftBlendMotion->set_inconsistent(!pedited->raw.bayersensor.pixelshiftBlendMotion);
|
||||
pixelShiftAutomatic->set_inconsistent(!pedited->raw.bayersensor.pixelShiftAutomatic);
|
||||
//allEnhance->set_inconsistent(!pedited->raw.bayersensor.allEnhance);
|
||||
lmmseIterations->setEditedState ( pedited->raw.bayersensor.lmmseIterations ? Edited : UnEdited);
|
||||
pixelShiftMotion->setEditedState ( pedited->raw.bayersensor.pixelshiftMotion ? Edited : UnEdited);
|
||||
pixelShiftMotionCorrection->setEditedState ( pedited->raw.bayersensor.pixelshiftMotionCorrection ? Edited : UnEdited);
|
||||
pixelShiftStddevFactor->setEditedState ( pedited->raw.bayersensor.pixelShiftStddevFactor ? Edited : UnEdited);
|
||||
pixelShiftEperIso->setEditedState ( pedited->raw.bayersensor.pixelShiftEperIso ? Edited : UnEdited);
|
||||
pixelShiftNreadIso->setEditedState ( pedited->raw.bayersensor.pixelShiftNreadIso ? Edited : UnEdited);
|
||||
pixelShiftPrnu->setEditedState ( pedited->raw.bayersensor.pixelShiftPrnu ? Edited : UnEdited);
|
||||
|
||||
if(!pedited->raw.bayersensor.method) {
|
||||
method->set_active(procparams::RAWParams::BayerSensor::numMethods); // No name
|
||||
@ -182,11 +232,15 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
|
||||
dcbIterations->setValue (pp->raw.bayersensor.dcb_iterations);
|
||||
dcbEnhance->set_active(pp->raw.bayersensor.dcb_enhance);
|
||||
pixelShiftShowMotion->set_active(pp->raw.bayersensor.pixelshiftShowMotion);
|
||||
pixelShiftBlendMotion->set_active(pp->raw.bayersensor.pixelshiftBlendMotion);
|
||||
pixelShiftAutomatic->set_active(pp->raw.bayersensor.pixelShiftAutomatic);
|
||||
ccSteps->setValue (pp->raw.bayersensor.ccSteps);
|
||||
lmmseIterations->setValue (pp->raw.bayersensor.lmmse_iterations);
|
||||
pixelShiftMotion->setValue (pp->raw.bayersensor.pixelshiftMotion);
|
||||
pixelShiftMotionCorrection->setValue (pp->raw.bayersensor.pixelshiftMotionCorrection);
|
||||
pixelShiftStddevFactor->setValue (pp->raw.bayersensor.pixelShiftStddevFactor);
|
||||
pixelShiftEperIso->setValue (pp->raw.bayersensor.pixelShiftEperIso);
|
||||
pixelShiftNreadIso->setValue (pp->raw.bayersensor.pixelShiftNreadIso);
|
||||
pixelShiftPrnu->setValue (pp->raw.bayersensor.pixelShiftPrnu);
|
||||
|
||||
if (!batchMode) {
|
||||
if (pp->raw.bayersensor.method == procparams::RAWParams::BayerSensor::methodstring[procparams::RAWParams::BayerSensor::dcb] ||
|
||||
@ -237,8 +291,12 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
|
||||
pp->raw.bayersensor.lmmse_iterations = lmmseIterations->getIntValue();
|
||||
pp->raw.bayersensor.pixelshiftMotion = pixelShiftMotion->getIntValue();
|
||||
pp->raw.bayersensor.pixelshiftMotionCorrection = pixelShiftMotionCorrection->getIntValue();
|
||||
pp->raw.bayersensor.pixelShiftStddevFactor = pixelShiftStddevFactor->getValue();
|
||||
pp->raw.bayersensor.pixelShiftEperIso = pixelShiftEperIso->getValue();
|
||||
pp->raw.bayersensor.pixelShiftNreadIso = pixelShiftNreadIso->getValue();
|
||||
pp->raw.bayersensor.pixelShiftPrnu = pixelShiftPrnu->getValue();
|
||||
pp->raw.bayersensor.pixelshiftShowMotion = pixelShiftShowMotion->get_active();
|
||||
pp->raw.bayersensor.pixelshiftBlendMotion = pixelShiftBlendMotion->get_active();
|
||||
pp->raw.bayersensor.pixelShiftAutomatic = pixelShiftAutomatic->get_active();
|
||||
|
||||
int currentRow = method->get_active_row_number();
|
||||
if( currentRow >= 0 && currentRow < procparams::RAWParams::BayerSensor::numMethods) {
|
||||
@ -261,8 +319,12 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
|
||||
pedited->raw.bayersensor.lmmseIterations = lmmseIterations->getEditedState ();
|
||||
pedited->raw.bayersensor.pixelshiftMotion = pixelShiftMotion->getEditedState ();
|
||||
pedited->raw.bayersensor.pixelshiftMotionCorrection = pixelShiftMotionCorrection->getEditedState ();
|
||||
pedited->raw.bayersensor.pixelShiftStddevFactor = pixelShiftStddevFactor->getEditedState ();
|
||||
pedited->raw.bayersensor.pixelShiftEperIso = pixelShiftEperIso->getEditedState ();
|
||||
pedited->raw.bayersensor.pixelShiftNreadIso = pixelShiftNreadIso->getEditedState ();
|
||||
pedited->raw.bayersensor.pixelShiftPrnu = pixelShiftPrnu->getEditedState ();
|
||||
pedited->raw.bayersensor.pixelshiftShowMotion = !pixelShiftShowMotion->get_inconsistent();
|
||||
pedited->raw.bayersensor.pixelshiftBlendMotion = !pixelShiftBlendMotion->get_inconsistent();
|
||||
pedited->raw.bayersensor.pixelShiftAutomatic = !pixelShiftAutomatic->get_inconsistent();
|
||||
}
|
||||
}
|
||||
|
||||
@ -281,6 +343,10 @@ void BayerProcess::setBatchMode(bool batchMode)
|
||||
lmmseIterations->showEditedCB ();
|
||||
pixelShiftMotion->showEditedCB ();
|
||||
pixelShiftMotionCorrection->showEditedCB ();
|
||||
pixelShiftStddevFactor->showEditedCB ();
|
||||
pixelShiftEperIso->showEditedCB ();
|
||||
pixelShiftNreadIso->showEditedCB ();
|
||||
pixelShiftPrnu->showEditedCB ();
|
||||
}
|
||||
|
||||
void BayerProcess::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
|
||||
@ -289,6 +355,10 @@ void BayerProcess::setDefaults(const rtengine::procparams::ProcParams* defParams
|
||||
lmmseIterations->setDefault( defParams->raw.bayersensor.lmmse_iterations);
|
||||
pixelShiftMotion->setDefault( defParams->raw.bayersensor.pixelshiftMotion);
|
||||
pixelShiftMotionCorrection->setDefault( defParams->raw.bayersensor.pixelshiftMotionCorrection);
|
||||
pixelShiftStddevFactor->setDefault( defParams->raw.bayersensor.pixelShiftStddevFactor);
|
||||
pixelShiftEperIso->setDefault( defParams->raw.bayersensor.pixelShiftEperIso);
|
||||
pixelShiftNreadIso->setDefault( defParams->raw.bayersensor.pixelShiftNreadIso);
|
||||
pixelShiftPrnu->setDefault( defParams->raw.bayersensor.pixelShiftPrnu);
|
||||
ccSteps->setDefault (defParams->raw.bayersensor.ccSteps);
|
||||
|
||||
if (pedited) {
|
||||
@ -296,12 +366,20 @@ void BayerProcess::setDefaults(const rtengine::procparams::ProcParams* defParams
|
||||
lmmseIterations->setDefaultEditedState( pedited->raw.bayersensor.lmmseIterations ? Edited : UnEdited);
|
||||
pixelShiftMotion->setDefaultEditedState( pedited->raw.bayersensor.pixelshiftMotion ? Edited : UnEdited);
|
||||
pixelShiftMotionCorrection->setDefaultEditedState( pedited->raw.bayersensor.pixelshiftMotionCorrection ? Edited : UnEdited);
|
||||
pixelShiftStddevFactor->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftStddevFactor ? Edited : UnEdited);
|
||||
pixelShiftEperIso->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftEperIso ? Edited : UnEdited);
|
||||
pixelShiftNreadIso->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftNreadIso ? Edited : UnEdited);
|
||||
pixelShiftPrnu->setDefaultEditedState( pedited->raw.bayersensor.pixelShiftPrnu ? Edited : UnEdited);
|
||||
ccSteps->setDefaultEditedState(pedited->raw.bayersensor.ccSteps ? Edited : UnEdited);
|
||||
} else {
|
||||
dcbIterations->setDefaultEditedState( Irrelevant );
|
||||
lmmseIterations->setDefaultEditedState( Irrelevant );
|
||||
pixelShiftMotion->setDefaultEditedState( Irrelevant );
|
||||
pixelShiftMotionCorrection->setDefaultEditedState( Irrelevant );
|
||||
pixelShiftStddevFactor->setDefaultEditedState( Irrelevant );
|
||||
pixelShiftEperIso->setDefaultEditedState( Irrelevant );
|
||||
pixelShiftNreadIso->setDefaultEditedState( Irrelevant );
|
||||
pixelShiftPrnu->setDefaultEditedState( Irrelevant );
|
||||
ccSteps->setDefaultEditedState(Irrelevant );
|
||||
}
|
||||
}
|
||||
@ -319,6 +397,14 @@ void BayerProcess::adjusterChanged (Adjuster* a, double newval)
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, a->getTextValue() );
|
||||
} else if (a == pixelShiftMotionCorrection) {
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, a->getTextValue() );
|
||||
} else if (a == pixelShiftStddevFactor) {
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, a->getTextValue() );
|
||||
} else if (a == pixelShiftEperIso) {
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, a->getTextValue() );
|
||||
} else if (a == pixelShiftNreadIso) {
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, a->getTextValue() );
|
||||
} else if (a == pixelShiftPrnu) {
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, a->getTextValue() );
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -410,24 +496,28 @@ void BayerProcess::pixelShiftShowMotionChanged ()
|
||||
}
|
||||
}
|
||||
|
||||
void BayerProcess::pixelShiftBlendMotionChanged ()
|
||||
void BayerProcess::pixelShiftAutomaticChanged ()
|
||||
{
|
||||
if (batchMode) {
|
||||
if (pixelShiftBlendMotion->get_inconsistent()) {
|
||||
pixelShiftBlendMotion->set_inconsistent (false);
|
||||
pixelShiftBlendMotionconn.block (true);
|
||||
pixelShiftBlendMotion->set_active (false);
|
||||
pixelShiftBlendMotionconn.block (false);
|
||||
if (pixelShiftAutomatic->get_inconsistent()) {
|
||||
pixelShiftAutomatic->set_inconsistent (false);
|
||||
pixelShiftAutomaticconn.block (true);
|
||||
pixelShiftAutomatic->set_active (false);
|
||||
pixelShiftAutomaticconn.block (false);
|
||||
} else if (lastDCBen) {
|
||||
pixelShiftBlendMotion->set_inconsistent (true);
|
||||
pixelShiftAutomatic->set_inconsistent (true);
|
||||
}
|
||||
|
||||
lastDCBen = pixelShiftBlendMotion->get_active ();
|
||||
lastDCBen = pixelShiftAutomatic->get_active ();
|
||||
}
|
||||
pixelShiftMotion->set_sensitive(!pixelShiftBlendMotion->get_active ());
|
||||
pixelShiftMotion->set_sensitive(!pixelShiftAutomatic->get_active ());
|
||||
pixelShiftEperIso->set_sensitive(pixelShiftAutomatic->get_active ());
|
||||
pixelShiftNreadIso->set_sensitive(pixelShiftAutomatic->get_active ());
|
||||
pixelShiftPrnu->set_sensitive(pixelShiftAutomatic->get_active ());
|
||||
pixelShiftStddevFactor->set_sensitive(pixelShiftAutomatic->get_active ());
|
||||
|
||||
if (listener) {
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, pixelShiftBlendMotion->get_active() ? M("GENERAL_ENABLED") : M("GENERAL_DISABLED"));
|
||||
listener->panelChanged (EvDemosaicPixelshiftMotion, pixelShiftAutomatic->get_active() ? M("GENERAL_ENABLED") : M("GENERAL_DISABLED"));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -45,11 +45,15 @@ protected:
|
||||
Adjuster* pixelShiftMotion;
|
||||
Adjuster* pixelShiftMotionCorrection;
|
||||
Gtk::CheckButton* pixelShiftShowMotion;
|
||||
Gtk::CheckButton* pixelShiftBlendMotion;
|
||||
Gtk::CheckButton* pixelShiftAutomatic;
|
||||
Adjuster* pixelShiftStddevFactor;
|
||||
Adjuster* pixelShiftEperIso;
|
||||
Adjuster* pixelShiftNreadIso;
|
||||
Adjuster* pixelShiftPrnu;
|
||||
bool lastDCBen;
|
||||
int oldMethod;
|
||||
//bool lastALLen;
|
||||
sigc::connection methodconn, imagenumberconn, dcbEnhconn, pixelShiftShowMotionconn, pixelShiftBlendMotionconn; //,allEnhconn;
|
||||
sigc::connection methodconn, imagenumberconn, dcbEnhconn, pixelShiftShowMotionconn, pixelShiftAutomaticconn; //,allEnhconn;
|
||||
public:
|
||||
|
||||
BayerProcess ();
|
||||
@ -64,7 +68,7 @@ public:
|
||||
void adjusterChanged (Adjuster* a, double newval);
|
||||
void dcbEnhanceChanged();
|
||||
void pixelShiftShowMotionChanged();
|
||||
void pixelShiftBlendMotionChanged();
|
||||
void pixelShiftAutomaticChanged();
|
||||
//void allEnhanceChanged();
|
||||
};
|
||||
|
||||
|
||||
@ -372,8 +372,12 @@ void ParamsEdited::set (bool v)
|
||||
raw.bayersensor.lmmseIterations = v;
|
||||
raw.bayersensor.pixelshiftMotion = v;
|
||||
raw.bayersensor.pixelshiftMotionCorrection = v;
|
||||
raw.bayersensor.pixelShiftStddevFactor = v;
|
||||
raw.bayersensor.pixelShiftEperIso = v;
|
||||
raw.bayersensor.pixelShiftNreadIso = v;
|
||||
raw.bayersensor.pixelShiftPrnu = v;
|
||||
raw.bayersensor.pixelshiftShowMotion = v;
|
||||
raw.bayersensor.pixelshiftBlendMotion = v;
|
||||
raw.bayersensor.pixelShiftAutomatic = v;
|
||||
raw.bayersensor.greenEq = v;
|
||||
raw.bayersensor.linenoise = v;
|
||||
raw.xtranssensor.method = v;
|
||||
@ -872,8 +876,12 @@ void ParamsEdited::initFrom (const std::vector<rtengine::procparams::ProcParams>
|
||||
raw.bayersensor.lmmseIterations = raw.bayersensor.lmmseIterations && p.raw.bayersensor.lmmse_iterations == other.raw.bayersensor.lmmse_iterations;
|
||||
raw.bayersensor.pixelshiftMotion = raw.bayersensor.pixelshiftMotion && p.raw.bayersensor.pixelshiftMotion == other.raw.bayersensor.pixelshiftMotion;
|
||||
raw.bayersensor.pixelshiftMotionCorrection = raw.bayersensor.pixelshiftMotionCorrection && p.raw.bayersensor.pixelshiftMotionCorrection == other.raw.bayersensor.pixelshiftMotionCorrection;
|
||||
raw.bayersensor.pixelShiftStddevFactor = raw.bayersensor.pixelShiftStddevFactor && p.raw.bayersensor.pixelShiftStddevFactor == other.raw.bayersensor.pixelShiftStddevFactor;
|
||||
raw.bayersensor.pixelShiftEperIso = raw.bayersensor.pixelShiftEperIso && p.raw.bayersensor.pixelShiftEperIso == other.raw.bayersensor.pixelShiftEperIso;
|
||||
raw.bayersensor.pixelShiftNreadIso = raw.bayersensor.pixelShiftNreadIso && p.raw.bayersensor.pixelShiftNreadIso == other.raw.bayersensor.pixelShiftNreadIso;
|
||||
raw.bayersensor.pixelShiftPrnu = raw.bayersensor.pixelShiftPrnu && p.raw.bayersensor.pixelShiftPrnu == other.raw.bayersensor.pixelShiftPrnu;
|
||||
raw.bayersensor.pixelshiftShowMotion = raw.bayersensor.pixelshiftShowMotion && p.raw.bayersensor.pixelshiftShowMotion == other.raw.bayersensor.pixelshiftShowMotion;
|
||||
raw.bayersensor.pixelshiftBlendMotion = raw.bayersensor.pixelshiftBlendMotion && p.raw.bayersensor.pixelshiftBlendMotion == other.raw.bayersensor.pixelshiftBlendMotion;
|
||||
raw.bayersensor.pixelShiftAutomatic = raw.bayersensor.pixelShiftAutomatic && p.raw.bayersensor.pixelShiftAutomatic == other.raw.bayersensor.pixelShiftAutomatic;
|
||||
raw.bayersensor.greenEq = raw.bayersensor.greenEq && p.raw.bayersensor.greenthresh == other.raw.bayersensor.greenthresh;
|
||||
raw.bayersensor.linenoise = raw.bayersensor.linenoise && p.raw.bayersensor.linenoise == other.raw.bayersensor.linenoise;
|
||||
raw.xtranssensor.method = raw.xtranssensor.method && p.raw.xtranssensor.method == other.raw.xtranssensor.method;
|
||||
@ -2294,12 +2302,28 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
|
||||
toEdit.raw.bayersensor.pixelshiftMotionCorrection = mods.raw.bayersensor.pixelshiftMotionCorrection;
|
||||
}
|
||||
|
||||
if (raw.bayersensor.pixelShiftStddevFactor) {
|
||||
toEdit.raw.bayersensor.pixelShiftStddevFactor = mods.raw.bayersensor.pixelShiftStddevFactor;
|
||||
}
|
||||
|
||||
if (raw.bayersensor.pixelShiftEperIso) {
|
||||
toEdit.raw.bayersensor.pixelShiftEperIso = mods.raw.bayersensor.pixelShiftEperIso;
|
||||
}
|
||||
|
||||
if (raw.bayersensor.pixelShiftNreadIso) {
|
||||
toEdit.raw.bayersensor.pixelShiftNreadIso = mods.raw.bayersensor.pixelShiftNreadIso;
|
||||
}
|
||||
|
||||
if (raw.bayersensor.pixelShiftPrnu) {
|
||||
toEdit.raw.bayersensor.pixelShiftPrnu = mods.raw.bayersensor.pixelShiftPrnu;
|
||||
}
|
||||
|
||||
if (raw.bayersensor.pixelshiftShowMotion) {
|
||||
toEdit.raw.bayersensor.pixelshiftShowMotion = mods.raw.bayersensor.pixelshiftShowMotion;
|
||||
}
|
||||
|
||||
if (raw.bayersensor.pixelshiftBlendMotion) {
|
||||
toEdit.raw.bayersensor.pixelshiftBlendMotion = mods.raw.bayersensor.pixelshiftBlendMotion;
|
||||
if (raw.bayersensor.pixelShiftAutomatic) {
|
||||
toEdit.raw.bayersensor.pixelShiftAutomatic = mods.raw.bayersensor.pixelShiftAutomatic;
|
||||
}
|
||||
|
||||
//if (raw.bayersensor.allEnhance) toEdit.raw.bayersensor.all_enhance = mods.raw.bayersensor.all_enhance;
|
||||
|
||||
@ -694,8 +694,12 @@ public:
|
||||
bool lmmseIterations;
|
||||
bool pixelshiftMotion;
|
||||
bool pixelshiftMotionCorrection;
|
||||
bool pixelShiftStddevFactor;
|
||||
bool pixelShiftEperIso;
|
||||
bool pixelShiftNreadIso;
|
||||
bool pixelShiftPrnu;
|
||||
bool pixelshiftShowMotion;
|
||||
bool pixelshiftBlendMotion;
|
||||
bool pixelShiftAutomatic;
|
||||
//bool allEnhance;
|
||||
bool greenEq;
|
||||
bool linenoise;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user