Changeset 21183 for trunk/psModules/src/camera/pmFPAMaskWeight.c

Timestamp:

Jan 26, 2009, 8:40:07 PM (17 years ago)

Author:

eugene

Message:

incorporating changes from 16bit mask upgrades (eam_branch_20081230)

File:

• trunk/psModules/src/camera/pmFPAMaskWeight.c (modified) (23 diffs)

trunk/psModules/src/camera/pmFPAMaskWeight.c

@@ -42 +42 @@
             continue;
         }
-        masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8);
+        masks->data[i] = psImageAlloc(image->numCols, image->numRows, PS_TYPE_IMAGE_MASK);
         psImageInit(masks->data[i], 0);
     }
@@ -98 +98 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool pmReadoutSetMask(pmReadout *readout, psMaskType satMask, psMaskType badMask)
+bool pmReadoutSetMask(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -124 +124 @@
     if (!readout->mask) {
         // Generate a (throwaway) mask image, if required
-        readout->mask = psImageAlloc(image->numCols, image->numRows, PS_TYPE_U8);
+        readout->mask = psImageAlloc(image->numCols, image->numRows, PS_TYPE_IMAGE_MASK);
     }
     psImage *mask = readout->mask;      // The mask pixels
@@ -131 +131 @@
     // Dereference pointers for speed
     psF32 **imageData = image->data.F32;// The image
-    psU8  **maskData  = mask->data.U8;  // The mask
+    psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA;  // The mask
 
     for (int i = 0; i < image->numRows; i++) {
@@ -153 +153 @@
 // pixels.  currently, it will set mask bits if (value <= BAD) or (value >= SATURATION)
 // should we optionally ignore these tests?
-bool pmReadoutGenerateMask(pmReadout *readout, psMaskType satMask, psMaskType badMask)
+bool pmReadoutGenerateMask(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -294 +294 @@
 }
 
-bool pmReadoutGenerateMaskWeight(pmReadout *readout, psMaskType satMask, psMaskType badMask, bool poisson)
+bool pmReadoutGenerateMaskWeight(pmReadout *readout, psImageMaskType satMask, psImageMaskType badMask, bool poisson)
 {
     PS_ASSERT_PTR_NON_NULL(readout, false);
@@ -306 +306 @@
 }
 
-bool pmCellGenerateMaskWeight(pmCell *cell, psMaskType satMask, psMaskType badMask, bool poisson)
+bool pmCellGenerateMaskWeight(pmCell *cell, psImageMaskType satMask, psImageMaskType badMask, bool poisson)
 {
     PS_ASSERT_PTR_NON_NULL(cell, false);
@@ -321 +321 @@
 
 
-bool pmReadoutWeightRenormPixels(const pmReadout *readout, psMaskType maskVal,
+bool pmReadoutWeightRenormPixels(const pmReadout *readout, psImageMaskType maskVal,
                                  psStatsOptions meanStat, psStatsOptions stdevStat, psRandom *rng)
 {
@@ -363 +363 @@
 
 
-bool pmReadoutWeightRenormPhot(const pmReadout *readout, psMaskType maskVal, int num, float width,
+bool pmReadoutWeightRenormPhot(const pmReadout *readout, psImageMaskType maskVal, int num, float width,
                                psStatsOptions meanStat, psStatsOptions stdevStat, psRandom *rng)
 {
@@ -411 +411 @@
     psVector *source = psVectorAlloc(num, PS_TYPE_F32); // Measurements of fake sources
     psVector *guess = psVectorAlloc(num, PS_TYPE_F32); // Guess at significance
-    psVector *photMask = psVectorAlloc(num, PS_TYPE_MASK); // Mask for fluxes
+    psVector *photMask = psVectorAlloc(num, PS_TYPE_VECTOR_MASK); // Mask for fluxes
     for (int i = 0; i < num; i++) {
         // Coordinates of interest
@@ -433 +433 @@
             float yGauss = gauss->data.F32[v]; // Value of Gaussian in y
             for (int u = 0, x = xPix - size; u < fullSize; u++, x++) {
-                if (mask && mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
+                if (mask && mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
                     continue;
                 }
@@ -453 +453 @@
         }
 
-        photMask->data.PS_TYPE_MASK_DATA[i] = ((isfinite(sumNoise) && isfinite(sumSource) &&
+        photMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = ((isfinite(sumNoise) && isfinite(sumSource) &&
                                                 isfinite(sumWeight) && sumGauss > 0 && sumGauss2 > 0) ?
                                                0 : 0xFF);
@@ -493 +493 @@
         ratio->data.F32[i] = measuredSig / guess->data.F32[i];
         if (guess->data.F32[i] <= 0.0 || source->data.F32[i] <= 0.0 || !isfinite(ratio->data.F32[i])) {
-            photMask->data.PS_TYPE_MASK_DATA[i] = 0xFF;
+            photMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xFF;
         }
         psTrace("psModules.camera", 9, "Ratio %d: %f, %f, %f\n",
@@ -523 +523 @@
 
 
-bool pmReadoutWeightRenorm(const pmReadout *readout, psMaskType maskVal, psStatsOptions meanStat,
+bool pmReadoutWeightRenorm(const pmReadout *readout, psImageMaskType maskVal, psStatsOptions meanStat,
                            psStatsOptions stdevStat, int width, psRandom *rng)
 {
@@ -591 +591 @@
 
 
-bool pmReadoutMaskNonfinite(pmReadout *readout, psMaskType maskVal)
+bool pmReadoutMaskNonfinite(pmReadout *readout, psImageMaskType maskVal)
 {
     PM_ASSERT_READOUT_NON_NULL(readout, false);
@@ -601 +601 @@
 
     if (!readout->mask) {
-        readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK);
+        readout->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK);
     }
     psImage *mask = readout->mask;      // Readout's mask
@@ -608 +608 @@
         for (int x = 0; x < numCols; x++) {
             if (!isfinite(image->data.F32[y][x]) || (weight && !isfinite(weight->data.F32[y][x]))) {
-                mask->data.PS_TYPE_MASK_DATA[y][x] |= maskVal;
+                mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= maskVal;
             }
         }
@@ -618 +618 @@
 
 
-bool pmReadoutMaskApply(pmReadout *readout, psMaskType maskVal)
+bool pmReadoutMaskApply(pmReadout *readout, psImageMaskType maskVal)
 {
     PM_ASSERT_READOUT_NON_NULL(readout, false);
@@ -625 +625 @@
 
     int numCols = readout->image->numCols, numRows = readout->image->numRows; // Size of image
-    psMaskType **maskData = readout->mask->data.PS_TYPE_MASK_DATA; // Dereference mask
+    psImageMaskType **maskData = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Dereference mask
     psF32 **imageData = readout->image->data.F32;// Dereference image
     psF32 **weightData = readout->weight ? readout->weight->data.F32 : NULL; // Dereference weight map
@@ -644 +644 @@
 
 
-bool pmReadoutInterpolateBadPixels(pmReadout *readout, psMaskType maskVal, psImageInterpolateMode mode,
-                                   float poorFrac, psMaskType maskPoor, psMaskType maskBad)
+bool pmReadoutInterpolateBadPixels(pmReadout *readout, psImageMaskType maskVal, psImageInterpolateMode mode,
+                                   float poorFrac, psImageMaskType maskPoor, psImageMaskType maskBad)
 {
     PM_ASSERT_READOUT_NON_NULL(readout, false);
@@ -667 +667 @@
     psVector *imagePix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_F32); // Corresponding values for image
     psVector *weightPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_F32); // Corresponding values for weight
-    psVector *maskPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_MASK); // Corresponding values for mask
+    psVector *maskPix = psVectorAllocEmpty(PIXELS_BUFFER, PS_TYPE_IMAGE_MASK); // Corresponding values for mask
+    // NOTE: maskPix carries the actual image mask values -- do NOT use
+    // PS_TYPE_VECTOR_MASK here; it is storage, and is not treated as a vector mask
 
     long numBad = 0;                    // Number of bad pixels interpolated
     for (int y = 0; y < numRows; y++) {
         for (int x = 0; x < numCols; x++) {
-            if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) {
+            if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) {
                 double imageValue, weightValue; // Image and weight value from interpolation
-                psMaskType maskValue = 0; // Mask value from interpolation
-                psImageInterpolateStatus status = psImageInterpolate(&imageValue, &weightValue, &maskValue,
-                                                                     x, y, interp);
+                psImageMaskType maskValue = 0; // Mask value from interpolation
+                psImageInterpolateStatus status = psImageInterpolate(&imageValue, &weightValue, &maskValue, x, y, interp);
                 if (status == PS_INTERPOLATE_STATUS_ERROR || status == PS_INTERPOLATE_STATUS_OFF) {
                     psError(PS_ERR_UNKNOWN, false, "Unable to interpolate readout at %d,%d", x, y);
@@ -697 +698 @@
                 imagePix->data.F32[numBad] = imageValue;
                 weightPix->data.F32[numBad] = weightValue;
-                maskPix->data.PS_TYPE_MASK_DATA[numBad] = maskValue;
+                maskPix->data.PS_TYPE_IMAGE_MASK_DATA[numBad] = maskValue;
                 numBad++;
             }
@@ -709 +710 @@
         image->data.F32[y][x] = imagePix->data.F32[i];
         weight->data.F32[y][x] = weightPix->data.F32[i];
-        mask->data.PS_TYPE_MASK_DATA[y][x] = maskPix->data.PS_TYPE_MASK_DATA[i];
+        mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = maskPix->data.PS_TYPE_IMAGE_MASK_DATA[i];
     }