pixelshift: experimental changes for Ilias :)

rtdata/languages/default

@@ -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

rtengine/pixelshift.cc

@@ -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)
+    if(adaptive) {
-        diff -= ((5.f / sqrtf(scale * (a+b) / 2.f)) / 0.75f);
+        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),
+                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),
+                                      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)
+                                      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),
+                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),
+                                      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)
+                                      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),
+                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),
+                                      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),
+                                      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),
+                                      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)
+                                      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),
+                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),
+                                      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),
+                                      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),
+                                      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)
+                                      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),
+                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),
+                                      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),
+                                      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),
+                                      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)
+                                      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),
+                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),
+                                      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),
+                                      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),
+                                      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)
+                                      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),
+                    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),
+                                                 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)
+                                                 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),
+                    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),
+                                                 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),
+                                                 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),
+                                                 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)
+                                                 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]);
                 }

rtengine/procparams.cc

@@ -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) {
+        if (!pedited || pedited->raw.bayersensor.pixelShiftAutomatic) {
-            keyFile.set_boolean ("RAW Bayer", "PixelShiftBlendMotion", raw.bayersensor.pixelshiftBlendMotion );
+            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"))  {
+            if (keyFile.has_key ("RAW Bayer", "pixelShiftAutomatic"))  {
-                raw.bayersensor.pixelshiftBlendMotion = keyFile.get_boolean("RAW Bayer", "PixelShiftBlendMotion");
+                raw.bayersensor.pixelShiftAutomatic = keyFile.get_boolean("RAW Bayer", "pixelShiftAutomatic");
 
                 if (pedited) {
-                    pedited->raw.bayersensor.pixelshiftBlendMotion = true;
+                    pedited->raw.bayersensor.pixelShiftAutomatic = true;
                 }
             }
 

rtengine/procparams.h

@@ -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;
     };

rtengine/rawimagesource.cc

@@ -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);

rtengine/rawimagesource.h

@@ -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);
 

rtgui/bayerprocess.cc

@@ -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")));
+    pixelShiftAutomatic = Gtk::manage (new Gtk::CheckButton(M("TP_RAW_PIXELSHIFTADAPTIVE")));
-    pixelShiftOptions->pack_start(*pixelShiftBlendMotion);
+    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()) {
+        if (pixelShiftAutomatic->get_inconsistent()) {
-            pixelShiftBlendMotion->set_inconsistent (false);
+            pixelShiftAutomatic->set_inconsistent (false);
-            pixelShiftBlendMotionconn.block (true);
+            pixelShiftAutomaticconn.block (true);
-            pixelShiftBlendMotion->set_active (false);
+            pixelShiftAutomatic->set_active (false);
-            pixelShiftBlendMotionconn.block (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"));
     }
 }
 

rtgui/bayerprocess.h

@@ -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();
 };
 

rtgui/paramsedited.cc

@@ -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) {
+    if (raw.bayersensor.pixelShiftAutomatic) {
-        toEdit.raw.bayersensor.pixelshiftBlendMotion = mods.raw.bayersensor.pixelshiftBlendMotion;
+        toEdit.raw.bayersensor.pixelShiftAutomatic = mods.raw.bayersensor.pixelShiftAutomatic;
     }
 
     //if (raw.bayersensor.allEnhance)    toEdit.raw.bayersensor.all_enhance      = mods.raw.bayersensor.all_enhance;

rtgui/paramsedited.h

@@ -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;