pixelshift: optional red/blue check

rtdata/languages/default

@@ -1655,6 +1655,7 @@ 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;Adaptive detection
+TP_RAW_PIXELSHIFTNONGREENHORIZONTAL;Check red/blue horizontal
 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

rtengine/dfmanager.cc

@@ -144,7 +144,7 @@ void dfInfo::updateRawImage()
         } else {
             int H = ri->get_height();
             int W = ri->get_width();
-            ri->compress_image();
+            ri->compress_image(0);
             int rSize = W * ((ri->getSensorType() == ST_BAYER || ri->getSensorType() == ST_FUJI_XTRANS) ? 1 : 3);
             acc_t **acc = new acc_t*[H];
 
@@ -164,7 +164,7 @@ void dfInfo::updateRawImage()
                 RawImage* temp = new RawImage(*iName);
 
                 if( !temp->loadRaw(true)) {
-                    temp->compress_image();     //\ TODO would be better working on original, because is temporary
+                    temp->compress_image(0);     //\ TODO would be better working on original, because is temporary
                     nFiles++;
 
                     if( ri->getSensorType() == ST_BAYER || ri->getSensorType() == ST_FUJI_XTRANS ) {
@@ -204,7 +204,7 @@ void dfInfo::updateRawImage()
             delete ri;
             ri = nullptr;
         } else {
-            ri->compress_image();
+            ri->compress_image(0);
         }
     }
 }

rtengine/ffmanager.cc

