Changeset 14106 for trunk/psModules/src/imcombine/pmSubtractionStamps.c

Timestamp:

Jul 10, 2007, 1:54:26 PM (19 years ago)

Author:

Paul Price

Message:

Adding additional convolution kernels: SPAM (binned pixels around a central single-pixel core) and FRIES (binning changes as a (Fibonacci-like) function of radius).

File:

• trunk/psModules/src/imcombine/pmSubtractionStamps.c (modified) (4 diffs)

trunk/psModules/src/imcombine/pmSubtractionStamps.c

@@ -6 +6 @@
 #include <pslib.h>
 
-#include "pmSubtraction.h"
 #include "pmSubtractionStamps.h"
 
@@ -40 +39 @@
 }
 
-psArray *pmSubtractionFindStamps(psArray *stamps, const psImage *image, const psImage *subMask,
-                                 float threshold, float spacing)
+
+psArray *pmSubtractionFindStamps(psArray *stamps, const psImage *image, const psImage *mask,
+                                 psMaskType maskVal, psMaskType used, float threshold,
+                                 float spacing, int border)
 {
     PS_ASSERT_IMAGE_NON_NULL(image, NULL);
     PS_ASSERT_IMAGE_TYPE(image, PS_TYPE_F32, NULL);
-    if (subMask) {
-        PS_ASSERT_IMAGE_NON_NULL(subMask, NULL);
-        PS_ASSERT_IMAGES_SIZE_EQUAL(image, subMask, NULL);
-        PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, NULL);
+    if (mask) {
+        PS_ASSERT_IMAGE_NON_NULL(mask, NULL);
+        PS_ASSERT_IMAGES_SIZE_EQUAL(image, mask, NULL);
+        PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL);
+    }
+    if (used == 0) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "The mask value for used stamps cannot be zero.");
+        return NULL;
     }
     PS_ASSERT_FLOAT_LARGER_THAN(spacing, 0.0, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(border, NULL);
+    PS_ASSERT_INT_LARGER_THAN(image->numCols, 2 * border, NULL);
+    PS_ASSERT_INT_LARGER_THAN(image->numRows, 2 * border, NULL);
 
-    // Size of image
-    int numRows = image->numRows;
-    int numCols = image->numCols;
-
-    // Number of stamps
-    int xNumStamps = numCols / spacing + 1;
-    int yNumStamps = numRows / spacing + 1;
+    maskVal |= used;                    // Make sure we don't get stamps we've already used
+    int xNumStamps = (image->numCols - 2 * border) / spacing + 1; // Number of stamps in x
+    int yNumStamps = (image->numRows - 2 * border) / spacing + 1; // Number of stamps in y
 
     if (stamps) {
@@ -74 +78 @@
         }
     }
+    // Footprint of image
+    int numRows = image->numRows;
+    int numCols = image->numCols;
 
     for (int j = 0, index = 0; j < yNumStamps; j++) {
@@ -89 +96 @@
 
                 // Bounds of region to search for stamp
-                int yMin = j * numRows / (yNumStamps + 1);
-                int yMax = (j + 1) * numRows / (yNumStamps + 1) - 1;
-                int xMin = i * numCols / (xNumStamps + 1);
-                int xMax = (i + 1) * numCols / (xNumStamps + 1) - 1;
-                assert(yMax < image->numRows && xMax < image->numCols &&
-                       yMin >= 0 && xMin >= 0);
+                int yMin = border + j * (numRows - border) / (yNumStamps + 1);
+                int yMax = border + (j + 1) * (numRows - border) / (yNumStamps + 1) - 1;
+                int xMin = border + i * (numCols - border) / (xNumStamps + 1);
+                int xMax = border + (i + 1) * (numCols - border) / (xNumStamps + 1) - 1;
+                assert(yMax < image->numRows - border && xMax < image->numCols - border &&
+                       yMin >= border && xMin >= border);
 
                 for (int y = yMin; y <= yMax ; y++) {
                     for (int x = xMin; x <= xMax ; x++) {
-                        if ((!subMask || !(subMask->data.PS_TYPE_MASK_DATA[y][x] &
-                                           (PM_SUBTRACTION_MASK_BORDER | PM_SUBTRACTION_MASK_FOOTPRINT |
-                                            PM_SUBTRACTION_MASK_REJ))) &&
-                            image->data.F32[y][x] > fluxBest) {
-                            fluxBest = image->data.F32[y][x];
-                            xBest = x;
-                            yBest = y;
+                        if (image->data.F32[y][x] > fluxBest) {
+                            bool ok = true;
+                            if (mask) {
+                                // Check kernel footprint for bad pixels
+                                if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
+                                    ok = false;
+                                } else {
+                                    for (int v = -border; v <= border && ok; v++) {
+                                        for (int u = -border; u <= border && ok; u++) {
+                                            if (mask->data.PS_TYPE_MASK_DATA[y + v][x + u] & maskVal) {
+                                                ok = false;
+#if 0
+                                                // Mark it so we don't have to look so hard next time
+                                                mask->data.PS_TYPE_MASK_DATA[y][x] |= maskVal;
+#endif
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            if (ok) {
+                                fluxBest = image->data.F32[y][x];
+                                xBest = x;
+                                yBest = y;
+                            }
                         }
                     }