Changeset 26047

Timestamp:

Nov 5, 2009, 1:22:53 PM (17 years ago)

Author:

Paul Price

Message:

Fix propagation of mask (for poor pixels) when poor box size = 0.

File:

• trunk/psModules/src/imcombine/pmSubtraction.c (modified) (5 diffs)

trunk/psModules/src/imcombine/pmSubtraction.c

@@ -390 +390 @@
     }
 
-    // Convolve the mask for bad pixels
+    // Convolve the mask for bad/poor pixels
     if (subMask && convMask) {
         int box = p_pmSubtractionBadRadius(*kernelImage, kernels, polyValues,
                                            wantDual, poorFrac); // Size of bad box
+        psAssert(box >= 0, "Bad radius must be >= 0");
+
+        int colMin = region.x0, colMax = region.x1, rowMin = region.y0, rowMax = region.y1; // Bounds
+        psImage *convolved = NULL; // Convolved subtraction mask
         if (box > 0) {
-            int colMin = region.x0, colMax = region.x1, rowMin = region.y0, rowMax = region.y1; // Bounds
-            psRegion region = psRegionSet(colMin - box, colMax + box,
-                                          rowMin - box, rowMax + box); // Region to convolve
-
-            psImage *image = subMask ? psImageSubset(subMask, region) : NULL; // Mask to convolve
-
-            psImage *convolved = psImageConvolveMask(NULL, image, subBad, subConvBad,
-                                                     -box, box, -box, box); // Convolved subtraction mask
-
+            psRegion maskRegion = psRegionSet(colMin - box, colMax + box,
+                                              rowMin - box, rowMax + box); // Region to convolve
+            psImage *image = subMask ? psImageSubset(subMask, maskRegion) : NULL; // Mask to convolve
+            convolved = psImageConvolveMask(NULL, image, subBad, subConvBad, -box, box, -box, box);
             psFree(image);
-
-            psAssert(convolved->numCols - 2 * box == colMax - colMin, "Bad number of columns");
-            psAssert(convolved->numRows - 2 * box == rowMax - rowMin, "Bad number of rows");
-
-            for (int yTarget = rowMin, ySource = box; yTarget < rowMax; yTarget++, ySource++) {
-                // Dereference images
-                psImageMaskType *target = &convMask->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][colMin]; // Target values
-                psImageMaskType *source = &convolved->data.PS_TYPE_IMAGE_MASK_DATA[ySource][box]; // Source values
-                for (int xTarget = colMin; xTarget < colMax; xTarget++, target++, source++) {
-                    if (*source & subConvBad) {
-                        *target |= maskBad;
-                    } else if (*source & subConvPoor) {
-                        *target |= maskPoor;
-                    }
+        } else {
+            convolved = psImageSubset(subMask, region);
+        }
+
+        psAssert(convolved->numCols - 2 * box == colMax - colMin, "Bad number of columns");
+        psAssert(convolved->numRows - 2 * box == rowMax - rowMin, "Bad number of rows");
+
+        for (int yTarget = rowMin, ySource = box; yTarget < rowMax; yTarget++, ySource++) {
+            // Dereference images
+            psImageMaskType *target = &convMask->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][colMin]; // Target values
+            psImageMaskType *source = &convolved->data.PS_TYPE_IMAGE_MASK_DATA[ySource][box]; // Source values
+            for (int xTarget = colMin; xTarget < colMax; xTarget++, target++, source++) {
+                if (*source & subConvBad) {
+                    *target |= maskBad;
+                } else if (*source & subConvPoor) {
+                    *target |= maskPoor;
                 }
             }
-
-            // No need to lock: we own this
-            psFree(convolved);
-        }
+        }
+
+        psFree(convolved);
     }
 
@@ -1066 +1066 @@
 
     if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
-        convolveRegion(out1->image, out1->variance, convMask, &kernelImage, &kernelVariance,
+        convolveRegion(out1->image, out1->variance, out1->mask, &kernelImage, &kernelVariance,
                        ro1->image, ro1->variance, kernelErr1, subMask, kernels, polyValues, background,
                        *region, maskBad, maskPoor, poorFrac, useFFT, false);
     }
     if (kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
-        convolveRegion(out2->image, out2->variance, convMask, &kernelImage, &kernelVariance,
+        convolveRegion(out2->image, out2->variance, out2->mask, &kernelImage, &kernelVariance,
                        ro2->image, ro2->variance, kernelErr2, subMask, kernels, polyValues, background,
                        *region, maskBad, maskPoor, poorFrac, useFFT,
@@ -1082 +1082 @@
 
     if ((kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro1->mask) {
-        psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
+        psImageMaskType **target = out1->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
         psImageMaskType **source = ro1->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask
 
@@ -1092 +1092 @@
     }
     if ((kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro2->mask) {
-        psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
+        psImageMaskType **target = out2->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask
         psImageMaskType **source = ro2->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask
 
@@ -1217 +1217 @@
                 out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
             }
+            psImageInit(out1->mask, 0);
             convMask = out1->mask;
         }
         if (kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) {
-            if (convMask) {
-                if (out2->mask) {
-                    psFree(out2->mask);
-                }
-                out2->mask = psMemIncrRefCounter(convMask);
-            } else {
-                if (!out2->mask) {
-                    out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
-                }
+            if (!out2->mask) {
+                out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
+            }
+            psImageInit(out2->mask, 0);
+            if (!convMask) {
                 convMask = out2->mask;
             }
         }
-        psImageInit(convMask, 0);
     }