@@ -136,7 +136,7 @@ void ffInfo::updateRawImage()
         } else {
             int H = ri->get_height();
             int W = ri->get_width();
-            ri->compress_image();
+            ri->compress_image(0);
             int rSize = W * ((ri->getSensorType() == ST_BAYER || ri->getSensorType() == ST_FUJI_XTRANS) ? 1 : 3);
             acc_t **acc = new acc_t*[H];
 
@@ -156,7 +156,7 @@ void ffInfo::updateRawImage()
                 RawImage* temp = new RawImage(*iName);
 
                 if( !temp->loadRaw(true)) {
-                    temp->compress_image();     //\ TODO would be better working on original, because is temporary
+                    temp->compress_image(0);     //\ TODO would be better working on original, because is temporary
                     nFiles++;
 
                     if( ri->getSensorType() == ST_BAYER || ri->getSensorType() == ST_FUJI_XTRANS ) {
@@ -195,7 +195,7 @@ void ffInfo::updateRawImage()
             delete ri;
             ri = nullptr;
         } else {
-            ri->compress_image();
+            ri->compress_image(0);
         }
     }
 

rtengine/pixelshift.cc

@@ -36,7 +36,7 @@
 namespace
 {
 
-float greenDiff(float a, float b, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu, bool showMotion)
+float colourDiff(float a, float b, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu, bool showMotion)
 {
     // calculate the difference between to green samples
     if(adaptive) {
@@ -68,7 +68,7 @@ float greenDiff(float a, float b, bool adaptive, float stddevFactor, float eperI
 using namespace std;
 using namespace rtengine;
 
-void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, bool showOnlyMask, unsigned int frame, unsigned int gridSize, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu)
+void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, bool showOnlyMask, unsigned int frame, unsigned int gridSize, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu, bool checkNonGreenHorizontal)
 {
 
     BENCHFUN
@@ -93,7 +93,8 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
     const float scaleGreen = 1.f / scale_mul[1];
 
     eperIso *= (100.f / idata->getISOSpeed());
-    eperIso *= scaleGreen;
+    
+    float eperIsoGreen = eperIso * scaleGreen;
 
     prnu /= 100.f;
     stddevFactor *= stddevFactor;
@@ -104,9 +105,7 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
     // For shades of green motion indicators 
     const float blendFactor = (motion == 0.f ? 1.f : 1.f / (1.f - motionThreshold));
 
-//    bool showOnlyMask = showMotion;
+    bool checkNonGreen = true;
-//    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
     switch (frame) {
@@ -128,6 +127,8 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
             offsY = 0;
     }
 
+    const float thresh = adaptive ? 0.f : motionThreshold;
+
 #ifdef _OPENMP
     #pragma omp parallel for schedule(dynamic,16)
 #endif
@@ -138,10 +139,16 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
         float *nonGreenDest1 = blue[i + offsY];
         int j = winx + border - offsX;
         int c = FC(i, j);
+        float scaleNonGreen0 = 1.f / scale_mul[0];
+        float scaleNonGreen2 = 1.f / scale_mul[2];
+        float eperIsoNonGreen0 = eperIso / scale_mul[0];
+        float eperIsoNonGreen2 = eperIso / scale_mul[2];
 
         if (c == 2 || ((c & 1) && FC(i, j + 1) == 2)) {
             // row with blue pixels => swap destination pointers for non green pixels
             std::swap(nonGreenDest0, nonGreenDest1);
+            std::swap(scaleNonGreen0, scaleNonGreen2);
+            std::swap(eperIsoNonGreen0, eperIsoNonGreen2);
         }
 
         // offset to keep the code short. It changes its value between 0 and 1 for each iteration of the loop
@@ -152,39 +159,39 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
         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, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                greenDifMax[0] =  max(colourDiff(riFrames[0 + offset]->data[i + offset][j - 1], riFrames[2 + offset]->data[i - offset + 1][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                      colourDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                      );
-                greenDifMax[1] =  max(greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                greenDifMax[1] =  max(colourDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                      colourDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                      );
             } 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, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                greenDifMax[0] =  max(colourDiff(riFrames[1 - offset]->data[i - offset - 1][j-2], riFrames[3 - offset]->data[i + offset -2][j - 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset + 1][j-2], riFrames[3 - offset]->data[i + offset][j - 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[1 - offset]->data[i - offset + 1][j-2], riFrames[3 - offset]->data[i + offset][j - 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset + 3][j-2], riFrames[3 - offset]->data[i + offset +2][j - 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[1 - offset]->data[i - offset + 3][j-2], riFrames[3 - offset]->data[i + offset +2][j - 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset - 1][j-2], riFrames[2 + offset]->data[i - offset][j - 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[0 + offset]->data[i + offset - 1][j-2], riFrames[2 + offset]->data[i - offset][j - 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset + 1][j-2], riFrames[2 + offset]->data[i - offset + 2][j - 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                      colourDiff(riFrames[0 + offset]->data[i + offset + 1][j-2], riFrames[2 + offset]->data[i - offset + 2][j - 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                      );
-                greenDifMax[1] =  max(greenDiff(riFrames[0 + offset]->data[i + offset-2][j - 1], riFrames[2 + offset]->data[i - offset - 1][j], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                greenDifMax[1] =  max(colourDiff(riFrames[0 + offset]->data[i + offset-2][j - 1], riFrames[2 + offset]->data[i - offset - 1][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset][j - 1], riFrames[2 + offset]->data[i - offset + 1][j], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[0 + offset]->data[i + offset][j - 1], riFrames[2 + offset]->data[i - offset + 1][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset+2][j - 1], riFrames[2 + offset]->data[i - offset + 3][j], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[0 + offset]->data[i + offset+2][j - 1], riFrames[2 + offset]->data[i - offset + 3][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[1 - offset]->data[i - offset][j - 1], riFrames[3 - offset]->data[i + offset - 1][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                      colourDiff(riFrames[1 - offset]->data[i - offset + 2][j - 1], riFrames[3 - offset]->data[i + offset + 1][j], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                      );
-                greenDifMax[2] =  max(greenDiff(riFrames[1 - offset]->data[i - offset - 1][j], riFrames[3 - offset]->data[i + offset -2][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                greenDifMax[2] =  max(colourDiff(riFrames[1 - offset]->data[i - offset - 1][j], riFrames[3 - offset]->data[i + offset -2][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset + 3][j], riFrames[3 - offset]->data[i + offset +2][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[1 - offset]->data[i - offset + 3][j], riFrames[3 - offset]->data[i + offset +2][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[0 + offset]->data[i + offset - 1][j], riFrames[2 + offset]->data[i - offset][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                      colourDiff(riFrames[0 + offset]->data[i + offset + 1][j], riFrames[2 + offset]->data[i - offset + 2][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                      );
-                greenDifMax[3] =  max(greenDiff(riFrames[0 + offset]->data[i + offset-2][j + 1], riFrames[2 + offset]->data[i - offset - 1][j+2], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                greenDifMax[3] =  max(colourDiff(riFrames[0 + offset]->data[i + offset-2][j + 1], riFrames[2 + offset]->data[i - offset - 1][j+2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset][j + 1], riFrames[2 + offset]->data[i - offset + 1][j+2], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[0 + offset]->data[i + offset][j + 1], riFrames[2 + offset]->data[i - offset + 1][j+2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[0 + offset]->data[i + offset+2][j + 1], riFrames[2 + offset]->data[i - offset + 3][j+2], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[0 + offset]->data[i + offset+2][j + 1], riFrames[2 + offset]->data[i - offset + 3][j+2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j+2], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                      colourDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j+2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                      greenDiff(riFrames[1 - offset]->data[i - offset + 2][j +- 1], riFrames[3 - offset]->data[i + offset + 1][j+2], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                      colourDiff(riFrames[1 - offset]->data[i - offset + 2][j +- 1], riFrames[3 - offset]->data[i + offset + 1][j+2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                      );
             }
         }
@@ -193,6 +200,7 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
 
         // this is the index for the last column of the grid. Obviously we have to start with gridSize - 1
         int lastIndex = gridSize - 1;
+        float korr = 0.f;
 
         for(; j < winw - (border + offsX); ++j) {
             offset ^= 1; // 0 => 1 or 1 => 0
@@ -202,22 +210,22 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
                 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, stddevFactor, eperIso, nreadIso, prnu, showMotion);
+                    gridMax = colourDiff(riFrames[1 - offset]->data[i - offset + 1][j], riFrames[3 - offset]->data[i + offset][j + 1], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion);
                     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, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                    greenDifMax[lastIndex] = max(colourDiff(riFrames[0 + offset]->data[i + offset][j + 1], riFrames[2 + offset]->data[i - offset + 1][j + 2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                                 greenDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j + 2], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                                 colourDiff(riFrames[1 - offset]->data[i - offset][j + 1], riFrames[3 - offset]->data[i + offset - 1][j + 2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                                 greenDiff(riFrames[1 - offset]->data[i - offset + 2][j + 1], riFrames[3 - offset]->data[i + offset + 1][j + 2], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                                 colourDiff(riFrames[1 - offset]->data[i - offset + 2][j + 1], riFrames[3 - offset]->data[i + offset + 1][j + 2], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                                 );
                     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, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                    greenDifMax[lastIndex] = max(colourDiff(riFrames[1 - offset]->data[i - offset - 1][j+2], riFrames[3 - offset]->data[i + offset -2][j + 3], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                                 greenDiff(riFrames[1 - offset]->data[i - offset + 1][j+2], riFrames[3 - offset]->data[i + offset][j + 3], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                                 colourDiff(riFrames[1 - offset]->data[i - offset + 1][j+2], riFrames[3 - offset]->data[i + offset][j + 3], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                                 greenDiff(riFrames[1 - offset]->data[i - offset + 3][j+2], riFrames[3 - offset]->data[i + offset +2][j + 3], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                                 colourDiff(riFrames[1 - offset]->data[i - offset + 3][j+2], riFrames[3 - offset]->data[i + offset +2][j + 3], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                                 greenDiff(riFrames[0 + offset]->data[i + offset - 1][j+2], riFrames[2 + offset]->data[i - offset][j + 3], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion),
+                                                 colourDiff(riFrames[0 + offset]->data[i + offset - 1][j+2], riFrames[2 + offset]->data[i - offset][j + 3], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion),
-                                                 greenDiff(riFrames[0 + offset]->data[i + offset + 1][j+2], riFrames[2 + offset]->data[i - offset + 2][j + 3], adaptive, stddevFactor, eperIso, nreadIso, prnu, showMotion)
+                                                 colourDiff(riFrames[0 + offset]->data[i + offset + 1][j+2], riFrames[2 + offset]->data[i - offset + 2][j + 3], adaptive, stddevFactor, eperIsoGreen, nreadIso, prnu, showMotion)
                                                 );
                     gridMax = max(greenDifMax[0],greenDifMax[1],greenDifMax[2],greenDifMax[3],greenDifMax[4]);
                 }
@@ -226,14 +234,8 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
                 lastIndex = lastIndex == gridSize ? 0 : lastIndex;
 
                 // increase motion detection dependent on brightness
-                float korr;
+                if(!adaptive) {
-                float thresh;
-                if(adaptive) {
-                    korr = 0.f;
-                    thresh = 0;
-                } else {
                     korr = log2Lut[((int)(riFrames[1 - offset]->data[i - offset + 1][j] * scaleGreen))>>1];
-                    thresh = motionThreshold;
                 }
 
                 if (gridMax > thresh - korr) {
@@ -260,6 +262,86 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
                     greenDest[j + offsX] = nonGreenDest0[j + offsX] = nonGreenDest1[j + offsX] = 0.f;
                     continue;
                 }
+
+                if(adaptive && checkNonGreenHorizontal) {
+                    float ng1 = riFrames[(offset << 1) + offset]->data[i][j + offset];
+                    float ng0 = riFrames[((offset^1) << 1) + (offset^1)]->data[i][j + (offset^1)+1];
+                    float ng2 = riFrames[((offset^1) << 1) + (offset^1)]->data[i][j + (offset^1)-1];
+                    float diff0 = ng0 - ng1;
+                    float diff2 = ng2 - ng1;
+                    if(diff0 * diff2 >= 0.f) {
+//                        float val = std::abs(diff0) > std::abs(diff2) ? ng0 : ng2;
+                        float val = (ng0 + ng2) / 2.f;
+                        float gridMax = colourDiff(ng1, val, true, stddevFactor, eperIsoNonGreen0, nreadIso, prnu, showMotion);
+                        if(gridMax > 0.f) {
+                            if(showMotion) {
+                                float blend = gridMax * blendFactor;
+                                if(!showOnlyMask) {
+                                    // if showMotion is enabled make the pixel green
+                                    nonGreenDest0[j + offsX] = 1000.f + 25000.f;
+                                    nonGreenDest1[j + offsX] = greenDest[j + offsX] = 0.f;
+                                } else {
+                                    greenDest[j + offsX] = nonGreenDest0[j + offsX] = nonGreenDest1[j + offsX] = 1000.f + 25000.f;
+                                }
+                            }
+                            continue;
+                        }
+                    }
+                    ng1 = riFrames[2 - offset]->data[i + 1][j - offset + 1];
+                    ng0 = riFrames[2 - (offset^1)]->data[i + 1][j - (offset^1) + 2];
+                    ng2 = riFrames[2 - (offset^1)]->data[i + 1][j - (offset^1)];
+                    diff0 = ng0 - ng1;
+                    diff2 = ng2 - ng1;
+                    if(diff0 * diff2 >= 0.f) {
+//                        float val = std::abs(diff0) > std::abs(diff2) ? ng0 : ng2;
+                        float val = (ng0 + ng2) / 2.f;
+                        float gridMax = colourDiff(ng1, val, true, stddevFactor, eperIsoNonGreen2, nreadIso, prnu, showMotion);
+                        if(gridMax > 0.f) {
+                            if(showMotion) {
+                                float blend = gridMax * blendFactor;
+                                if(!showOnlyMask) {
+                                    nonGreenDest1[j + offsX] = 1000.f + 25000.f;
+                                    nonGreenDest0[j + offsX] = greenDest[j + offsX] = 0.f;
+                                } else {
+                                    greenDest[j + offsX] = nonGreenDest0[j + offsX] = nonGreenDest1[j + offsX] = 1000.f + 25000.f;
+                                }
+                            }
+                            continue;
+                        }
+                    }
+//                    float ngDiff = nonGreenDiff(ng0,ng1,ng2);
+//                    float korr = log2Lut[((int)(riFrames[(offset << 1) + offset]->data[i][j + offset] * scaleNonGreen0))>>1];
+//                    if(ngDiff > 0.5f - korr) {
+//                        if(showMotion) {
+//                            if(!showOnlyMask) {
+//                                // if showMotion is enabled make the pixel green
+//                                nonGreenDest0[j + offsX] = 1000.f + 25000.f;
+//                                nonGreenDest1[j + offsX] = greenDest[j + offsX] = 0.f;
+//                            } else {
+//                                greenDest[j + offsX] = nonGreenDest0[j + offsX] = nonGreenDest1[j + offsX] = 1000.f + 25000.f;
+//                            }
+//                        }
+//                        continue;
+//                    }
+//
+//                    ng1 = riFrames[2 - offset]->data[i + 1][j - offset + 1];
+//                    ng0 = riFrames[2 - (offset^1)]->data[i + 1][j - (offset^1) + 2];
+//                    ng2 = riFrames[2 - (offset^1)]->data[i + 1][j - (offset^1)];
+//                    ngDiff = nonGreenDiff(ng0,ng1,ng2);
+//                    korr = log2Lut[((int)(riFrames[2 - offset]->data[i + 1][j - offset + 1] * scaleNonGreen2))>>1];
+//                    if(ngDiff > 0.5f - korr) {
+//                        if(showMotion) {
+//                            if(!showOnlyMask) {
+//                                // if showMotion is enabled make the pixel green
+//                                nonGreenDest0[j + offsX] = 1000.f + 25000.f;
+//                                nonGreenDest1[j + offsX] = greenDest[j + offsX] = 0.f;
+//                            } else {
+//                                greenDest[j + offsX] = nonGreenDest0[j + offsX] = nonGreenDest1[j + offsX] = 1000.f + 25000.f;
+//                            }
+//                        }
+//                        continue;
+//                    }
+                }
             }
 
 //            if(false && detectMotion && checkRedBlue) {
@@ -270,9 +352,9 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
 //                float diff2 = ng1 - ng2;
 //                    float gridMax;
 //                if(diff0 * diff2 > 0.f) {
-////                    if(greenDiff(ng1, fabsf(diff0) < fabsf(diff2) ? ng0 : ng2) > motionThreshold ) {
+////                    if(colourDiff(ng1, fabsf(diff0) < fabsf(diff2) ? ng0 : ng2) > motionThreshold ) {
-//                    gridMax = greenDiff(ng1, std::max(ng0, ng2));
+//                    gridMax = colourDiff(ng1, std::max(ng0, ng2));
-////                    gridMax = greenDiff(ng1, ((ng0 + ng2) / 2.f));
+////                    gridMax = colourDiff(ng1, ((ng0 + ng2) / 2.f));
 //                    if(gridMax > motionThreshold ) {
 //                    float factor = 1.f / (1.f - motionThreshold);
 //                    float blend = (gridMax - motionThreshold) * factor;
@@ -309,9 +391,9 @@ void RawImageSource::pixelshift(int winx, int winy, int winw, int winh, bool det
 //                diff0 = ng1 - ng0;
 //                diff2 = ng1 - ng2;
 //                if(signbit(diff0) == signbit(diff2)) {
-////                    if(greenDiff(ng1, fabsf(diff0) < fabsf(diff2) ? ng0 : ng2) > motionThreshold ) {
+////                    if(colourDiff(ng1, fabsf(diff0) < fabsf(diff2) ? ng0 : ng2) > motionThreshold ) {
-//                    gridMax = greenDiff(ng1, std::max(ng0, ng2));
+//                    gridMax = colourDiff(ng1, std::max(ng0, ng2));
-////                    gridMax = greenDiff(ng1, ((ng0 + ng2) / 2.f));
+////                    gridMax = colourDiff(ng1, ((ng0 + ng2) / 2.f));
 //                    if(gridMax > motionThreshold ) {
 //                    float factor = 1.f / (1.f - motionThreshold);
 //                    float blend = (gridMax - motionThreshold) * factor;

rtengine/procparams.cc

@@ -885,7 +885,7 @@ void RAWParams::setDefaults()
     bayersensor.dcb_enhance = true;
     //bayersensor.all_enhance = false;
     bayersensor.lmmse_iterations = 2;
-    bayersensor.pixelshiftMotion = 70;
+    bayersensor.pixelshiftMotion = 0;
     bayersensor.pixelshiftMotionCorrection = 3;
     bayersensor.pixelShiftStddevFactor = 5.0;
     bayersensor.pixelShiftEperIso = 0.75;
@@ -894,6 +894,7 @@ void RAWParams::setDefaults()
     bayersensor.pixelshiftShowMotion = false;
     bayersensor.pixelshiftShowMotionMaskOnly = false;
     bayersensor.pixelShiftAutomatic = true;
+    bayersensor.pixelShiftNonGreenHorizontal = false;
     bayersensor.black0 = 0.0;
     bayersensor.black1 = 0.0;
     bayersensor.black2 = 0.0;
@@ -3409,6 +3410,10 @@ int ProcParams::save (const Glib::ustring &fname, const Glib::ustring &fname2, b
             keyFile.set_boolean ("RAW Bayer", "pixelShiftAutomatic", raw.bayersensor.pixelShiftAutomatic );
         }
 
+        if (!pedited || pedited->raw.bayersensor.pixelShiftNonGreenHorizontal) {
+            keyFile.set_boolean ("RAW Bayer", "pixelShiftNonGreenHorizontal", raw.bayersensor.pixelShiftNonGreenHorizontal );
+        }
+
         //if (!pedited || pedited->raw.bayersensor.allEnhance)    keyFile.set_boolean ("RAW Bayer", "ALLEnhance", raw.bayersensor.all_enhance );
 
         if (!pedited || pedited->raw.xtranssensor.method) {
@@ -7539,6 +7544,13 @@ int ProcParams::load (const Glib::ustring &fname, ParamsEdited* pedited)
                 }
             }
 
+            if (keyFile.has_key ("RAW Bayer", "pixelShiftNonGreenHorizontal"))  {
+                raw.bayersensor.pixelShiftNonGreenHorizontal = keyFile.get_boolean("RAW Bayer", "pixelShiftNonGreenHorizontal");
+
+                if (pedited) {
+                    pedited->raw.bayersensor.pixelShiftNonGreenHorizontal = true;
+                }
+            }
             //if (keyFile.has_key ("RAW Bayer", "ALLEnhance"))     { raw.bayersensor.all_enhance = keyFile.get_boolean("RAW Bayer", "ALLEnhance"); if (pedited) pedited->raw.bayersensor.allEnhance = true; }
         }
 

rtengine/procparams.h

@@ -1191,6 +1191,7 @@ public:
         bool pixelshiftShowMotion;
         bool pixelshiftShowMotionMaskOnly;
         bool pixelShiftAutomatic;
+        bool pixelShiftNonGreenHorizontal;
         bool dcb_enhance;
         //bool all_enhance;
     };

rtengine/rawimage.cc

@@ -659,7 +659,7 @@ int RawImage::loadRaw (bool loadData, unsigned int imageNum, bool closeFile, Pro
     return 0;
 }
 
-float** RawImage::compress_image()
+float** RawImage::compress_image(int frameNum)
 {
     if( !image ) {
         return nullptr;
@@ -667,11 +667,12 @@ float** RawImage::compress_image()
 
     if (isBayer() || isXtrans()) {
         if (!allocation) {
-            allocation = new float[height * width];
+            // shift the beginning of all frames but the first by 32 floats to avoid cache miss conflicts on CPUs which have <= 4-way associative L1-Cache
+            allocation = new float[height * width + frameNum * 32];
             data = new float*[height];
 
             for (int i = 0; i < height; i++) {
-                data[i] = allocation + i * width;
+                data[i] = allocation + i * width + frameNum * 32;
             }
         }
     } else if (colors == 1) {

rtengine/rawimage.h

@@ -119,7 +119,7 @@ public:
     {
         return image;
     }
-    float** compress_image(); // revert to compressed pixels format and release image data
+    float** compress_image(int frameNum); // revert to compressed pixels format and release image data
     float** data;             // holds pixel values, data[i][j] corresponds to the ith row and jth column
     unsigned prefilters;               // original filters saved ( used for 4 color processing )
     unsigned int getFrameCount() const { return is_raw; }

rtengine/rawimagesource.cc

@@ -37,7 +37,7 @@
 #include <omp.h>
 #endif
 #include "opthelper.h"
-//#define BENCHMARK
+#define BENCHMARK
 #include "StopWatch.h"
 #define clipretinex( val, minv, maxv )    (( val = (val < minv ? minv : val ) ) > maxv ? maxv : val )
 #undef CLIPD
@@ -1521,7 +1521,7 @@ StopWatch Stop1("decode");
 {
     int errCodeThr = 0;
 #ifdef _OPENMP
-#pragma omp for
+#pragma omp for nowait
 #endif
     for(unsigned int i = 0; i < numFrames; ++i) {
         if(i == 0) {
@@ -1531,7 +1531,7 @@ StopWatch Stop1("decode");
             riFrames[i] = new RawImage(fname);
             errCodeThr = riFrames[i]->loadRaw (true, i);
         }
-        riFrames[i]->compress_image();
+        riFrames[i]->compress_image(i);
     }
 #ifdef _OPENMP
 #pragma omp critical
@@ -1966,7 +1966,7 @@ void RawImageSource::demosaic(const RAWParams &raw)
                 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(0, 0, W, H, raw.bayersensor.pixelshiftMotion > 0, raw.bayersensor.pixelshiftMotion, raw.bayersensor.pixelshiftShowMotion, raw.bayersensor.pixelshiftShowMotionMaskOnly, currFrame, raw.bayersensor.pixelshiftMotionCorrection, raw.bayersensor.pixelShiftAutomatic, raw.bayersensor.pixelShiftStddevFactor, raw.bayersensor.pixelShiftEperIso, raw.bayersensor.pixelShiftNreadIso, raw.bayersensor.pixelShiftPrnu);
+                pixelshift(0, 0, W, H, raw.bayersensor.pixelshiftMotion > 0, raw.bayersensor.pixelshiftMotion, raw.bayersensor.pixelshiftShowMotion, raw.bayersensor.pixelshiftShowMotionMaskOnly, currFrame, raw.bayersensor.pixelshiftMotionCorrection, raw.bayersensor.pixelShiftAutomatic, raw.bayersensor.pixelShiftStddevFactor, raw.bayersensor.pixelShiftEperIso, raw.bayersensor.pixelShiftNreadIso, raw.bayersensor.pixelShiftPrnu, raw.bayersensor.pixelShiftNonGreenHorizontal);
             }
         } else if (raw.bayersensor.method == RAWParams::BayerSensor::methodstring[RAWParams::BayerSensor::dcb] ) {
             dcb_demosaic(raw.bayersensor.dcb_iterations, raw.bayersensor.dcb_enhance);
@@ -3520,63 +3520,23 @@ void RawImageSource::scaleColors(int winx, int winy, int winw, int winh, const R
 
 void RawImageSource::scaleColors_pixelshift(int winx, int winy, int winw, int winh, const RAWParams &raw)
 {
-    chmax[0] = chmax[1] = chmax[2] = chmax[3] = 0; //channel maxima
+    BENCHFUN
-    float black_lev[4] = {0.f};//black level
-
-    //adjust black level  (eg Canon)
-    bool isMono = false;
-
-    black_lev[0] = raw.bayersensor.black1; //R
-    black_lev[1] = raw.bayersensor.black0; //G1
-    black_lev[2] = raw.bayersensor.black2; //B
-    black_lev[3] = raw.bayersensor.black3; //G2
-
-    for(int i = 0; i < 4 ; i++) {
-        cblacksom[i] = max( c_black[i] + black_lev[i], 0.0f );    // adjust black level
-    }
-
-    initialGain = calculate_scale_mul(scale_mul, ref_pre_mul, c_white, cblacksom, isMono, ri->get_colors()); // recalculate scale colors with adjusted levels
-
-    //fprintf(stderr, "recalc: %f [%f %f %f %f]\n", initialGain, scale_mul[0], scale_mul[1], scale_mul[2], scale_mul[3]);
-    for(int i = 0; i < 4 ; i++) {
-        clmax[i] = (c_white[i] - cblacksom[i]) * scale_mul[i];    // raw clip level
-    }
-
-    // this seems strange, but it works
 
     // scale image colors
 
 #ifdef _OPENMP
-        #pragma omp parallel
+        #pragma omp parallel for schedule(dynamic,64) collapse(2)
 #endif
-        {
+    for(int frame = 0; frame < 4; ++frame) {
-            float tmpchmax[3];
-            tmpchmax[0] = tmpchmax[1] = tmpchmax[2] = 0.0f;
-#ifdef _OPENMP
-            #pragma omp for nowait
-#endif
-
         for (int row = winy; row < winy + winh; row ++)
         {
             for (int col = winx; col < winx + winw; col++) {
                 int c = FC(row,col);
-                    for(int frame = 0; frame < 4; ++frame) {
                 float val = (riFrames[frame]->data[row][col] - cblacksom[c]) * scale_mul[c];
-                        tmpchmax[c] = max(tmpchmax[c], val);
                 riFrames[frame]->data[row][col] = val;
             }
         }
     }
-
-#ifdef _OPENMP
-            #pragma omp critical
-#endif
-            {
-                chmax[0] = max(tmpchmax[0], chmax[0]);
-                chmax[1] = max(tmpchmax[1], chmax[1]);
-                chmax[2] = max(tmpchmax[2], chmax[2]);
-            }
-        }
     pixelShiftColoursScaled = true;
 }
 

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(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, bool showOnlyMask, unsigned int frame, unsigned int gridSize, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu);
+    void pixelshift(int winx, int winy, int winw, int winh, bool detectMotion, int motion, bool showMotion, bool showOnlyMask, unsigned int frame, unsigned int gridSize, bool adaptive, float stddevFactor, float eperIso, float nreadIso, float prnu, bool checkNonGreenHorizontal);
     void    hflip       (Imagefloat* im);
     void    vflip       (Imagefloat* im);
 

rtgui/bayerprocess.cc

@@ -92,6 +92,9 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
     pixelShiftAutomatic = Gtk::manage (new Gtk::CheckButton(M("TP_RAW_PIXELSHIFTADAPTIVE")));
     pixelShiftOptions->pack_start(*pixelShiftAutomatic);
 
+    pixelShiftNonGreenHorizontal = Gtk::manage (new Gtk::CheckButton(M("TP_RAW_PIXELSHIFTNONGREENHORIZONTAL")));
+    pixelShiftOptions->pack_start(*pixelShiftNonGreenHorizontal);
+
     pixelShiftMotion = Gtk::manage (new Adjuster (M("TP_RAW_PIXELSHIFTMOTION"), 0, 100, 1, 70));
     pixelShiftMotion->setAdjusterListener (this);
     pixelShiftMotion->set_tooltip_markup (M("TP_RAW_PIXELSHIFTMOTION_TOOLTIP"));
@@ -185,6 +188,7 @@ BayerProcess::BayerProcess () : FoldableToolPanel(this, "bayerprocess", M("TP_RA
     pixelShiftShowMotionconn = pixelShiftShowMotion->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::pixelShiftShowMotionChanged), true);
     pixelShiftShowMotionMaskOnlyconn = pixelShiftShowMotionMaskOnly->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::pixelShiftShowMotionMaskOnlyChanged), true);
     pixelShiftAutomaticconn = pixelShiftAutomatic->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::pixelShiftAutomaticChanged), true);
+    pixelShiftNonGreenHorizontalconn = pixelShiftNonGreenHorizontal->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::pixelShiftNonGreenHorizontalChanged), true);
     //allEnhconn = allEnhance->signal_toggled().connect ( sigc::mem_fun(*this, &BayerProcess::allEnhanceChanged), true);
 }
 
@@ -215,6 +219,7 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
         pixelShiftShowMotion->set_inconsistent(!pedited->raw.bayersensor.pixelshiftShowMotion);
         pixelShiftShowMotionMaskOnly->set_inconsistent(!pedited->raw.bayersensor.pixelshiftShowMotionMaskOnly);
         pixelShiftAutomatic->set_inconsistent(!pedited->raw.bayersensor.pixelShiftAutomatic);
+        pixelShiftNonGreenHorizontal->set_inconsistent(!pedited->raw.bayersensor.pixelShiftNonGreenHorizontal);
         //allEnhance->set_inconsistent(!pedited->raw.bayersensor.allEnhance);
         lmmseIterations->setEditedState ( pedited->raw.bayersensor.lmmseIterations ? Edited : UnEdited);
         pixelShiftMotion->setEditedState ( pedited->raw.bayersensor.pixelshiftMotion ? Edited : UnEdited);
@@ -239,6 +244,7 @@ void BayerProcess::read(const rtengine::procparams::ProcParams* pp, const Params
     pixelShiftShowMotion->set_active(pp->raw.bayersensor.pixelshiftShowMotion);
     pixelShiftShowMotionMaskOnly->set_active(pp->raw.bayersensor.pixelshiftShowMotionMaskOnly);
     pixelShiftAutomatic->set_active(pp->raw.bayersensor.pixelShiftAutomatic);
+    pixelShiftNonGreenHorizontal->set_active(pp->raw.bayersensor.pixelShiftNonGreenHorizontal);
     ccSteps->setValue (pp->raw.bayersensor.ccSteps);
     lmmseIterations->setValue (pp->raw.bayersensor.lmmse_iterations);
     pixelShiftMotion->setValue (pp->raw.bayersensor.pixelshiftMotion);
@@ -304,6 +310,7 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
     pp->raw.bayersensor.pixelshiftShowMotion = pixelShiftShowMotion->get_active();
     pp->raw.bayersensor.pixelshiftShowMotionMaskOnly = pixelShiftShowMotionMaskOnly->get_active();
     pp->raw.bayersensor.pixelShiftAutomatic = pixelShiftAutomatic->get_active();
+    pp->raw.bayersensor.pixelShiftNonGreenHorizontal = pixelShiftNonGreenHorizontal->get_active();
 
     int currentRow = method->get_active_row_number();
     if( currentRow >= 0 && currentRow < procparams::RAWParams::BayerSensor::numMethods) {
@@ -333,6 +340,7 @@ void BayerProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pe
         pedited->raw.bayersensor.pixelshiftShowMotion = !pixelShiftShowMotion->get_inconsistent();
         pedited->raw.bayersensor.pixelshiftShowMotionMaskOnly = !pixelShiftShowMotionMaskOnly->get_inconsistent();
         pedited->raw.bayersensor.pixelShiftAutomatic = !pixelShiftAutomatic->get_inconsistent();
+        pedited->raw.bayersensor.pixelShiftNonGreenHorizontal = !pixelShiftNonGreenHorizontal->get_inconsistent();
     }
 }
 
@@ -543,6 +551,7 @@ void BayerProcess::pixelShiftAutomaticChanged ()
     pixelShiftNreadIso->set_sensitive(pixelShiftAutomatic->get_active ());
     pixelShiftPrnu->set_sensitive(pixelShiftAutomatic->get_active ());
     pixelShiftStddevFactor->set_sensitive(pixelShiftAutomatic->get_active ());
+    pixelShiftNonGreenHorizontal->set_sensitive(pixelShiftAutomatic->get_active ());
 
     if (listener) {
         listener->panelChanged (EvDemosaicPixelshiftMotion, pixelShiftAutomatic->get_active() ? M("GENERAL_ENABLED") : M("GENERAL_DISABLED"));
@@ -550,6 +559,27 @@ void BayerProcess::pixelShiftAutomaticChanged ()
 }
 
 
+void BayerProcess::pixelShiftNonGreenHorizontalChanged ()
+{
+    if (batchMode) {
+        if (pixelShiftNonGreenHorizontal->get_inconsistent()) {
+            pixelShiftNonGreenHorizontal->set_inconsistent (false);
+            pixelShiftNonGreenHorizontalconn.block (true);
+            pixelShiftNonGreenHorizontal->set_active (false);
+            pixelShiftNonGreenHorizontalconn.block (false);
+        } else if (lastDCBen) {
+            pixelShiftNonGreenHorizontal->set_inconsistent (true);
+        }
+
+        lastDCBen = pixelShiftNonGreenHorizontal->get_active ();
+    }
+
+    if (listener) {
+        listener->panelChanged (EvDemosaicPixelshiftMotion, pixelShiftNonGreenHorizontal->get_active() ? M("GENERAL_ENABLED") : M("GENERAL_DISABLED"));
+    }
+}
+
+
 /*void BayerProcess::allEnhanceChanged ()
 {
     if (batchMode) {

rtgui/bayerprocess.h

@@ -47,6 +47,7 @@ protected:
     Gtk::CheckButton* pixelShiftShowMotion;
     Gtk::CheckButton* pixelShiftShowMotionMaskOnly;
     Gtk::CheckButton* pixelShiftAutomatic;
+    Gtk::CheckButton* pixelShiftNonGreenHorizontal;
     Adjuster* pixelShiftStddevFactor;
     Adjuster* pixelShiftEperIso;
     Adjuster* pixelShiftNreadIso;
@@ -54,7 +55,7 @@ protected:
     bool lastDCBen;
     int oldMethod;
     //bool lastALLen;
-    sigc::connection methodconn, imagenumberconn, dcbEnhconn, pixelShiftShowMotionconn, pixelShiftShowMotionMaskOnlyconn, pixelShiftAutomaticconn; //,allEnhconn;
+    sigc::connection methodconn, imagenumberconn, dcbEnhconn, pixelShiftShowMotionconn, pixelShiftShowMotionMaskOnlyconn, pixelShiftAutomaticconn, pixelShiftNonGreenHorizontalconn; //,allEnhconn;
 public:
 
     BayerProcess ();
@@ -71,6 +72,7 @@ public:
     void pixelShiftShowMotionChanged();
     void pixelShiftShowMotionMaskOnlyChanged();
     void pixelShiftAutomaticChanged();
+    void pixelShiftNonGreenHorizontalChanged();
     //void allEnhanceChanged();
 };
 

rtgui/paramsedited.cc

@@ -379,6 +379,7 @@ void ParamsEdited::set (bool v)
     raw.bayersensor.pixelshiftShowMotion = v;
     raw.bayersensor.pixelshiftShowMotionMaskOnly = v;
     raw.bayersensor.pixelShiftAutomatic = v;
+    raw.bayersensor.pixelShiftNonGreenHorizontal = v;
     raw.bayersensor.greenEq = v;
     raw.bayersensor.linenoise = v;
     raw.xtranssensor.method = v;
@@ -884,6 +885,7 @@ void ParamsEdited::initFrom (const std::vector<rtengine::procparams::ProcParams>
         raw.bayersensor.pixelshiftShowMotion = raw.bayersensor.pixelshiftShowMotion && p.raw.bayersensor.pixelshiftShowMotion == other.raw.bayersensor.pixelshiftShowMotion;
         raw.bayersensor.pixelshiftShowMotionMaskOnly = raw.bayersensor.pixelshiftShowMotionMaskOnly && p.raw.bayersensor.pixelshiftShowMotionMaskOnly == other.raw.bayersensor.pixelshiftShowMotionMaskOnly;
         raw.bayersensor.pixelShiftAutomatic = raw.bayersensor.pixelShiftAutomatic && p.raw.bayersensor.pixelShiftAutomatic == other.raw.bayersensor.pixelShiftAutomatic;
+        raw.bayersensor.pixelShiftNonGreenHorizontal = raw.bayersensor.pixelShiftNonGreenHorizontal && p.raw.bayersensor.pixelShiftNonGreenHorizontal == other.raw.bayersensor.pixelShiftNonGreenHorizontal;
         raw.bayersensor.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;
@@ -2332,6 +2334,10 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten
         toEdit.raw.bayersensor.pixelShiftAutomatic = mods.raw.bayersensor.pixelShiftAutomatic;
     }
 
+    if (raw.bayersensor.pixelShiftNonGreenHorizontal) {
+        toEdit.raw.bayersensor.pixelShiftNonGreenHorizontal = mods.raw.bayersensor.pixelShiftNonGreenHorizontal;
+    }
+
     //if (raw.bayersensor.allEnhance)    toEdit.raw.bayersensor.all_enhance      = mods.raw.bayersensor.all_enhance;
     if (raw.bayersensor.greenEq) {
         toEdit.raw.bayersensor.greenthresh      = dontforceSet && options.baBehav[ADDSET_PREPROCESS_GREENEQUIL] ? toEdit.raw.bayersensor.greenthresh + mods.raw.bayersensor.greenthresh : mods.raw.bayersensor.greenthresh;

rtgui/paramsedited.h

@@ -701,6 +701,8 @@ public:
         bool pixelshiftShowMotion;
         bool pixelshiftShowMotionMaskOnly;
         bool pixelShiftAutomatic;
+        bool pixelShiftNonGreenHorizontal;
+
         //bool allEnhance;
         bool greenEq;
         bool linenoise;